#include <vlc_plugin.h>
#include <assert.h>
+#include <time.h>
#include <vlc_access.h> /* DVB-specific things */
#include <vlc_demux.h>
#include <vlc_meta.h>
#include <vlc_epg.h>
#include <vlc_charset.h> /* FromCharset, for EIT */
-
-#include <vlc_network.h> /* net_ for ts-out mode */
+#include <vlc_bits.h>
#include "../mux/mpeg/csa.h"
#include "../mux/mpeg/dvbpsi_compat.h"
+#include "../codec/opus_header.h"
+
+#include "opus.h"
+
#undef TS_DEBUG
VLC_FORMAT(1, 2) static void ts_debug(const char *format, ...)
{
#endif
}
+#ifdef HAVE_ARIBB24
+ #include <aribb24/aribb24.h>
+ #include <aribb24/decoder.h>
+#endif
+
+typedef enum arib_modes_e
+{
+ ARIBMODE_AUTO = -1,
+ ARIBMODE_DISABLED = 0,
+ ARIBMODE_ENABLED = 1
+} arib_modes_e;
+
/*****************************************************************************
* Module descriptor
*****************************************************************************/
" the TS stream, instead of 1, 2, 3, etc. Useful to" \
" do \'#duplicate{..., select=\"es=<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 Key")
#define CSA_LONGTEXT N_("CSA encryption key. This must be a " \
"16 char string (8 hexadecimal bytes).")
#define PCR_TEXT N_("Trust in-stream PCR")
#define PCR_LONGTEXT N_("Use the stream PCR as a reference.")
+static const int const arib_mode_list[] =
+ { ARIBMODE_AUTO, ARIBMODE_ENABLED, ARIBMODE_DISABLED };
+static const char *const arib_mode_list_text[] =
+ { N_("Auto"), N_("Enabled"), N_("Disabled") };
+
+#define SUPPORT_ARIB_TEXT N_("ARIB STD-B24 mode")
+#define SUPPORT_ARIB_LONGTEXT N_( \
+ "Forces ARIB STD-B24 mode for decoding characters." \
+ "This feature affects EPG information and subtitles." )
+
vlc_module_begin ()
set_description( N_("MPEG Transport Stream demuxer") )
set_shortname ( "MPEG-TS" )
change_safe()
add_bool( "ts-es-id-pid", true, PID_TEXT, PID_LONGTEXT, true )
change_safe()
- add_string( "ts-out", NULL, TSOUT_TEXT, TSOUT_LONGTEXT, true )
- add_integer( "ts-out-mtu", 1400, MTUOUT_TEXT,
- MTUOUT_LONGTEXT, true )
-
+ add_obsolete_string( "ts-out" ) /* since 2.2.0 */
+ add_obsolete_integer( "ts-out-mtu" ) /* since 2.2.0 */
add_string( "ts-csa-ck", NULL, CSA_TEXT, CSA_LONGTEXT, true )
change_safe()
add_string( "ts-csa2-ck", NULL, CSA2_TEXT, CSA2_LONGTEXT, true )
add_bool( "ts-split-es", true, SPLIT_ES_TEXT, SPLIT_ES_LONGTEXT, false )
add_bool( "ts-seek-percent", false, SEEK_PERCENT_TEXT, SEEK_PERCENT_LONGTEXT, true )
+ add_integer( "ts-arib", ARIBMODE_AUTO, SUPPORT_ARIB_TEXT, SUPPORT_ARIB_LONGTEXT, false )
+ change_integer_list( arib_mode_list, arib_mode_list_text )
+
add_obsolete_bool( "ts-silent" );
set_capability( "demux", 10 )
} es_mpeg4_descriptor_t;
+#define ES_DESCRIPTOR_COUNT 255
typedef struct
{
/* IOD */
char *psz_url;
- es_mpeg4_descriptor_t es_descr[255];
+ es_mpeg4_descriptor_t es_descr[ES_DESCRIPTOR_COUNT];
} iod_descriptor_t;
TS_ES_DATA_TABLE_SECTION
} ts_es_data_type_t;
+typedef enum
+{
+ TS_PMT_REGISTRATION_NONE = 0,
+ TS_PMT_REGISTRATION_HDMV
+} ts_pmt_registration_type_t;
+
typedef struct
{
es_format_t fmt;
/* TS packet size (188, 192, 204) */
int i_packet_size;
+ /* Additional TS packet header size (BluRay TS packets have 4-byte header before sync byte) */
+ int i_packet_header_size;
+
/* how many TS packet we read at once */
int i_ts_read;
mtime_t *p_pcrs;
int64_t *p_pos;
+ struct
+ {
+ arib_modes_e e_mode;
+#ifdef HAVE_ARIBB24
+ arib_instance_t *p_instance;
+#endif
+ } arib;
+
/* All pid */
ts_pid_t pid[8192];
int i_csa_pkt_size;
bool b_split_es;
- bool b_udp_out;
- int fd; /* udp socket */
- uint8_t *buffer;
bool b_trust_pcr;
/* */
static void PIDInit ( ts_pid_t *pid, bool b_psi, ts_psi_t *p_owner );
static void PIDClean( demux_t *, ts_pid_t *pid );
-static void PIDFillFormat( ts_es_t *es, int i_stream_type );
+static void PIDFillFormat( es_format_t *fmt, int i_stream_type );
static void PATCallBack( void*, dvbpsi_pat_t * );
static void PMTCallBack( void *data, dvbpsi_pmt_t *p_pmt );
static bool GatherData( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk );
static block_t* ReadTSPacket( demux_t *p_demux );
-static mtime_t GetPCR( block_t *p_pkt );
-static int SeekToPCR( demux_t *p_demux, int64_t i_pos );
static int Seek( demux_t *p_demux, double f_percent );
static void GetFirstPCR( demux_t *p_demux );
static void GetLastPCR( demux_t *p_demux );
#define TS_PACKET_SIZE_192 192
#define TS_PACKET_SIZE_204 204
#define TS_PACKET_SIZE_MAX 204
-#define TS_TOPFIELD_HEADER 1320
-static int DetectPacketSize( demux_t *p_demux )
+static int DetectPacketSize( demux_t *p_demux, int *pi_header_size )
{
const uint8_t *p_peek;
if( stream_Peek( p_demux->s,
&p_peek, TS_PACKET_SIZE_MAX ) < TS_PACKET_SIZE_MAX )
return -1;
+ *pi_header_size = 0;
+
if( memcmp( p_peek, "TFrc", 4 ) == 0 )
{
#if 0
p_peek[i_sync + 2 * TS_PACKET_SIZE_192] == 0x47 &&
p_peek[i_sync + 3 * TS_PACKET_SIZE_192] == 0x47 )
{
+ if( i_sync == 4 )
+ {
+ *pi_header_size = 4; /* BluRay TS packets have 4-byte header */
+ }
return TS_PACKET_SIZE_192;
}
else if( p_peek[i_sync + 1 * TS_PACKET_SIZE_204] == 0x47 &&
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
- int i_packet_size;
+ int i_packet_size, i_packet_header_size = 0;
ts_pid_t *pat;
/* Search first sync byte */
- i_packet_size = DetectPacketSize( p_demux );
+ i_packet_size = DetectPacketSize( p_demux, &i_packet_header_size );
if( i_packet_size < 0 )
return VLC_EGENERIC;
memset( p_sys, 0, sizeof( demux_sys_t ) );
vlc_mutex_init( &p_sys->csa_lock );
- p_sys->buffer = NULL;
p_demux->pf_demux = Demux;
p_demux->pf_control = Control;
/* PID 8191 is padding */
p_sys->pid[8191].b_seen = true;
p_sys->i_packet_size = i_packet_size;
- p_sys->b_udp_out = false;
- p_sys->fd = -1;
+ p_sys->i_packet_header_size = i_packet_header_size;
p_sys->i_ts_read = 50;
p_sys->csa = NULL;
p_sys->b_start_record = false;
p_sys->b_trust_pcr = var_CreateGetBool( p_demux, "ts-trust-pcr" );
- char* psz_string = var_CreateGetString( p_demux, "ts-out" );
- if( psz_string && *psz_string )
- {
- char *psz = strchr( psz_string, ':' );
- int i_port = 0;
-
- p_sys->b_udp_out = true;
-
- if( psz )
- {
- *psz++ = '\0';
- i_port = atoi( psz );
- }
- if( i_port <= 0 ) i_port = 1234;
- msg_Dbg( p_demux, "resend ts to '%s:%d'", psz_string, i_port );
-
- p_sys->fd = net_ConnectUDP( VLC_OBJECT(p_demux), psz_string, i_port, -1 );
- if( p_sys->fd < 0 )
- {
- msg_Err( p_demux, "failed to open udp socket, send disabled" );
- p_sys->b_udp_out = false;
- }
- else
- {
- int i_mtu = var_CreateGetInteger( p_demux, "ts-out-mtu" );
- p_sys->i_ts_read = i_mtu / p_sys->i_packet_size;
- if( p_sys->i_ts_read <= 0 )
- {
- p_sys->i_ts_read = 1500 / p_sys->i_packet_size;
- }
- p_sys->buffer = xmalloc( p_sys->i_packet_size * p_sys->i_ts_read );
- }
- }
- free( psz_string );
-
/* We handle description of an extra PMT */
- psz_string = var_CreateGetString( p_demux, "ts-extra-pmt" );
+ char* psz_string = var_CreateGetString( p_demux, "ts-extra-pmt" );
p_sys->b_user_pmt = false;
if( psz_string && *psz_string )
UserPmt( p_demux, psz_string );
p_sys->p_pcrs = (mtime_t *)calloc( p_sys->i_pcrs_num, sizeof( mtime_t ) );
p_sys->p_pos = (int64_t *)calloc( p_sys->i_pcrs_num, sizeof( int64_t ) );
+ p_sys->arib.e_mode = var_InheritInteger( p_demux, "ts-arib" );
+
if( !p_sys->p_pcrs || !p_sys->p_pos )
{
Close( p_this );
}
if( p_sys->i_first_pcr < 0 || p_sys->i_last_pcr < 0 )
{
+ msg_Dbg( p_demux, "Force Seek Per Percent: PCR's not found,");
p_sys->b_force_seek_per_percent = true;
}
while( p_sys->i_pmt_es <= 0 && vlc_object_alive( p_demux ) )
{
- if( p_demux->pf_demux( p_demux ) != 1 )
+ if( Demux( p_demux ) != 1 )
break;
}
-
return VLC_SUCCESS;
}
free( p_sys->programs_list.p_values );
- /* When streaming, close the port */
- if( p_sys->fd > -1 )
- {
- net_Close( p_sys->fd );
- }
-
- free( p_sys->buffer );
-
free( p_sys->p_pcrs );
free( p_sys->p_pos );
+#ifdef HAVE_ARIBB24
+ if ( p_sys->arib.p_instance )
+ arib_instance_destroy( p_sys->arib.p_instance );
+#endif
+
vlc_mutex_destroy( &p_sys->csa_lock );
free( p_sys );
}
p_sys->b_start_record = false;
}
- if( p_sys->b_udp_out )
- {
- memcpy( &p_sys->buffer[i_pkt * p_sys->i_packet_size],
- p_pkt->p_buffer, p_sys->i_packet_size );
- }
-
/* Parse the TS packet */
ts_pid_t *p_pid = &p_sys->pid[PIDGet( p_pkt )];
}
block_Release( p_pkt );
}
- else if( !p_sys->b_udp_out )
- {
- b_frame = GatherData( p_demux, p_pid, p_pkt );
- }
else
{
- PCRHandle( p_demux, p_pid, p_pkt );
- block_Release( p_pkt );
+ b_frame = GatherData( p_demux, p_pid, p_pkt );
}
}
else
break;
}
- if( p_sys->b_udp_out )
- {
- /* Send the complete block */
- net_Write( p_demux, p_sys->fd, NULL, p_sys->buffer,
- p_sys->i_ts_read * p_sys->i_packet_size );
- }
-
demux_UpdateTitleFromStream( p_demux );
return 1;
}
if( !DVBEventInformation( p_demux, &i_time, &i_length ) && i_length > 0 )
*pf = (double)i_time/(double)i_length;
else if( (i64 = stream_Size( p_demux->s) ) > 0 )
- *pf = (double)stream_Tell( p_demux->s ) / (double)i64;
+ {
+ int64_t offset = stream_Tell( p_demux->s );
+
+ *pf = (double)offset / (double)i64;
+ }
else
*pf = 0.0;
}
else
{
const int i_stream_type = strtol( psz_opt, NULL, 0 );
- PIDFillFormat( pid->es, i_stream_type );
+ PIDFillFormat( &pid->es->fmt, i_stream_type );
}
pid->es->fmt.i_group = i_number;
if( p_sys->b_es_id_pid )
pid->b_valid = false;
}
+static int16_t read_opus_flag(uint8_t **buf, size_t *len)
+{
+ if (*len < 2)
+ return -1;
+
+ int16_t ret = ((*buf)[0] << 8) | (*buf)[1];
+
+ *len -= 2;
+ *buf += 2;
+
+ if (ret & (3<<13))
+ ret = -1;
+
+ return ret;
+}
+
+static block_t *Opus_Parse(demux_t *demux, block_t *block)
+{
+ block_t *out = NULL;
+ block_t **last = NULL;
+
+ uint8_t *buf = block->p_buffer;
+ size_t len = block->i_buffer;
+
+ while (len > 3 && ((buf[0] << 3) | (buf[1] >> 5)) == 0x3ff) {
+ int16_t start_trim = 0, end_trim = 0;
+ int start_trim_flag = (buf[1] >> 4) & 1;
+ int end_trim_flag = (buf[1] >> 3) & 1;
+ int control_extension_flag = (buf[1] >> 2) & 1;
+
+ len -= 2;
+ buf += 2;
+
+ unsigned au_size = 0;
+ while (len--) {
+ int c = *buf++;
+ au_size += c;
+ if (c != 0xff)
+ break;
+ }
+
+ if (start_trim_flag) {
+ start_trim = read_opus_flag(&buf, &len);
+ if (start_trim < 0) {
+ msg_Err(demux, "Invalid start trimming flag");
+ }
+ }
+ if (end_trim_flag) {
+ end_trim = read_opus_flag(&buf, &len);
+ if (end_trim < 0) {
+ msg_Err(demux, "Invalid end trimming flag");
+ }
+ }
+ if (control_extension_flag && len) {
+ unsigned l = *buf++; len--;
+ if (l > len) {
+ msg_Err(demux, "Invalid control extension length %d > %zu", l, len);
+ break;
+ }
+ buf += l;
+ len -= l;
+ }
+
+ if (!au_size || au_size > len) {
+ msg_Err(demux, "Invalid Opus AU size %d (PES %zu)", au_size, len);
+ break;
+ }
+
+ block_t *au = block_Alloc(au_size);
+ if (!au)
+ break;
+ memcpy(au->p_buffer, buf, au_size);
+ block_CopyProperties(au, block);
+ au->p_next = NULL;
+
+ if (!out)
+ out = au;
+ else
+ *last = au;
+ last = &au->p_next;
+
+ au->i_nb_samples = opus_frame_duration(buf, au_size);
+ if (end_trim && end_trim <= au->i_nb_samples)
+ au->i_length = end_trim; /* Blatant abuse of the i_length field. */
+ else
+ au->i_length = 0;
+
+ if (start_trim && start_trim < (au->i_nb_samples - au->i_length)) {
+ au->i_nb_samples -= start_trim;
+ if (au->i_nb_samples == 0)
+ au->i_flags |= BLOCK_FLAG_PREROLL;
+ }
+
+ buf += au_size;
+ len -= au_size;
+ }
+
+ block_Release(block);
+ return out;
+}
+
/****************************************************************************
* gathering stuff
****************************************************************************/
/* FIXME find real max size */
/* const int i_max = */ block_ChainExtract( p_pes, header, 34 );
- if( header[0] != 0 || header[1] != 0 || header[2] != 1 )
+ if( pid->b_scrambled || header[0] != 0 || header[1] != 0 || header[2] != 1 )
{
- msg_Warn( p_demux, "invalid header [0x%02x:%02x:%02x:%02x] (pid: %d)",
- header[0], header[1],header[2],header[3], pid->i_pid );
+ if ( !pid->b_scrambled )
+ msg_Warn( p_demux, "invalid header [0x%02x:%02x:%02x:%02x] (pid: %d)",
+ header[0], header[1],header[2],header[3], pid->i_pid );
block_ChainRelease( p_pes );
return;
}
/* Append a \0 */
p_block = block_Realloc( p_block, 0, p_block->i_buffer + 1 );
if( !p_block )
- abort();
+ return;
p_block->p_buffer[p_block->i_buffer -1] = '\0';
}
else if( pid->es->fmt.i_codec == VLC_CODEC_TELETEXT )
}
}
}
-
- for( int i = 0; i < pid->i_extra_es; i++ )
+ else if( pid->es->fmt.i_codec == VLC_CODEC_ARIB_A ||
+ pid->es->fmt.i_codec == VLC_CODEC_ARIB_C )
+ {
+ if( p_block->i_pts <= VLC_TS_INVALID )
+ {
+ 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 );
+ if( !p_block )
+ return;
+ p_block->p_buffer[p_block->i_buffer -1] = '\0';
+ }
+ }
+ else if( pid->es->fmt.i_codec == VLC_CODEC_OPUS)
{
- es_out_Send( p_demux->out, pid->extra_es[i]->id,
- block_Duplicate( p_block ) );
+ p_block = Opus_Parse(p_demux, p_block);
}
- if (!p_sys->b_trust_pcr)
- es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block->i_pts);
+ while (p_block) {
+ block_t *p_next = p_block->p_next;
+ p_block->p_next = NULL;
+ for( int i = 0; i < pid->i_extra_es; i++ )
+ {
+ es_out_Send( p_demux->out, pid->extra_es[i]->id,
+ block_Duplicate( p_block ) );
+ }
+
+ if (!p_sys->b_trust_pcr)
+ es_out_Control( p_demux->out, ES_OUT_SET_GROUP_PCR,
+ pid->i_owner_number, p_block->i_pts);
+
+ es_out_Send( p_demux->out, pid->es->id, p_block );
- es_out_Send( p_demux->out, pid->es->id, p_block );
+ p_block = p_next;
+ }
}
else
{
if( p_content->i_buffer > 9 && p_content->p_buffer[0] == 0xc6 )
{
int i_index = 0;
- int i_offset = 4;
+ size_t i_offset = 4;
if( p_content->p_buffer[3] & 0x40 )
{
i_index = ((p_content->p_buffer[7] & 0x0f) << 8) |
return NULL;
}
+ /* Skip header (BluRay streams).
+ * re-sync logic would do this (by adjusting packet start), but this would result in losing first and last ts packets.
+ * First packet is usually PAT, and losing it means losing whole first GOP. This is fatal with still-image based menus.
+ */
+ p_pkt->p_buffer += p_sys->i_packet_header_size;
+ p_pkt->i_buffer -= p_sys->i_packet_header_size;
+
/* Check sync byte and re-sync if needed */
if( p_pkt->p_buffer[0] != 0x47 )
{
while( i_skip < i_peek - p_sys->i_packet_size )
{
- if( p_peek[i_skip] == 0x47 &&
- p_peek[i_skip + p_sys->i_packet_size] == 0x47 )
+ if( p_peek[i_skip + p_sys->i_packet_header_size] == 0x47 &&
+ p_peek[i_skip + p_sys->i_packet_header_size + p_sys->i_packet_size] == 0x47 )
{
break;
}
demux_sys_t *p_sys = p_demux->p_sys;
mtime_t i_pcr = -1;
- int64_t i_initial_pos = stream_Tell( p_demux->s );
+ const int64_t i_initial_pos = stream_Tell( p_demux->s );
if( i_pos < 0 )
return VLC_EGENERIC;
- int64_t i_last_pos = i_pos + p_sys->i_packet_size * 4500; //XXX
- if( i_last_pos > stream_Size( p_demux->s ) - p_sys->i_packet_size )
- {
- i_last_pos = stream_Size( p_demux->s ) - p_sys->i_packet_size;
- }
+ int64_t i_last_pos = stream_Size( p_demux->s ) - p_sys->i_packet_size;
+ if( i_pos > i_last_pos )
+ i_pos = i_last_pos;
if( stream_Seek( p_demux->s, i_pos ) )
return VLC_EGENERIC;
while( vlc_object_alive( p_demux ) )
{
- block_t *p_pkt;
+ block_t *p_pkt;
+
if( !( p_pkt = ReadTSPacket( p_demux ) ) )
{
break;
if( i_pcr < 0 )
{
stream_Seek( p_demux->s, i_initial_pos );
+ assert( i_initial_pos == stream_Tell( p_demux->s ) );
return VLC_EGENERIC;
}
- else
- {
- p_sys->i_current_pcr = i_pcr;
- return VLC_SUCCESS;
- }
+
+ p_sys->i_current_pcr = i_pcr;
+ return VLC_SUCCESS;
}
static int Seek( demux_t *p_demux, double f_percent )
int i_cnt = 0;
while( i_head_pos <= i_tail_pos )
{
+ /* Round i_pos to a multiple of p_sys->i_packet_size */
int64_t i_pos = i_head_pos + (i_tail_pos - i_head_pos) / 2;
+ int64_t i_div = i_pos % p_sys->i_packet_size;
+ i_pos -= i_div;
if( SeekToPCR( p_demux, i_pos ) )
break;
p_sys->i_current_pcr = AdjustPCRWrapAround( p_demux, p_sys->i_current_pcr );
while( vlc_object_alive (p_demux) )
{
block_t *p_pkt;
+
if( !( p_pkt = ReadTSPacket( p_demux ) ) )
{
break;
{
demux_sys_t *p_sys = p_demux->p_sys;
- int64_t i_initial_pos = stream_Tell( p_demux->s );
+ const int64_t i_initial_pos = stream_Tell( p_demux->s );
mtime_t i_initial_pcr = p_sys->i_current_pcr;
- int64_t i_last_pos = stream_Size( p_demux->s ) - p_sys->i_packet_size;
+ int64_t i_stream_size = stream_Size( p_demux->s );
+ int64_t i_last_pos = i_stream_size - p_sys->i_packet_size;
+ /* Round i_pos to a multiple of p_sys->i_packet_size */
int64_t i_pos = i_last_pos - p_sys->i_packet_size * 4500; /* FIXME if the value is not reasonable, please change it. */
- if( i_pos < 0 )
+ int64_t i_div = i_pos % p_sys->i_packet_size;
+ i_pos -= i_div;
+
+ if( i_pos <= i_initial_pos && i_pos >= i_stream_size )
+ i_pos = i_initial_pos + p_sys->i_packet_size;
+ if( i_pos < 0 && i_pos >= i_stream_size )
return;
while( vlc_object_alive( p_demux ) )
}
}
stream_Seek( p_demux->s, i_initial_pos );
+ assert( i_initial_pos == stream_Tell( p_demux->s ) );
p_sys->i_current_pcr = i_initial_pcr;
}
for( i = 1; i < p_sys->i_pcrs_num && vlc_object_alive( p_demux ); ++i )
{
+ /* Round i_pos to a multiple of p_sys->i_packet_size */
int64_t i_pos = i_size / p_sys->i_pcrs_num * i;
+ int64_t i_div = i_pos % p_sys->i_packet_size;
+ i_pos -= i_div;
if( SeekToPCR( p_demux, i_pos ) )
break;
p_sys->p_pcrs[i] = p_sys->i_current_pcr;
p_sys->i_current_pcr = AdjustPCRWrapAround( p_demux, i_pcr );
/* Search program and set the PCR */
- for( int i = 0; i < p_sys->i_pmt; i++ )
+ int i_group = -1;
+ for( int i = 0; i < p_sys->i_pmt && i_group < 0 ; i++ )
+ {
+ bool b_pmt_has_es = false;
+
for( int 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 )
{
+ /* We've found our target group */
p_sys->pmt[i]->psi->prg[i_prg]->i_pcr_value = i_pcr;
- if (p_sys->b_trust_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)(VLC_TS_0 + i_pcr * 100 / 9) );
+ i_group = p_sys->pmt[i]->psi->prg[i_prg]->i_number;
+ for( int j = 0; j < 8192; j++ )
+ {
+ const ts_pid_t *pid = &p_sys->pid[j];
+ if( pid->b_valid && pid->p_owner == p_sys->pmt[i]->psi && pid->es )
+ {
+ b_pmt_has_es = true;
+ break;
+ }
+ }
}
+ }
+
+ if ( p_sys->b_trust_pcr && i_group > 0 && b_pmt_has_es )
+ es_out_Control( p_demux->out, ES_OUT_SET_GROUP_PCR,
+ i_group, VLC_TS_0 + i_pcr * 100 / 9 );
+ }
}
static bool GatherData( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
PCRHandle( p_demux, pid, p_bk );
- if( i_skip >= 188 || pid->es->id == NULL || p_demux->p_sys->b_udp_out )
+ if( i_skip >= 188 || pid->es->id == NULL )
{
block_Release( p_bk );
return i_ret;
return i_ret;
}
-static void PIDFillFormat( ts_es_t *es, int i_stream_type )
+static void PIDFillFormat( es_format_t *fmt, int i_stream_type )
{
- es_format_t *fmt = &es->fmt;
-
switch( i_stream_type )
{
case 0x01: /* MPEG-1 video */
break;
case 0x82: /* SCTE-27 (sub) */
es_format_Init( fmt, SPU_ES, VLC_CODEC_SCTE_27 );
- es->data_type = TS_ES_DATA_TABLE_SECTION;
- break;
- case 0x83: /* LPCM (audio) */
- es_format_Init( fmt, AUDIO_ES, VLC_CODEC_DVD_LPCM );
break;
case 0x84: /* SDDS (audio) */
es_format_Init( fmt, AUDIO_ES, VLC_CODEC_SDDS );
int i_length = 0;
int i_data_sav = i_data;
uint8_t *p_data_sav = p_data;
- for (int i = 0; i_data > 0 && i < 255; i++)
+ for (int i = 0; i_data > 0 && i < ES_DESCRIPTOR_COUNT; i++)
{
es_mpeg4_descriptor_t *es_descr = &p_iod->es_descr[i];
ts_debug( "\n* ERR missing DecoderConfigDescr" );
continue;
}
+ int i_config_desc_length = IODDescriptorLength( &i_data, &p_data ); /* DecoderConfigDescr_length */
decoder_config_descriptor_t *dec_descr = &es_descr->dec_descr;
dec_descr->i_objectTypeIndication = IODGetBytes( &i_data, &p_data, 1 );
i_flags = IODGetBytes( &i_data, &p_data, 1 );
IODGetBytes( &i_data, &p_data, 4); /* maxBitrate */
IODGetBytes( &i_data, &p_data, 4 ); /* avgBitrate */
- int i_decoderConfigDescr_length = IODDescriptorLength( &i_data, &p_data );
- if( i_decoderConfigDescr_length > 13 && IODGetBytes( &i_data, &p_data, 1 ) == 0x05 )
+ if( i_config_desc_length > 13 && IODGetBytes( &i_data, &p_data, 1 ) == 0x05 )
{
dec_descr->i_extra = IODDescriptorLength( &i_data, &p_data );
if( dec_descr->i_extra > 0 )
#include "dvb-text.h"
-static char *EITConvertToUTF8( const unsigned char *psz_instring,
+static char *EITConvertToUTF8( demux_t *p_demux,
+ const unsigned char *psz_instring,
size_t i_length,
bool b_broken )
{
+ demux_sys_t *p_sys = p_demux->p_sys;
+#ifdef HAVE_ARIBB24
+ if( p_sys->arib.e_mode == ARIBMODE_ENABLED )
+ {
+ if ( !p_sys->arib.p_instance )
+ p_sys->arib.p_instance = arib_instance_new( p_demux );
+ if ( !p_sys->arib.p_instance )
+ return NULL;
+ arib_decoder_t *p_decoder = arib_get_decoder( p_sys->arib.p_instance );
+ if ( !p_decoder )
+ return NULL;
+
+ char *psz_outstring = NULL;
+ size_t i_out;
+
+ i_out = i_length * 4;
+ psz_outstring = (char*) calloc( i_out + 1, sizeof(char) );
+ if( !psz_outstring )
+ return NULL;
+
+ arib_initialize_decoder( p_decoder );
+ i_out = arib_decode_buffer( p_decoder, psz_instring, i_length,
+ psz_outstring, i_out );
+ arib_finalize_decoder( p_decoder );
+
+ return psz_outstring;
+ }
+#else
+ VLC_UNUSED(p_sys);
+#endif
/* Deal with no longer broken providers (no switch byte
but sending ISO_8859-1 instead of ISO_6937) without
removing them from the broken providers table
/* FIXME: Digital+ ES also uses ISO8859-1 */
- str1 = EITConvertToUTF8(pD->i_service_provider_name,
+ str1 = EITConvertToUTF8(p_demux,
+ pD->i_service_provider_name,
pD->i_service_provider_name_length,
p_sys->b_broken_charset );
- str2 = EITConvertToUTF8(pD->i_service_name,
+ str2 = EITConvertToUTF8(p_demux,
+ pD->i_service_name,
pD->i_service_name_length,
p_sys->b_broken_charset );
int64_t i_start;
int i_duration;
int i_min_age = 0;
+ int64_t i_tot_time = 0;
i_start = EITConvertStartTime( p_evt->i_start_time );
i_duration = EITConvertDuration( p_evt->i_duration );
+ if( p_sys->arib.e_mode == ARIBMODE_ENABLED )
+ {
+ if( p_sys->i_tdt_delta == 0 )
+ p_sys->i_tdt_delta = CLOCK_FREQ * (i_start + i_duration - 5) - mdate();
+
+ i_tot_time = (mdate() + p_sys->i_tdt_delta) / CLOCK_FREQ;
+
+ tzset(); // JST -> UTC
+ i_start += timezone; // FIXME: what about DST?
+ i_tot_time += timezone;
+
+ if( p_evt->i_running_status == 0x00 &&
+ (i_start - 5 < i_tot_time &&
+ i_tot_time < i_start + i_duration + 5) )
+ {
+ p_evt->i_running_status = 0x04;
+ msg_Dbg( p_demux, " EIT running status 0x00 -> 0x04" );
+ }
+ }
+
msg_Dbg( p_demux, " * event id=%d start_time:%d duration=%d "
"running=%d free_ca=%d",
p_evt->i_event_id, (int)i_start, (int)i_duration,
for( p_dr = p_evt->p_first_descriptor; p_dr; p_dr = p_dr->p_next )
{
- if( p_dr->i_tag == 0x4d )
+ switch(p_dr->i_tag)
+ {
+ case 0x4d:
{
dvbpsi_short_event_dr_t *pE = dvbpsi_DecodeShortEventDr( p_dr );
/* Only take first description, as we don't handle language-info
for epg atm*/
- if( pE && psz_name == NULL)
+ if( pE && psz_name == NULL )
{
- psz_name = EITConvertToUTF8( pE->i_event_name, pE->i_event_name_length,
+ psz_name = EITConvertToUTF8( p_demux,
+ pE->i_event_name, pE->i_event_name_length,
p_sys->b_broken_charset );
- psz_text = EITConvertToUTF8( pE->i_text, pE->i_text_length,
+ free( psz_text );
+ psz_text = EITConvertToUTF8( p_demux,
+ pE->i_text, pE->i_text_length,
p_sys->b_broken_charset );
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 )
+ break;
+
+ case 0x4e:
{
dvbpsi_extended_event_dr_t *pE = dvbpsi_DecodeExtendedEventDr( p_dr );
if( pE )
if( pE->i_text_length > 0 )
{
- char *psz_text = EITConvertToUTF8( pE->i_text, pE->i_text_length,
+ char *psz_text = EITConvertToUTF8( p_demux,
+ pE->i_text, pE->i_text_length,
p_sys->b_broken_charset );
if( psz_text )
{
for( int i = 0; i < pE->i_entry_count; i++ )
{
- char *psz_dsc = EITConvertToUTF8( pE->i_item_description[i],
+ char *psz_dsc = EITConvertToUTF8( p_demux,
+ pE->i_item_description[i],
pE->i_item_description_length[i],
p_sys->b_broken_charset );
- char *psz_itm = EITConvertToUTF8( pE->i_item[i], pE->i_item_length[i],
+ char *psz_itm = EITConvertToUTF8( p_demux,
+ pE->i_item[i], pE->i_item_length[i],
p_sys->b_broken_charset );
if( psz_dsc && psz_itm )
}
}
}
- else if( p_dr->i_tag == 0x55 )
+ break;
+
+ case 0x55:
{
dvbpsi_parental_rating_dr_t *pR = dvbpsi_DecodeParentalRatingDr( p_dr );
if ( pR )
{
if ( p_rating->i_rating + 3 > i_min_age )
i_min_age = p_rating->i_rating + 3;
- msg_Dbg( p_demux, "..* event parental control set to %d years",
+ msg_Dbg( p_demux, " - parental control set to %d years",
i_min_age );
}
}
}
}
- else
- {
- msg_Dbg( p_demux, " - tag=0x%x(%d)", p_dr->i_tag, p_dr->i_tag );
+ break;
+
+ default:
+ msg_Dbg( p_demux, " - event unknown dr 0x%x(%d)", p_dr->i_tag, p_dr->i_tag );
+ break;
}
}
/* */
- if( i_start > 0 )
+ if( i_start > 0 && psz_name && psz_text)
vlc_epg_AddEvent( p_epg, i_start, i_duration, psz_name, psz_text,
*psz_extra ? psz_extra : NULL, i_min_age );
/* Update "now playing" field */
- if( p_evt->i_running_status == 0x04 && i_start > 0 )
+ if( p_evt->i_running_status == 0x04 && i_start > 0 && psz_name && psz_text )
vlc_epg_SetCurrent( p_epg, i_start );
free( psz_name );
#endif
}
else if( p_demux->p_sys->pid[0x11].psi->i_sdt_version != -1 &&
- i_table_id == 0x70 ) /* TDT */
+ (i_table_id == 0x70 /* TDT */ || i_table_id == 0x73 /* TOT */) )
{
msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
i_table_id, i_table_id, i_extension, i_extension );
assert( strlen(psz_tag) == 4 );
return !memcmp( p_dr->p_data, psz_tag, 4 );
}
+
+static bool PMTEsHasComponentTag( const dvbpsi_pmt_es_t *p_es,
+ int i_component_tag )
+{
+ dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x52 );
+ if( !p_dr )
+ return false;
+ dvbpsi_stream_identifier_dr_t *p_si = dvbpsi_DecodeStreamIdentifierDr( p_dr );
+ if( !p_si )
+ return false;
+
+ return p_si->i_component_tag == i_component_tag;
+}
+
static void PMTSetupEsISO14496( demux_t *p_demux, ts_pid_t *pid,
const ts_prg_psi_t *prg, const dvbpsi_pmt_es_t *p_es )
{
es_format_t *p_fmt = &pid->es->fmt;
- /* MPEG-4 stream: search SL_DESCRIPTOR */
+ /* MPEG-4 stream: search FMC_DESCRIPTOR (SL Packetized stream) */
dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x1f );
if( p_dr && p_dr->i_length == 2 )
{
const 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 );
+ msg_Dbg( p_demux, "found FMC_descriptor declaring sl packetization on es_id=%d", i_es_id );
pid->es->p_mpeg4desc = NULL;
- for( int i = 0; i < 255; i++ )
+ for( int i = 0; i < ES_DESCRIPTOR_COUNT; i++ )
{
iod_descriptor_t *iod = prg->iod;
-
- if( iod->es_descr[i].b_ok && iod->es_descr[i].i_es_id == i_es_id )
+ if( iod->es_descr[i].i_es_id == i_es_id )
{
- pid->es->p_mpeg4desc = &iod->es_descr[i];
+ if ( iod->es_descr[i].b_ok )
+ pid->es->p_mpeg4desc = &iod->es_descr[i];
+ else
+ msg_Dbg( p_demux, "MPEG-4 descriptor not yet available on es_id=%d", i_es_id );
break;
}
}
}
if( !pid->es->p_mpeg4desc )
{
- msg_Err( p_demux, "MPEG-4 descriptor not found" );
+ switch( p_es->i_type )
+ {
+ /* non fatal, set by packetizer */
+ case 0x0f: /* ADTS */
+ case 0x11: /* LOAS */
+ msg_Info( p_demux, "MPEG-4 descriptor not found for pid 0x%x type 0x%x",
+ pid->i_pid, p_es->i_type );
+ break;
+ default:
+ msg_Err( p_demux, "MPEG-4 descriptor not found for pid 0x%x type 0x%x",
+ pid->i_pid, p_es->i_type );
+ break;
+ }
return;
}
}
}
}
+
+static int vlc_ceil_log2( const unsigned int val )
+{
+ int n = 31 - clz(val);
+ if ((1U << n) != val)
+ n++;
+
+ return n;
+}
+
+static void OpusSetup(demux_t *demux, uint8_t *p, size_t len, es_format_t *p_fmt)
+{
+ OpusHeader h;
+
+ /* default mapping */
+ static const unsigned char map[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+ memcpy(h.stream_map, map, sizeof(map));
+
+ int csc, mapping;
+ int channels = 0;
+ int stream_count = 0;
+ int ccc = p[1]; // channel_config_code
+ if (ccc <= 8) {
+ channels = ccc;
+ if (channels)
+ mapping = channels > 2;
+ else {
+ mapping = 255;
+ channels = 2; // dual mono
+ }
+ static const uint8_t p_csc[8] = { 0, 1, 1, 2, 2, 2, 3, 3 };
+ csc = p_csc[channels - 1];
+ stream_count = channels - csc;
+
+ static const uint8_t map[6][7] = {
+ { 2,1 },
+ { 1,2,3 },
+ { 4,1,2,3 },
+ { 4,1,2,3,5 },
+ { 4,1,2,3,5,6 },
+ { 6,1,2,3,4,5,7 },
+ };
+ if (channels > 2)
+ memcpy(&h.stream_map[1], map[channels-3], channels - 1);
+ } else if (ccc == 0x81) {
+ if (len < 4)
+ goto explicit_config_too_short;
+
+ channels = p[2];
+ mapping = p[3];
+ csc = 0;
+ if (mapping) {
+ bs_t s;
+ bs_init(&s, &p[4], len - 4);
+ stream_count = 1;
+ if (channels) {
+ int bits = vlc_ceil_log2(channels);
+ if (s.i_left < bits)
+ goto explicit_config_too_short;
+ stream_count = bs_read(&s, bits) + 1;
+ bits = vlc_ceil_log2(stream_count + 1);
+ if (s.i_left < bits)
+ goto explicit_config_too_short;
+ csc = bs_read(&s, bits);
+ }
+ int channel_bits = vlc_ceil_log2(stream_count + csc + 1);
+ if (s.i_left < channels * channel_bits)
+ goto explicit_config_too_short;
+
+ unsigned char silence = (1U << (stream_count + csc + 1)) - 1;
+ for (int i = 0; i < channels; i++) {
+ unsigned char m = bs_read(&s, channel_bits);
+ if (m == silence)
+ m = 0xff;
+ h.stream_map[i] = m;
+ }
+ }
+ } else if (ccc >= 0x80 && ccc <= 0x88) {
+ channels = ccc - 0x80;
+ if (channels)
+ mapping = 1;
+ else {
+ mapping = 255;
+ channels = 2; // dual mono
+ }
+ csc = 0;
+ stream_count = channels;
+ } else {
+ msg_Err(demux, "Opus channel configuration 0x%.2x is reserved", ccc);
+ }
+
+ if (!channels) {
+ msg_Err(demux, "Opus channel configuration 0x%.2x not supported yet", p[1]);
+ return;
+ }
+
+ opus_prepare_header(channels, 0, &h);
+ h.preskip = 0;
+ h.input_sample_rate = 48000;
+ h.nb_coupled = csc;
+ h.nb_streams = channels - csc;
+ h.channel_mapping = mapping;
+
+ if (h.channels) {
+ opus_write_header((uint8_t**)&p_fmt->p_extra, &p_fmt->i_extra, &h, NULL /* FIXME */);
+ if (p_fmt->p_extra) {
+ p_fmt->i_cat = AUDIO_ES;
+ p_fmt->i_codec = VLC_CODEC_OPUS;
+ p_fmt->audio.i_channels = h.channels;
+ p_fmt->audio.i_rate = 48000;
+ }
+ }
+
+ return;
+
+explicit_config_too_short:
+ msg_Err(demux, "Opus descriptor too short");
+}
+
static void PMTSetupEs0x06( demux_t *p_demux, ts_pid_t *pid,
const dvbpsi_pmt_es_t *p_es )
{
es_format_t *p_fmt = &pid->es->fmt;
+ dvbpsi_descriptor_t *p_subs_dr = PMTEsFindDescriptor( p_es, 0x59 );
+ dvbpsi_descriptor_t *desc;
if( PMTEsHasRegistration( p_demux, p_es, "AC-3" ) ||
PMTEsFindDescriptor( p_es, 0x6a ) ||
p_fmt->i_cat = AUDIO_ES;
p_fmt->i_codec = VLC_CODEC_A52;
}
+ else if( (desc = PMTEsFindDescriptor( p_es, 0x7f ) ) && desc->i_length >= 2 &&
+ desc->p_data[0] == 0x80)
+ {
+ OpusSetup(p_demux, desc->p_data, desc->i_length, p_fmt);
+ }
else if( PMTEsFindDescriptor( p_es, 0x7a ) )
{
/* DVB with stream_type 0x06 (ETS EN 300 468) */
p_fmt->i_cat = AUDIO_ES;
p_fmt->i_codec = VLC_CODEC_DTS;
}
- else if( PMTEsHasRegistration( p_demux, p_es, "BSSD" ) )
+ else if( PMTEsHasRegistration( p_demux, p_es, "BSSD" ) && !p_subs_dr )
{
+ /* BSSD is AES3 DATA, but could also be subtitles
+ * we need to check for secondary descriptor then s*/
p_fmt->i_cat = AUDIO_ES;
p_fmt->b_packetized = true;
p_fmt->i_codec = VLC_CODEC_302M;
p_fmt->i_cat = VIDEO_ES;
p_fmt->i_codec = VLC_CODEC_HEVC;
}
+ else if ( p_demux->p_sys->arib.e_mode == ARIBMODE_ENABLED )
+ {
+ /* Lookup our data component descriptor first ARIB STD B10 6.4 */
+ dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0xFD );
+ /* and check that it maps to something ARIB STD B14 Table 5.1/5.2 */
+ if ( p_dr && p_dr->i_length >= 2 )
+ {
+ if( !memcmp( p_dr->p_data, "\x00\x08", 2 ) && (
+ PMTEsHasComponentTag( p_es, 0x30 ) ||
+ PMTEsHasComponentTag( p_es, 0x31 ) ||
+ PMTEsHasComponentTag( p_es, 0x32 ) ||
+ PMTEsHasComponentTag( p_es, 0x33 ) ||
+ PMTEsHasComponentTag( p_es, 0x34 ) ||
+ PMTEsHasComponentTag( p_es, 0x35 ) ||
+ PMTEsHasComponentTag( p_es, 0x36 ) ||
+ PMTEsHasComponentTag( p_es, 0x37 ) ) )
+ {
+ es_format_Init( &pid->es->fmt, SPU_ES, VLC_CODEC_ARIB_A );
+ p_fmt->psz_language = strndup ( "jpn", 3 );
+ p_fmt->psz_description = strdup( _("ARIB subtitles") );
+ }
+ else if( !memcmp( p_dr->p_data, "\x00\x12", 2 ) && (
+ PMTEsHasComponentTag( p_es, 0x87 ) ||
+ PMTEsHasComponentTag( p_es, 0x88 ) ) )
+ {
+ es_format_Init( &pid->es->fmt, SPU_ES, VLC_CODEC_ARIB_C );
+ p_fmt->psz_language = strndup ( "jpn", 3 );
+ p_fmt->psz_description = strdup( _("ARIB subtitles") );
+ }
+ }
+ }
else
{
/* Subtitle/Teletext/VBI fallbacks */
- dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x59 );
-
dvbpsi_subtitling_dr_t *p_sub;
- if( p_dr && ( p_sub = dvbpsi_DecodeSubtitlingDr( p_dr ) ) )
+ if( p_subs_dr && ( p_sub = dvbpsi_DecodeSubtitlingDr( p_subs_dr ) ) )
{
for( int i = 0; i < p_sub->i_subtitles_number; i++ )
{
p_fmt->b_packetized = true;
}
-static void PMTSetupEsHDMV( ts_pid_t *pid, const dvbpsi_pmt_es_t *p_es )
+static void PMTSetupEs0x83( const dvbpsi_pmt_t *p_pmt, ts_pid_t *pid )
+{
+ /* WiDi broadcasts without registration on PMT 0x1, PCR 0x1000 and
+ * with audio track pid being 0x1100..0x11FF */
+ if ( p_pmt->i_program_number == 0x1 &&
+ p_pmt->i_pcr_pid == 0x1000 &&
+ ( pid->i_pid >> 8 ) == 0x11 )
+ {
+ /* Not enough ? might contain 0x83 private descriptor, 2 bytes 0x473F */
+ es_format_Init( &pid->es->fmt, AUDIO_ES, VLC_CODEC_WIDI_LPCM );
+ }
+ else
+ es_format_Init( &pid->es->fmt, AUDIO_ES, VLC_CODEC_DVD_LPCM );
+}
+
+static bool PMTSetupEsHDMV( demux_t *p_demux, ts_pid_t *pid,
+ const dvbpsi_pmt_es_t *p_es )
{
es_format_t *p_fmt = &pid->es->fmt;
break;
case 0x91: /* Interactive graphics */
case 0x92: /* Subtitle */
+ return false;
default:
+ msg_Info( p_demux, "HDMV registration not implemented for pid 0x%x type 0x%x",
+ p_es->i_pid, p_es->i_type );
+ return false;
break;
}
+ return true;
}
-static void PMTSetupEsRegistration( demux_t *p_demux, ts_pid_t *pid,
+static bool PMTSetupEsRegistration( demux_t *p_demux, ts_pid_t *pid,
const dvbpsi_pmt_es_t *p_es )
{
static const struct
p_fmt->i_codec = p_regs[i].i_codec;
if (p_es->i_type == 0x87)
p_fmt->i_codec = VLC_CODEC_EAC3;
- return;
+ return true;
}
}
+ return false;
}
static char *GetAudioTypeDesc(demux_t *p_demux, int type)
if( ProgramIsSelected( p_demux, prg->i_number ) )
SetPIDFilter( p_demux, prg->i_pid_pcr, true ); /* Set demux filter */
- /* Parse descriptor */
- bool b_hdmv = false;
+ /* Parse PMT descriptors */
+ ts_pmt_registration_type_t registration_type = TS_PMT_REGISTRATION_NONE;
dvbpsi_descriptor_t *p_dr;
+
+ /* First pass for standard detection */
+ if ( p_sys->arib.e_mode == ARIBMODE_AUTO )
+ {
+ int i_arib_flags = 0; /* Descriptors can be repeated */
+ for( p_dr = p_pmt->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
+ {
+ switch(p_dr->i_tag)
+ {
+ case 0x09:
+ {
+ dvbpsi_ca_dr_t *p_cadr = dvbpsi_DecodeCADr( p_dr );
+ i_arib_flags |= (p_cadr->i_ca_system_id == 0x05);
+ }
+ break;
+ case 0xF6:
+ i_arib_flags |= 1 << 1;
+ break;
+ case 0xC1:
+ i_arib_flags |= 1 << 2;
+ break;
+ default:
+ break;
+ }
+ }
+ if ( i_arib_flags == 0b111 )
+ p_sys->arib.e_mode = ARIBMODE_ENABLED;
+ }
+
for( p_dr = p_pmt->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
+ {
+ /* special descriptors handling */
switch(p_dr->i_tag)
{
case 0x1d: /* We have found an IOD descriptor */
- msg_Dbg( p_demux, " * descriptor : IOD (0x1d)" );
+ msg_Dbg( p_demux, " * PMT descriptor : IOD (0x1d)" );
prg->iod = IODNew( p_dr->i_length, p_dr->p_data );
break;
case 0x9:
- msg_Dbg( p_demux, " * descriptor : CA (0x9) SysID 0x%x",
+ msg_Dbg( p_demux, " * PMT descriptor : CA (0x9) SysID 0x%x",
(p_dr->p_data[0] << 8) | p_dr->p_data[1] );
break;
case 0x5: /* Registration Descriptor */
if( p_dr->i_length != 4 )
{
- msg_Warn( p_demux, "invalid Registration Descriptor" );
+ msg_Warn( p_demux, " * PMT invalid Registration Descriptor" );
}
else
{
- msg_Dbg( p_demux, " * descriptor : registration %4.4s", p_dr->p_data );
+ msg_Dbg( p_demux, " * PMT descriptor : registration %4.4s", p_dr->p_data );
if( !memcmp( p_dr->p_data, "HDMV", 4 ) || !memcmp( p_dr->p_data, "HDPR", 4 ) )
- b_hdmv = true; /* Blu-Ray */
+ registration_type = TS_PMT_REGISTRATION_HDMV; /* Blu-Ray */
}
break;
+ case 0x0f:
+ msg_Dbg( p_demux, " * PMT descriptor : Private Data (0x0f)" );
+ break;
+
+ case 0xC1:
+ msg_Dbg( p_demux, " * PMT descriptor : Digital copy control (0xC1)" );
+ break;
+
+ case 0x88: /* EACEM Simulcast HD Logical channels ordering */
+ msg_Dbg( p_demux, " * descriptor : EACEM Simulcast HD" );
+ /* TODO: apply visibility flags */
+ break;
+
default:
- msg_Dbg( p_demux, " * descriptor : unknown (0x%x)", p_dr->i_tag );
+ msg_Dbg( p_demux, " * PMT descriptor : unknown (0x%x)", p_dr->i_tag );
}
-
+ }
dvbpsi_pmt_es_t *p_es;
for( p_es = p_pmt->p_first_es; p_es != NULL; p_es = p_es->p_next )
{
if( !old_pid && p_sys->pid[p_es->i_pid].b_valid )
{
- msg_Warn( p_demux, "pmt error: pid=%d already defined",
+ msg_Warn( p_demux, " * PMT error: pid=%d already defined",
p_es->i_pid );
continue;
}
+ char const * psz_typedesc = "";
+ switch(p_es->i_type)
+ {
+ case 0x00:
+ psz_typedesc = "ISO/IEC Reserved";
+ break;
+ case 0x01:
+ psz_typedesc = "ISO/IEC 11172 Video";
+ break;
+ case 0x02:
+ psz_typedesc = "ISO/IEC 13818-2 Video or ISO/IEC 11172-2 constrained parameter video stream";
+ break;
+ case 0x03:
+ psz_typedesc = "ISO/IEC 11172 Audio";
+ break;
+ case 0x04:
+ psz_typedesc = "ISO/IEC 13818-3 Audio";
+ break;
+ case 0x05:
+ psz_typedesc = "ISO/IEC 13818-1 private_sections";
+ break;
+ case 0x06:
+ psz_typedesc = "ISO/IEC 13818-1 PES packets containing private data";
+ break;
+ case 0x07:
+ psz_typedesc = "ISO/IEC 13522 MHEG";
+ break;
+ case 0x08:
+ psz_typedesc = "ISO/IEC 13818-1 Annex A DSM CC";
+ break;
+ case 0x09:
+ psz_typedesc = "ITU-T Rec. H.222.1";
+ break;
+ case 0x0A:
+ psz_typedesc = "ISO/IEC 13818-6 type A";
+ break;
+ case 0x0B:
+ psz_typedesc = "ISO/IEC 13818-6 type B";
+ break;
+ case 0x0C:
+ psz_typedesc = "ISO/IEC 13818-6 type C";
+ break;
+ case 0x0D:
+ psz_typedesc = "ISO/IEC 13818-6 type D";
+ break;
+ case 0x0E:
+ psz_typedesc = "ISO/IEC 13818-1 auxiliary";
+ break;
+ default:
+ if (p_es->i_type >= 0x0F && p_es->i_type <=0x7F)
+ psz_typedesc = "ISO/IEC 13818-1 Reserved";
+ else
+ psz_typedesc = "User Private";
+ }
+
+ msg_Dbg( p_demux, " * pid=%d type=0x%x %s",
+ p_es->i_pid, p_es->i_type, psz_typedesc );
+
for( p_dr = p_es->p_first_descriptor; p_dr != NULL;
p_dr = p_dr->p_next )
{
- 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 );
+ msg_Dbg( p_demux, " - descriptor tag 0x%x",
+ p_dr->i_tag );
}
PIDInit( pid, false, pmt->psi );
- PIDFillFormat( pid->es, p_es->i_type );
+ PIDFillFormat( &pid->es->fmt, p_es->i_type );
pid->i_owner_number = prg->i_number;
pid->i_pid = p_es->i_pid;
pid->b_seen = p_sys->pid[p_es->i_pid].b_seen;
- if( p_es->i_type == 0x10 || p_es->i_type == 0x11 ||
- p_es->i_type == 0x12 || p_es->i_type == 0x0f )
- {
- PMTSetupEsISO14496( p_demux, pid, prg, p_es );
- }
- else if( p_es->i_type == 0x06 )
- {
- PMTSetupEs0x06( p_demux, pid, p_es );
- }
- else if( p_es->i_type == 0xEA )
- {
- PMTSetupEs0xEA( p_demux, pid, p_es );
- }
- else if( p_es->i_type == 0xd1 )
- {
- PMTSetupEs0xD1( p_demux, pid, p_es );
- }
- else if( p_es->i_type == 0xa0 )
- {
- PMTSetupEs0xA0( p_demux, pid, p_es );
- }
- else if( b_hdmv )
+
+ bool b_registration_applied = false;
+ if ( p_es->i_type >= 0x80 ) /* non standard, extensions */
{
- PMTSetupEsHDMV( pid, p_es );
+ if ( registration_type == TS_PMT_REGISTRATION_HDMV )
+ {
+ if (( b_registration_applied = PMTSetupEsHDMV( p_demux, pid, p_es ) ))
+ msg_Dbg( p_demux, " + HDMV registration applied to pid %d type 0x%x",
+ p_es->i_pid, p_es->i_type );
+ }
+ else
+ {
+ if (( b_registration_applied = PMTSetupEsRegistration( p_demux, pid, p_es ) ))
+ msg_Dbg( p_demux, " + registration applied to pid %d type 0x%x",
+ p_es->i_pid, p_es->i_type );
+ }
}
- else if( p_es->i_type >= 0x80 )
+
+ if ( !b_registration_applied )
{
- PMTSetupEsRegistration( p_demux, pid, p_es );
+ switch( p_es->i_type )
+ {
+ case 0x06:
+ /* Handle PES private data */
+ PMTSetupEs0x06( p_demux, pid, p_es );
+ break;
+ /* All other private or reserved types */
+ case 0x0f:
+ case 0x10:
+ case 0x11:
+ case 0x12:
+ PMTSetupEsISO14496( p_demux, pid, prg, p_es );
+ break;
+ case 0x83:
+ /* LPCM (audio) */
+ PMTSetupEs0x83( p_pmt, pid );
+ break;
+ case 0xa0:
+ PMTSetupEs0xA0( p_demux, pid, p_es );
+ break;
+ case 0xd1:
+ PMTSetupEs0xD1( p_demux, pid, p_es );
+ break;
+ case 0xEA:
+ PMTSetupEs0xEA( p_demux, pid, p_es );
+ default:
+ break;
+ }
}
if( pid->es->fmt.i_cat == AUDIO_ES ||
PMTParseEsIso639( p_demux, pid, p_es );
}
+ switch( pid->es->fmt.i_codec )
+ {
+ case VLC_CODEC_SCTE_27:
+ pid->es->data_type = TS_ES_DATA_TABLE_SECTION;
+ break;
+ default:
+ //pid->es->data_type = TS_ES_DATA_PES;
+ break;
+ }
+
pid->es->fmt.i_group = p_pmt->i_program_number;
for( int i = 0; i < pid->i_extra_es; i++ )
pid->extra_es[i]->fmt.i_group = p_pmt->i_program_number;
if( pid->es->fmt.i_cat == UNKNOWN_ES )
{
- msg_Dbg( p_demux, " * es pid=%d type=%d *unknown*",
- p_es->i_pid, p_es->i_type );
+ msg_Dbg( p_demux, " => pid %d content is *unknown*",
+ p_es->i_pid );
}
- else if( !p_sys->b_udp_out )
+ else
{
- 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 );
+ msg_Dbg( p_demux, " => pid %d has now es fcc=%4.4s",
+ p_es->i_pid, (char*)&pid->es->fmt.i_codec );
if( p_sys->b_es_id_pid ) pid->es->fmt.i_id = p_es->i_pid;
p_dr = PMTEsFindDescriptor( p_es, 0x09 );
if( p_dr && p_dr->i_length >= 2 )
{
- msg_Dbg( p_demux, " * descriptor : CA (0x9) SysID 0x%x",
+ msg_Dbg( p_demux, " * PMT descriptor : CA (0x9) SysID 0x%x",
(p_dr->p_data[0] << 8) | p_dr->p_data[1] );
}
- if( ProgramIsSelected( p_demux, prg->i_number ) &&
- ( pid->es->id != NULL || p_sys->b_udp_out ) )
+ if( ProgramIsSelected( p_demux, prg->i_number ) && pid->es->id != NULL )
SetPIDFilter( p_demux, p_es->i_pid, true ); /* Set demux filter */
}