* Preamble
*****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
#include <vlc/vlc.h>
-#include <stdio.h>
-#include <stdlib.h> /* malloc(), free() */
#include <ctype.h>
#include <vlc_access.h> /* DVB-specific things */
# endif
#endif
#ifdef HAVE_TIME_H
-# include <time.h>
+# include <time.h>
#endif
#undef TS_DEBUG
set_category( CAT_INPUT );
set_subcategory( SUBCAT_INPUT_DEMUX );
- add_string( "ts-extra-pmt", NULL, NULL, PMT_TEXT, PMT_LONGTEXT, VLC_TRUE );
- add_bool( "ts-es-id-pid", 1, NULL, PID_TEXT, PID_LONGTEXT, VLC_TRUE );
- add_string( "ts-out", NULL, NULL, TSOUT_TEXT, TSOUT_LONGTEXT, VLC_TRUE );
- add_integer( "ts-out-mtu", 1500, NULL, MTUOUT_TEXT,
- MTUOUT_LONGTEXT, VLC_TRUE );
- add_string( "ts-csa-ck", NULL, NULL, CSA_TEXT, CSA_LONGTEXT, VLC_TRUE );
- add_integer( "ts-csa-pkt", 188, NULL, CPKT_TEXT, CPKT_LONGTEXT, VLC_TRUE );
- add_bool( "ts-silent", 0, NULL, SILENT_TEXT, SILENT_LONGTEXT, VLC_TRUE );
-
- add_file( "ts-dump-file", NULL, NULL, TSDUMP_TEXT, TSDUMP_LONGTEXT, VLC_FALSE );
- add_bool( "ts-dump-append", 0, NULL, APPEND_TEXT, APPEND_LONGTEXT, VLC_FALSE );
+ add_string( "ts-extra-pmt", NULL, NULL, PMT_TEXT, PMT_LONGTEXT, true );
+ add_bool( "ts-es-id-pid", 1, NULL, PID_TEXT, PID_LONGTEXT, true );
+ add_string( "ts-out", NULL, NULL, TSOUT_TEXT, TSOUT_LONGTEXT, true );
+ add_integer( "ts-out-mtu", 1400, NULL, MTUOUT_TEXT,
+ MTUOUT_LONGTEXT, true );
+ add_string( "ts-csa-ck", NULL, NULL, CSA_TEXT, CSA_LONGTEXT, true );
+ add_integer( "ts-csa-pkt", 188, NULL, CPKT_TEXT, CPKT_LONGTEXT, true );
+ add_bool( "ts-silent", 0, NULL, SILENT_TEXT, SILENT_LONGTEXT, true );
+
+ add_file( "ts-dump-file", NULL, NULL, TSDUMP_TEXT, TSDUMP_LONGTEXT, false );
+ change_unsafe();
+ add_bool( "ts-dump-append", 0, NULL, APPEND_TEXT, APPEND_LONGTEXT, false );
add_integer( "ts-dump-size", 16384, NULL, DUMPSIZE_TEXT,
- DUMPSIZE_LONGTEXT, VLC_TRUE );
+ DUMPSIZE_LONGTEXT, true );
set_capability( "demux2", 10 );
set_callbacks( Open, Close );
{
uint8_t i_objectTypeIndication;
uint8_t i_streamType;
- vlc_bool_t b_upStream;
+ bool b_upStream;
uint32_t i_bufferSizeDB;
uint32_t i_maxBitrate;
uint32_t i_avgBitrate;
typedef struct
{
- vlc_bool_t b_useAccessUnitStartFlag;
- vlc_bool_t b_useAccessUnitEndFlag;
- vlc_bool_t b_useRandomAccessPointFlag;
- vlc_bool_t b_useRandomAccessUnitsOnlyFlag;
- vlc_bool_t b_usePaddingFlag;
- vlc_bool_t b_useTimeStampsFlags;
- vlc_bool_t b_useIdleFlag;
- vlc_bool_t b_durationFlag;
+ bool b_useAccessUnitStartFlag;
+ bool b_useAccessUnitEndFlag;
+ bool b_useRandomAccessPointFlag;
+ bool b_useRandomAccessUnitsOnlyFlag;
+ bool b_usePaddingFlag;
+ bool b_useTimeStampsFlags;
+ bool b_useIdleFlag;
+ bool b_durationFlag;
uint32_t i_timeStampResolution;
uint32_t i_OCRResolution;
uint8_t i_timeStampLength;
typedef struct
{
- vlc_bool_t b_ok;
+ bool b_ok;
uint16_t i_es_id;
- vlc_bool_t b_streamDependenceFlag;
- vlc_bool_t b_OCRStreamFlag;
+ bool b_streamDependenceFlag;
+ bool b_OCRStreamFlag;
uint8_t i_streamPriority;
char *psz_url;
{
int i_pid;
- vlc_bool_t b_seen;
- vlc_bool_t b_valid;
+ bool b_seen;
+ bool b_valid;
int i_cc; /* countinuity counter */
/* PSI owner (ie PMT -> PAT, ES -> PMT */
ts_pid_t **pmt;
/* */
- vlc_bool_t b_es_id_pid;
+ bool b_es_id_pid;
csa_t *csa;
int i_csa_pkt_size;
- vlc_bool_t b_silent;
+ bool b_silent;
- vlc_bool_t b_udp_out;
+ bool b_udp_out;
int fd; /* udp socket */
uint8_t *buffer;
- vlc_bool_t b_dvb_control;
+ bool b_dvb_control;
int i_dvb_program;
int64_t i_dvb_start;
int64_t i_dvb_length;
char *psz_file; /* file to dump data in */
FILE *p_file; /* filehandle */
uint64_t i_write; /* bytes written */
- vlc_bool_t b_file_out; /* dump mode enabled */
+ bool b_file_out; /* dump mode enabled */
/* */
- vlc_bool_t b_meta;
+ bool b_meta;
};
static int Demux ( demux_t *p_demux );
static int DemuxFile( demux_t *p_demux );
static int Control( demux_t *p_demux, int i_query, va_list args );
-static void PIDInit ( ts_pid_t *pid, vlc_bool_t b_psi, ts_psi_t *p_owner );
+static void PIDInit ( ts_pid_t *pid, bool b_psi, ts_psi_t *p_owner );
static void PIDClean( es_out_t *out, ts_pid_t *pid );
static int PIDFillFormat( ts_pid_t *pid, int i_stream_type );
return ( (p->p_buffer[1]&0x1f)<<8 )|p->p_buffer[2];
}
-static vlc_bool_t GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk );
+static bool GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk );
static void PCRHandle( demux_t *p_demux, ts_pid_t *, block_t * );
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
- uint8_t *p_peek;
+ const uint8_t *p_peek;
int i_sync, i_peek, i;
int i_packet_size;
ts_pid_t *pat;
const char *psz_mode;
- vlc_bool_t b_append;
- vlc_bool_t b_topfield = VLC_FALSE;
+ bool b_append;
+ bool b_topfield = false;
vlc_value_t val;
if( stream_Peek( p_demux->s, &p_peek, TS_PACKET_SIZE_MAX ) <
TS_PACKET_SIZE_MAX ) return VLC_EGENERIC;
- if( p_peek[0] == 'T' && p_peek[1] == 'F' &&
- p_peek[2] == 'r' && p_peek[3] == 'c' )
+ if( memcmp( p_peek, "TFrc", 4 ) == 0 )
{
- b_topfield = VLC_TRUE;
+ b_topfield = true;
msg_Dbg( p_demux, "this is a topfield file" );
}
}
if( i_sync >= TS_PACKET_SIZE_MAX && !b_topfield )
{
- if( strcmp( p_demux->psz_demux, "ts" ) ) return VLC_EGENERIC;
+ if( !p_demux->b_force )
+ return VLC_EGENERIC;
msg_Warn( p_demux, "this does not look like a TS stream, continuing" );
}
{
i_packet_size = TS_PACKET_SIZE_204;
}
- else if( !strcmp( p_demux->psz_demux, "ts" ) )
+ else if( p_demux->b_force )
{
i_packet_size = TS_PACKET_SIZE_188;
}
{
i_packet_size = TS_PACKET_SIZE_188;
#if 0
- /* I used the TF5000PVR 2004 Firmware .doc header documentation,
+ /* I used the TF5000PVR 2004 Firmware .doc header documentation,
* http://www.i-topfield.com/data/product/firmware/Structure%20of%20Recorded%20File%20in%20TF5000PVR%20(Feb%2021%202004).doc
* but after the filename the offsets seem to be incorrect. - DJ */
int i_duration, i_name;
// 4 bytes of freq. Uimsbf (56,57,58,59)
// 2 bytes of symbol rate Uimsbf (60,61)
// 2 bytes of TS stream ID Uimsbf (62,63)
- // 4 bytes reserved
+ // 4 bytes reserved
// 2 bytes reserved
// 2 bytes duration Uimsbf (70,71)
//i_duration = (int) (p_peek[70] << 8) | p_peek[71];
}
p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
+ if( !p_sys )
+ return VLC_ENOMEM;
memset( p_sys, 0, sizeof( demux_sys_t ) );
p_sys->i_packet_size = i_packet_size;
/* Fill dump mode fields */
p_sys->i_write = 0;
p_sys->p_file = NULL;
- p_sys->b_file_out = VLC_FALSE;
+ p_sys->b_file_out = false;
p_sys->psz_file = var_CreateGetString( p_demux, "ts-dump-file" );
if( *p_sys->psz_file != '\0' )
{
- p_sys->b_file_out = VLC_TRUE;
+ p_sys->b_file_out = true;
var_Create( p_demux, "ts-dump-append", VLC_VAR_BOOL|VLC_VAR_DOINHERIT );
var_Get( p_demux, "ts-dump-append", &val );
else if( ( p_sys->p_file = utf8_fopen( p_sys->psz_file, psz_mode ) ) == NULL )
{
msg_Err( p_demux, "cannot create `%s' for writing", p_sys->psz_file );
- p_sys->b_file_out = VLC_FALSE;
+ p_sys->b_file_out = false;
}
if( p_sys->b_file_out )
p_demux->pf_control = Control;
/* Init p_sys field */
- p_sys->b_meta = VLC_TRUE;
- p_sys->b_dvb_control = VLC_TRUE;
+ p_sys->b_meta = true;
+ p_sys->b_dvb_control = true;
p_sys->i_dvb_program = 0;
- p_sys->i_dvb_start = 0;;
+ p_sys->i_dvb_start = 0;
p_sys->i_dvb_length = 0;
for( i = 0; i < 8192; i++ )
ts_pid_t *pid = &p_sys->pid[i];
pid->i_pid = i;
- pid->b_seen = VLC_FALSE;
- pid->b_valid = VLC_FALSE;
+ pid->b_seen = false;
+ pid->b_valid = false;
}
/* PID 8191 is padding */
- p_sys->pid[8191].b_seen = VLC_TRUE;
+ p_sys->pid[8191].b_seen = true;
p_sys->i_packet_size = i_packet_size;
- p_sys->b_udp_out = VLC_FALSE;
+ p_sys->b_udp_out = false;
p_sys->i_ts_read = 50;
p_sys->csa = NULL;
/* Init PAT handler */
pat = &p_sys->pid[0];
- PIDInit( pat, VLC_TRUE, NULL );
+ PIDInit( pat, true, NULL );
pat->psi->handle = dvbpsi_AttachPAT( (dvbpsi_pat_callback)PATCallBack,
p_demux );
#ifdef TS_USE_DVB_SI
ts_pid_t *sdt = &p_sys->pid[0x11];
ts_pid_t *eit = &p_sys->pid[0x12];
- PIDInit( sdt, VLC_TRUE, NULL );
+ PIDInit( sdt, true, NULL );
sdt->psi->handle =
dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack,
p_demux );
- PIDInit( eit, VLC_TRUE, NULL );
+ PIDInit( eit, true, NULL );
eit->psi->handle =
dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack,
p_demux );
if( p_sys->b_dvb_control )
{
if( stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
- ACCESS_SET_PRIVATE_ID_STATE, 0x11, VLC_TRUE ) ||
+ ACCESS_SET_PRIVATE_ID_STATE, 0x11, true ) ||
stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
- ACCESS_SET_PRIVATE_ID_STATE, 0x12, VLC_TRUE ) )
- p_sys->b_dvb_control = VLC_FALSE;
+ ACCESS_SET_PRIVATE_ID_STATE, 0x12, true ) )
+ p_sys->b_dvb_control = false;
}
}
#endif
char *psz = strchr( val.psz_string, ':' );
int i_port = 0;
- p_sys->b_udp_out = VLC_TRUE;
+ p_sys->b_udp_out = true;
if( psz )
{
if( p_sys->fd < 0 )
{
msg_Err( p_demux, "failed to open udp socket, send disabled" );
- p_sys->b_udp_out = VLC_FALSE;
+ p_sys->b_udp_out = false;
}
else
{
p_sys->buffer = malloc( p_sys->i_packet_size * p_sys->i_ts_read );
}
}
- if( val.psz_string )
- {
- free( val.psz_string );
- }
+ free( val.psz_string );
/* We handle description of an extra PMT */
var_Create( p_demux, "ts-extra-pmt", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
ts_prg_psi_t *prg;
msg_Dbg( p_demux, "extra pmt specified (pid=%d)", i_pid );
- PIDInit( pmt, VLC_TRUE, NULL );
+ PIDInit( pmt, true, NULL );
/* Dummy PMT */
prg = malloc( sizeof( ts_prg_psi_t ) );
+ if( !prg )
+ {
+ msg_Err( p_demux, "out of memory" );
+ Close( VLC_OBJECT(p_demux) );
+ return VLC_ENOMEM;
+ }
+
memset( prg, 0, sizeof( ts_prg_psi_t ) );
prg->i_pid_pcr = -1;
prg->i_pid_pmt = -1;
{
ts_pid_t *pid = &p_sys->pid[i_pid];
- PIDInit( pid, VLC_FALSE, pmt->psi);
+ PIDInit( pid, false, pmt->psi);
if( pmt->psi->prg[0]->i_pid_pcr <= 0 )
{
pmt->psi->prg[0]->i_pid_pcr = i_pid;
}
}
}
- if( val.psz_string )
- {
- free( val.psz_string );
- }
+ free( val.psz_string );
var_Create( p_demux, "ts-csa-ck", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Get( p_demux, "ts-csa-ck", &val );
}
}
}
- if( val.psz_string )
- {
- free( val.psz_string );
- }
+ free( val.psz_string );
var_Create( p_demux, "ts-silent", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
var_Get( p_demux, "ts-silent", &val );
/* too much */
stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE, pid->i_pid,
- VLC_FALSE );
+ false );
}
}
while( i_pos < i_data )
{
ts_pid_t *p_pid; /* point to a PID structure */
- vlc_bool_t b_payload; /* indicates a packet with payload */
- vlc_bool_t b_adaptation; /* adaptation field */
+ bool b_payload; /* indicates a packet with payload */
+ bool b_adaptation; /* adaptation field */
int i_cc = 0; /* continuity counter */
if( p_sys->buffer[i_pos] != 0x47 )
/* We read at most 100 TS packet or until a frame is completed */
for( i_pkt = 0; i_pkt < p_sys->i_ts_read; i_pkt++ )
{
- vlc_bool_t b_frame = VLC_FALSE;
+ bool b_frame = false;
block_t *p_pkt;
ts_pid_t *p_pid;
while( !p_demux->b_die )
{
- uint8_t *p_peek;
+ const uint8_t *p_peek;
int i_peek, i_skip = 0;
i_peek = stream_Peek( p_demux->s, &p_peek,
PCRHandle( p_demux, p_pid, p_pkt );
block_Release( p_pkt );
}
- p_pid->b_seen = VLC_TRUE;
+ p_pid->b_seen = true;
if( b_frame )
{
{
stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE, i_pmt_pid,
- VLC_FALSE );
+ false );
/* All ES */
for( i = 2; i < 8192; i++ )
{
stream_Control( p_demux->s,
STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE,
- i, VLC_FALSE );
+ i, false );
break;
}
}
{
stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE, i_pmt_pid,
- VLC_TRUE );
+ true );
stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE, p_prg->i_pid_pcr,
- VLC_TRUE );
+ true );
for( i = 2; i < 8192; i++ )
{
stream_Control( p_demux->s,
STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE,
- i, VLC_TRUE );
+ i, true );
break;
}
}
}
}
-static void PIDInit( ts_pid_t *pid, vlc_bool_t b_psi, ts_psi_t *p_owner )
+static void PIDInit( ts_pid_t *pid, bool b_psi, ts_psi_t *p_owner )
{
- vlc_bool_t b_old_valid = pid->b_valid;
+ bool b_old_valid = pid->b_valid;
- pid->b_valid = VLC_TRUE;
+ pid->b_valid = true;
pid->i_cc = 0xff;
pid->p_owner = p_owner;
pid->i_owner_number = 0;
if( !b_old_valid )
{
+ free( pid->psi );
pid->psi = malloc( sizeof( ts_psi_t ) );
- pid->psi->handle= NULL;
- pid->psi->i_prg = 0;
- pid->psi->prg = NULL;
+ if( pid->psi )
+ {
+ pid->psi->handle= NULL;
+ pid->psi->i_prg = 0;
+ pid->psi->prg = NULL;
+ }
}
pid->psi->i_pat_version = -1;
pid->psi->i_sdt_version = -1;
if( p_owner )
{
ts_prg_psi_t *prg = malloc( sizeof( ts_prg_psi_t ) );
- /* PMT */
- prg->i_version = -1;
- prg->i_number = -1;
- prg->i_pid_pcr = -1;
- prg->i_pid_pmt = -1;
- prg->iod = NULL;
- prg->handle = NULL;
-
- TAB_APPEND( pid->psi->i_prg, pid->psi->prg, prg );
+ if( prg )
+ {
+ /* PMT */
+ prg->i_version = -1;
+ prg->i_number = -1;
+ prg->i_pid_pcr = -1;
+ prg->i_pid_pmt = -1;
+ prg->iod = NULL;
+ prg->handle = NULL;
+
+ TAB_APPEND( pid->psi->i_prg, pid->psi->prg, prg );
+ }
}
}
else
{
pid->psi = NULL;
pid->es = malloc( sizeof( ts_es_t ) );
-
- es_format_Init( &pid->es->fmt, UNKNOWN_ES, 0 );
- pid->es->id = NULL;
- pid->es->p_pes = NULL;
- pid->es->i_pes_size= 0;
- pid->es->i_pes_gathered= 0;
- pid->es->pp_last = &pid->es->p_pes;
- pid->es->p_mpeg4desc = NULL;
- pid->es->b_gather = VLC_FALSE;
+ if( pid->es )
+ {
+ es_format_Init( &pid->es->fmt, UNKNOWN_ES, 0 );
+ pid->es->id = NULL;
+ pid->es->p_pes = NULL;
+ pid->es->i_pes_size= 0;
+ pid->es->i_pes_gathered= 0;
+ pid->es->pp_last = &pid->es->p_pes;
+ pid->es->p_mpeg4desc = NULL;
+ pid->es->b_gather = false;
+ }
}
}
dvbpsi_DetachPMT( pid->psi->prg[i]->handle );
free( pid->psi->prg[i] );
}
- if( pid->psi->prg ) free( pid->psi->prg );
+ free( pid->psi->prg );
free( pid->psi );
}
else
if( pid->i_extra_es ) free( pid->extra_es );
}
- pid->b_valid = VLC_FALSE;
+ pid->b_valid = false;
}
/****************************************************************************
/* */
i_skip += 2;
}
+#ifdef ZVBI_COMPILED
else if( pid->es->fmt.i_codec == VLC_FOURCC( 't', 'e', 'l', 'x' ) )
- i_skip = 0; /* FIXME hack for zvbi support, breaks telx decoder */
-
+ i_skip = 0; /*hack for zvbi support */
+#endif
/* skip header */
while( p_pes && i_skip > 0 )
{
}
}
-static vlc_bool_t GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
+static bool GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
{
const uint8_t *p = p_bk->p_buffer;
- const vlc_bool_t b_unit_start = p[1]&0x40;
- const vlc_bool_t b_adaptation = p[3]&0x20;
- const vlc_bool_t b_payload = p[3]&0x10;
+ const bool b_unit_start = p[1]&0x40;
+ const bool b_adaptation = p[3]&0x20;
+ const bool b_payload = p[3]&0x10;
const int i_cc = p[3]&0x0f; /* continuity counter */
- vlc_bool_t b_discontinuity = VLC_FALSE;/* discontinuity */
+ bool b_discontinuity = false;/* discontinuity */
/* transport_scrambling_control is ignored */
int i_skip = 0;
- vlc_bool_t i_ret = VLC_FALSE;
+ bool i_ret = false;
int i_diff;
#if 0
if( p[4] > 0 )
{
/* discontinuity indicator found in stream */
- b_discontinuity = (p[5]&0x80) ? VLC_TRUE : VLC_FALSE;
+ b_discontinuity = (p[5]&0x80) ? true : false;
if( b_discontinuity && pid->es->p_pes )
{
msg_Warn( p_demux, "discontinuity indicator (pid=%d) ",
if( pid->es->p_pes )
{
ParsePES( p_demux, pid );
- i_ret = VLC_TRUE;
+ i_ret = true;
}
block_ChainLastAppend( &pid->es->pp_last, p_bk );
pid->es->i_pes_gathered >= pid->es->i_pes_size )
{
ParsePES( p_demux, pid );
- i_ret = VLC_TRUE;
+ i_ret = true;
}
}
else
pid->es->i_pes_gathered >= pid->es->i_pes_size )
{
ParsePES( p_demux, pid );
- i_ret = VLC_TRUE;
+ i_ret = true;
}
}
}
break;
case 0x10: /* MPEG4 (video) */
es_format_Init( fmt, VIDEO_ES, VLC_FOURCC( 'm', 'p', '4', 'v' ) );
- pid->es->b_gather = VLC_TRUE;
+ pid->es->b_gather = true;
break;
case 0x1B: /* H264 <- check transport syntax/needed descriptor */
es_format_Init( fmt, VIDEO_ES, VLC_FOURCC( 'h', '2', '6', '4' ) );
case 0xa0: /* MSCODEC vlc (video) (fixed later) */
es_format_Init( fmt, UNKNOWN_ES, 0 );
- pid->es->b_gather = VLC_TRUE;
+ pid->es->b_gather = true;
break;
case 0x06: /* PES_PRIVATE (fixed later) */
}
/* PES packets usually contain truncated frames */
- fmt->b_packetized = VLC_FALSE;
+ fmt->b_packetized = false;
return fmt->i_cat == UNKNOWN_ES ? VLC_EGENERIC : VLC_SUCCESS ;
}
i_url_len = IODGetByte( pi_data, pp_data );
url = malloc( i_url_len + 1 );
+ if( !url ) return NULL;
for( i = 0; i < i_url_len; i++ )
{
url[i] = IODGetByte( pi_data, pp_data );
int i;
int i_es_index;
uint8_t i_flags, i_iod_tag, byte1, byte2, byte3;
- vlc_bool_t b_url;
+ bool b_url;
int i_iod_length;
p_iod = malloc( sizeof( iod_descriptor_t ) );
+ if( !p_iod ) return NULL;
memset( p_iod, 0, sizeof( iod_descriptor_t ) );
#ifdef TS_DEBUG
}
else
{
- if( es_descr.dec_descr.p_decoder_specific_info != NULL )
- {
- free( es_descr.dec_descr.p_decoder_specific_info );
- es_descr.dec_descr.p_decoder_specific_info = NULL;
- es_descr.dec_descr.i_decoder_specific_info_len = 0;
- }
+ free( es_descr.dec_descr.p_decoder_specific_info );
+ es_descr.dec_descr.p_decoder_specific_info = NULL;
+ es_descr.dec_descr.i_decoder_specific_info_len = 0;
}
}
es_descr.b_ok = 0;
** libdvbpsi callbacks
****************************************************************************
****************************************************************************/
-static vlc_bool_t DVBProgramIsSelected( demux_t *p_demux, uint16_t i_pgrm )
+static bool DVBProgramIsSelected( demux_t *p_demux, uint16_t i_pgrm )
{
demux_sys_t *p_sys = p_demux->p_sys;
- if ( !p_sys->b_dvb_control ) return VLC_FALSE;
+ if ( !p_sys->b_dvb_control ) return false;
if ( (p_sys->i_dvb_program == -1 && p_sys->p_programs_list == NULL)
|| p_sys->i_dvb_program == 0 )
- return VLC_TRUE;
- if ( p_sys->i_dvb_program == i_pgrm ) return VLC_TRUE;
+ return true;
+ if ( p_sys->i_dvb_program == i_pgrm ) return true;
if ( p_sys->p_programs_list != NULL )
{
for ( i = 0; i < p_sys->p_programs_list->i_count; i++ )
{
if ( i_pgrm == p_sys->p_programs_list->p_values[i].i_int )
- return VLC_TRUE;
+ return true;
}
}
- return VLC_FALSE;
+ return false;
}
#ifdef TS_USE_DVB_SI
const int c = ( mp == 14 || mp == 15 ) ? 1 : 0;
*p_y = 1900 + yp + c*1;
- *p_m = mp - 1 + c*12;
+ *p_m = mp - 1 - c*12;
*p_d = i_mjd - 14956 - (int)(yp*365.25) - (int)(mp*30.6001);
}
#define CVT_FROM_BCD(v) ((((v) >> 4)&0xf)*10 + ((v)&0xf))
}
static int EITConvertDuration( uint32_t i_duration )
{
- return CVT_FROM_BCD(i_duration >> 16) * 3600 +
+ return CVT_FROM_BCD(i_duration >> 16) * 3600 +
CVT_FROM_BCD(i_duration >> 8 ) * 60 +
CVT_FROM_BCD(i_duration );
}
#undef CVT_FROM_BCD
-static inline char *FixUTF8( char *p )
-{
- EnsureUTF8( p );
- return p;
-}
/* FIXME same than dvbsi_to_utf8 from dvb access */
-static char *EITConvertToUTF8( unsigned char *psz_instring, size_t i_length )
+static char *EITConvertToUTF8( const unsigned char *psz_instring,
+ size_t i_length )
{
const char *psz_encoding;
- const unsigned char *psz_stringstart, *psz_outstring;
- char *psz_tmp;
- char psz_encbuf[12];
- size_t i_in, i_out;
+ char *psz_outstring;
+ char psz_encbuf[sizeof( "ISO_8859-123" )];
+ size_t i_in, i_out, offset = 1;
vlc_iconv_t iconv_handle;
+
if( i_length < 1 ) return NULL;
if( psz_instring[0] >= 0x20 )
{
- psz_stringstart = psz_instring;
- psz_encoding = "ISO_8859-1"; /* should be ISO6937 according to spec, but this seems to be the one used */
+ psz_encoding = "ISO_8859-1";
+ /* According to the specification, this should be ISO6937,
+ * but it seems Latin-1 is used instead. */
+ offset = 0;
}
else switch( psz_instring[0] )
{
case 0x01:
- psz_stringstart = &psz_instring[1];
psz_encoding = "ISO_8859-5";
break;
case 0x02:
- psz_stringstart = &psz_instring[1];
psz_encoding = "ISO_8859-6";
break;
case 0x03:
- psz_stringstart = &psz_instring[1];
psz_encoding = "ISO_8859-7";
break;
case 0x04:
- psz_stringstart = &psz_instring[1];
psz_encoding = "ISO_8859-8";
break;
case 0x05:
- psz_stringstart = &psz_instring[1];
psz_encoding = "ISO_8859-9";
break;
case 0x06:
- psz_stringstart = &psz_instring[1];
psz_encoding = "ISO_8859-10";
break;
case 0x07:
- psz_stringstart = &psz_instring[1];
psz_encoding = "ISO_8859-11";
break;
case 0x08:
- psz_stringstart = &psz_instring[1]; /*possibly reserved?*/
psz_encoding = "ISO_8859-12";
break;
case 0x09:
- psz_stringstart = &psz_instring[1];
psz_encoding = "ISO_8859-13";
break;
case 0x0a:
- psz_stringstart = &psz_instring[1];
psz_encoding = "ISO_8859-14";
break;
case 0x0b:
- psz_stringstart = &psz_instring[1];
psz_encoding = "ISO_8859-15";
break;
case 0x10:
- if( i_length < 3 || psz_instring[1] != '\0' || psz_instring[2] > 0x0f
- || psz_instring[2] == 0 )
- return FixUTF8(strndup(psz_instring,i_length));
- sprintf( psz_encbuf, "ISO_8859-%d", psz_instring[2] );
- psz_stringstart = &psz_instring[3];
- psz_encoding = psz_encbuf;
+#warning Is Latin-10 (psz_instring[2] == 16) really illegal?
+ if( i_length < 3 || psz_instring[1] != 0x00 || psz_instring[2] > 15
+ || psz_instring[2] == 0 )
+ {
+ psz_encoding = "UTF-8";
+ offset = 0;
+ }
+ else
+ {
+ sprintf( psz_encbuf, "ISO_8859-%u", psz_instring[2] );
+ psz_encoding = psz_encbuf;
+ offset = 3;
+ }
break;
case 0x11:
- psz_stringstart = &psz_instring[1];
+#warning Is there a BOM or do we use a fixed endianess?
psz_encoding = "UTF-16";
break;
case 0x12:
- psz_stringstart = &psz_instring[1];
psz_encoding = "KSC5601-1987";
break;
case 0x13:
- psz_stringstart = &psz_instring[1];
- psz_encoding = "GB2312";/*GB-2312-1980 */
+ psz_encoding = "GB2312"; /* GB-2312-1980 */
break;
case 0x14:
- psz_stringstart = &psz_instring[1];
psz_encoding = "BIG-5";
break;
case 0x15:
- return FixUTF8(strndup(&psz_instring[1],i_length-1));
+ psz_encoding = "UTF-8";
break;
default:
/* invalid */
- return FixUTF8(strndup(psz_instring,i_length));
+ psz_encoding = "UTF-8";
+ offset = 0;
+ }
+
+ i_in = i_length - offset;
+ i_out = i_in * 6 + 1;
+
+ psz_outstring = malloc( i_out );
+ if( !psz_outstring )
+ {
+ return NULL;
}
+
iconv_handle = vlc_iconv_open( "UTF-8", psz_encoding );
- i_in = i_length - (psz_stringstart - psz_instring );
- i_out = i_in * 6;
- psz_outstring = psz_tmp = (char*)malloc( i_out * sizeof(char) + 1 );
- vlc_iconv( iconv_handle, &psz_stringstart, &i_in, &psz_tmp, &i_out );
- vlc_iconv_close( iconv_handle );
- *psz_tmp = '\0';
+ if( iconv_handle == (vlc_iconv_t)(-1) )
+ {
+ /* Invalid character set (e.g. ISO_8859-12) */
+ memcpy( psz_outstring, &psz_instring[offset], i_in );
+ psz_outstring[i_in] = '\0';
+ EnsureUTF8( psz_outstring );
+ }
+ else
+ {
+ const char *psz_in = (const char *)&psz_instring[offset];
+ char *psz_out = psz_outstring;
+
+ while( vlc_iconv( iconv_handle, &psz_in, &i_in,
+ &psz_out, &i_out ) == (size_t)(-1) )
+ {
+ /* skip naughty byte. This may fail terribly for multibyte stuff,
+ * but what can we do anyway? */
+ psz_in++;
+ i_in--;
+ vlc_iconv( iconv_handle, NULL, NULL, NULL, NULL ); /* reset */
+ }
+ vlc_iconv_close( iconv_handle );
+
+ *psz_out = '\0';
+ }
return psz_outstring;
}
strcat( psz_extra, psz_itm );
strcat( psz_extra, ")" );
}
- if( psz_dsc )
- free( psz_dsc );
- if( psz_itm )
- free( psz_itm );
+ free( psz_dsc );
+ free( psz_itm );
}
}
}
if( p_evt->i_running_status == 0x04 && i_start > 0 )
vlc_epg_SetCurrent( p_epg, i_start );
- if( psz_name )
- free( psz_name );
- if( psz_text )
- free( psz_text );
+ free( psz_name );
+ free( psz_text );
free( psz_extra );
}
/* Set demux filter */
stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE, prg->i_pid_pcr,
- VLC_TRUE );
+ true );
}
else if ( p_sys->b_dvb_control )
{
}
}
- PIDInit( pid, VLC_FALSE, pmt->psi );
+ PIDInit( pid, false, pmt->psi );
PIDFillFormat( pid, p_es->i_type );
pid->i_owner_number = prg->i_number;
pid->i_pid = p_es->i_pid;
pid->b_seen = p_sys->pid[p_es->i_pid].b_seen;
if( p_es->i_type == 0x10 || p_es->i_type == 0x11 ||
- p_es->i_type == 0x12 )
+ p_es->i_type == 0x12 || p_es->i_type == 0x0f )
{
/* MPEG-4 stream: search SL_DESCRIPTOR */
dvbpsi_descriptor_t *p_dr = p_es->p_first_descriptor;;
if( pid->es->fmt.i_extra > 0 )
{
pid->es->fmt.p_extra = malloc( pid->es->fmt.i_extra );
- memcpy( pid->es->fmt.p_extra,
- dcd->p_decoder_specific_info,
- pid->es->fmt.i_extra );
+ if( pid->es->fmt.p_extra )
+ memcpy( pid->es->fmt.p_extra,
+ dcd->p_decoder_specific_info,
+ pid->es->fmt.i_extra );
}
}
}
pid->es->fmt.i_codec = VLC_FOURCC( 't', 'e', 'l', 'x' );
pid->es->fmt.i_extra = p_dr->i_length;
pid->es->fmt.p_extra = malloc( p_dr->i_length );
- memcpy( pid->es->fmt.p_extra, p_dr->p_data,
- p_dr->i_length );
+ if( pid->es->fmt.p_extra )
+ memcpy( pid->es->fmt.p_extra, p_dr->p_data,
+ p_dr->i_length );
#if defined _DVBPSI_DR_56_H_ && defined DVBPSI_VERSION \
&& DVBPSI_VERSION_INT > ((0<<16)+(1<<8)+5)
for( n = 0; n < sub->i_pages_number; n++ )
{
dvbpsi_teletextpage_t *p_page = &sub->p_pages[n];
- if( p_page->i_teletext_type == 0x2
- || p_page->i_teletext_type == 0x5 )
+ if( (p_page->i_teletext_type == 0x2)
+ || (p_page->i_teletext_type == 0x5) )
{
ts_es_t *p_es;
else
{
p_es = malloc( sizeof( ts_es_t ) );
+ if( !p_es ) break;
es_format_Copy( &p_es->fmt, &pid->es->fmt );
- free( p_es->fmt.psz_language ); p_es->fmt.psz_language = NULL;
- free( p_es->fmt.psz_description ); p_es->fmt.psz_description = NULL;
-
+ free( p_es->fmt.psz_language );
+ free( p_es->fmt.psz_description );
+ p_es->fmt.psz_language = NULL;
+ p_es->fmt.psz_description = NULL;
p_es->id = NULL;
p_es->p_pes = NULL;
p_es->i_pes_size = 0;
}
p_es->fmt.psz_language = malloc( 4 );
- memcpy( p_es->fmt.psz_language,
- p_page->i_iso6392_language_code, 3 );
- p_es->fmt.psz_language[3] = 0;
-
+ if( p_es->fmt.psz_language )
+ {
+ memcpy( p_es->fmt.psz_language,
+ p_page->i_iso6392_language_code, 3 );
+ p_es->fmt.psz_language[3] = 0;
+ }
switch( p_page->i_teletext_type )
{
case 0x2:
pid->es->fmt.i_codec = VLC_FOURCC( 'd', 'v', 'b', 's' );
pid->es->fmt.i_extra = p_dr->i_length;
pid->es->fmt.p_extra = malloc( p_dr->i_length );
- memcpy( pid->es->fmt.p_extra, p_dr->p_data,
- p_dr->i_length );
+ if( pid->es->fmt.p_extra )
+ memcpy( pid->es->fmt.p_extra, p_dr->p_data,
+ p_dr->i_length );
#ifdef _DVBPSI_DR_59_H_
pid->es->fmt.i_group = p_pmt->i_program_number;
else
{
p_es = malloc( sizeof( ts_es_t ) );
-
+ if( !p_es ) break;
es_format_Copy( &p_es->fmt, &pid->es->fmt );
free( p_es->fmt.psz_language ); p_es->fmt.psz_language = NULL;
free( p_es->fmt.psz_description ); p_es->fmt.psz_description = NULL;
}
p_es->fmt.psz_language = malloc( 4 );
- memcpy( p_es->fmt.psz_language,
- p_sub->i_iso6392_language_code, 3 );
- p_es->fmt.psz_language[3] = 0;
+ if( p_es->fmt.psz_language )
+ {
+ memcpy( p_es->fmt.psz_language,
+ p_sub->i_iso6392_language_code, 3 );
+ p_es->fmt.psz_language[3] = 0;
+ }
switch( p_sub->i_subtitling_type )
{
( p_dr->p_data[4] << 8 ) | p_dr->p_data[5];
pid->es->fmt.video.i_height =
( p_dr->p_data[6] << 8 ) | p_dr->p_data[7];
- pid->es->fmt.i_extra =
+ pid->es->fmt.i_extra =
(p_dr->p_data[8] << 8) | p_dr->p_data[9];
if( pid->es->fmt.i_extra > 0 )
{
pid->es->fmt.p_extra = malloc( pid->es->fmt.i_extra );
- memcpy( pid->es->fmt.p_extra, &p_dr->p_data[10],
- pid->es->fmt.i_extra );
+ if( pid->es->fmt.p_extra )
+ memcpy( pid->es->fmt.p_extra, &p_dr->p_data[10],
+ pid->es->fmt.i_extra );
}
}
else
/* For such stream we will gather them ourself and don't launch a
* packetizer.
* Yes it's ugly but it's the only way to have DIV3 working */
- pid->es->fmt.b_packetized = VLC_TRUE;
+ pid->es->fmt.b_packetized = true;
}
if( pid->es->fmt.i_cat == AUDIO_ES ||
{
#if defined(DR_0A_API_VER) && (DR_0A_API_VER >= 2)
pid->es->fmt.psz_language = malloc( 4 );
- memcpy( pid->es->fmt.psz_language,
- p_decoded->code[0].iso_639_code, 3 );
- pid->es->fmt.psz_language[3] = 0;
- msg_Dbg( p_demux, "found language: %s", pid->es->fmt.psz_language);
+ if( pid->es->fmt.psz_language )
+ {
+ memcpy( pid->es->fmt.psz_language,
+ p_decoded->code[0].iso_639_code, 3 );
+ pid->es->fmt.psz_language[3] = 0;
+ msg_Dbg( p_demux, "found language: %s", pid->es->fmt.psz_language);
+ }
switch( p_decoded->code[0].i_audio_type ) {
case 0:
pid->es->fmt.psz_description = NULL;
pid->es->fmt.p_extra_languages =
malloc( sizeof(*pid->es->fmt.p_extra_languages) *
pid->es->fmt.i_extra_languages );
- for( i = 0; i < pid->es->fmt.i_extra_languages; i++ ) {
- msg_Dbg( p_demux, "bang" );
- pid->es->fmt.p_extra_languages[i].psz_language =
- malloc(4);
- memcpy(pid->es->fmt.p_extra_languages[i].psz_language,
- p_decoded->code[i+1].iso_639_code, 3 );
- pid->es->fmt.p_extra_languages[i].psz_language[3] = '\0';
- switch( p_decoded->code[i].i_audio_type ) {
- case 0:
- pid->es->fmt.p_extra_languages[i].psz_description =
- NULL;
- break;
- case 1:
- pid->es->fmt.p_extra_languages[i].psz_description =
- strdup(_("clean effects"));
- break;
- case 2:
- pid->es->fmt.p_extra_languages[i].psz_description =
- strdup(_("hearing impaired"));
- break;
- case 3:
- pid->es->fmt.p_extra_languages[i].psz_description =
- strdup(_("visual impaired commentary"));
- break;
- default:
- msg_Dbg( p_demux, "unknown audio type: %d",
- p_decoded->code[i].i_audio_type);
- pid->es->fmt.psz_description = NULL;
- break;
- }
+ if( pid->es->fmt.p_extra_languages )
+ {
+ for( i = 0; i < pid->es->fmt.i_extra_languages; i++ )
+ {
+ msg_Dbg( p_demux, "bang" );
+ pid->es->fmt.p_extra_languages[i].psz_language =
+ malloc(4);
+ if( pid->es->fmt.p_extra_languages[i].psz_language )
+ {
+ memcpy( pid->es->fmt.p_extra_languages[i].psz_language,
+ p_decoded->code[i+1].iso_639_code, 3 );
+ pid->es->fmt.p_extra_languages[i].psz_language[3] = '\0';
+ }
+ switch( p_decoded->code[i].i_audio_type ) {
+ case 0:
+ pid->es->fmt.p_extra_languages[i].psz_description =
+ NULL;
+ break;
+ case 1:
+ pid->es->fmt.p_extra_languages[i].psz_description =
+ strdup(_("clean effects"));
+ break;
+ case 2:
+ pid->es->fmt.p_extra_languages[i].psz_description =
+ strdup(_("hearing impaired"));
+ break;
+ case 3:
+ pid->es->fmt.p_extra_languages[i].psz_description =
+ strdup(_("visual impaired commentary"));
+ break;
+ default:
+ msg_Dbg( p_demux, "unknown audio type: %d",
+ p_decoded->code[i].i_audio_type);
+ pid->es->fmt.psz_description = NULL;
+ break;
+ }
+ }
}
#else
pid->es->fmt.psz_language = malloc( 4 );
- memcpy( pid->es->fmt.psz_language,
- p_decoded->i_iso_639_code, 3 );
- pid->es->fmt.psz_language[3] = 0;
+ if( pid->es->fmt.psz_language )
+ {
+ memcpy( pid->es->fmt.psz_language,
+ p_decoded->i_iso_639_code, 3 );
+ pid->es->fmt.psz_language[3] = 0;
+ }
#endif
}
}
/* Set demux filter */
stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE, p_es->i_pid,
- VLC_TRUE );
+ true );
}
}
{
stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE, pp_clean[i]->i_pid,
- VLC_FALSE );
+ false );
}
PIDClean( p_demux->out, pp_clean[i] );
for( i = 0; i < p_sys->i_pmt; i++ )
{
ts_pid_t *pmt = p_sys->pmt[i];
- vlc_bool_t b_keep = VLC_FALSE;
+ bool b_keep = false;
for( p_program = p_pat->p_first_program; p_program != NULL;
p_program = p_program->p_next )
if( p_program->i_number ==
pmt->psi->prg[i_prg]->i_number )
{
- b_keep = VLC_TRUE;
+ b_keep = true;
break;
}
}
{
if( stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE, i,
- VLC_FALSE ) )
- p_sys->b_dvb_control = VLC_FALSE;
+ false ) )
+ p_sys->b_dvb_control = false;
}
PIDClean( p_demux->out, pid );
{
if( stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE,
- pmt_rm[i]->i_pid, VLC_FALSE ) )
- p_sys->b_dvb_control = VLC_FALSE;
+ pmt_rm[i]->i_pid, false ) )
+ p_sys->b_dvb_control = false;
}
for( i_prg = 0; i_prg < pmt_rm[i]->psi->i_prg; i_prg++ )
TAB_REMOVE( p_sys->i_pmt, p_sys->pmt, pmt_rm[i] );
}
- if( pmt_rm ) free( pmt_rm );
+ free( pmt_rm );
}
/* now create programs */
if( p_program->i_number != 0 )
{
ts_pid_t *pmt = &p_sys->pid[p_program->i_pid];
- vlc_bool_t b_add = VLC_TRUE;
+ bool b_add = true;
if( pmt->b_valid )
{
{
if( pmt->psi->prg[i_prg]->i_number == p_program->i_number )
{
- b_add = VLC_FALSE;
+ b_add = false;
break;
}
}
if( b_add )
{
- PIDInit( pmt, VLC_TRUE, pat->psi );
+ PIDInit( pmt, true, pat->psi );
pmt->psi->prg[pmt->psi->i_prg-1]->handle =
dvbpsi_AttachPMT( p_program->i_number,
(dvbpsi_pmt_callback)PMTCallBack,
if( stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
ACCESS_SET_PRIVATE_ID_STATE,
- p_program->i_pid, VLC_TRUE ) )
- p_sys->b_dvb_control = VLC_FALSE;
+ p_program->i_pid, true ) )
+ p_sys->b_dvb_control = false;
}
}
}