int i_version;
int i_number;
int i_pid_pcr;
+ int i_pid_pmt;
/* IOD stuff (mpeg4) */
iod_descriptor_t *iod;
+ /* Conditional Access PMT (EN 50 221) */
+ uint8_t *p_capmt;
+ int i_capmt_size;
+
} ts_prg_psi_t;
typedef struct
vlc_bool_t b_udp_out;
int fd; /* udp socket */
uint8_t *buffer;
+
+ vlc_bool_t b_dvb_control;
+ int i_dvb_program;
+ vlc_list_t *p_programs_list;
};
static int Demux ( demux_t *p_demux );
static iod_descriptor_t *IODNew( int , uint8_t * );
static void IODFree( iod_descriptor_t * );
+static void DVBCAPMTSend( demux_t *p_demux );
+
#define TS_PACKET_SIZE_188 188
#define TS_PACKET_SIZE_192 192
#define TS_PACKET_SIZE_204 204
memset( p_sys, 0, sizeof( demux_sys_t ) );
/* Init p_sys field */
+ p_sys->b_dvb_control = VLC_TRUE;
+ p_sys->i_dvb_program = 0;
for( i = 0; i < 8192; i++ )
{
ts_pid_t *pid = &p_sys->pid[i];
{
ts_pid_t *pmt = &p_sys->pid[i_pid];
- msg_Dbg( p_demux, "extra pmt specified (pid=0x%x)", i_pid );
+ msg_Dbg( p_demux, "extra pmt specified (pid=%d)", i_pid );
PIDInit( pmt, VLC_TRUE, NULL );
/* FIXME we should also ask for a number */
pmt->psi->prg[0]->handle =
{
pid->es->fmt.i_id = i_pid;
}
- msg_Dbg( p_demux, " * es pid=0x%x type=0x%x "
+ msg_Dbg( p_demux, " * es pid=%d type=%d "
"fcc=%4.4s", i_pid, i_stream_type,
(char*)&pid->es->fmt.i_codec );
pid->es->id = es_out_Add( p_demux->out,
}
else
{
- uint64_t i_ck = strtoll( psz, NULL, 16 );
+ uint64_t i_ck = strtoull( psz, NULL, 16 );
uint8_t ck[8];
int i;
for( i = 0; i < 8; i++ )
if( pid->b_seen )
{
- msg_Dbg( p_demux, " - pid[0x%x] seen", pid->i_pid );
+ msg_Dbg( p_demux, " - pid[%d] seen", pid->i_pid );
+ }
+
+ if( p_sys->b_dvb_control && pid->i_pid > 0 )
+ {
+ /* too much */
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS, ACCESS_SET_PRIVATE_ID_STATE, pid->i_pid, VLC_FALSE );
}
+
}
if( p_sys->b_udp_out )
}
if( p_sys->i_pmt ) free( p_sys->pmt );
+
+ if ( p_sys->p_programs_list )
+ {
+ vlc_value_t val;
+ val.p_list = p_sys->p_programs_list;
+ var_Change( p_demux, "programs", VLC_VAR_FREELIST, &val, NULL );
+ }
+
free( p_sys );
}
{
if( !p_pid->b_seen )
{
- msg_Dbg( p_demux, "pid[0x%x] unknown", p_pid->i_pid );
+ msg_Dbg( p_demux, "pid[%d] unknown", p_pid->i_pid );
}
/* We have to handle PCR if present */
PCRHandle( p_demux, p_pid, p_pkt );
*****************************************************************************/
static int Control( demux_t *p_demux, int i_query, va_list args )
{
- /* demux_sys_t *p_sys = p_demux->p_sys; */
+ demux_sys_t *p_sys = p_demux->p_sys;
double f, *pf;
int64_t i64;
+ int i_int;
switch( i_query )
{
*pi64 = 0;
return VLC_EGENERIC;
#endif
+ case DEMUX_SET_GROUP:
+ {
+ uint16_t i_vpid = 0, i_apid1 = 0, i_apid2 = 0, i_apid3 = 0;
+ ts_prg_psi_t *p_prg = NULL;
+ vlc_list_t *p_list;
+
+ i_int = (int)va_arg( args, int );
+ p_list = (vlc_list_t *)va_arg( args, vlc_list_t * );
+ msg_Dbg( p_demux, "DEMUX_SET_GROUP %d %p", i_int, p_list );
+
+ if( p_sys->b_dvb_control && i_int > 0 && i_int != p_sys->i_dvb_program )
+ {
+ int i_pmt_pid = -1;
+ int i;
+
+ /* Search pmt to be unselected */
+ for( i = 0; i < p_sys->i_pmt; i++ )
+ {
+ ts_pid_t *pmt = p_sys->pmt[i];
+ int i_prg;
+
+ for( i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
+ {
+ if( pmt->psi->prg[i_prg]->i_number == p_sys->i_dvb_program )
+ {
+ i_pmt_pid = p_sys->pmt[i]->i_pid;
+ break;
+ }
+ }
+ if( i_pmt_pid > 0 ) break;
+ }
+
+ if( i_pmt_pid > 0 )
+ {
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_STATE, i_pmt_pid,
+ VLC_FALSE );
+ /* All ES */
+ for( i = 2; i < 8192; i++ )
+ {
+ ts_pid_t *pid = &p_sys->pid[i];
+ int i_prg;
+
+ if( !pid->b_valid || pid->psi ) continue;
+
+ for( i_prg = 0; i_prg < pid->p_owner->i_prg; i_prg++ )
+ {
+ if( pid->p_owner->prg[i_prg]->i_pid_pmt == i_pmt_pid && pid->es->id )
+ {
+ /* We only remove es that aren't defined by extra pmt */
+ stream_Control( p_demux->s,
+ STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_STATE,
+ i, VLC_FALSE );
+ break;
+ }
+ }
+ }
+ }
+
+ /* select new program */
+ p_sys->i_dvb_program = i_int;
+ i_pmt_pid = -1;
+ for( i = 0; i < p_sys->i_pmt; i++ )
+ {
+ ts_pid_t *pmt = p_sys->pmt[i];
+ int i_prg;
+
+ for( i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
+ {
+ if( pmt->psi->prg[i_prg]->i_number == i_int )
+ {
+ i_pmt_pid = p_sys->pmt[i]->i_pid;
+ p_prg = p_sys->pmt[i]->psi->prg[i_prg];
+ break;
+ }
+ }
+ if( i_pmt_pid > 0 ) break;
+ }
+ if( i_pmt_pid > 0 )
+ {
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_STATE, i_pmt_pid,
+ VLC_TRUE );
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_STATE, p_prg->i_pid_pcr,
+ VLC_TRUE );
+
+ for( i = 2; i < 8192; i++ )
+ {
+ ts_pid_t *pid = &p_sys->pid[i];
+ int i_prg;
+
+ if( !pid->b_valid || pid->psi ) continue;
+
+ for( i_prg = 0; i_prg < pid->p_owner->i_prg; i_prg++ )
+ {
+ if( pid->p_owner->prg[i_prg]->i_pid_pmt == i_pmt_pid && pid->es->id )
+ {
+ if ( pid->es->fmt.i_cat == VIDEO_ES && !i_vpid )
+ i_vpid = i;
+ if ( pid->es->fmt.i_cat == AUDIO_ES && !i_apid1 )
+ i_apid1 = i;
+ else if ( pid->es->fmt.i_cat == AUDIO_ES && !i_apid2 )
+ i_apid2 = i;
+ else if ( pid->es->fmt.i_cat == AUDIO_ES && !i_apid3 )
+ i_apid3 = i;
+
+ stream_Control( p_demux->s,
+ STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_STATE,
+ i, VLC_TRUE );
+ break;
+ }
+ }
+ }
+
+ /* Set CAM descrambling */
+ DVBCAPMTSend( p_demux );
+ }
+ }
+ else
+ {
+ p_sys->i_dvb_program = -1;
+ p_sys->p_programs_list = p_list;
+ }
+ return VLC_SUCCESS;
+ }
+
case DEMUX_GET_FPS:
case DEMUX_SET_TIME:
default:
prg->i_version = -1;
prg->i_number = -1;
prg->i_pid_pcr = -1;
+ prg->i_pid_pmt = -1;
prg->iod = NULL;
+ prg->p_capmt = NULL;
+ prg->i_capmt_size = 0;
prg->handle = NULL;
TAB_APPEND( pid->psi->i_prg, pid->psi->prg, prg );
{
if( pid->psi->prg[i]->iod )
IODFree( pid->psi->prg[i]->iod );
+ if ( pid->psi->prg[i]->i_capmt_size )
+ free( pid->psi->prg[i]->p_capmt );
if( pid->psi->prg[i]->handle )
dvbpsi_DetachPMT( pid->psi->prg[i]->handle );
free( pid->psi->prg[i] );
if( header[0] != 0 || header[1] != 0 || header[2] != 1 )
{
if( !p_demux->p_sys->b_silent )
- msg_Warn( p_demux, "invalid header [0x%x:%x:%x:%x] (pid: 0x%x)",
+ msg_Warn( p_demux, "invalid header [0x%x:%x:%x:%x] (pid: %d)",
header[0], header[1],header[2],header[3], pid->i_pid );
block_ChainRelease( p_pes );
return;
int i_diff;
#if 0
- msg_Dbg( p_demux, "pid=0x%x unit_start=%d adaptation=%d payload=%d "
+ msg_Dbg( p_demux, "pid=%d unit_start=%d adaptation=%d payload=%d "
"cc=0x%x", pid->i_pid, b_unit_start, b_adaptation,
b_payload, i_cc );
#endif
if( p[1]&0x80 )
{
- msg_Dbg( p_demux, "transport_error_indicator set (pid=0x%x)",
+ msg_Dbg( p_demux, "transport_error_indicator set (pid=%d)",
pid->i_pid );
}
{
if( p[5]&0x80 )
{
- msg_Warn( p_demux, "discontinuity_indicator (pid=0x%x) "
+ msg_Warn( p_demux, "discontinuity_indicator (pid=%d) "
"ignored", pid->i_pid );
}
}
{
if( pid->i_cc == 0xff )
{
- msg_Warn( p_demux, "first packet for pid=0x%x cc=0x%x",
+ msg_Warn( p_demux, "first packet for pid=%d cc=0x%x",
pid->i_pid, i_cc );
pid->i_cc = i_cc;
}
pid->i_cc = i_cc;
- if( pid->es->p_pes )
+ if( pid->es->p_pes && pid->es->fmt.i_cat != VIDEO_ES )
{
+ /* Small video artifacts are usually better then
+ * dropping full frames */
pid->es->p_pes->i_flags |= BLOCK_FLAG_DISCONTINUITY;
}
}
** libdvbpsi callbacks
****************************************************************************
****************************************************************************/
+static vlc_bool_t 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->i_dvb_program == -1 && p_sys->p_programs_list == NULL )
+ return VLC_TRUE;
+ if ( p_sys->i_dvb_program == i_pgrm ) return VLC_TRUE;
+
+ if ( p_sys->p_programs_list != NULL )
+ {
+ int i;
+ 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 VLC_FALSE;
+}
+
static void PMTCallBack( demux_t *p_demux, dvbpsi_pmt_t *p_pmt )
{
demux_sys_t *p_sys = p_demux->p_sys;
ts_pid_t *pmt = NULL;
ts_prg_psi_t *prg = NULL;
- int i;
+
+ int i_cad_length = 0;
+ ts_pid_t **pp_clean = NULL;
+ int i_clean = 0, i;
msg_Dbg( p_demux, "PMTCallBack called" );
break;
}
}
- if( pmt )
- break;
+ if( pmt ) break;
}
if( pmt == 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 );
+ TAB_APPEND( i_clean, pp_clean, pid );
}
}
if( prg->iod )
IODFree( prg->iod );
prg->iod = NULL;
}
+ if ( prg->i_capmt_size )
+ free( prg->p_capmt );
+ prg->i_capmt_size = 0;
- msg_Dbg( p_demux, "new PMT program number=%d version=%d pid_pcr=0x%x",
+ msg_Dbg( p_demux, "new PMT program number=%d version=%d pid_pcr=%d",
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;
+ if( DVBProgramIsSelected( p_demux, prg->i_number ) )
+ {
+ /* Set demux filter */
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_STATE, prg->i_pid_pcr,
+ VLC_TRUE );
+ }
+ else if ( p_sys->b_dvb_control )
+ {
+ msg_Warn( p_demux, "skipping program (not selected)" );
+ dvbpsi_DeletePMT(p_pmt);
+ return;
+ }
+
/* Parse descriptor */
for( p_dr = p_pmt->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
{
prg->iod = IODNew( p_dr->i_length, p_dr->p_data );
}
+ else if( p_dr->i_tag == 0x9 )
+ {
+ msg_Dbg( p_demux, " * descriptor : CA (0x9)" );
+ i_cad_length += p_dr->i_length + 2;
+ }
else
{
msg_Dbg( p_demux, " * descriptor : unknown (0x%x)", p_dr->i_tag );
}
}
+ if ( i_cad_length )
+ {
+ prg->p_capmt = malloc( 6 + i_cad_length );
+ prg->i_capmt_size = 6 + i_cad_length;
+
+ prg->p_capmt[0] = p_pmt->i_program_number >> 8;
+ prg->p_capmt[1] = p_pmt->i_program_number & 0xff;
+ prg->p_capmt[2] = (p_pmt->i_version << 1) | 0x1;
+ prg->p_capmt[3] = (i_cad_length + 1) >> 8;
+ prg->p_capmt[4] = (i_cad_length + 1) & 0xff;
+ prg->p_capmt[5] = 0x1; /* ok_descrambling */
+
+ i = 6;
+ for( p_dr = p_pmt->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
+ {
+ if( p_dr->i_tag == 0x9 )
+ {
+ prg->p_capmt[i] = 0x9;
+ prg->p_capmt[i+1] = p_dr->i_length;
+ memcpy( &prg->p_capmt[i+2], p_dr->p_data, p_dr->i_length );
+ i += p_dr->i_length + 2;
+ }
+ }
+ }
+
for( p_es = p_pmt->p_first_es; p_es != NULL; p_es = p_es->p_next )
{
- ts_pid_t *pid = &p_sys->pid[p_es->i_pid];
+ ts_pid_t tmp_pid, *old_pid = 0, *pid = &tmp_pid;
- if( pid->b_valid )
+ /* Find out if the PID was already declared */
+ for( i = 0; i < i_clean; i++ )
{
- msg_Warn( p_demux, "pmt error: pid=0x%x already defined",
+ if( pp_clean[i] == &p_sys->pid[p_es->i_pid] )
+ {
+ old_pid = pp_clean[i];
+ break;
+ }
+ }
+
+ if( !old_pid && p_sys->pid[p_es->i_pid].b_valid )
+ {
+ msg_Warn( p_demux, "pmt error: pid=%d 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;
+ 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 )
if( p_dr && p_dr->i_length == 2 )
{
- int i;
int i_es_id = ( p_dr->p_data[0] << 8 ) | p_dr->p_data[1];
msg_Warn( p_demux, "found SL_descriptor es_id=%d", i_es_id );
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",
+ msg_Dbg( p_demux, " * es pid=%d type=%d dr->i_tag=0x%x",
p_es->i_pid, p_es->i_type, p_dr->i_tag );
if( p_dr->i_tag == 0x6a )
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" );
+ 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', ' ' );
}
+ else if( p_dr->i_tag == 0x45 )
+ {
+ msg_Dbg( p_demux, " * VBI Data descriptor" );
+ pid->es->fmt.i_cat = SPU_ES;
+ pid->es->fmt.i_codec = VLC_FOURCC( 'v', 'b', 'i', 'd' );
+ pid->es->fmt.psz_description = strdup( "VBI Data" );
+ 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 );
+ }
+ else if( p_dr->i_tag == 0x46 )
+ {
+ msg_Dbg( p_demux, " * VBI Teletext descriptor" );
+ pid->es->fmt.i_cat = SPU_ES;
+ pid->es->fmt.i_codec = VLC_FOURCC( 'v', 'b', 'i', 't' );
+ pid->es->fmt.psz_description = strdup( "VBI Teletext" );
+ 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 );
+ }
else if( p_dr->i_tag == 0x56 )
{
- msg_Dbg( p_demux, " * Teletext descriptor" );
+ msg_Dbg( p_demux, " * EBU Teletext descriptor" );
pid->es->fmt.i_cat = SPU_ES;
pid->es->fmt.i_codec = VLC_FOURCC( 't', 'e', 'l', 'x' );
+ pid->es->fmt.psz_description = strdup( "Teletext" );
+ 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 );
}
#ifdef _DVBPSI_DR_59_H_
else if( p_dr->i_tag == 0x59 )
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*",
+ msg_Dbg( p_demux, " * es pid=%d type=%d *unknown*",
p_es->i_pid, p_es->i_type );
}
else if( !p_sys->b_udp_out )
{
- int i;
-
- msg_Dbg( p_demux, " * es pid=0x%x type=0x%x fcc=%4.4s",
+ msg_Dbg( p_demux, " * es pid=%d type=%d fcc=%4.4s",
p_es->i_pid, p_es->i_type, (char*)&pid->es->fmt.i_codec );
- if( p_sys->b_es_id_pid )
+ if( p_sys->b_es_id_pid ) pid->es->fmt.i_id = p_es->i_pid;
+
+ /* Check if we can avoid restarting the ES */
+ if( old_pid &&
+ pid->es->fmt.i_codec == old_pid->es->fmt.i_codec &&
+ pid->es->fmt.i_extra == old_pid->es->fmt.i_extra &&
+ pid->es->fmt.i_extra == 0 &&
+ pid->i_extra_es == old_pid->i_extra_es &&
+ ( ( !pid->es->fmt.psz_language &&
+ !old_pid->es->fmt.psz_language ) ||
+ ( pid->es->fmt.psz_language &&
+ old_pid->es->fmt.psz_language &&
+ !strcmp( pid->es->fmt.psz_language,
+ old_pid->es->fmt.psz_language ) ) ) )
+ {
+ pid->es->id = old_pid->es->id;
+ old_pid->es->id = NULL;
+ for( i = 0; i < pid->i_extra_es; i++ )
+ {
+ pid->extra_es[i]->id = old_pid->extra_es[i]->id;
+ old_pid->extra_es[i]->id = NULL;
+ }
+ }
+ else
+ {
+ if( old_pid )
+ {
+ PIDClean( p_demux->out, old_pid );
+ TAB_REMOVE( i_clean, pp_clean, old_pid );
+ old_pid = 0;
+ }
+
+ 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 );
+ }
+ }
+ }
+
+ i_cad_length = 0;
+ /* Add ES to the list */
+ if( old_pid )
+ {
+ PIDClean( p_demux->out, old_pid );
+ TAB_REMOVE( i_clean, pp_clean, old_pid );
+ }
+ p_sys->pid[p_es->i_pid] = *pid;
+
+ for( p_dr = p_es->p_first_descriptor; p_dr != NULL;
+ p_dr = p_dr->p_next )
+ {
+ if( p_dr->i_tag == 0x9 )
+ {
+ msg_Dbg( p_demux, " * descriptor : CA (0x9)" );
+ i_cad_length += p_dr->i_length + 2;
+ }
+ else
+ {
+ msg_Dbg( p_demux, " * descriptor : unknown (0x%x)",
+ p_dr->i_tag );
+ }
+ }
+
+ if ( i_cad_length )
+ {
+ if ( !prg->i_capmt_size )
{
- pid->es->fmt.i_id = p_es->i_pid;
+ prg->p_capmt = malloc( 5 + 6 + i_cad_length );
+ prg->i_capmt_size = 5 + 6 + i_cad_length;
+
+ prg->p_capmt[0] = p_pmt->i_program_number >> 8;
+ prg->p_capmt[1] = p_pmt->i_program_number & 0xff;
+ prg->p_capmt[2] = (p_pmt->i_version << 1) | 0x1;
+ prg->p_capmt[3] = 0; /* cad length */
+ prg->p_capmt[4] = 0;
+
+ i = 5;
+ }
+ else
+ {
+ prg->p_capmt = realloc( prg->p_capmt,
+ prg->i_capmt_size + 6 + i_cad_length );
+ i = prg->i_capmt_size;
+ prg->i_capmt_size += 6 + i_cad_length;
}
- pid->es->id = es_out_Add( p_demux->out, &pid->es->fmt );
+ prg->p_capmt[i] = p_es->i_type;
+ prg->p_capmt[i+1] = p_es->i_pid >> 8;
+ prg->p_capmt[i+2] = p_es->i_pid & 0xff;
+ prg->p_capmt[i+3] = (i_cad_length + 1) >> 8;
+ prg->p_capmt[i+4] = (i_cad_length + 1) & 0xff;
+ prg->p_capmt[i+5] = 0x1; /* ok_descrambling */
+ i += 6;
- for( i = 0; i < pid->i_extra_es; i++ )
+ for( p_dr = p_es->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
{
- pid->extra_es[i]->id =
- es_out_Add( p_demux->out, &pid->extra_es[i]->fmt);
+ if( p_dr->i_tag == 0x9 )
+ {
+ prg->p_capmt[i] = 0x9;
+ prg->p_capmt[i+1] = p_dr->i_length;
+ memcpy( &prg->p_capmt[i+2], p_dr->p_data, p_dr->i_length );
+ i += p_dr->i_length + 2;
+ }
}
}
+ else if ( prg->i_capmt_size )
+ {
+ prg->p_capmt = realloc( prg->p_capmt,
+ prg->i_capmt_size + 5 );
+ i = prg->i_capmt_size;
+ prg->i_capmt_size += 5;
+
+ prg->p_capmt[i] = p_es->i_type;
+ prg->p_capmt[i+1] = p_es->i_pid >> 8;
+ prg->p_capmt[i+2] = p_es->i_pid & 0xff;
+ prg->p_capmt[i+3] = 0;
+ prg->p_capmt[i+4] = 0;
+ i += 5;
+ }
+
+ if( DVBProgramIsSelected( p_demux, prg->i_number ) )
+ {
+ /* Set demux filter */
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_STATE, p_es->i_pid,
+ VLC_TRUE );
+ }
+ }
+
+ dvbpsi_DeletePMT( p_pmt );
+
+ for ( i = 0; i < i_clean; i++ )
+ {
+ if( DVBProgramIsSelected( p_demux, prg->i_number ) )
+ {
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_STATE, pp_clean[i]->i_pid,
+ VLC_FALSE );
+ }
+
+ PIDClean( p_demux->out, pp_clean[i] );
+ }
+ if( i_clean ) free( pp_clean );
+
+ if( DVBProgramIsSelected( p_demux, prg->i_number ) )
+ {
+ /* Set CAM descrambling */
+ DVBCAPMTSend( p_demux );
}
- dvbpsi_DeletePMT(p_pmt);
}
static void PATCallBack( demux_t *p_demux, dvbpsi_pat_t *p_pat )
return;
}
- msg_Dbg( p_demux, "new PAT ts_id=0x%x version=%d current_next=%d",
+ msg_Dbg( p_demux, "new PAT ts_id=%d version=%d current_next=%d",
p_pat->i_ts_id, p_pat->i_version, p_pat->b_current_next );
/* Clean old */
break;
}
}
- if( b_keep )
- break;
+ if( b_keep ) break;
}
}
+
if( !b_keep )
{
TAB_APPEND( i_pmt_rm, pmt_rm, pmt );
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 */
+ if( pid->p_owner->prg[i_prg]->i_pid_pmt !=
+ pmt_rm[j]->i_pid ) continue;
+
+ if( p_sys->b_dvb_control && pid->es->id )
{
- /* We only remove es that aren't defined by extra pmt */
- PIDClean( p_demux->out, pid );
- 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;
}
- }
- if( !pid->b_valid )
+
+ PIDClean( p_demux->out, pid );
break;
+ }
+
+ if( !pid->b_valid ) break;
}
}
/* Delete PMT pid */
for( i = 0; i < i_pmt_rm; i++ )
{
+ if( p_sys->b_dvb_control )
+ {
+ 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;
+ }
+
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 );
- }
+
+ 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 )
{
- msg_Dbg( p_demux, " * number=%d pid=0x%x", p_program->i_number,
+ msg_Dbg( p_demux, " * number=%d pid=%d", p_program->i_number,
p_program->i_pid );
if( p_program->i_number != 0 )
{
p_demux );
pmt->psi->prg[pmt->psi->i_prg-1]->i_number =
p_program->i_number;
+ pmt->psi->prg[pmt->psi->i_prg-1]->i_pid_pmt =
+ p_program->i_pid;
+
+ /* Now select PID at access level */
+ if( p_sys->b_dvb_control )
+ {
+ if( p_sys->i_dvb_program <= 0 || p_sys->i_dvb_program == p_program->i_number )
+ {
+ if( p_sys->i_dvb_program == 0 )
+ p_sys->i_dvb_program = p_program->i_number;
+
+ 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;
+ }
+ else
+ {
+ if( stream_Control( p_demux->s, STREAM_CONTROL_ACCESS, ACCESS_SET_PRIVATE_ID_STATE, p_program->i_pid, VLC_FALSE ) )
+ p_sys->b_dvb_control = VLC_FALSE;
+ }
+ }
}
}
}
dvbpsi_DeletePAT( p_pat );
}
+
+static void DVBCAPMTSend( demux_t *p_demux )
+{
+ demux_sys_t *p_sys = p_demux->p_sys;
+ int i_nb_capmts = 0;
+ int i;
+
+ for( i = 0; i < p_sys->i_pmt; i++ )
+ {
+ ts_pid_t *pmt = p_sys->pmt[i];
+ int i_prg;
+
+ for( i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
+ {
+ if( DVBProgramIsSelected( p_demux, pmt->psi->prg[i_prg]->i_number )
+ && pmt->psi->prg[i_prg]->i_capmt_size )
+ {
+ i_nb_capmts++;
+ }
+ }
+ }
+
+ if ( i_nb_capmts )
+ {
+ uint8_t **pp_capmts = malloc( i_nb_capmts * sizeof(uint8_t *) );
+ int i_current_capmt = 0;
+
+ for( i = 0; i < p_sys->i_pmt; i++ )
+ {
+ ts_pid_t *pmt = p_sys->pmt[i];
+ int i_prg;
+
+ for( i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
+ {
+ if( DVBProgramIsSelected( p_demux, pmt->psi->prg[i_prg]->i_number )
+ && pmt->psi->prg[i_prg]->i_capmt_size )
+ {
+ uint8_t *p_capmt = malloc( pmt->psi->prg[i_prg]->i_capmt_size + 10 );
+ int i_pos = 0;
+ pp_capmts[i_current_capmt] = p_capmt;
+
+ p_capmt[i_pos] = 0x9F;
+ p_capmt[i_pos+1] = 0x80;
+ p_capmt[i_pos+2] = 0x32;
+ i_pos += 3;
+
+ if ( (pmt->psi->prg[i_prg]->i_capmt_size + 1) < 128 )
+ {
+ p_capmt[i_pos] = (pmt->psi->prg[i_prg]->i_capmt_size + 1);
+ i_pos++;
+ }
+ else if ( (pmt->psi->prg[i_prg]->i_capmt_size + 1) < 256 )
+ {
+ p_capmt[i_pos] = 0x81;
+ p_capmt[i_pos+1] = (pmt->psi->prg[i_prg]->i_capmt_size + 1);
+ i_pos += 2;
+ }
+ else if ( (pmt->psi->prg[i_prg]->i_capmt_size + 1) < 65536 )
+ {
+ p_capmt[i_pos] = 0x82;
+ p_capmt[i_pos+1] =
+ (pmt->psi->prg[i_prg]->i_capmt_size + 1) >> 8;
+ p_capmt[i_pos+2] =
+ (pmt->psi->prg[i_prg]->i_capmt_size + 1) & 0xff;
+ i_pos += 3;
+ }
+ else if ( (pmt->psi->prg[i_prg]->i_capmt_size + 1) < 16777216 )
+ {
+ p_capmt[i_pos] = 0x83;
+ p_capmt[i_pos+1] =
+ (pmt->psi->prg[i_prg]->i_capmt_size + 1) >> 16;
+ p_capmt[i_pos+2] =
+ ((pmt->psi->prg[i_prg]->i_capmt_size + 1) >> 8) & 0xff;
+ p_capmt[i_pos+3] =
+ (pmt->psi->prg[i_prg]->i_capmt_size + 1) & 0xff;
+ i_pos += 4;
+ }
+ else
+ {
+ p_capmt[i_pos] = 0x84;
+ p_capmt[i_pos+1] =
+ (pmt->psi->prg[i_prg]->i_capmt_size + 1) >> 24;
+ p_capmt[i_pos+2] =
+ ((pmt->psi->prg[i_prg]->i_capmt_size + 1) >> 16) & 0xff;
+ p_capmt[i_pos+3] =
+ ((pmt->psi->prg[i_prg]->i_capmt_size + 1) >> 8) & 0xff;
+ p_capmt[i_pos+4] =
+ (pmt->psi->prg[i_prg]->i_capmt_size + 1) & 0xff;
+ i_pos += 5;
+ }
+
+ if ( i_nb_capmts > 1 )
+ {
+ if ( i_current_capmt == 0 )
+ p_capmt[i_pos] = 0x1; /* first */
+ else if ( i_current_capmt == i_nb_capmts - 1 )
+ p_capmt[i_pos] = 0x2; /* last */
+ else
+ p_capmt[i_pos] = 0x0; /* more */
+ }
+ else
+ p_capmt[i_pos] = 0x3; /* only */
+ i_pos++;
+ i_current_capmt++;
+
+ memcpy( &p_capmt[i_pos], pmt->psi->prg[i_prg]->p_capmt,
+ pmt->psi->prg[i_prg]->i_capmt_size );
+ }
+ }
+ }
+
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_CA, pp_capmts, i_nb_capmts );
+ }
+}
projects / vlc / blobdiff