# include "config.h"
#endif
-#include <vlc/vlc.h>
+#include <vlc_common.h>
+#include <vlc_plugin.h>
#include <vlc_demux.h>
#include "vlc_codec.h"
#include "vlc_meta.h"
#include "vlc_input.h"
#include "../codec/cc.h"
+#include <assert.h>
+
/*****************************************************************************
* Module descriptor
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close( vlc_object_t * );
-vlc_module_begin();
- set_shortname( _("TY") );
- set_description(_("TY Stream audio/video demux"));
- set_category( CAT_INPUT );
- set_subcategory( SUBCAT_INPUT_DEMUX );
- set_capability("demux2", 6);
+vlc_module_begin ()
+ set_shortname( N_("TY") )
+ set_description(N_("TY Stream audio/video demux"))
+ set_category( CAT_INPUT )
+ set_subcategory( SUBCAT_INPUT_DEMUX )
+ set_capability("demux", 6)
/* FIXME: there seems to be a segfault when using PVR access
* and TY demux has a bigger priority than PS
* Something must be wrong.
*/
- set_callbacks( Open, Close );
- add_shortcut("ty");
- add_shortcut("tivo");
-vlc_module_end();
+ set_callbacks( Open, Close )
+ add_shortcut("ty")
+ add_shortcut("tivo")
+vlc_module_end ()
/*****************************************************************************
* Local prototypes
typedef struct
{
long l_rec_size;
- uint8_t ex1, ex2;
+ uint8_t ex[2];
uint8_t rec_type;
uint8_t subrec_type;
- vlc_bool_t b_ext;
+ bool b_ext;
uint64_t l_ty_pts; /* TY PTS in the record header */
} ty_rec_hdr_t;
} xds_class_t;
typedef struct
{
- vlc_bool_t b_started;
+ bool b_started;
int i_data;
uint8_t p_data[XDS_MAX_DATA_SIZE];
int i_sum;
typedef struct
{
/* Are we in XDS mode */
- vlc_bool_t b_xds;
+ bool b_xds;
/* Current class type */
xds_class_t i_class;
int i_type;
- vlc_bool_t b_future;
+ bool b_future;
/* */
xds_packet_t pkt[XDS_MAX_CLASS_COUNT][128]; /* XXX it is way too much, but simpler */
/* */
- vlc_bool_t b_meta_changed;
+ bool b_meta_changed;
xds_meta_t meta;
} xds_t;
int i_stuff_cnt;
size_t i_stream_size; /* size of input stream (if known) */
//uint64_t l_program_len; /* length of this stream in msec */
- vlc_bool_t b_seekable; /* is this stream seekable? */
- vlc_bool_t b_have_master; /* are master chunks present? */
+ bool b_seekable; /* is this stream seekable? */
+ bool b_have_master; /* are master chunks present? */
tivo_type_t tivo_type; /* tivo type (SA / DTiVo) */
tivo_series_t tivo_series; /* Series1 or Series2 */
tivo_audio_t audio_type; /* AC3 or MPEG */
//mtime_t l_last_ty_pts_sync; /* audio PTS at time of last TY PTS */
uint64_t l_first_ty_pts; /* first TY PTS in this master chunk */
uint64_t l_final_ty_pts; /* final TY PTS in this master chunk */
- int i_seq_table_size; /* number of entries in SEQ table */
- int i_bits_per_seq_entry; /* # of bits in SEQ table bitmask */
+ unsigned i_seq_table_size; /* number of entries in SEQ table */
+ unsigned i_bits_per_seq_entry; /* # of bits in SEQ table bitmask */
mtime_t firstAudioPTS;
mtime_t lastAudioPTS;
int i_num_recs; /* number of recs in this chunk */
int i_seq_rec; /* record number where seq start is */
ty_seq_table_t *seq_table; /* table of SEQ entries from mstr chk */
- vlc_bool_t eof;
- vlc_bool_t b_first_chunk;
+ bool eof;
+ bool b_first_chunk;
};
static int get_chunk_header(demux_t *);
static int ty_stream_seek_pct(demux_t *p_demux, double seek_pct);
static int ty_stream_seek_time(demux_t *, uint64_t);
-static ty_rec_hdr_t *parse_chunk_headers( demux_t *p_demux, const uint8_t *p_buf,
+static ty_rec_hdr_t *parse_chunk_headers( const uint8_t *p_buf,
int i_num_recs, int *pi_payload_size);
static int probe_stream(demux_t *p_demux);
static void analyze_chunk(demux_t *p_demux, const uint8_t *p_chunk);
U32_AT(&p_peek[8]) != CHUNK_SIZE )
{
if( !p_demux->b_force &&
- !demux2_IsPathExtension( p_demux, ".ty" ) &&
- !demux2_IsPathExtension( p_demux, ".ty+" ) )
+ !demux_IsPathExtension( p_demux, ".ty" ) &&
+ !demux_IsPathExtension( p_demux, ".ty+" ) )
return VLC_EGENERIC;
msg_Warn( p_demux, "this does not look like a TY file, "
"continuing anyway..." );
memset(p_sys, 0, sizeof(demux_sys_t));
/* set up our struct (most were zero'd out with the memset above) */
- p_sys->b_first_chunk = VLC_TRUE;
+ p_sys->b_first_chunk = true;
p_sys->b_have_master = (U32_AT(p_peek) == TIVO_PES_FILEID);
p_sys->firstAudioPTS = -1;
p_sys->i_stream_size = stream_Size(p_demux->s);
/* register the proper audio codec */
if (p_sys->audio_type == TIVO_AUDIO_MPEG) {
- es_format_Init( &fmt, AUDIO_ES, VLC_FOURCC( 'm', 'p', 'g', 'a' ) );
+ es_format_Init( &fmt, AUDIO_ES, VLC_CODEC_MPGA );
} else {
- es_format_Init( &fmt, AUDIO_ES, VLC_FOURCC( 'a', '5', '2', ' ' ) );
+ es_format_Init( &fmt, AUDIO_ES, VLC_CODEC_A52 );
}
fmt.i_group = TY_ES_GROUP;
p_sys->p_audio = es_out_Add( p_demux->out, &fmt );
/* register the video stream */
- es_format_Init( &fmt, VIDEO_ES, VLC_FOURCC( 'm', 'p', 'g', 'v' ) );
+ es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_MPGV );
fmt.i_group = TY_ES_GROUP;
p_sys->p_video = es_out_Add( p_demux->out, &fmt );
if( ( i64 = p_sys->i_stream_size ) > 0 )
{
pf = (double*) va_arg( args, double* );
- *pf = (double)stream_Tell( p_demux->s ) / (double) i64;
+ *pf = ((double)1.0) * stream_Tell( p_demux->s ) / (double) i64;
return VLC_SUCCESS;
}
return VLC_EGENERIC;
XdsExit( &p_sys->xds );
cc_Exit( &p_sys->cc );
free( p_sys->rec_hdrs );
- if( p_sys->seq_table )
- free( p_sys->seq_table );
+ free( p_sys->seq_table );
free(p_sys);
}
//subrec_type, esOffset1);
p_sys->lastVideoPTS = get_pts(
&p_block_in->p_buffer[ esOffset1 + VIDEO_PTS_OFFSET ] );
- /*msg_Dbg(p_demux, "Video rec %d PTS "I64Fd, p_sys->i_cur_rec,
+ /*msg_Dbg(p_demux, "Video rec %d PTS %"PRId64, p_sys->i_cur_rec,
p_sys->lastVideoPTS );*/
if (subrec_type != 0x06) {
/* if we found a PES, and it's not type 6, then we're S2 */
continue;
es_format_Init( &fmt, SPU_ES, fcc[i] );
- fmt.psz_description = strdup( _(ppsz_description[i]) );
+ fmt.psz_description = strdup( vlc_gettext(ppsz_description[i]) );
fmt.i_group = TY_ES_GROUP;
p_sys->p_cc[i] = es_out_Add( p_demux->out, &fmt );
es_format_Clean( &fmt );
/* Send the CC data */
if( p_block_in->i_pts > 0 && p_sys->cc.i_data > 0 )
{
- int i_cc_count;
-
- block_t *p_cc = block_New( p_demux, p_sys->cc.i_data );
- p_cc->i_flags |= BLOCK_FLAG_TYPE_I;
- p_cc->i_pts = p_block_in->i_pts;
- memcpy( p_cc->p_buffer, p_sys->cc.p_data, p_sys->cc.i_data );
-
- for( i = 0, i_cc_count = 0; i < 4; i++ )
- i_cc_count += p_sys->p_cc[i] ? 1 : 0;
-
for( i = 0; i < 4; i++ )
{
- if( !p_sys->p_cc[i] )
- continue;
- if( i_cc_count > 1 )
- es_out_Send( p_demux->out, p_sys->p_cc[i], block_Duplicate( p_cc ) );
- else
+ if( p_sys->p_cc[i] )
+ {
+ block_t *p_cc = block_New( p_demux, p_sys->cc.i_data );
+ p_cc->i_flags |= BLOCK_FLAG_TYPE_I;
+ p_cc->i_pts = p_block_in->i_pts;
+ memcpy( p_cc->p_buffer, p_sys->cc.p_data, p_sys->cc.i_data );
+
es_out_Send( p_demux->out, p_sys->p_cc[i], p_cc );
+ }
}
cc_Flush( &p_sys->cc );
}
return -1;
#if 0
int i;
- printf( "Audio Packet Header " );
+ fprintf( stderr, "Audio Packet Header " );
for( i = 0 ; i < 24 ; i++ )
- printf( "%2.2x ", p_block_in->p_buffer[i] );
- printf( "\n" );
+ fprintf( stderr, "%2.2x ", p_block_in->p_buffer[i] );
+ fprintf( stderr, "\n" );
#endif
if( subrec_type == 2 )
{
demux_sys_t *p_sys = p_demux->p_sys;
int i_field;
- int i_channel;
if( p_block_in )
block_Release(p_block_in);
/* XDS data (extract programs infos) transmitted on field 2 only */
if( i_field == 1 )
- DemuxDecodeXds( p_demux, rec_hdr->ex1, rec_hdr->ex2 );
+ DemuxDecodeXds( p_demux, rec_hdr->ex[0], rec_hdr->ex[1] );
if( p_sys->cc.i_data + 3 > CC_MAX_DATA_SIZE )
return 0;
- p_sys->cc.p_data[p_sys->cc.i_data+0] = i_field;
- p_sys->cc.p_data[p_sys->cc.i_data+1] = rec_hdr->ex1;
- p_sys->cc.p_data[p_sys->cc.i_data+2] = rec_hdr->ex2;
- p_sys->cc.i_data += 3;
-
- i_channel = cc_Channel( i_field, &p_sys->cc.p_data[p_sys->cc.i_data-3 + 1] );
- if( i_channel >= 0 && i_channel < 4 )
- p_sys->cc.pb_present[i_channel] = VLC_TRUE;
+ cc_AppendData( &p_sys->cc, i_field, rec_hdr->ex );
return 0;
}
{
demux_sys_t *p_sys = p_demux->p_sys;
int64_t seek_pos = p_sys->i_stream_size * seek_pct;
- int i, i_cur_part;
long l_skip_amt;
+ int i;
+ unsigned i_cur_part;
/* if we're not seekable, there's nothing to do */
if (!p_sys->b_seekable)
/* seek within the chunk to get roughly to where we want */
p_sys->i_cur_rec = (int)
((double) ((seek_pos % CHUNK_SIZE) / (double) (CHUNK_SIZE)) * p_sys->i_num_recs);
- msg_Dbg(p_demux, "Seeked to file pos " I64Fd, seek_pos);
+ msg_Dbg(p_demux, "Seeked to file pos %"PRId64, seek_pos);
msg_Dbg(p_demux, " (chunk %d, record %d)",
p_sys->i_cur_chunk - 1, p_sys->i_cur_rec);
/* to hell with syncing any audio or video, just start reading records... :) */
/*p_sys->lastAudioPTS = p_sys->lastVideoPTS = 0;*/
- es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
return VLC_SUCCESS;
}
{
int i, j;
- h->b_xds = VLC_FALSE;
+ h->b_xds = false;
h->i_class = XDS_MAX_CLASS_COUNT;
h->i_type = 0;
- h->b_future = VLC_FALSE;
+ h->b_future = false;
for( i = 0; i < XDS_MAX_CLASS_COUNT; i++ )
{
for( j = 0; j < 128; j++ )
- h->pkt[i][j].b_started = VLC_FALSE;
+ h->pkt[i][j].b_started = false;
}
- h->b_meta_changed = VLC_FALSE;
+ h->b_meta_changed = false;
memset( &h->meta, 0, sizeof(h->meta) );
}
static void XdsExit( xds_t *h )
{
/* */
- if( h->meta.psz_channel_name )
- free( h->meta.psz_channel_name );
- if( h->meta.psz_channel_call_letter )
- free( h->meta.psz_channel_call_letter );
- if( h->meta.psz_channel_number )
- free( h->meta.psz_channel_number );
+ free( h->meta.psz_channel_name );
+ free( h->meta.psz_channel_call_letter );
+ free( h->meta.psz_channel_number );
/* */
- if( h->meta.current.psz_name )
- free( h->meta.current.psz_name );
- if( h->meta.current.psz_rating )
- free( h->meta.current.psz_rating );
+ free( h->meta.current.psz_name );
+ free( h->meta.current.psz_rating );
/* */
- if( h->meta.future.psz_name )
- free( h->meta.future.psz_name );
- if( h->meta.future.psz_rating )
- free( h->meta.future.psz_rating );
+ free( h->meta.future.psz_name );
+ free( h->meta.future.psz_rating );
}
static void XdsStringUtf8( char dst[2*32+1], const uint8_t *p_src, int i_src )
{
}
dst[i_dst++] = '\0';
}
-static vlc_bool_t XdsChangeString( xds_t *h, char **ppsz_dst, const char *psz_new )
+static bool XdsChangeString( xds_t *h, char **ppsz_dst, const char *psz_new )
{
if( *ppsz_dst && psz_new && !strcmp( *ppsz_dst, psz_new ) )
- return VLC_FALSE;
+ return false;
if( *ppsz_dst == NULL && psz_new == NULL )
- return VLC_FALSE;
+ return false;
- if( *ppsz_dst )
- free( *ppsz_dst );
+ free( *ppsz_dst );
if( psz_new )
*ppsz_dst = strdup( psz_new );
else
*ppsz_dst = NULL;
- h->b_meta_changed = VLC_TRUE;
- return VLC_TRUE;
+ h->b_meta_changed = true;
+ return true;
}
static void XdsDecodeCurrentFuture( xds_t *h, xds_packet_t *pk )
{
const xds_class_t i_class = ( d1 - 1 ) >> 1;
const int i_type = d2;
- const vlc_bool_t b_start = d1 & 0x01;
+ const bool b_start = d1 & 0x01;
xds_packet_t *pk = &h->pkt[i_class][i_type];
if( !b_start && !pk->b_started )
{
//fprintf( stderr, "xxxxxxxxxxxxxxxXDS Continuying a non started packet, ignoring\n" );
- h->b_xds = VLC_FALSE;
+ h->b_xds = false;
return;
}
- h->b_xds = VLC_TRUE;
+ h->b_xds = true;
h->i_class = i_class;
h->i_type = i_type;
h->b_future = !b_start;
- pk->b_started = VLC_TRUE;
+ pk->b_started = true;
if( b_start )
{
pk->i_data = 0;
if( pk->i_sum & 0x7f )
{
//fprintf( stderr, "xxxxxxxxxxxxxxxXDS invalid checksum, ignoring ---------------------------------\n" );
- pk->b_started = VLC_FALSE;
+ pk->b_started = false;
return;
}
if( pk->i_data <= 0 )
{
//fprintf( stderr, "xxxxxxxxxxxxxxxXDS empty packet, ignoring ---------------------------------\n" );
- pk->b_started = VLC_FALSE;
+ pk->b_started = false;
return;
}
XdsDecode( h, pk );
/* Reset it */
- pk->b_started = VLC_FALSE;
+ pk->b_started = false;
}
else if( d1 >= 0x20 && h->b_xds )
{
{
/* Broken -> reinit */
//fprintf( stderr, "xxxxxxxxxxxxxxxXDS broken, reset\n" );
- h->b_xds = VLC_FALSE;
- pk->b_started = VLC_FALSE;
+ h->b_xds = false;
+ pk->b_started = false;
return;
}
/* TODO check parity bit */
}
else
{
- h->b_xds = VLC_FALSE;
+ h->b_xds = false;
}
}
es_out_Control( p_demux->out, ES_OUT_SET_GROUP_EPG, TY_ES_GROUP, p_epg );
vlc_epg_Delete( p_epg );
}
- p_demux->p_sys->xds.b_meta_changed = VLC_FALSE;
+ p_demux->p_sys->xds.b_meta_changed = false;
}
/* seek to an exact time position within the stream, if possible.
static int ty_stream_seek_time(demux_t *p_demux, uint64_t l_seek_time)
{
demux_sys_t *p_sys = p_demux->p_sys;
- int i, i_seq_entry = 0;
+ int i_seq_entry = 0;
int i_skip_cnt;
+ unsigned i;
long l_cur_pos = stream_Tell(p_demux->s);
- int i_cur_part = l_cur_pos / TIVO_PART_LENGTH;
+ unsigned i_cur_part = l_cur_pos / TIVO_PART_LENGTH;
long l_seek_secs = l_seek_time / 1000000000;
uint64_t l_fwd_stamp = 1;
so we need to skip past any stream data prior to the seq_rec
in this chunk */
i_skip_cnt = 0;
- for (i=0; i<p_sys->i_seq_rec; i++)
- i_skip_cnt += p_sys->rec_hdrs[i].l_rec_size;
+ for (int j=0; j<p_sys->i_seq_rec; j++)
+ i_skip_cnt += p_sys->rec_hdrs[j].l_rec_size;
stream_Read(p_demux->s, NULL, i_skip_cnt);
p_sys->i_cur_rec = p_sys->i_seq_rec;
//p_sys->l_last_ty_pts = p_sys->rec_hdrs[p_sys->i_seq_rec].l_ty_pts;
{
demux_sys_t *p_sys = p_demux->p_sys;
uint8_t mst_buf[32];
- int i, i_map_size;
+ uint32_t i, i_map_size;
int64_t i_save_pos = stream_Tell(p_demux->s);
int64_t i_pts_secs;
entire table directly from the stream into memory in place. */
/* clear the SEQ table */
- if (p_sys->seq_table != NULL)
- free(p_sys->seq_table);
+ free(p_sys->seq_table);
/* parse header info */
stream_Read(p_demux->s, mst_buf, 32);
p_sys->i_seq_table_size = i / (8 + i_map_size);
/* parse all the entries */
- p_sys->seq_table = malloc(p_sys->i_seq_table_size * sizeof(ty_seq_table_t));
- for (i=0; i<p_sys->i_seq_table_size; i++) {
- stream_Read(p_demux->s, mst_buf, 8 + i_map_size);
+ p_sys->seq_table = calloc(p_sys->i_seq_table_size, sizeof(ty_seq_table_t));
+ if (p_sys->seq_table == NULL)
+ {
+ p_sys->i_seq_table_size = 0;
+ return;
+ }
+ for (unsigned i=0; i<p_sys->i_seq_table_size; i++) {
+ stream_Read(p_demux->s, mst_buf, 8);
p_sys->seq_table[i].l_timestamp = U64_AT(&mst_buf[0]);
if (i_map_size > 8) {
msg_Err(p_demux, "Unsupported SEQ bitmap size in master chunk");
- memset(p_sys->seq_table[i].chunk_bitmask, i_map_size, 0);
+ stream_Read(p_demux->s, NULL, i_map_size);
} else {
+ stream_Read(p_demux->s, mst_buf + 8, i_map_size);
memcpy(p_sys->seq_table[i].chunk_bitmask, &mst_buf[8], i_map_size);
}
}
p_sys->l_first_ty_pts = p_sys->seq_table[0].l_timestamp;
p_sys->l_final_ty_pts =
p_sys->seq_table[p_sys->i_seq_table_size - 1].l_timestamp;
- p_sys->b_have_master = VLC_TRUE;
+ p_sys->b_have_master = true;
i_pts_secs = p_sys->l_first_ty_pts / 1000000000;
- msg_Dbg( p_demux, "first TY pts in master is %02d:%02d:%02d",
- (int)(i_pts_secs / 3600), (int)((i_pts_secs / 60) % 60), (int)(i_pts_secs % 60) );
+ msg_Dbg( p_demux,
+ "first TY pts in master is %02"PRId64":%02"PRId64":%02"PRId64,
+ i_pts_secs / 3600, (i_pts_secs / 60) % 60, i_pts_secs % 60 );
i_pts_secs = p_sys->l_final_ty_pts / 1000000000;
- msg_Dbg( p_demux, "final TY pts in master is %02d:%02d:%02d",
- (int)(i_pts_secs / 3600), (int)((i_pts_secs / 60) % 60), (int)(i_pts_secs % 60) );
+ msg_Dbg( p_demux,
+ "final TY pts in master is %02"PRId64":%02"PRId64":%02"PRId64,
+ i_pts_secs / 3600, (i_pts_secs / 60) % 60, i_pts_secs % 60 );
/* seek past this chunk */
stream_Seek(p_demux->s, i_save_pos + CHUNK_SIZE);
demux_sys_t *p_sys = p_demux->p_sys;
const uint8_t *p_buf;
int i;
- vlc_bool_t b_probe_error = VLC_FALSE;
+ bool b_probe_error = false;
/* we need CHUNK_PEEK_COUNT chunks of data, first one might be a Part header, so ... */
if (stream_Peek( p_demux->s, &p_buf, CHUNK_PEEK_COUNT * CHUNK_SIZE ) <
/* the final tally */
if (p_sys->tivo_series == TIVO_SERIES_UNKNOWN) {
msg_Err(p_demux, "Can't determine Tivo Series.");
- b_probe_error = VLC_TRUE;
+ b_probe_error = true;
}
if (p_sys->audio_type == TIVO_AUDIO_UNKNOWN) {
msg_Err(p_demux, "Can't determine Tivo Audio Type.");
- b_probe_error = VLC_TRUE;
+ b_probe_error = true;
}
if (p_sys->tivo_type == TIVO_TYPE_UNKNOWN) {
msg_Err(p_demux, "Can't determine Tivo Type (SA/DTivo).");
- b_probe_error = VLC_TRUE;
+ b_probe_error = true;
}
return b_probe_error?VLC_EGENERIC:VLC_SUCCESS;
}
int i_num_recs, i;
ty_rec_hdr_t *p_hdrs;
int i_num_6e0, i_num_be0, i_num_9c0, i_num_3c0;
- uint32_t i_payload_size;
+ int i_payload_size;
/* skip if it's a Part header */
if( U32_AT( &p_chunk[ 0 ] ) == TIVO_PES_FILEID )
p_chunk += 4; /* skip past rec count & SEQ bytes */
//msg_Dbg(p_demux, "probe: chunk has %d recs", i_num_recs);
- p_hdrs = parse_chunk_headers(p_demux, p_chunk, i_num_recs, &i_payload_size);
+ p_hdrs = parse_chunk_headers(p_chunk, i_num_recs, &i_payload_size);
/* scan headers.
* 1. check video packets. Presence of 0x6e0 means S1.
* No 6e0 but have be0 means S2.
p_sys->i_seq_rec = p_peek[1];
}
p_sys->i_cur_rec = 0;
- p_sys->b_first_chunk = VLC_FALSE;
+ p_sys->b_first_chunk = false;
/*msg_Dbg( p_demux, "chunk has %d records", i_num_recs );*/
- if (p_sys->rec_hdrs)
- free(p_sys->rec_hdrs);
+ free(p_sys->rec_hdrs);
/* skip past the 4 bytes we "peeked" earlier */
stream_Read( p_demux->s, NULL, 4 );
p_hdr_buf = malloc(i_num_recs * 16);
if (stream_Read(p_demux->s, p_hdr_buf, i_num_recs * 16) < i_num_recs * 16) {
free( p_hdr_buf );
- p_sys->eof = VLC_TRUE;
+ p_sys->eof = true;
return 0;
}
/* parse them */
- p_sys->rec_hdrs = parse_chunk_headers(p_demux, p_hdr_buf, i_num_recs,
+ p_sys->rec_hdrs = parse_chunk_headers(p_hdr_buf, i_num_recs,
&i_payload_size);
free(p_hdr_buf);
}
-static ty_rec_hdr_t *parse_chunk_headers( demux_t *p_demux, const uint8_t *p_buf,
+static ty_rec_hdr_t *parse_chunk_headers( const uint8_t *p_buf,
int i_num_recs, int *pi_payload_size)
{
int i;
/* marker bit 2 set, so read extended data */
b1 = ( ( ( record_header[ 0 ] & 0x0f ) << 4 ) |
( ( record_header[ 1 ] & 0xf0 ) >> 4 ) );
- b1 &= 0x7f;
b2 = ( ( ( record_header[ 1 ] & 0x0f ) << 4 ) |
( ( record_header[ 2 ] & 0xf0 ) >> 4 ) );
- b2 &= 0x7f;
- p_rec_hdr->ex1 = b1;
- p_rec_hdr->ex2 = b2;
+ p_rec_hdr->ex[0] = b1;
+ p_rec_hdr->ex[1] = b2;
p_rec_hdr->l_rec_size = 0;
p_rec_hdr->l_ty_pts = 0;
- p_rec_hdr->b_ext = VLC_TRUE;
+ p_rec_hdr->b_ext = true;
}
else
{
p_rec_hdr->l_rec_size = ( record_header[ 0 ] << 8 |
record_header[ 1 ] ) << 4 | ( record_header[ 2 ] >> 4 );
*pi_payload_size += p_rec_hdr->l_rec_size;
- p_rec_hdr->b_ext = VLC_FALSE;
+ p_rec_hdr->b_ext = false;
p_rec_hdr->l_ty_pts = U64_AT( &record_header[ 8 ] );
}
//fprintf( stderr, "parse_chunk_headers[%d] t=0x%x s=%d\n", i, p_rec_hdr->rec_type, p_rec_hdr->subrec_type );