* ts.c: Transport Stream input module for VLC.
*****************************************************************************
* Copyright (C) 2004 VideoLAN
- * $Id: ts.c,v 1.8 2004/01/25 20:05:28 hartman Exp $
+ * $Id$
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
/*****************************************************************************
* Module descriptor
*****************************************************************************/
-static int Open ( vlc_object_t * );
-static void Close ( vlc_object_t * );
+static int Open ( vlc_object_t * );
+static void Close ( vlc_object_t * );
vlc_module_begin();
set_description( _("ISO 13818-1 MPEG Transport Stream input - new" ) );
add_string( "ts-out", NULL, NULL, "fast udp streaming", "send TS to specific ip:port by udp (you must know what you are doing)", VLC_TRUE );
add_integer( "ts-out-mtu", 1500, NULL, "MTU for out mode", "MTU for out mode", VLC_TRUE );
add_string( "ts-csa-ck", NULL, NULL, "CSA ck", "CSA ck", VLC_TRUE );
+ add_bool( "ts-silent", 0, NULL, "Silent mode", "do not complain on encrypted PES", VLC_TRUE );
set_capability( "demux2", 10 );
set_callbacks( Open, Close );
- add_shortcut( "ts2" );
+ add_shortcut( "ts" );
vlc_module_end();
/*****************************************************************************
typedef struct
{
+ dvbpsi_handle handle;
+
int i_version;
int i_number;
int i_pid_pcr;
- dvbpsi_handle handle;
-
/* IOD stuff (mpeg4) */
iod_descriptor_t *iod;
+} ts_prg_psi_t;
+typedef struct
+{
+ /* for special PAT case */
+ dvbpsi_handle handle;
+ int i_pat_version;
+
+ /* For PMT */
+ int i_prg;
+ ts_prg_psi_t **prg;
} ts_psi_t;
typedef struct
{
es_format_t fmt;
es_out_id_t *id;
+ int i_pes_size;
+ int i_pes_gathered;
block_t *p_pes;
+ block_t **pp_last;
es_mpeg4_descriptor_t *p_mpeg4desc;
+ int b_gather;
} ts_es_t;
typedef struct
/* PSI owner (ie PMT -> PAT, ES -> PMT */
ts_psi_t *p_owner;
+ int i_owner_number;
/* */
ts_psi_t *psi;
ts_es_t *es;
+ /* Some private streams encapsulate several ES (eg. DVB subtitles)*/
+ ts_es_t **extra_es;
+ int i_extra_es;
+
} ts_pid_t;
struct demux_sys_t
/* */
vlc_bool_t b_es_id_pid;
csa_t *csa;
+ vlc_bool_t b_silent;
vlc_bool_t b_udp_out;
int fd; /* udp socket */
}
static vlc_bool_t GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk );
-static char *LanguageNameISO639( char *p );
+
+static void PCRHandle( demux_t *p_demux, ts_pid_t *, block_t * );
static iod_descriptor_t *IODNew( int , uint8_t * );
static void IODFree( iod_descriptor_t * );
uint8_t *p_peek;
int i_peek;
+ int i_sync;
int i;
ts_pid_t *pat;
msg_Err( p_demux, "cannot peek" );
return VLC_EGENERIC;
}
- if( p_peek[0] != 0x47 || ( i_peek >= 189 && p_peek[188] != 0x47 ) )
+
+ /* Search first synch */
+ for( i_sync = 0; i_sync < i_peek; i_sync++ )
+ {
+ if( p_peek[i_sync] == 0x47 ) break;
+ }
+ if( i_sync >= i_peek )
{
if( strcmp( p_demux->psz_demux, "ts" ) )
{
}
msg_Warn( p_demux, "this does not look like a TS stream, continuing" );
}
+ if( strcmp( p_demux->psz_demux, "ts" ) )
+ {
+ /* Check next 3 sync points */
+ i_peek = 188*3 + 1 + i_sync;
+ if( ( stream_Peek( p_demux->s, &p_peek, i_peek ) ) < i_peek )
+ {
+ msg_Err( p_demux, "cannot peek" );
+ return VLC_EGENERIC;
+ }
+ if( p_peek[i_sync+ 188] != 0x47 || p_peek[i_sync+2*188] != 0x47 ||
+ p_peek[i_sync+3*188] != 0x47 )
+ {
+ msg_Warn( p_demux, "TS module discarded (lost sync)" );
+ return VLC_EGENERIC;
+ }
+ }
/* Fill p_demux field */
p_demux->pf_demux = Demux;
/* Init PAT handler */
pat = &p_sys->pid[0];
PIDInit( pat, VLC_TRUE, NULL );
- pat->psi->handle = dvbpsi_AttachPAT( (dvbpsi_pat_callback)PATCallBack, p_demux );
+ pat->psi->handle = dvbpsi_AttachPAT( (dvbpsi_pat_callback)PATCallBack,
+ p_demux );
/* Init PMT array */
p_sys->i_pmt = 0;
}
else
{
- var_Create( p_demux, "ts-out-mtu", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+ var_Create( p_demux, "ts-out-mtu",
+ VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Get( p_demux, "ts-out-mtu", &mtu );
p_sys->i_ts_read = mtu.i_int / 188;
if( p_sys->i_ts_read <= 0 )
msg_Dbg( p_demux, "extra pmt specified (pid=0x%x)", i_pid );
PIDInit( pmt, VLC_TRUE, NULL );
/* FIXME we should also ask for a number */
- pmt->psi->handle = dvbpsi_AttachPMT( 1, (dvbpsi_pmt_callback)PMTCallBack, p_demux );
- pmt->psi->i_number = 0; /* special one */
+ pmt->psi->prg[0]->handle =
+ dvbpsi_AttachPMT( 1, (dvbpsi_pmt_callback)PMTCallBack,
+ p_demux );
+ pmt->psi->prg[0]->i_number = 0; /* special one */
psz = strchr( psz, '=' ) + 1; /* can't failed */
while( psz && *psz )
if( *psz == ':' )
{
i_stream_type = strtol( psz + 1, &psz, 0 );
- if( i_pid >= 2 && i_pid < 8192 && !p_sys->pid[i_pid].b_valid )
+ if( i_pid >= 2 && i_pid < 8192 &&
+ !p_sys->pid[i_pid].b_valid )
{
ts_pid_t *pid = &p_sys->pid[i_pid];
PIDInit( pid, VLC_FALSE, pmt->psi);
- if( pmt->psi->i_pid_pcr <= 0 )
+ if( pmt->psi->prg[0]->i_pid_pcr <= 0 )
{
- pmt->psi->i_pid_pcr = i_pid;
+ pmt->psi->prg[0]->i_pid_pcr = i_pid;
}
PIDFillFormat( pid, i_stream_type);
if( pid->es->fmt.i_cat != UNKNOWN_ES )
{
pid->es->fmt.i_id = i_pid;
}
- msg_Dbg( p_demux, " * es pid=0x%x type=0x%x fcc=%4.4s", i_pid, i_stream_type, (char*)&pid->es->fmt.i_codec );
- pid->es->id = es_out_Add( p_demux->out, &pid->es->fmt );
+ msg_Dbg( p_demux, " * es pid=0x%x type=0x%x "
+ "fcc=%4.4s", i_pid, i_stream_type,
+ (char*)&pid->es->fmt.i_codec );
+ pid->es->id = es_out_Add( p_demux->out,
+ &pid->es->fmt );
}
}
}
ck[i] = ( i_ck >> ( 56 - 8*i) )&0xff;
}
- msg_Dbg( p_demux, "using CSA scrambling with ck=%x:%x:%x:%x:%x:%x:%x:%x",
+ msg_Dbg( p_demux, "using CSA scrambling with "
+ "ck=%x:%x:%x:%x:%x:%x:%x:%x",
ck[0], ck[1], ck[2], ck[3], ck[4], ck[5], ck[6], ck[7] );
p_sys->csa = csa_New();
free( val.psz_string );
}
+ var_Create( p_demux, "ts-silent", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
+ var_Get( p_demux, "ts-silent", &val );
+ p_sys->b_silent = val.b_bool;
return VLC_SUCCESS;
}
{
case 0: /* PAT */
dvbpsi_DetachPAT( pid->psi->handle );
+ free( pid->psi );
break;
case 1: /* CAT */
+ free( pid->psi );
break;
default:
- dvbpsi_DetachPMT( pid->psi->handle );
- if( pid->psi->iod )
- {
- IODFree( pid->psi->iod );
- }
+ PIDClean( p_demux->out, pid );
break;
}
- free( pid->psi );
}
else if( pid->b_valid && pid->es )
{
- if( pid->es->p_pes )
- {
- block_ChainRelease( pid->es->p_pes );
- }
- free( pid->es );
+ PIDClean( p_demux->out, pid );
}
+
if( pid->b_seen )
{
msg_Dbg( p_demux, " - pid[0x%x] seen", pid->i_pid );
csa_Delete( p_sys->csa );
}
+ if( p_sys->i_pmt ) free( p_sys->pmt );
free( p_sys );
}
-
/*****************************************************************************
* Demux:
*****************************************************************************/
{
if( p_pid->psi )
{
- dvbpsi_PushPacket( p_pid->psi->handle, p_pkt->p_buffer );
+ if( p_pid->i_pid == 0 )
+ {
+ dvbpsi_PushPacket( p_pid->psi->handle, p_pkt->p_buffer );
+ }
+ else
+ {
+ int i_prg;
+ for( i_prg = 0; i_prg < p_pid->psi->i_prg; i_prg++ )
+ {
+ dvbpsi_PushPacket( p_pid->psi->prg[i_prg]->handle,
+ p_pkt->p_buffer );
+ }
+ }
block_Release( p_pkt );
}
else if( !p_sys->b_udp_out )
{
msg_Dbg( p_demux, "pid[0x%x] unknown", p_pid->i_pid );
}
+ /* We have to handle PCR if present */
+ PCRHandle( p_demux, p_pid, p_pkt );
block_Release( p_pkt );
}
p_pid->b_seen = VLC_TRUE;
*pi64 = p_sys->i_time;
return VLC_SUCCESS;
-#if 0
case DEMUX_GET_LENGTH:
pi64 = (int64_t*)va_arg( args, int64_t * );
if( p_sys->i_mux_rate > 0 )
{
- *pi64 = (int64_t)1000000 * ( stream_Size( p_demux->s ) / 50 ) / p_sys->i_mux_rate;
+ *pi64 = I64C(1000000) * ( stream_Size( p_demux->s ) / 50 ) /
+ p_sys->i_mux_rate;
return VLC_SUCCESS;
}
*pi64 = 0;
return VLC_EGENERIC;
-
- case DEMUX_SET_TIME:
#endif
case DEMUX_GET_FPS:
- pf = (double*)va_arg( args, double * );
- *pf = (double)1000000.0 / (double)p_sys->i_pcr_inc;
- return VLC_SUCCESS;
-#endif
+ case DEMUX_SET_TIME:
default:
return VLC_EGENERIC;
}
static void PIDInit( ts_pid_t *pid, vlc_bool_t b_psi, ts_psi_t *p_owner )
{
+ vlc_bool_t b_old_valid = pid->b_valid;
+
pid->b_valid = VLC_TRUE;
pid->i_cc = 0xff;
pid->p_owner = p_owner;
+ pid->i_owner_number = 0;
+
+ pid->extra_es = NULL;
+ pid->i_extra_es = 0;
if( b_psi )
{
- pid->psi = malloc( sizeof( ts_psi_t ) );
pid->es = NULL;
- pid->psi->i_version = -1;
- pid->psi->i_number = -1;
- pid->psi->i_pid_pcr = -1;
- pid->psi->handle = NULL;
- pid->psi->iod = NULL;
+ if( !b_old_valid )
+ {
+ pid->psi = malloc( sizeof( ts_psi_t ) );
+ pid->psi->i_prg = 0;
+ pid->psi->prg = NULL;
+ pid->psi->handle= NULL;
+ }
+ pid->psi->i_pat_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->iod = NULL;
+ prg->handle = NULL;
+
+ TAB_APPEND( pid->psi->i_prg, pid->psi->prg, prg );
+ }
}
else
{
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->psi )
{
- if( pid->psi->handle )
- {
- dvbpsi_DetachPMT( pid->psi->handle );
- }
- if( pid->psi->iod )
+ int i;
+
+ if( pid->psi->handle ) dvbpsi_DetachPMT( pid->psi->handle );
+ for( i = 0; i < pid->psi->i_prg; i++ )
{
- IODFree( pid->psi->iod );
+ if( pid->psi->prg[i]->iod )
+ IODFree( pid->psi->prg[i]->iod );
+ if( pid->psi->prg[i]->handle )
+ dvbpsi_DetachPMT( pid->psi->prg[i]->handle );
+ free( pid->psi->prg[i] );
}
+ if( pid->psi->prg ) free( pid->psi->prg );
free( pid->psi );
}
else
{
+ int i;
+
if( pid->es->id )
- {
es_out_Del( out, pid->es->id );
- }
+
if( pid->es->p_pes )
- {
block_ChainRelease( pid->es->p_pes );
- }
+
+ es_format_Clean( &pid->es->fmt );
+
free( pid->es );
+
+ for( i = 0; i < pid->i_extra_es; i++ )
+ {
+ if( pid->extra_es[i]->id )
+ es_out_Del( out, pid->extra_es[i]->id );
+
+ if( pid->extra_es[i]->p_pes )
+ block_ChainRelease( pid->extra_es[i]->p_pes );
+
+ es_format_Clean( &pid->extra_es[i]->fmt );
+
+ free( pid->extra_es[i] );
+ }
+ if( pid->i_extra_es ) free( pid->extra_es );
}
+
pid->b_valid = VLC_FALSE;
}
{
block_t *p_pes = pid->es->p_pes;
uint8_t header[30];
- int i_pes_size;
+ int i_pes_size = 0;
int i_skip = 0;
mtime_t i_dts = -1;
mtime_t i_pts = -1;
+ mtime_t i_length = 0;
int i_max;
/* remove the pes from pid */
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;
/* FIXME find real max size */
i_max = block_ChainExtract( p_pes, header, 30 );
if( header[0] != 0 || header[1] != 0 || header[2] != 1 )
{
- msg_Warn( p_demux, "invalid header [0x%x:%x:%x:%x]", header[0], header[1],header[2],header[3] );
+ if ( !p_demux->p_sys->b_silent )
+ msg_Warn( p_demux, "invalid header [0x%x:%x:%x:%x]", header[0],
+ header[1],header[2],header[3] );
block_ChainRelease( p_pes );
return;
}
- i_pes_size = (header[4] << 8)|header[5];
-
/* TODO check size */
-
switch( header[3] )
{
case 0xBC: /* Program stream map */
(mtime_t)(header[10] << 22)|
((mtime_t)(header[11]&0xfe) << 14)|
(mtime_t)(header[12] << 7)|
- (mtime_t)(header[12] >> 1);
+ (mtime_t)(header[13] >> 1);
if( header[7]&0x40 ) /* has dts */
{
if( header[i_skip]&0x20 )
{
- p_pes->i_pts = ((mtime_t)(header[i_skip]&0x0e ) << 29)|
- (mtime_t)(header[i_skip+1] << 22)|
- ((mtime_t)(header[i_skip+2]&0xfe) << 14)|
- (mtime_t)(header[i_skip+3] << 7)|
- (mtime_t)(header[i_skip+4] >> 1);
+ i_pts = ((mtime_t)(header[i_skip]&0x0e ) << 29)|
+ (mtime_t)(header[i_skip+1] << 22)|
+ ((mtime_t)(header[i_skip+2]&0xfe) << 14)|
+ (mtime_t)(header[i_skip+3] << 7)|
+ (mtime_t)(header[i_skip+4] >> 1);
if( header[i_skip]&0x10 ) /* has dts */
{
- p_pes->i_dts = ((mtime_t)(header[i_skip+5]&0x0e ) << 29)|
- (mtime_t)(header[i_skip+6] << 22)|
- ((mtime_t)(header[i_skip+7]&0xfe) << 14)|
- (mtime_t)(header[i_skip+8] << 7)|
- (mtime_t)(header[i_skip+9] >> 1);
+ i_dts = ((mtime_t)(header[i_skip+5]&0x0e ) << 29)|
+ (mtime_t)(header[i_skip+6] << 22)|
+ ((mtime_t)(header[i_skip+7]&0xfe) << 14)|
+ (mtime_t)(header[i_skip+8] << 7)|
+ (mtime_t)(header[i_skip+9] >> 1);
i_skip += 10;
}
else
{
i_skip += 1;
}
+ else if( pid->es->fmt.i_codec == VLC_FOURCC( 's', 'u', 'b', 't' ) &&
+ pid->es->p_mpeg4desc )
+ {
+ decoder_config_descriptor_t *dcd = &pid->es->p_mpeg4desc->dec_descr;
+
+ if( dcd->i_decoder_specific_info_len > 2 &&
+ dcd->p_decoder_specific_info[0] == 0x10 &&
+ ( dcd->p_decoder_specific_info[1]&0x10 ) )
+ {
+ /* display length */
+ if( p_pes->i_buffer + 2 <= i_skip )
+ {
+ i_length = GetWBE( &p_pes->p_buffer[i_skip] );
+ }
+
+ i_skip += 2;
+ }
+ if( p_pes->i_buffer + 2 <= i_skip )
+ {
+ i_pes_size = GetWBE( &p_pes->p_buffer[i_skip] );
+ }
+ /* */
+ i_skip += 2;
+ }
/* skip header */
while( p_pes && i_skip > 0 )
break;
}
}
+
if( p_pes )
{
+ block_t *p_block;
+ int i;
+
if( i_dts >= 0 )
{
p_pes->i_dts = i_dts * 100 / 9;
{
p_pes->i_pts = i_pts * 100 / 9;
}
+ p_pes->i_length = i_length * 100 / 9;
- /* For mpeg4/mscodec we first gather the packet -> will make ffmpeg happier */
- es_out_Send( p_demux->out, pid->es->id, block_ChainGather( p_pes ) );
+ p_block = block_ChainGather( p_pes );
+ if( pid->es->fmt.i_codec == VLC_FOURCC( 's', 'u', 'b', 't' ) )
+ {
+ if( i_pes_size > 0 && p_block->i_buffer > i_pes_size )
+ {
+ p_block->i_buffer = i_pes_size;
+ }
+ /* Append a \0 */
+ p_block = block_Realloc( p_block, 0, p_block->i_buffer + 1 );
+ p_block->p_buffer[p_block->i_buffer -1] = '\0';
+ }
+
+ for( i = 0; i < pid->i_extra_es; i++ )
+ {
+ es_out_Send( p_demux->out, pid->extra_es[i]->id,
+ block_Duplicate( p_block ) );
+ }
+
+ es_out_Send( p_demux->out, pid->es->id, p_block );
}
else
{
msg_Warn( p_demux, "empty pes" );
}
-};
+}
+
+static void PCRHandle( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
+{
+ demux_sys_t *p_sys = p_demux->p_sys;
+ const uint8_t *p = p_bk->p_buffer;
+
+ if( ( p[3]&0x20 ) && /* adaptation */
+ ( p[5]&0x10 ) &&
+ ( p[4] >= 7 ) )
+ {
+ int i;
+ mtime_t i_pcr; /* 33 bits */
+
+ i_pcr = ( (mtime_t)p[6] << 25 ) |
+ ( (mtime_t)p[7] << 17 ) |
+ ( (mtime_t)p[8] << 9 ) |
+ ( (mtime_t)p[9] << 1 ) |
+ ( (mtime_t)p[10] >> 7 );
+
+ /* Search program and set the PCR */
+ for( i = 0; i < p_sys->i_pmt; i++ )
+ {
+ int i_prg;
+ for( i_prg = 0; i_prg < p_sys->pmt[i]->psi->i_prg; i_prg++ )
+ {
+ if( pid->i_pid == p_sys->pmt[i]->psi->prg[i_prg]->i_pid_pcr )
+ {
+ es_out_Control( p_demux->out, ES_OUT_SET_GROUP_PCR,
+ (int)p_sys->pmt[i]->psi->prg[i_prg]->i_number,
+ (int64_t)(i_pcr * 100 / 9) );
+ }
+ }
+ }
+ }
+}
static vlc_bool_t GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
{
const vlc_bool_t b_adaptation= p[3]&0x20;
const vlc_bool_t b_payload = p[3]&0x10;
const int i_cc = p[3]&0x0f; /* continuity counter */
+
/* transport_scrambling_control is ignored */
int i_skip = 0;
- vlc_bool_t i_ret = VLC_FALSE;
-
+ vlc_bool_t i_ret = VLC_FALSE;
int i_diff;
- //msg_Dbg( p_demux, "pid=0x%x unit_start=%d adaptation=%d payload=%d cc=0x%x", i_pid, b_unit_start, b_adaptation, b_payload, i_continuity_counter);
+#if 0
+ msg_Dbg( p_demux, "pid=0x%x unit_start=%d adaptation=%d payload=%d "
+ "cc=0x%x", pid->i_pid, p[1]&0x40, b_adaptation, b_payload, i_cc);
+#endif
+
if( p[1]&0x80 )
{
- msg_Dbg( p_demux, "transport_error_indicator set (pid=0x%x)", pid->i_pid );
+ msg_Dbg( p_demux, "transport_error_indicator set (pid=0x%x)",
+ pid->i_pid );
}
if( p_demux->p_sys->csa )
{
if( p[5]&0x80 )
{
- msg_Warn( p_demux, "discontinuity_indicator (pid=0x%x) ignored", pid->i_pid );
+ msg_Warn( p_demux, "discontinuity_indicator (pid=0x%x) "
+ "ignored", pid->i_pid );
}
}
}
+
/* test continuity counter */
/* continuous when (one of this):
* diff == 1
* diff == 0 and payload == 0
- * diff == 0 and duplicate packet (playload != 0) <- do we should test the content ?
+ * diff == 0 and duplicate packet (playload != 0) <- should we
+ * test the content ?
*/
i_diff = ( i_cc - pid->i_cc )&0x0f;
{
if( pid->i_cc == 0xff )
{
- msg_Warn( p_demux, "first packet for pid=0x%x cc=0x%x", pid->i_pid, i_cc );
+ msg_Warn( p_demux, "first packet for pid=0x%x cc=0x%x",
+ pid->i_pid, i_cc );
pid->i_cc = i_cc;
}
else if( i_diff != 0 )
if( pid->es->p_pes )
{
- block_ChainRelease( pid->es->p_pes );
- pid->es->p_pes = NULL;
+ pid->es->p_pes->i_flags |= BLOCK_FLAG_DISCONTINUITY;
}
}
}
- if( b_adaptation &&
- (p[5] & 0x10) && p[4]>=7 && pid->p_owner && pid->p_owner->i_pid_pcr == pid->i_pid )
- {
- mtime_t i_pcr; /* 33 bits */
-
- i_pcr = ( (mtime_t)p[6] << 25 ) |
- ( (mtime_t)p[7] << 17 ) |
- ( (mtime_t)p[8] << 9 ) |
- ( (mtime_t)p[9] << 1 ) |
- ( (mtime_t)p[10] >> 7 );
-
- es_out_Control( p_demux->out, ES_OUT_SET_GROUP_PCR, (int)pid->p_owner->i_number, (int64_t)(i_pcr * 100 / 9) );
- }
-
+ PCRHandle( p_demux, pid, p_bk );
if( i_skip >= 188 || pid->es->id == NULL || p_demux->p_sys->b_udp_out )
{
}
else
{
- const vlc_bool_t b_unit_start= p[1]&0x40;
+ const vlc_bool_t b_unit_start = p[1]&0x40;
/* we have to gather it */
p_bk->p_buffer += i_skip;
i_ret = VLC_TRUE;
}
- pid->es->p_pes = p_bk;
+ block_ChainLastAppend( &pid->es->pp_last, p_bk );
+ if( p_bk->i_buffer > 6 )
+ {
+ pid->es->i_pes_size = GetWBE( &p_bk->p_buffer[4] );
+ if( pid->es->i_pes_size > 0 )
+ {
+ pid->es->i_pes_size += 6;
+ }
+ }
+ pid->es->i_pes_gathered += p_bk->i_buffer;
+ if( pid->es->i_pes_size > 0 &&
+ pid->es->i_pes_gathered >= pid->es->i_pes_size )
+ {
+ ParsePES( p_demux, pid );
+ i_ret = VLC_TRUE;
+ }
}
else
{
}
else
{
- /* TODO check if when have gather enough packet to form a PES (ie read PES size)*/
- block_ChainAppend( &pid->es->p_pes, p_bk );
+ block_ChainLastAppend( &pid->es->pp_last, p_bk );
+ pid->es->i_pes_gathered += p_bk->i_buffer;
+ if( pid->es->i_pes_size > 0 &&
+ pid->es->i_pes_gathered >= pid->es->i_pes_size )
+ {
+ ParsePES( p_demux, pid );
+ i_ret = VLC_TRUE;
+ }
}
}
}
return i_ret;
}
-static char *LanguageNameISO639( char *psz_code )
-{
- const iso639_lang_t *pl;
-
- pl = GetLang_2B( psz_code );
- if( !strcmp( pl->psz_iso639_1, "??" ) )
- {
- pl = GetLang_2T( psz_code );
- }
-
- if( !strcmp( pl->psz_iso639_1, "??" ) )
- {
- return strdup( psz_code );
- }
- else
- {
- if( *pl->psz_native_name )
- {
- return strdup( pl->psz_native_name );
- }
- return strdup( pl->psz_eng_name );
- }
-}
-
static int PIDFillFormat( ts_pid_t *pid, int i_stream_type )
{
es_format_t *fmt = &pid->es->fmt;
break;
case 0x10: /* MPEG4 (video) */
es_format_Init( fmt, VIDEO_ES, VLC_FOURCC( 'm', 'p', '4', 'v' ) );
+ pid->es->b_gather = VLC_TRUE;
break;
case 0x1B: /* H264 <- check transport syntax/needed descriptor */
es_format_Init( fmt, VIDEO_ES, VLC_FOURCC( 'h', '2', '6', '4' ) );
es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 's', 'd', 'd', 'b' ) );
break;
- case 0x06: /* PES_PRIVATE (fixed later) */
case 0xa0: /* MSCODEC vlc (video) (fixed later) */
+ es_format_Init( fmt, UNKNOWN_ES, 0 );
+ pid->es->b_gather = VLC_TRUE;
+ break;
+
+ case 0x06: /* PES_PRIVATE (fixed later) */
+ case 0x12: /* MPEG-4 generic (sub/scene/...) (fixed later) */
default:
es_format_Init( fmt, UNKNOWN_ES, 0 );
break;
}
+ /* PES packets usually contain truncated frames */
+ fmt->b_packetized = VLC_FALSE;
+
return fmt->i_cat == UNKNOWN_ES ? VLC_EGENERIC : VLC_SUCCESS ;
}
dvbpsi_pmt_es_t *p_es;
ts_pid_t *pmt = NULL;
+ ts_prg_psi_t *prg = NULL;
int i;
msg_Dbg( p_demux, "PMTCallBack called" );
+
/* First find this PMT declared in PAT */
for( i = 0; i < p_sys->i_pmt; i++ )
{
- if( p_sys->pmt[i]->psi->i_number == p_pmt->i_program_number )
+ int i_prg;
+ for( i_prg = 0; i_prg < p_sys->pmt[i]->psi->i_prg; i_prg++ )
{
- pmt = p_sys->pmt[i];
+ if( p_sys->pmt[i]->psi->prg[i_prg]->i_number ==
+ p_pmt->i_program_number )
+ {
+ pmt = p_sys->pmt[i];
+ prg = p_sys->pmt[i]->psi->prg[i_prg];
+ break;
+ }
}
+ if( pmt )
+ break;
}
+
if( pmt == NULL )
{
msg_Warn( p_demux, "unreferenced program (broken stream)" );
return;
}
- if( pmt->psi->i_version != -1 && ( !p_pmt->b_current_next || pmt->psi->i_version == p_pmt->i_version ) )
+ if( prg->i_version != -1 &&
+ ( !p_pmt->b_current_next || prg->i_version == p_pmt->i_version ) )
{
dvbpsi_DeletePMT( p_pmt );
return;
{
ts_pid_t *pid = &p_sys->pid[i];
- if( pid->b_valid && pid->p_owner == pmt->psi && pid->psi == NULL )
+ if( pid->b_valid && pid->p_owner == pmt->psi &&
+ pid->i_owner_number == prg->i_number && pid->psi == NULL )
{
PIDClean( p_demux->out, pid );
}
}
- if( pmt->psi->iod )
+ if( prg->iod )
{
- IODFree( pmt->psi->iod );
- pmt->psi->iod = NULL;
+ IODFree( prg->iod );
+ prg->iod = NULL;
}
- msg_Dbg( p_demux, "new PMT program number=%d version=%d pid_pcr=0x%x", p_pmt->i_program_number, p_pmt->i_version, p_pmt->i_pcr_pid );
- pmt->psi->i_pid_pcr = p_pmt->i_pcr_pid;
- pmt->psi->i_version = p_pmt->i_version;
+ msg_Dbg( p_demux, "new PMT program number=%d version=%d pid_pcr=0x%x",
+ p_pmt->i_program_number, p_pmt->i_version, p_pmt->i_pcr_pid );
+ prg->i_pid_pcr = p_pmt->i_pcr_pid;
+ prg->i_version = p_pmt->i_version;
/* Parse descriptor */
for( p_dr = p_pmt->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
if( p_dr->i_tag == 0x1d )
{
/* We have found an IOD descriptor */
- msg_Warn( p_demux, "found IOD descriptor" );
+ msg_Warn( p_demux, " * descriptor : IOD (0x1d)" );
- pmt->psi->iod = IODNew( p_dr->i_length, p_dr->p_data );
+ prg->iod = IODNew( p_dr->i_length, p_dr->p_data );
+ }
+ else
+ {
+ msg_Dbg( p_demux, " * descriptor : unknown (0x%x)", p_dr->i_tag );
}
}
if( pid->b_valid )
{
- msg_Warn( p_demux, "pmt error: pid=0x%x already defined", p_es->i_pid );
+ msg_Warn( p_demux, "pmt error: pid=0x%x already defined",
+ p_es->i_pid );
continue;
}
PIDInit( pid, VLC_FALSE, pmt->psi );
PIDFillFormat( pid, p_es->i_type );
+ pid->i_owner_number = prg->i_number;
- if( p_es->i_type == 0x10 || p_es->i_type == 0x11 )
+ if( p_es->i_type == 0x10 || p_es->i_type == 0x11 ||
+ p_es->i_type == 0x12 )
{
/* MPEG-4 stream: search SL_DESCRIPTOR */
dvbpsi_descriptor_t *p_dr = p_es->p_first_descriptor;;
for( i = 0; i < 255; i++ )
{
- iod_descriptor_t *iod = pmt->psi->iod;
+ iod_descriptor_t *iod = prg->iod;
if( iod->es_descr[i].b_ok &&
iod->es_descr[i].i_es_id == i_es_id )
if( pid->es->p_mpeg4desc != NULL )
{
- decoder_config_descriptor_t *dcd = &pid->es->p_mpeg4desc->dec_descr;
+ decoder_config_descriptor_t *dcd =
+ &pid->es->p_mpeg4desc->dec_descr;
if( dcd->i_streamType == 0x04 ) /* VisualStream */
{
pid->es->fmt.i_cat = VIDEO_ES;
switch( dcd->i_objectTypeIndication )
{
- case 0x20:
- pid->es->fmt.i_codec = VLC_FOURCC('m','p','4','v'); // mpeg4
- break;
- case 0x60:
- case 0x61:
- case 0x62:
- case 0x63:
- case 0x64:
- case 0x65:
- pid->es->fmt.i_codec = VLC_FOURCC( 'm','p','g','v' ); // mpeg2
- break;
- case 0x6a:
- pid->es->fmt.i_codec = VLC_FOURCC( 'm','p','g','v' ); // mpeg1
- break;
- case 0x6c:
- pid->es->fmt.i_codec = VLC_FOURCC( 'j','p','e','g' ); // mpeg1
- break;
+ case 0x0B: /* mpeg4 sub */
+ pid->es->fmt.i_cat = SPU_ES;
+ pid->es->fmt.i_codec = VLC_FOURCC('s','u','b','t');
+ break;
- default:
- pid->es->fmt.i_cat = UNKNOWN_ES;
- break;
+ case 0x20: /* mpeg4 */
+ pid->es->fmt.i_codec = VLC_FOURCC('m','p','4','v');
+ break;
+ case 0x60:
+ case 0x61:
+ case 0x62:
+ case 0x63:
+ case 0x64:
+ case 0x65: /* mpeg2 */
+ pid->es->fmt.i_codec = VLC_FOURCC( 'm','p','g','v' );
+ break;
+ case 0x6a: /* mpeg1 */
+ pid->es->fmt.i_codec = VLC_FOURCC( 'm','p','g','v' );
+ break;
+ case 0x6c: /* mpeg1 */
+ pid->es->fmt.i_codec = VLC_FOURCC( 'j','p','e','g' );
+ break;
+ default:
+ pid->es->fmt.i_cat = UNKNOWN_ES;
+ break;
}
}
else if( dcd->i_streamType == 0x05 ) /* AudioStream */
pid->es->fmt.i_cat = AUDIO_ES;
switch( dcd->i_objectTypeIndication )
{
- case 0x40:
- pid->es->fmt.i_codec = VLC_FOURCC('m','p','4','a'); // mpeg4
- break;
- case 0x66:
- case 0x67:
- case 0x68:
- pid->es->fmt.i_codec = VLC_FOURCC('m','p','4','a');// mpeg2 aac
- break;
- case 0x69:
- pid->es->fmt.i_codec = VLC_FOURCC('m','p','g','a'); // mpeg2
- break;
- case 0x6b:
- pid->es->fmt.i_codec = VLC_FOURCC('m','p','g','a'); // mpeg1
- break;
- default:
- pid->es->fmt.i_cat = UNKNOWN_ES;
- break;
+ case 0x40: /* mpeg4 */
+ pid->es->fmt.i_codec = VLC_FOURCC('m','p','4','a');
+ break;
+ case 0x66:
+ case 0x67:
+ case 0x68: /* mpeg2 aac */
+ pid->es->fmt.i_codec = VLC_FOURCC('m','p','4','a');
+ break;
+ case 0x69: /* mpeg2 */
+ pid->es->fmt.i_codec = VLC_FOURCC('m','p','g','a');
+ break;
+ case 0x6b: /* mpeg1 */
+ pid->es->fmt.i_codec = VLC_FOURCC('m','p','g','a');
+ break;
+ default:
+ pid->es->fmt.i_cat = UNKNOWN_ES;
+ break;
}
}
else
{
dvbpsi_descriptor_t *p_dr;
- for( p_dr = p_es->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
+ for( p_dr = p_es->p_first_descriptor; p_dr != NULL;
+ p_dr = p_dr->p_next )
{
+ msg_Dbg( p_demux, " * es pid=0x%x type=0x%x dr->i_tag=0x%x",
+ p_es->i_pid, p_es->i_type, p_dr->i_tag );
+
if( p_dr->i_tag == 0x6a )
{
pid->es->fmt.i_cat = AUDIO_ES;
pid->es->fmt.i_codec = VLC_FOURCC( 'a', '5', '2', ' ' );
}
+ else if( p_dr->i_tag == 0x05 )
+ {
+
+ /* DTS registration descriptor (ETSI TS 101 154 Annex F) */
+ pid->es->fmt.i_cat = AUDIO_ES;
+ pid->es->fmt.i_codec = VLC_FOURCC( 'd', 't', 's', ' ' );
+ }
+ else if( p_dr->i_tag == 0x73 )
+ {
+ /* DTS audio descriptor (ETSI TS 101 154 Annex F) */
+ msg_Dbg( p_demux, " * DTS audio descriptor not decoded" );
+ pid->es->fmt.i_cat = AUDIO_ES;
+ pid->es->fmt.i_codec = VLC_FOURCC( 'd', 't', 's', ' ' );
+ }
#ifdef _DVBPSI_DR_59_H_
else if( p_dr->i_tag == 0x59 )
{
- /* DVB subtitle */
- /* TODO */
+ uint16_t n;
+ dvbpsi_subtitling_dr_t *sub;
+
+ /* DVB subtitles */
+ pid->es->fmt.i_cat = SPU_ES;
+ pid->es->fmt.i_codec = VLC_FOURCC( 'd', 'v', 'b', 's' );
+ pid->es->fmt.i_group = p_pmt->i_program_number;
+
+ sub = dvbpsi_DecodeSubtitlingDr( p_dr );
+ if( !sub ) continue;
+
+ /* Each subtitle ES contains n languages,
+ * We are going to create n ES for the n tracks */
+ if( sub->i_subtitles_number > 0 )
+ {
+ pid->es->fmt.psz_language = malloc( 4 );
+ memcpy( pid->es->fmt.psz_language,
+ sub->p_subtitle[0].i_iso6392_language_code, 3);
+ pid->es->fmt.psz_language[3] = 0;
+
+ pid->es->fmt.subs.dvb.i_id =
+ sub->p_subtitle[0].i_composition_page_id;
+ /* Hack, FIXME */
+ pid->es->fmt.subs.dvb.i_id |=
+ (sub->p_subtitle[0].i_ancillary_page_id << 16);
+ }
+ else pid->es->fmt.i_cat = UNKNOWN_ES;
+
+ for( n = 1; n < sub->i_subtitles_number; n++ )
+ {
+ ts_es_t *p_es = malloc( sizeof( ts_es_t ) );
+ p_es->fmt = pid->es->fmt;
+ p_es->id = NULL;
+ p_es->p_pes = NULL;
+ p_es->i_pes_size = 0;
+ p_es->i_pes_gathered = 0;
+ p_es->pp_last = &p_es->p_pes;
+ p_es->p_mpeg4desc = NULL;
+
+ p_es->fmt.psz_language = malloc( 4 );
+ memcpy( p_es->fmt.psz_language,
+ sub->p_subtitle[n].i_iso6392_language_code, 3);
+ p_es->fmt.psz_language[3] = 0;
+
+ p_es->fmt.subs.dvb.i_id =
+ sub->p_subtitle[n].i_composition_page_id;
+
+ TAB_APPEND( pid->i_extra_es, pid->extra_es, p_es );
+ }
}
-#endif
+#endif /* _DVBPSI_DR_59_H_ */
}
}
else if( p_es->i_type == 0xa0 )
{
- /* MSCODEC send by vlc */
- dvbpsi_descriptor_t *p_dr = p_es->p_first_descriptor;;
+ /* MSCODEC sent by vlc */
+ dvbpsi_descriptor_t *p_dr = p_es->p_first_descriptor;
while( p_dr && ( p_dr->i_tag != 0xa0 ) ) p_dr = p_dr->p_next;
if( p_dr && p_dr->i_length >= 8 )
{
pid->es->fmt.i_cat = VIDEO_ES;
- pid->es->fmt.i_codec = VLC_FOURCC( p_dr->p_data[0], p_dr->p_data[1],
- p_dr->p_data[2], p_dr->p_data[3] );
- pid->es->fmt.video.i_width = ( 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 = (p_dr->p_data[8] << 8) | p_dr->p_data[9];
+ pid->es->fmt.i_codec =
+ VLC_FOURCC( p_dr->p_data[0], p_dr->p_data[1],
+ p_dr->p_data[2], p_dr->p_data[3] );
+ pid->es->fmt.video.i_width =
+ ( 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 =
+ (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 );
+ memcpy( pid->es->fmt.p_extra, &p_dr->p_data[10],
+ pid->es->fmt.i_extra );
}
}
else
{
- msg_Warn( p_demux, "private MSCODEC (vlc) without bih private descriptor" );
+ msg_Warn( p_demux, "private MSCODEC (vlc) without bih private "
+ "descriptor" );
}
+ /* 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;
}
- if( pid->es->fmt.i_cat == AUDIO_ES || pid->es->fmt.i_cat == SPU_ES )
+ if( pid->es->fmt.i_cat == AUDIO_ES ||
+ ( pid->es->fmt.i_cat == SPU_ES &&
+ pid->es->fmt.i_codec != VLC_FOURCC('d','v','b','s') ) )
{
/* get language descriptor */
dvbpsi_descriptor_t *p_dr = p_es->p_first_descriptor;
if( p_dr )
{
dvbpsi_iso639_dr_t *p_decoded = dvbpsi_DecodeISO639Dr( p_dr );
- pid->es->fmt.psz_language =
- LanguageNameISO639( (char*)&p_decoded->i_iso_639_code );
+
+ if( p_decoded )
+ {
+ 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;
+ }
}
}
pid->es->fmt.i_group = p_pmt->i_program_number;
if( pid->es->fmt.i_cat == UNKNOWN_ES )
{
- msg_Dbg( p_demux, " * es pid=0x%x type=0x%x *unknown*", p_es->i_pid, p_es->i_type );
+ msg_Dbg( p_demux, " * es pid=0x%x type=0x%x *unknown*",
+ p_es->i_pid, p_es->i_type );
}
else if( !p_sys->b_udp_out )
{
- msg_Dbg( p_demux, " * es pid=0x%x type=0x%x fcc=%4.4s", p_es->i_pid, p_es->i_type, (char*)&pid->es->fmt.i_codec );
+ int i;
+
+ msg_Dbg( p_demux, " * es pid=0x%x type=0x%x fcc=%4.4s",
+ p_es->i_pid, p_es->i_type, (char*)&pid->es->fmt.i_codec );
+
if( p_sys->b_es_id_pid )
{
pid->es->fmt.i_id = p_es->i_pid;
}
+
pid->es->id = es_out_Add( p_demux->out, &pid->es->fmt );
+
+ for( i = 0; i < pid->i_extra_es; i++ )
+ {
+ pid->extra_es[i]->id =
+ es_out_Add( p_demux->out, &pid->extra_es[i]->fmt);
+ }
}
}
dvbpsi_DeletePMT(p_pmt);
demux_sys_t *p_sys = p_demux->p_sys;
dvbpsi_pat_program_t *p_program;
ts_pid_t *pat = &p_sys->pid[0];
- int i;
+ int i, j;
msg_Dbg( p_demux, "PATCallBack called" );
- if( pat->psi->i_version != -1 && ( !p_pat->b_current_next || p_pat->i_version == pat->psi->i_version ) )
+ if( pat->psi->i_pat_version != -1 &&
+ ( !p_pat->b_current_next ||
+ p_pat->i_version == pat->psi->i_pat_version ) )
{
dvbpsi_DeletePAT( p_pat );
return;
}
- msg_Dbg( p_demux, "new PAT ts_id=0x%x version=%d current_next=%d", p_pat->i_ts_id, p_pat->i_version, p_pat->b_current_next );
+ msg_Dbg( p_demux, "new PAT ts_id=0x%x version=%d current_next=%d",
+ p_pat->i_ts_id, p_pat->i_version, p_pat->b_current_next );
/* Clean old */
- for( i = 2; i < 8192; i++ )
+ if( p_sys->i_pmt > 0 )
{
- ts_pid_t *pid = &p_sys->pid[i];
+ int i_pmt_rm = 0;
+ ts_pid_t **pmt_rm = NULL;
- if( pid->b_valid )
+ /* Search pmt to be deleted */
+ for( i = 0; i < p_sys->i_pmt; i++ )
{
- if( pid->psi )
+ ts_pid_t *pmt = p_sys->pmt[i];
+ vlc_bool_t b_keep = VLC_FALSE;
+
+ for( p_program = p_pat->p_first_program; p_program != NULL;
+ p_program = p_program->p_next )
{
- if( pid->p_owner == pat->psi )
+ if( p_program->i_pid == pmt->i_pid )
{
- PIDClean( p_demux->out, pid );
- TAB_REMOVE( p_sys->i_pmt, p_sys->pmt, pid );
+ int i_prg;
+ for( i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
+ {
+ if( p_program->i_number ==
+ pmt->psi->prg[i_prg]->i_number )
+ {
+ b_keep = VLC_TRUE;
+ break;
+ }
+ }
+ if( b_keep )
+ break;
}
}
- else if( pid->p_owner && pid->p_owner->i_number != 0 && pid->es->id )
+ if( !b_keep )
+ {
+ TAB_APPEND( i_pmt_rm, pmt_rm, pmt );
+ }
+ }
+
+ /* Delete all ES attached to thoses PMT */
+ for( i = 2; i < 8192; i++ )
+ {
+ ts_pid_t *pid = &p_sys->pid[i];
+
+ if( !pid->b_valid || pid->psi ) continue;
+
+ for( j = 0; j < i_pmt_rm; j++ )
{
- /* We only remove es that aren't defined by extra pmt */
- PIDClean( p_demux->out, pid );
+ int i_prg;
+ for( i_prg = 0; i_prg < pid->p_owner->i_prg; i_prg++ )
+ {
+ if( pid->p_owner->prg[i_prg]->i_pid_pcr ==
+ pmt_rm[j]->i_pid && pid->es->id )
+ {
+ /* We only remove es that aren't defined by extra pmt */
+ PIDClean( p_demux->out, pid );
+ break;
+ }
+ }
+ if( !pid->b_valid )
+ break;
}
}
+
+ /* Delete PMT pid */
+ for( i = 0; i < i_pmt_rm; i++ )
+ {
+ PIDClean( p_demux->out, &p_sys->pid[pmt_rm[i]->i_pid] );
+ TAB_REMOVE( p_sys->i_pmt, p_sys->pmt, pmt_rm[i] );
+ }
+ if( pmt_rm )
+ {
+ free( pmt_rm );
+ }
}
/* now create programs */
- for( p_program = p_pat->p_first_program; p_program != NULL; p_program = p_program->p_next )
+ for( p_program = p_pat->p_first_program; p_program != NULL;
+ p_program = p_program->p_next )
{
- msg_Dbg( p_demux, " * number=%d pid=0x%x", p_program->i_number, p_program->i_pid );
+ msg_Dbg( p_demux, " * number=%d pid=0x%x", p_program->i_number,
+ p_program->i_pid );
if( p_program->i_number != 0 )
{
ts_pid_t *pmt = &p_sys->pid[p_program->i_pid];
+ vlc_bool_t b_add = VLC_TRUE;
- PIDInit( pmt, VLC_TRUE, pat->psi );
- pmt->psi->handle = dvbpsi_AttachPMT( p_program->i_number, (dvbpsi_pmt_callback)PMTCallBack, p_demux );
- pmt->psi->i_number = p_program->i_number;
+ if( pmt->b_valid )
+ {
+ int i_prg;
+ for( i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
+ {
+ if( pmt->psi->prg[i_prg]->i_number == p_program->i_number )
+ {
+ b_add = VLC_FALSE;
+ break;
+ }
+ }
+ }
+ else
+ {
+ TAB_APPEND( p_sys->i_pmt, p_sys->pmt, pmt );
+ }
- TAB_APPEND( p_sys->i_pmt, p_sys->pmt, pmt );
+ if( b_add )
+ {
+ PIDInit( pmt, VLC_TRUE, pat->psi );
+ pmt->psi->prg[pmt->psi->i_prg-1]->handle =
+ dvbpsi_AttachPMT( p_program->i_number,
+ (dvbpsi_pmt_callback)PMTCallBack,
+ p_demux );
+ pmt->psi->prg[pmt->psi->i_prg-1]->i_number =
+ p_program->i_number;
+ }
}
}
- pat->psi->i_version = p_pat->i_version;
+ pat->psi->i_pat_version = p_pat->i_version;
dvbpsi_DeletePAT( p_pat );
}