#include "../mux/mpeg/csa.h"
+#define TS_USE_DVB_SI 0
+
+/* Undef it to disable sdt/eit parsing */
+#define TS_USE_DVB_SI 0
+
/* Include dvbpsi headers */
#ifdef HAVE_DVBPSI_DR_H
# include <dvbpsi/dvbpsi.h>
+# include <dvbpsi/demux.h>
# include <dvbpsi/descriptor.h>
# include <dvbpsi/pat.h>
# include <dvbpsi/pmt.h>
+# include <dvbpsi/sdt.h>
+# include <dvbpsi/eit.h>
# include <dvbpsi/dr.h>
# include <dvbpsi/psi.h>
#else
# include "dvbpsi.h"
+# include "demux.h"
# include "descriptor.h"
# include "tables/pat.h"
# include "tables/pmt.h"
+# include "tables/sdt.h"
+# include "tables/eit.h"
# include "descriptors/dr.h"
# include "psi.h"
#endif
+
/* TODO:
* - XXX: do not mark options message to be translated, they are too osbcure for now ...
* - test it
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
+#define PMT_TEXT N_("Extra PMT")
+#define PMT_LONGTEXT N_( \
+ "Allows a user to specify an extra pmt (pmt_pid=pid:stream_type[,...])" )
+
+#define PID_TEXT N_("Set id of ES to PID")
+#define PID_LONGTEXT N_("set id of es to pid")
+
+#define TSOUT_TEXT N_("Fast udp streaming")
+#define TSOUT_LONGTEXT N_( \
+ "Sends TS to specific ip:port by udp (you must know what you are doing)")
+
+#define MTUOUT_TEXT N_("MTU for out mode")
+#define MTUOUT_LONGTEXT N_("MTU for out mode")
+
+#define CSA_TEXT N_("CSA ck")
+#define CSA_LONGTEXT N_("CSA ck")
+
+#define SILENT_TEXT N_("Silent mode")
+#define SILENT_LONGTEXT N_("do not complain on encrypted PES")
+
+#define CAPMT_SYSID_TEXT N_("CAPMT System ID")
+#define CAPMT_SYSID_LONGTEXT N_("only forward descriptors from this SysID to the CAM")
+
vlc_module_begin();
- set_description( _("ISO 13818-1 MPEG Transport Stream input - new" ) );
- add_string( "ts-extra-pmt", NULL, NULL, "extra PMT", "allow user to specify an extra pmt (pmt_pid=pid:stream_type[,...])", VLC_TRUE );
- add_bool( "ts-es-id-pid", 0, NULL, "set id of es to pid", "set id of es to pid", VLC_TRUE );
- 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_description( _("MPEG Transport Stream demuxer") );
+ set_shortname ( _("MPEG-TS") );
+ 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", 0, 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_bool( "ts-silent", 0, NULL, SILENT_TEXT, SILENT_LONGTEXT, VLC_TRUE );
+ add_integer( "ts-capmt-sysid", 0, NULL, CAPMT_SYSID_TEXT,
+ CAPMT_SYSID_LONGTEXT, VLC_TRUE );
+
set_capability( "demux2", 10 );
set_callbacks( Open, Close );
- add_shortcut( "ts2" );
+ add_shortcut( "ts" );
vlc_module_end();
/*****************************************************************************
decoder_config_descriptor_t dec_descr;
sl_config_descriptor_t sl_descr;
+
} es_mpeg4_descriptor_t;
typedef struct
{
- uint8_t i_iod_label;
+ uint8_t i_iod_label, i_iod_label_scope;
/* IOD */
uint16_t i_od_id;
int i_version;
int i_number;
int i_pid_pcr;
+ int i_pid_pmt;
/* IOD stuff (mpeg4) */
iod_descriptor_t *iod;
+
} ts_prg_psi_t;
typedef struct
{
- /* for special PAT case */
- dvbpsi_handle handle;
+ demux_t *p_demux; /* Hack */
+ int i_table_id;
+ int i_version;
+ int i_service_id;
+} ts_eit_psi_t;
+
+typedef struct
+{
+ /* for special PAT/SDT case */
+ dvbpsi_handle handle; /* PAT/SDT/EIT */
int i_pat_version;
+ int i_sdt_version;
/* For PMT */
int i_prg;
ts_prg_psi_t **prg;
+
+ /* For EIT */
+ int i_eit;
+ ts_eit_psi_t **eit;
+
} 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
struct demux_sys_t
{
+ /* TS packet size (188, 192, 204) */
+ int i_packet_size;
+
/* how many TS packet we read at once */
int i_ts_read;
vlc_bool_t b_es_id_pid;
csa_t *csa;
vlc_bool_t b_silent;
+ uint16_t i_capmt_sysid;
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;
+
+ /* */
+ vlc_bool_t b_meta;
};
static int Demux ( demux_t *p_demux );
static void PATCallBack( demux_t *, dvbpsi_pat_t * );
static void PMTCallBack( demux_t *p_demux, dvbpsi_pmt_t *p_pmt );
+static void PSINewTableCallBack( demux_t *, dvbpsi_handle,
+ uint8_t i_table_id, uint16_t i_extension );
+
static inline int PIDGet( block_t *p )
{
static iod_descriptor_t *IODNew( int , uint8_t * );
static void IODFree( iod_descriptor_t * );
+#define TS_PACKET_SIZE_188 188
+#define TS_PACKET_SIZE_192 192
+#define TS_PACKET_SIZE_204 204
+#define TS_PACKET_SIZE_MAX 204
/*****************************************************************************
* Open
demux_sys_t *p_sys;
uint8_t *p_peek;
- int i_peek;
- int i_sync;
- int i;
+ int i_sync, i_peek, i;
+ int i_packet_size;
ts_pid_t *pat;
vlc_value_t val;
- if( ( i_peek = stream_Peek( p_demux->s, &p_peek, 189 ) ) < 1 )
+ if( stream_Peek( p_demux->s, &p_peek, TS_PACKET_SIZE_MAX ) <
+ TS_PACKET_SIZE_MAX ) return VLC_EGENERIC;
+
+ /* Search first sync byte */
+ for( i_sync = 0; i_sync < TS_PACKET_SIZE_MAX; i_sync++ )
+ {
+ if( p_peek[i_sync] == 0x47 ) break;
+ }
+ if( i_sync >= TS_PACKET_SIZE_MAX )
+ {
+ if( strcmp( p_demux->psz_demux, "ts" ) ) return VLC_EGENERIC;
+ msg_Warn( p_demux, "this does not look like a TS stream, continuing" );
+ }
+
+ /* Check next 3 sync bytes */
+ i_peek = TS_PACKET_SIZE_MAX * 3 + i_sync + 1;
+ if( ( stream_Peek( p_demux->s, &p_peek, i_peek ) ) < i_peek )
{
msg_Err( p_demux, "cannot peek" );
return VLC_EGENERIC;
}
-
- /* Search first synch */
- for( i_sync = 0; i_sync < i_peek; i_sync++ )
+ if( p_peek[i_sync + TS_PACKET_SIZE_188] == 0x47 &&
+ p_peek[i_sync + 2 * TS_PACKET_SIZE_188] == 0x47 &&
+ p_peek[i_sync + 3 * TS_PACKET_SIZE_188] == 0x47 )
{
- if( p_peek[i_sync] == 0x47 ) break;
+ i_packet_size = TS_PACKET_SIZE_188;
}
- if( i_sync >= i_peek )
+ else if( p_peek[i_sync + TS_PACKET_SIZE_192] == 0x47 &&
+ p_peek[i_sync + 2 * TS_PACKET_SIZE_192] == 0x47 &&
+ p_peek[i_sync + 3 * TS_PACKET_SIZE_192] == 0x47 )
{
- if( strcmp( p_demux->psz_demux, "ts2" ) )
- {
- msg_Warn( p_demux, "TS module discarded" );
- return VLC_EGENERIC;
- }
- msg_Warn( p_demux, "this does not look like a TS stream, continuing" );
+ i_packet_size = TS_PACKET_SIZE_192;
}
- if( strcmp( p_demux->psz_demux, "ts2" ) )
+ else if( p_peek[i_sync + TS_PACKET_SIZE_204] == 0x47 &&
+ p_peek[i_sync + 2 * TS_PACKET_SIZE_204] == 0x47 &&
+ p_peek[i_sync + 3 * TS_PACKET_SIZE_204] == 0x47 )
{
- /* 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;
- }
+ i_packet_size = TS_PACKET_SIZE_204;
+ }
+ else if( !strcmp( p_demux->psz_demux, "ts" ) )
+ {
+ i_packet_size = TS_PACKET_SIZE_188;
+ }
+ else
+ {
+ msg_Warn( p_demux, "TS module discarded (lost sync)" );
+ return VLC_EGENERIC;
}
/* Fill p_demux field */
memset( p_sys, 0, sizeof( demux_sys_t ) );
/* Init p_sys field */
+#if TS_USE_DVB_SI
+ p_sys->b_meta = VLC_TRUE;
+#else
+ p_sys->b_meta = VLC_TRUE;
+#endif
+ 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];
pid->b_seen = VLC_FALSE;
pid->b_valid = VLC_FALSE;
}
+ p_sys->i_packet_size = i_packet_size;
p_sys->b_udp_out = VLC_FALSE;
p_sys->i_ts_read = 50;
p_sys->csa = NULL;
PIDInit( pat, VLC_TRUE, NULL );
pat->psi->handle = dvbpsi_AttachPAT( (dvbpsi_pat_callback)PATCallBack,
p_demux );
+#if TS_USE_DVB_SI
+ if( p_sys->b_meta )
+ {
+ ts_pid_t *sdt = &p_sys->pid[0x11];
+ ts_pid_t *eit = &p_sys->pid[0x12];
+
+ PIDInit( sdt, VLC_TRUE, NULL );
+ sdt->psi->handle = dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack,
+ p_demux );
+ PIDInit( eit, VLC_TRUE, NULL );
+ eit->psi->handle = dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack,
+ p_demux );
+ if( p_sys->b_dvb_control )
+ {
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_STATE, 0x11, VLC_TRUE );
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_STATE, 0x12, VLC_TRUE );
+ }
+ }
+#endif
/* Init PMT array */
p_sys->i_pmt = 0;
/* Read config */
var_Create( p_demux, "ts-es-id-pid", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
var_Get( p_demux, "ts-es-id-pid", &val );
- p_sys->b_es_id_pid = val.b_bool,
+ p_sys->b_es_id_pid = val.b_bool;
var_Create( p_demux, "ts-out", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Get( p_demux, "ts-out", &val );
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;
+ p_sys->i_ts_read = mtu.i_int / p_sys->i_packet_size;
if( p_sys->i_ts_read <= 0 )
{
- p_sys->i_ts_read = 1500 / 188;
+ p_sys->i_ts_read = 1500 / p_sys->i_packet_size;
}
- p_sys->buffer = malloc( 188 * p_sys->i_ts_read );
+ p_sys->buffer = malloc( p_sys->i_packet_size * p_sys->i_ts_read );
}
}
if( val.psz_string )
{
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 );
+ pmt->psi->i_prg = 1;
+ pmt->psi->prg = malloc( sizeof(ts_prg_psi_t) );
/* FIXME we should also ask for a number */
pmt->psi->prg[0]->handle =
dvbpsi_AttachPMT( 1, (dvbpsi_pmt_callback)PMTCallBack,
{
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
{
+#ifndef UNDER_CE
+ uint64_t i_ck = strtoull( psz, NULL, 16 );
+#else
uint64_t i_ck = strtoll( psz, NULL, 16 );
+#endif
uint8_t ck[8];
int i;
for( i = 0; i < 8; i++ )
var_Get( p_demux, "ts-silent", &val );
p_sys->b_silent = val.b_bool;
+ var_Create( p_demux, "ts-capmt-sysid", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+ var_Get( p_demux, "ts-capmt-sysid", &val );
+ p_sys->i_capmt_sysid = val.i_int;
+
return VLC_SUCCESS;
}
if( pid->b_valid && pid->psi )
{
+ int j;
switch( pid->i_pid )
{
case 0: /* PAT */
case 1: /* CAT */
free( pid->psi );
break;
+ case 0x11: /* SDT */
+ dvbpsi_DetachDemux( pid->psi->handle );
+ free( pid->psi );
+ break;
+ case 0x12: /* EIT */
+ dvbpsi_DetachDemux( pid->psi->handle );
+ for( j = 0; j < pid->psi->i_eit; j++ )
+ {
+ free( pid->psi->eit[j] );
+ }
+ if( pid->psi->i_eit )
+ free( pid->psi->eit );
+ free( pid->psi );
+ break;
default:
PIDClean( p_demux->out, pid );
break;
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 );
}
ts_pid_t *p_pid;
/* Get a new TS packet */
- if( ( p_pkt = stream_Block( p_demux->s, 188 ) ) == NULL )
+ if( !( p_pkt = stream_Block( p_demux->s, p_sys->i_packet_size ) ) )
{
msg_Dbg( p_demux, "eof ?" );
return 0;
}
+
+ /* Check sync byte and re-sync if needed */
if( p_pkt->p_buffer[0] != 0x47 )
{
msg_Warn( p_demux, "lost synchro" );
block_Release( p_pkt );
- /* Resynch */
while( !p_demux->b_die )
{
- uint8_t *p_peek;
- int i_peek = stream_Peek( p_demux->s, &p_peek, 1880 );
- int i_skip = 0;
- vlc_bool_t b_ok = VLC_FALSE;
+ uint8_t *p_peek;
+ int i_peek, i_skip = 0;
- if( i_peek < 189 )
+ i_peek = stream_Peek( p_demux->s, &p_peek,
+ p_sys->i_packet_size * 10 );
+ if( i_peek < p_sys->i_packet_size + 1 )
{
msg_Dbg( p_demux, "eof ?" );
return 0;
}
- while( i_skip < i_peek - 188 )
+ while( i_skip < i_peek - p_sys->i_packet_size )
{
- if( p_peek[i_skip] == 0x47 && p_peek[i_skip+188] == 0x47 )
+ if( p_peek[i_skip] == 0x47 &&
+ p_peek[i_skip + p_sys->i_packet_size] == 0x47 )
{
- b_ok = VLC_TRUE;
break;
}
i_skip++;
}
+
+ msg_Dbg( p_demux, "skipping %d bytes of garbage", i_skip );
stream_Read( p_demux->s, NULL, i_skip );
- msg_Dbg( p_demux, "%d bytes of garbage", i_skip );
- if( b_ok )
+
+ if( i_skip < i_peek - p_sys->i_packet_size )
{
break;
}
}
- if( ( p_pkt = stream_Block( p_demux->s, 188 ) ) == NULL )
+
+ if( !( p_pkt = stream_Block( p_demux->s, p_sys->i_packet_size ) ) )
{
msg_Dbg( p_demux, "eof ?" );
return 0;
if( p_sys->b_udp_out )
{
- memcpy( &p_sys->buffer[i_pkt*188], p_pkt->p_buffer, 188 );
+ memcpy( &p_sys->buffer[i_pkt * p_sys->i_packet_size],
+ p_pkt->p_buffer, p_sys->i_packet_size );
}
/* Parse the TS packet */
{
if( p_pid->psi )
{
- if( p_pid->i_pid == 0 )
+ if( p_pid->i_pid == 0 || p_pid->i_pid == 0x11 || p_pid->i_pid == 0x12 )
{
dvbpsi_PushPacket( p_pid->psi->handle, p_pkt->p_buffer );
}
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 );
+ dvbpsi_PushPacket( p_pid->psi->prg[i_prg]->handle,
+ p_pkt->p_buffer );
}
}
block_Release( p_pkt );
}
else
{
+ PCRHandle( p_demux, p_pid, p_pkt );
block_Release( p_pkt );
}
}
{
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 );
if( p_sys->b_udp_out )
{
/* Send the complete block */
- net_Write( p_demux, p_sys->fd, p_sys->buffer, p_sys->i_ts_read * 188 );
+ net_Write( p_demux, p_sys->fd, NULL, p_sys->buffer,
+ p_sys->i_ts_read * p_sys->i_packet_size );
}
return 1;
*****************************************************************************/
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;
+ }
+ }
+ }
+ }
+ }
+ 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:
if( !b_old_valid )
{
pid->psi = malloc( sizeof( ts_psi_t ) );
+ pid->psi->handle= NULL;
pid->psi->i_prg = 0;
pid->psi->prg = NULL;
- pid->psi->handle= NULL;
+ pid->psi->i_eit = 0;
+ pid->psi->eit = 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 ) );
prg->i_version = -1;
prg->i_number = -1;
prg->i_pid_pcr = -1;
+ prg->i_pid_pmt = -1;
prg->iod = NULL;
prg->handle = NULL;
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->handle ) dvbpsi_DetachPMT( pid->psi->handle );
for( i = 0; i < pid->psi->i_prg; i++ )
{
- 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 );
+ 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 );
/****************************************************************************
* gathering stuff
****************************************************************************/
-static void ParsePES ( demux_t *p_demux, ts_pid_t *pid )
+static void ParsePES( demux_t *p_demux, ts_pid_t *pid )
{
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 )
{
- 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] );
+ if( !p_demux->p_sys->b_silent )
+ 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;
}
- i_pes_size = (header[4] << 8)|header[5];
-
/* TODO check size */
-
switch( header[3] )
{
case 0xBC: /* Program stream map */
{
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 )
}
}
+ /* ISO/IEC 13818-1 2.7.5: if no pts and no dts, then dts == pts */
+ if( i_pts >= 0 && i_dts < 0 )
+ i_dts = i_pts;
+
if( p_pes )
{
block_t *p_block;
{
p_pes->i_pts = i_pts * 100 / 9;
}
+ p_pes->i_length = i_length * 100 / 9;
- if( 1 ) //pid->es->b_gather )
- {
- /* For mpeg4/mscodec we first gather the packet.
- * This will make ffmpeg a lot happier */
- p_block = block_ChainGather( p_pes );
- }
- else
+ p_block = block_ChainGather( p_pes );
+ if( pid->es->fmt.i_codec == VLC_FOURCC( 's', 'u', 'b', 't' ) )
{
- p_block = p_pes;
+ 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++ )
static vlc_bool_t 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_adaptation= p[3]&0x20;
- const vlc_bool_t b_payload = p[3]&0x10;
- const int i_cc = p[3]&0x0f; /* continuity counter */
+ 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 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=%d unit_start=%d adaptation=%d payload=%d "
+ "cc=0x%x", pid->i_pid, b_unit_start, b_adaptation,
+ b_payload, i_cc );
+#endif
+
+ /* For now, ignore additional error correction
+ * TODO: handle Reed-Solomon 204,188 error correction */
+ p_bk->i_buffer = TS_PACKET_SIZE_188;
+
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=%d)",
+ pid->i_pid );
}
if( p_demux->p_sys->csa )
if( !b_adaptation )
{
+ /* We don't have any adaptation_field, so payload starts
+ * immediately after the 4 byte TS header */
i_skip = 4;
}
else
{
- /* p[4] is adaptation length */
+ /* p[4] is adaptation_field_length minus one */
i_skip = 5 + p[4];
if( p[4] > 0 )
{
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 );
}
}
}
- /* test continuity counter */
+
+ /* 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",
+ 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 )
{
- pid->es->p_pes->i_flags |= BLOCK_FLAG_DISCONTINUITY;
+ /* Small video artifacts are usually better then
+ * dropping full frames */
+ pid->es->p_pes->i_flags |= BLOCK_FLAG_CORRUPTED;
}
}
}
if( i_skip >= 188 || pid->es->id == NULL || p_demux->p_sys->b_udp_out )
{
block_Release( p_bk );
+ return i_ret;
}
- else
- {
- const vlc_bool_t b_unit_start= p[1]&0x40;
- /* we have to gather it */
- p_bk->p_buffer += i_skip;
- p_bk->i_buffer -= i_skip;
+ /* We have to gather it */
+ p_bk->p_buffer += i_skip;
+ p_bk->i_buffer -= i_skip;
+
+ if( b_unit_start )
+ {
+ if( pid->es->p_pes )
+ {
+ ParsePES( p_demux, pid );
+ i_ret = VLC_TRUE;
+ }
- if( b_unit_start )
+ block_ChainLastAppend( &pid->es->pp_last, p_bk );
+ if( p_bk->i_buffer > 6 )
{
- if( pid->es->p_pes )
+ pid->es->i_pes_size = GetWBE( &p_bk->p_buffer[4] );
+ if( pid->es->i_pes_size > 0 )
{
- ParsePES( p_demux, pid );
- i_ret = VLC_TRUE;
+ pid->es->i_pes_size += 6;
}
-
- 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;
+ }
+ }
+ else
+ {
+ if( pid->es->p_pes == NULL )
+ {
+ /* msg_Dbg( p_demux, "broken packet" ); */
+ block_Release( p_bk );
}
else
{
- if( pid->es->p_pes == NULL )
- {
- /* msg_Dbg( p_demux, "broken packet" ); */
- block_Release( p_bk );
- }
- else
+ 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 )
{
- /* TODO check if when have gathered enough packets to form a
- * PES (ie read PES size)*/
- block_ChainLastAppend( &pid->es->pp_last, p_bk );
+ ParsePES( p_demux, pid );
+ i_ret = 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;
iod_descriptor_t *p_iod;
int i;
int i_es_index;
- uint8_t i_flags;
+ uint8_t i_flags, i_iod_tag, byte1, byte2, byte3;
vlc_bool_t b_url;
int i_iod_length;
return p_iod;
}
- p_iod->i_iod_label = IODGetByte( &i_data, &p_data );
+ byte1 = IODGetByte( &i_data, &p_data );
+ byte2 = IODGetByte( &i_data, &p_data );
+ byte3 = IODGetByte( &i_data, &p_data );
+ if( byte2 == 0x02 ) //old vlc's buggy implementation of the IOD_descriptor
+ {
+ p_iod->i_iod_label_scope = 0x11;
+ p_iod->i_iod_label = byte1;
+ i_iod_tag = byte2;
+ }
+ else //correct implementation of the IOD_descriptor
+ {
+ p_iod->i_iod_label_scope = byte1;
+ p_iod->i_iod_label = byte2;
+ i_iod_tag = byte3;
+ }
fprintf( stderr, "\n* iod_label:%d", p_iod->i_iod_label );
fprintf( stderr, "\n* ===========" );
- fprintf( stderr, "\n* tag:0x%x", p_data[0] );
+ fprintf( stderr, "\n* tag:0x%x", i_iod_tag );
- if( IODGetByte( &i_data, &p_data ) != 0x02 )
+ if( i_iod_tag != 0x02 )
{
- fprintf( stderr, "\n ERR: tag != 0x02" );
+ fprintf( stderr, "\n ERR: tag %02x != 0x02", i_iod_tag );
return p_iod;
}
** 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;
+}
+
+#if TS_USE_DVB_SI
+static void SDTCallBack( demux_t *p_demux, dvbpsi_sdt_t *p_sdt )
+{
+ demux_sys_t *p_sys = p_demux->p_sys;
+ ts_pid_t *sdt = &p_sys->pid[0x11];
+ dvbpsi_sdt_service_t *p_srv;
+
+ msg_Dbg( p_demux, "SDTCallBack called" );
+
+ if( sdt->psi->i_sdt_version != -1 &&
+ ( !p_sdt->b_current_next ||
+ p_sdt->i_version == sdt->psi->i_sdt_version ) )
+ {
+ dvbpsi_DeleteSDT( p_sdt );
+ return;
+ }
+
+ msg_Dbg( p_demux, "new SDT ts_id=%d version=%d current_next=%d network_id=%d",
+ p_sdt->i_ts_id, p_sdt->i_version, p_sdt->b_current_next, p_sdt->i_network_id );
+
+ for( p_srv = p_sdt->p_first_service; p_srv; p_srv = p_srv->p_next )
+ {
+ vlc_meta_t *p_meta = vlc_meta_New();
+ dvbpsi_descriptor_t *p_dr;
+
+ msg_Dbg( p_demux, " * service id=%d eit schedule=%d present=%d runing=%d free_ca=%d",
+ p_srv->i_service_id,
+ p_srv->b_eit_schedule, p_srv->b_eit_present, p_srv->i_running_status,
+ p_srv->b_free_ca );
+
+ for( p_dr = p_srv->p_first_descriptor; p_dr; p_dr = p_dr->p_next )
+ {
+ if( p_dr->i_tag == 0x48 )
+ {
+ static const char *psz_type[0x11] = {
+ "Reserved",
+ "Digital television service",
+ "Digital radio sound service",
+ "Teletext service",
+ "NVOD reference service",
+ "NVOD time-shifted service",
+ "Mosaic service",
+ "PAL coded signal",
+ "SECAM coded signal",
+ "D/D2-MAC",
+ "FM Radio",
+ "NTSC coded signal",
+ "Data broadcast service",
+ "Reserved for Common Interface Usage",
+ "RCS Map (see EN 301 790 [35])",
+ "RCS FLS (see EN 301 790 [35])",
+ "DVB MHP service"
+ };
+ dvbpsi_service_dr_t *pD = dvbpsi_DecodeServiceDr( p_dr );
+ char str1[257];
+ char str2[257];
+
+ memcpy( str1, pD->i_service_provider_name, pD->i_service_provider_name_length );
+ str1[pD->i_service_provider_name_length] = '\0';
+ memcpy( str2, pD->i_service_name, pD->i_service_name_length );
+ str2[pD->i_service_name_length] = '\0';
+
+ msg_Dbg( p_demux, " - type=%d provider=%s name=%s",
+ pD->i_service_type, str1, str2 );
+
+ vlc_meta_Add( p_meta, "Name", str2 );
+ vlc_meta_Add( p_meta, "Provider", str1 );
+ if( pD->i_service_type >= 0x01 && pD->i_service_type <= 0x10 )
+ vlc_meta_Add( p_meta, "Type", psz_type[pD->i_service_type] );
+ }
+ }
+
+ if( p_srv->i_running_status == 0x01 )
+ vlc_meta_Add( p_meta, "Status", "Not running" );
+ else if( p_srv->i_running_status == 0x02 )
+ vlc_meta_Add( p_meta, "Status", "Starts in a few seconds" );
+ else if( p_srv->i_running_status == 0x03 )
+ vlc_meta_Add( p_meta, "Status", "Pausing" );
+ else if( p_srv->i_running_status == 0x04 )
+ vlc_meta_Add( p_meta, "Status", "Running" );
+ else
+ vlc_meta_Add( p_meta, "Status", "Unknown" );
+
+
+ es_out_Control( p_demux->out, ES_OUT_SET_GROUP_META,
+ p_srv->i_service_id, p_meta );
+ vlc_meta_Delete( p_meta );
+ }
+
+ sdt->psi->i_sdt_version = p_sdt->i_version;
+ dvbpsi_DeleteSDT( p_sdt );
+}
+#if 0
+static void DecodeMjd( int i_mjd, int *p_y, int *p_m, int *p_d )
+{
+ int yp = (int)( ( (double)i_mjd - 15078.2)/365.25 );
+ int mp = (int)( ((double)i_mjd - 14956.1 - (int)(yp * 365.25)) / 30.6001 );
+
+ *p_d = i_mjd - 14956 - (int)(yp*365.25) - (int)(mp*30.6001);
+
+ if( mp == 14 || mp == 15 )
+ {
+ *p_y = yp + 1;
+ *p_m = mp - 1 + 12;
+ }
+ else
+ {
+ *p_y = yp;
+ *p_m = mp - 1;
+ }
+}
+#endif
+
+static void EITCallBack( ts_eit_psi_t *psi, dvbpsi_eit_t *p_eit )
+{
+ demux_t *p_demux = psi->p_demux;
+
+ dvbpsi_eit_event_t *p_evt;
+
+ msg_Dbg( p_demux, "EITCallBack called" );
+ if( psi->i_version != -1 &&
+ ( !p_eit->b_current_next || psi->i_version == p_eit->i_version ) )
+ {
+ dvbpsi_DeleteEIT( p_eit );
+ return;
+ }
+
+ msg_Dbg( p_demux, "new EIT service_id=%d version=%d current_next=%d ts_id=%d network_id=%d"
+ "segment_last_section_number=%d last_table_id=%d",
+ p_eit->i_service_id, p_eit->i_version, p_eit->b_current_next, p_eit->i_ts_id,
+ p_eit->i_network_id, p_eit->i_segment_last_section_number, p_eit->i_last_table_id );
+
+ for( p_evt = p_eit->p_first_event; p_evt; p_evt = p_evt->p_next )
+ {
+ vlc_meta_t *p_meta = vlc_meta_New();
+ dvbpsi_descriptor_t *p_dr;
+ char *psz_cat = malloc( strlen("Event")+10 );
+ char psz_start[15];
+ char psz_duration[15];
+ char psz_name[256];
+ char psz_text[256];
+ char *psz_extra = strdup("");
+ char *psz_value;
+
+ sprintf( psz_cat, "Event %d", p_evt->i_event_id );
+ sprintf( psz_start, "%d%d:%d%d:%d%d",
+ (int)(p_evt->i_start_time >> 20)&0xf,
+ (int)(p_evt->i_start_time >> 16)&0xf,
+ (int)(p_evt->i_start_time >> 12)&0xf,
+ (int)(p_evt->i_start_time >> 8)&0xf,
+ (int)(p_evt->i_start_time >> 4)&0xf,
+ (int)(p_evt->i_start_time )&0xf );
+ sprintf( psz_duration, "%d%d:%d%d:%d%d",
+ (p_evt->i_duration >> 20)&0xf, (p_evt->i_duration >> 16)&0xf,
+ (p_evt->i_duration >> 12)&0xf, (p_evt->i_duration >> 8)&0xf,
+ (p_evt->i_duration >> 4)&0xf, (p_evt->i_duration )&0xf );
+ psz_name[0] = psz_text[0] = '\0';
+
+ msg_Dbg( p_demux, " * event id=%d start_time:mjd=%d %s duration=%s "
+ "running=%d free_ca=%d",
+ p_evt->i_event_id,
+ (int)(p_evt->i_start_time >> 24),
+ psz_start, psz_duration,
+ p_evt->i_running_status, p_evt->b_free_ca );
+
+ for( p_dr = p_evt->p_first_descriptor; p_dr; p_dr = p_dr->p_next )
+ {
+ if( p_dr->i_tag == 0x4d )
+ {
+ dvbpsi_short_event_dr_t *pE = dvbpsi_DecodeShortEventDr( p_dr );
+
+ if( pE )
+ {
+ memcpy( psz_name, pE->i_event_name, pE->i_event_name_length);
+ psz_name[pE->i_event_name_length] = '\0';
+ memcpy( psz_text, pE->i_text, pE->i_text_length );
+ psz_text[pE->i_text_length] = '\0';
+
+ msg_Dbg( p_demux, " - short event lang=%3.3s '%s' : '%s'",
+ pE->i_iso_639_code, psz_name, psz_text );
+ }
+ }
+ else if( p_dr->i_tag == 0x4e )
+ {
+ dvbpsi_extended_event_dr_t *pE = dvbpsi_DecodeExtendedEventDr( p_dr );
+ char str1[257];
+ char str2[257];
+
+ if( pE )
+ {
+ int i;
+ msg_Dbg( p_demux, " - extended event lang=%3.3s",
+ pE->i_iso_639_code );
+ for( i = 0; i < pE->i_entry_count; i++ )
+ {
+ memcpy( str1, pE->i_item_description[i],
+ pE->i_item_description_length[i] );
+ str1[pE->i_item_description_length[i]] = '\0';
+
+ memcpy( str1, pE->i_item[i],
+ pE->i_item_length[i] );
+ str2[pE->i_item_length[i]] = '\0';
+
+ msg_Dbg( p_demux, " - desc='%s' item='%s'", str1, str2 );
+ psz_extra = realloc( psz_extra,
+ strlen(psz_extra) +
+ strlen(str1) +strlen(str2) + 1 + 3 );
+ strcat( psz_extra, str1 );
+ strcat( psz_extra, "(" );
+ strcat( psz_extra, str2 );
+ strcat( psz_extra, ") " );
+ }
+
+ memcpy( str1, pE->i_text, pE->i_text_length );
+ str1[pE->i_text_length] = '\0';
+ msg_Dbg( p_demux, " - text='%s'", str1 );
+ psz_extra = realloc( psz_extra,
+ strlen(psz_extra) + strlen(str1) + 2 );
+ strcat( psz_extra, str1 );
+ strcat( psz_extra, " " );
+ }
+ }
+ else
+ {
+ msg_Dbg( p_demux, " - tag=0x%x(%d)", p_dr->i_tag, p_dr->i_tag );
+ }
+ }
+
+ asprintf( &psz_value, "%s: %s (+%s) %s (%s)",
+ psz_start,
+ psz_name,
+ psz_duration,
+ psz_text, psz_extra );
+ vlc_meta_Add( p_meta, psz_cat, psz_value );
+ free( psz_value );
+
+ es_out_Control( p_demux->out, ES_OUT_SET_GROUP_META,
+ p_eit->i_service_id, p_meta );
+ vlc_meta_Delete( p_meta );
+
+ free( psz_cat );
+ free( psz_extra );
+ }
+ psi->i_version = p_eit->i_version;
+ dvbpsi_DeleteEIT( p_eit );
+}
+
+static void PSINewTableCallBack( demux_t *p_demux, dvbpsi_handle h,
+ uint8_t i_table_id, uint16_t i_extension )
+{
+#if 0
+ msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
+ i_table_id, i_table_id, i_extension, i_extension );
+#endif
+ if( i_table_id == 0x42 )
+ {
+ msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
+ i_table_id, i_table_id, i_extension, i_extension );
+
+ dvbpsi_AttachSDT( h, i_table_id, i_extension, (dvbpsi_sdt_callback)SDTCallBack, p_demux );
+ }
+ else if( i_table_id == 0x4e || /* Current/Following */
+ ( i_table_id >= 0x50 && i_table_id <= 0x5f ) ) /* Schedule */
+ {
+ ts_eit_psi_t *psi = malloc( sizeof(ts_eit_psi_t) );
+
+ msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
+ i_table_id, i_table_id, i_extension, i_extension );
+
+ psi->p_demux = p_demux;
+ psi->i_table_id = i_table_id;
+ psi->i_version = -1;
+ psi->i_service_id = i_extension;
+
+ dvbpsi_AttachEIT( h, i_table_id, i_extension, (dvbpsi_eit_callback)EITCallBack, psi );
+ }
+}
+#endif
+
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;
+
+ ts_pid_t **pp_clean = NULL;
+ int i_clean = 0, i;
msg_Dbg( p_demux, "PMTCallBack called" );
int i_prg;
for( i_prg = 0; i_prg < p_sys->pmt[i]->psi->i_prg; i_prg++ )
{
- if( p_sys->pmt[i]->psi->prg[i_prg]->i_number == p_pmt->i_program_number )
+ 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 ) break;
}
if( pmt == NULL )
{
ts_pid_t *pid = &p_sys->pid[i];
- if( pid->b_valid && pid->p_owner == pmt->psi && pid->i_owner_number == prg->i_number && 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 );
+ TAB_APPEND( i_clean, pp_clean, pid );
}
}
if( prg->iod )
prg->iod = NULL;
}
- 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 )
{
if( p_dr->i_tag == 0x1d )
{
/* We have found an IOD descriptor */
- msg_Warn( p_demux, " * descriptor : IOD (0x1d)" );
+ msg_Dbg( p_demux, " * descriptor : IOD (0x1d)" );
prg->iod = IODNew( p_dr->i_length, p_dr->p_data );
}
+ else if( p_dr->i_tag == 0x9 )
+ {
+ uint16_t i_sysid = ((uint16_t)p_dr->p_data[0] << 8)
+ | p_dr->p_data[1];
+ msg_Dbg( p_demux, " * descriptor : CA (0x9) SysID 0x%x", i_sysid );
+ }
else
{
msg_Dbg( p_demux, " * descriptor : unknown (0x%x)", p_dr->i_tag );
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 )
+ 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;;
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 );
pid->es->fmt.i_cat = VIDEO_ES;
switch( dcd->i_objectTypeIndication )
{
+ case 0x0B: /* mpeg4 sub */
+ pid->es->fmt.i_cat = SPU_ES;
+ pid->es->fmt.i_codec = VLC_FOURCC('s','u','b','t');
+ break;
+
case 0x20: /* mpeg4 */
pid->es->fmt.i_codec = VLC_FOURCC('m','p','4','v');
break;
+ case 0x21: /* h264 */
+ pid->es->fmt.i_codec = VLC_FOURCC('h','2','6','4');
+ break;
case 0x60:
case 0x61:
case 0x62:
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 )
+ if( p_dr->i_tag == 0x05 )
{
+ /* Registration Descriptor */
+ if( p_dr->i_length != 4 )
+ {
+ msg_Warn( p_demux, "invalid Registration Descriptor" );
+ }
+ else
+ {
+ if( !memcmp( p_dr->p_data, "AC-3", 4 ) )
+ {
+ /* ATSC with stream_type 0x81 (but this descriptor
+ * is then not mandatory */
+ pid->es->fmt.i_cat = AUDIO_ES;
+ pid->es->fmt.i_codec = VLC_FOURCC('a','5','2',' ');
+ }
+ else if( !memcmp( p_dr->p_data, "DTS1", 4 ) ||
+ !memcmp( p_dr->p_data, "DTS2", 4 ) ||
+ !memcmp( p_dr->p_data, "DTS3", 4 ) )
+ {
+ /*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( !memcmp( p_dr->p_data, "BSSD", 4 ) )
+ {
+ pid->es->fmt.i_cat = AUDIO_ES;
+ pid->es->fmt.i_codec = VLC_FOURCC('l','p','c','m');
+ }
+ else
+ {
+ msg_Warn( p_demux,
+ "unknown Registration Descriptor (%4.4s)",
+ p_dr->p_data );
+ }
+ }
+
+ }
+ else if( p_dr->i_tag == 0x6a )
+ {
+ /* DVB with stream_type 0x06 */
pid->es->fmt.i_cat = AUDIO_ES;
pid->es->fmt.i_codec = VLC_FOURCC( 'a', '5', '2', ' ' );
}
+ 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', ' ' );
+ }
+ 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, " * 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.subs.dvb.i_id =
sub->p_subtitle[0].i_composition_page_id;
+ /* Hack, FIXME */
+ pid->es->fmt.subs.dvb.i_id |=
+ ((int)sub->p_subtitle[0].i_ancillary_page_id << 16);
}
else pid->es->fmt.i_cat = UNKNOWN_ES;
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.subs.dvb.i_id =
sub->p_subtitle[n].i_composition_page_id;
+ /* Hack, FIXME */
+ p_es->fmt.subs.dvb.i_id |=
+ ((int)sub->p_subtitle[n].i_ancillary_page_id << 16);
TAB_APPEND( pid->i_extra_es, pid->extra_es, p_es );
}
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->fmt.i_id = p_es->i_pid;
+ 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 );
+ }
+ }
+ }
- pid->es->id = es_out_Add( p_demux->out, &pid->es->fmt );
+ /* 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( 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 )
+ {
+ if( p_dr->i_tag == 0x9 )
{
- pid->extra_es[i]->id =
- es_out_Add( p_demux->out, &pid->extra_es[i]->fmt);
+ uint16_t i_sysid = ((uint16_t)p_dr->p_data[0] << 8)
+ | p_dr->p_data[1];
+ msg_Dbg( p_demux, " * descriptor : CA (0x9) SysID 0x%x",
+ i_sysid );
}
}
+
+ 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 );
+ }
+ }
+
+ if( DVBProgramIsSelected( p_demux, prg->i_number ) )
+ {
+ /* Set CAM descrambling */
+ stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
+ ACCESS_SET_PRIVATE_ID_CA, p_pmt );
+ }
+ else
+ {
+ 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] );
}
- dvbpsi_DeletePMT(p_pmt);
+ if( i_clean ) free( pp_clean );
}
static void PATCallBack( demux_t *p_demux, dvbpsi_pat_t *p_pat )
msg_Dbg( p_demux, "PATCallBack called" );
if( pat->psi->i_pat_version != -1 &&
- ( !p_pat->b_current_next || p_pat->i_version == pat->psi->i_pat_version ) )
+ ( !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",
+ 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 */
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 )
+ if( p_program->i_number ==
+ pmt->psi->prg[i_prg]->i_number )
{
b_keep = VLC_TRUE;
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 )
{
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;
+ (dvbpsi_pmt_callback)PMTCallBack,
+ 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( DVBProgramIsSelected( p_demux, 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;
+ }
+ }
}
}
}
projects / vlc / blobdiff