Skip to content

V
vlc-gpu
Commit 58cd832e authored by Laurent Aimar's avatar Laurent Aimar
Browse files
Options

Clean up + fixed a few memleaks.

parent aea60015
Show whitespace changes
Inline Side-by-side
Showing with 500 additions and 474 deletions
modules/demux/ty.c
View file @ 58cd832e
......@@ -192,6 +192,12 @@ static int probe_stream(demux_t *p_demux);
static void analyze_chunk(demux_t *p_demux, const uint8_t *p_chunk);
static void parse_master(demux_t *p_demux);
static int DemuxRecVideo( demux_t *p_demux, ty_rec_hdr_t *rec_hdr, block_t *p_block_in );
static int DemuxRecAudio( demux_t *p_demux, ty_rec_hdr_t *rec_hdr, block_t *p_block_in );
static int DemuxRecCc( demux_t *p_demux, ty_rec_hdr_t *rec_hdr, block_t *p_block_in );
static int DemuxRecXds( demux_t *p_demux, ty_rec_hdr_t *rec_hdr, block_t *p_block_in );
/*
* Open: check file and initialize demux structures
*
......@@ -281,6 +287,188 @@ static int Open(vlc_object_t *p_this)
return VLC_SUCCESS;
}
/* =========================================================================== */
/* Demux: Read & Demux one record from the chunk
*
* Returns -1 in case of error, 0 in case of EOF, 1 otherwise
*
* NOTE: I think we can return the number of packets sent instead of just 1.
* that means we can demux an entire chunk and shoot it back (may be more efficient)
* -- should try that some day :) --
*/
static int Demux( demux_t *p_demux )
{
demux_sys_t *p_sys = p_demux->p_sys;
ty_rec_hdr_t *p_rec;
block_t *p_block_in = NULL;
/*msg_Dbg(p_demux, "ty demux processing" );*/
/* did we hit EOF earlier? */
if( p_sys->eof )
return 0;
/*
* what we do (1 record now.. maybe more later):
* - use stream_Read() to read the chunk header & record headers
* - discard entire chunk if it is a PART header chunk
* - parse all the headers into record header array
* - keep a pointer of which record we're on
* - use stream_Block() to fetch each record
* - parse out PTS from PES headers
* - set PTS for data packets
* - pass the data on to the proper codec via es_out_Send()
* if this is the first time or
* if we're at the end of this chunk, start a new one
*/
/* parse the next chunk's record headers */
if( p_sys->b_first_chunk || p_sys->i_cur_rec >= p_sys->i_num_recs )
{
if( get_chunk_header(p_demux) == 0 )
return 0;
}
/*======================================================================
* parse & send one record of the chunk
*====================================================================== */
p_rec = &p_sys->rec_hdrs[p_sys->i_cur_rec];
if( !p_rec->b_ext )
{
const long l_rec_size = p_rec->l_rec_size;
/*msg_Dbg(p_demux, "Record Type 0x%x/%02x %ld bytes",
subrec_type, p_rec->rec_type, l_rec_size );*/
/* some normal records are 0 length, so check for that... */
if( l_rec_size <= 0 )
{
/* no data in payload; we're done */
p_sys->i_cur_rec++;
return 1;
}
/* read in this record's payload */
if( !( p_block_in = stream_Block( p_demux->s, l_rec_size ) ) )
return 0;
/* set these as 'unknown' for now */
p_block_in->i_pts =
p_block_in->i_dts = 0;
}
/*else
{
-- don't read any data from the stream, data was in the record header --
msg_Dbg(p_demux,
"Record Type 0x%02x/%02x, ext data = %02x, %02x", subrec_type,
p_rec->rec_type, p_rec->ex1, p_rec->ex2);
}*/
if( p_rec->rec_type == 0xe0 )
{
/* Video */
DemuxRecVideo( p_demux, p_rec, p_block_in );
}
else if ( p_rec->rec_type == 0xc0 )
{
/* Audio */
DemuxRecAudio( p_demux, p_rec, p_block_in );
}
else if ( p_rec->rec_type == 0x01 )
{
/* Closed Captions */
DemuxRecCc( p_demux, p_rec, p_block_in );
}
else if ( p_rec->rec_type == 0x02 )
{
/* XDS */
DemuxRecXds( p_demux, p_rec, p_block_in );
}
else if ( p_rec->rec_type == 0x03 )
{
/* Tivo data services (e.g. "thumbs-up to record!") useless for us */
if( p_block_in )
block_Release(p_block_in);
}
else if ( p_rec->rec_type == 0x05 )
{
/* Unknown, but seen regularly */
if( p_block_in )
block_Release(p_block_in);
}
else
{
msg_Dbg(p_demux, "Invalid record type 0x%02x", p_rec->rec_type );
if( p_block_in )
block_Release(p_block_in);
}
/* */
p_sys->i_cur_rec++;
return 1;
}
/* Control */
static int Control(demux_t *p_demux, int i_query, va_list args)
{
demux_sys_t *p_sys = p_demux->p_sys;
double f, *pf;
int64_t i64, *p_i64;
/*msg_Info(p_demux, "control cmd %d", i_query);*/
switch( i_query )
{
case DEMUX_GET_POSITION:
/* arg is 0.0 - 1.0 percent of overall file position */
if( ( i64 = p_sys->i_stream_size ) > 0 )
{
pf = (double*) va_arg( args, double* );
*pf = (double)stream_Tell( p_demux->s ) / (double) i64;
return VLC_SUCCESS;
}
return VLC_EGENERIC;
case DEMUX_SET_POSITION:
/* arg is 0.0 - 1.0 percent of overall file position */
f = (double) va_arg( args, double );
/* msg_Dbg(p_demux, "Control - set position to %2.3f", f); */
if ((i64 = p_sys->i_stream_size) > 0)
return ty_stream_seek_pct(p_demux, f);
return VLC_EGENERIC;
case DEMUX_GET_TIME:
/* return TiVo timestamp */
p_i64 = (int64_t *) va_arg(args, int64_t *);
//*p_i64 = p_sys->lastAudioPTS - p_sys->firstAudioPTS;
//*p_i64 = (p_sys->l_last_ty_pts / 1000) + (p_sys->lastAudioPTS -
// p_sys->l_last_ty_pts_sync);
*p_i64 = (p_sys->l_last_ty_pts / 1000);
return VLC_SUCCESS;
case DEMUX_GET_LENGTH: /* length of program in microseconds, 0 if unk */
/* size / bitrate */
p_i64 = (int64_t *) va_arg(args, int64_t *);
*p_i64 = 0;
return VLC_SUCCESS;
case DEMUX_SET_TIME: /* arg is time in microsecs */
i64 = (int64_t) va_arg( args, int64_t );
return ty_stream_seek_time(p_demux, i64 * 1000);
case DEMUX_GET_FPS:
default:
return VLC_EGENERIC;
}
}
/* Close */
static void Close( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys = p_demux->p_sys;
free( p_sys->rec_hdrs );
if( p_sys->seq_table )
free( p_sys->seq_table );
free(p_sys);
}
/* =========================================================================== */
/* Compute Presentation Time Stamp (PTS)
......@@ -383,107 +571,17 @@ static int check_sync_pes( demux_t *p_demux, block_t *p_block,
return 0;
}
/* =========================================================================== */
/* Demux: Read & Demux one record from the chunk
*
* Returns -1 in case of error, 0 in case of EOF, 1 otherwise
*
* NOTE: I think we can return the number of packets sent instead of just 1.
* that means we can demux an entire chunk and shoot it back (may be more efficient)
* -- should try that some day :) --
*/
static int Demux( demux_t *p_demux )
static int DemuxRecVideo( demux_t *p_demux, ty_rec_hdr_t *rec_hdr, block_t *p_block_in )
{
demux_sys_t *p_sys = p_demux->p_sys;
int invalidType = 0;
int recordsDecoded = 0;
int rec_type;
long l_rec_size;
int i_cur_rec;
int subrec_type;
ty_rec_hdr_t *rec_hdr;
block_t *p_block_in = NULL;
const int subrec_type = rec_hdr->subrec_type;
const long l_rec_size = rec_hdr->l_rec_size; // p_block_in->i_buffer might be better
int esOffset1;
uint8_t lastCC[ 16 ];
uint8_t lastXDS[ 16 ];
/*msg_Dbg(p_demux, "ty demux processing" );*/
/* did we hit EOF earlier? */
if (p_sys->eof) return 0;
/*
* what we do (1 record now.. maybe more later):
* - use stream_Read() to read the chunk header & record headers
* - discard entire chunk if it is a PART header chunk
* - parse all the headers into record header array
* - keep a pointer of which record we're on
* - use stream_Block() to fetch each record
* - parse out PTS from PES headers
* - set PTS for data packets
* - pass the data on to the proper codec via es_out_Send()
* if this is the first time or
* if we're at the end of this chunk, start a new one
*/
/* parse the next chunk's record headers */
if (p_sys->b_first_chunk || p_sys->i_cur_rec >= p_sys->i_num_recs)
if (get_chunk_header(p_demux) == 0)
return 0;
/*======================================================================
* parse & send one record of the chunk
*====================================================================== */
i_cur_rec = p_sys->i_cur_rec;
recordsDecoded++;
rec_hdr = &p_sys->rec_hdrs[ i_cur_rec ];
subrec_type = rec_hdr->subrec_type;
rec_type = rec_hdr->rec_type;
l_rec_size = rec_hdr->l_rec_size;
if (!rec_hdr->b_ext)
{
/*msg_Dbg(p_demux, "Record Type 0x%x/%02x %ld bytes",
subrec_type, rec_type, l_rec_size );*/
/* some normal records are 0 length, so check for that... */
if (l_rec_size > 0)
{
/* read in this record's payload */
if( !( p_block_in = stream_Block( p_demux->s, l_rec_size ) ) )
{
/* EOF */
p_sys->eof = 1;
return 0;
}
/* set these as 'unknown' for now */
p_block_in->i_pts = p_block_in->i_dts = 0;
}
else
{
/* no data in payload; we're done */
p_sys->i_cur_rec++;
return 1;
}
}
/*else
{
-- don't read any data from the stream, data was in the record header --
msg_Dbg(p_demux,
"Record Type 0x%02x/%02x, ext data = %02x, %02x", subrec_type,
rec_type, rec_hdr->ex1, rec_hdr->ex2);
}*/
assert( rec_hdr->rec_type == 0xe0 );
if( !p_block_in )
return -1;
/*================================================================*
* Video Parsing
*================================================================*/
if ( rec_type == 0xe0 )
{
#if 0
msg_Dbg(p_demux, "packet buffer has "
"%02x %02x %02x %02x %02x %02x %02x %02x "
......@@ -498,15 +596,14 @@ static int Demux( demux_t *p_demux )
p_block_in->p_buffer[14], p_block_in->p_buffer[15]);
#endif
//if( subrec_type == 0x06 || subrec_type == 0x07 )
if( subrec_type != 0x02 && subrec_type != 0x0c
&& subrec_type != 0x08 && l_rec_size > 4 )
if( subrec_type != 0x02 && subrec_type != 0x0c &&
subrec_type != 0x08 && l_rec_size > 4 )
{
/* get the PTS from this packet if it has one.
* on S1, only 0x06 has PES. On S2, however, most all do.
* Do NOT Pass the PES Header to the MPEG2 codec */
esOffset1 = find_es_header( ty_VideoPacket, p_block_in->p_buffer,
5 );
if ( esOffset1 != -1 )
esOffset1 = find_es_header( ty_VideoPacket, p_block_in->p_buffer, 5 );
if( esOffset1 != -1 )
{
//msg_Dbg(p_demux, "Video PES hdr in pkt type 0x%02x at offset %d",
//subrec_type, esOffset1);
......@@ -532,12 +629,16 @@ static int Demux( demux_t *p_demux )
msg_Dbg(p_demux, "No Video PES hdr in pkt type 0x%02x",
subrec_type); */
}
if (subrec_type == 0x06) {
if(subrec_type == 0x06 )
{
/* type 6 (S1 DTivo) has no data, so we're done */
block_Release(p_block_in);
} else {
return 0;
}
/* if it's not a continue blk, then set PTS */
if (subrec_type != 0x02)
if( subrec_type != 0x02 )
{
/*msg_Dbg(p_demux, "Video rec %d type 0x%02X", p_sys->i_cur_rec,
subrec_type);*/
......@@ -575,15 +676,18 @@ static int Demux( demux_t *p_demux )
//msg_Dbg(p_demux, "sending rec %d as video type 0x%02x",
//p_sys->i_cur_rec, subrec_type);
es_out_Send(p_demux->out, p_sys->p_video, p_block_in);
}
} /* end if video rec type */
/* ================================================================
* Audio Parsing
* ================================================================
* parse PES headers and send the rest to the codec
*/
else if ( rec_type == 0xc0 )
{
return 0;
}
static int DemuxRecAudio( demux_t *p_demux, ty_rec_hdr_t *rec_hdr, block_t *p_block_in )
{
demux_sys_t *p_sys = p_demux->p_sys;
const int subrec_type = rec_hdr->subrec_type;
const long l_rec_size = rec_hdr->l_rec_size;
int esOffset1;
assert( rec_hdr->rec_type == 0xc0 );
if( !p_block_in )
return -1;
#if 0
int i;
printf( "Audio Packet Header " );
......@@ -592,20 +696,30 @@ static int Demux( demux_t *p_demux )
printf( "\n" );
#endif
if( subrec_type == 2 )
{
/* SA or DTiVo Audio Data, no PES (continued block)
* ================================================
*/
if ( subrec_type == 2 )
{
/* continue PES if previous was incomplete */
if (p_sys->i_pes_buf_cnt > 0)
{
int i_need = p_sys->i_Pes_Length - p_sys->i_pes_buf_cnt;
const int i_need = p_sys->i_Pes_Length - p_sys->i_pes_buf_cnt;
msg_Dbg(p_demux, "continuing PES header");
/* do we have enough data to complete? */
if (i_need < l_rec_size)
if (i_need >= l_rec_size)
{
/* don't have complete PES hdr; save what we have and return */
memcpy(&p_sys->pes_buffer[p_sys->i_pes_buf_cnt],
p_block_in->p_buffer, l_rec_size);
p_sys->i_pes_buf_cnt += l_rec_size;
/* */
block_Release(p_block_in);
return 0;
}
/* we have enough; reconstruct this p_frame with the new hdr */
memcpy(&p_sys->pes_buffer[p_sys->i_pes_buf_cnt],
p_block_in->p_buffer, i_need);
......@@ -632,17 +746,6 @@ static int Demux( demux_t *p_demux )
}
p_sys->i_pes_buf_cnt = 0;
}
else
{
/* don't have complete PES hdr; save what we have and return */
memcpy(&p_sys->pes_buffer[p_sys->i_pes_buf_cnt],
p_block_in->p_buffer, l_rec_size);
p_sys->i_pes_buf_cnt += l_rec_size;
p_sys->i_cur_rec++;
block_Release(p_block_in);
return 1;
}
}
/* S2 DTivo has AC3 packets with 2 padding bytes at end. This is
* not allowed in the AC3 spec and will cause problems. So here
* we try to trim things. */
......@@ -659,13 +762,11 @@ static int Demux( demux_t *p_demux )
p_sys->l_ac3_pkt_size += p_block_in->i_buffer;
}
}
es_out_Send( p_demux->out, p_sys->p_audio, p_block_in );
} /* subrec == 2 */
}
else if( subrec_type == 0x03 )
{
/* MPEG Audio with PES Header, either SA or DTiVo */
/* ================================================ */
if ( subrec_type == 0x03 )
{
esOffset1 = find_es_header( ty_MPEGAudioPacket,
p_block_in->p_buffer, 5 );
......@@ -682,23 +783,23 @@ static int Demux( demux_t *p_demux )
SA_PTS_OFFSET ] );
if (p_sys->firstAudioPTS < 0)
p_sys->firstAudioPTS = p_sys->lastAudioPTS;
block_Release(p_block_in);
return 0;
/*msg_Dbg(p_demux, "SA Audio PTS %lld",
p_sys->lastAudioPTS );*/
}
else
/* DTiVo Audio with PES Header */
/* ================================================ */
{
/* Check for complete PES */
if (check_sync_pes(p_demux, p_block_in, esOffset1,
l_rec_size) == -1)
{
/* partial PES header found, nothing else.
* we're done. */
p_sys->i_cur_rec++;
block_Release(p_block_in);
return 1;
return 0;
}
#if 0
msg_Dbg(p_demux, "packet buffer has "
......@@ -713,35 +814,21 @@ static int Demux( demux_t *p_demux )
p_block_in->p_buffer[12], p_block_in->p_buffer[13],
p_block_in->p_buffer[14], p_block_in->p_buffer[15]);
#endif
/* set PCR before we send */
if( p_block_in->i_pts > 0 )
es_out_Control( p_demux->out, ES_OUT_SET_PCR,
p_block_in->i_pts );
es_out_Send( p_demux->out, p_sys->p_audio, p_block_in );
} /* if DTiVo */
} /* if subrec == 0x03 */
}
else if( subrec_type == 0x04 )
{
/* SA Audio with no PES Header */
/* ================================================ */
if ( subrec_type == 0x04 )
{
/*msg_Dbg(p_demux,
"Adding SA Audio Packet Size %ld", l_rec_size ); */
/* set PCR before we send */
if (p_sys->lastAudioPTS > 0)
{
p_block_in->i_pts = p_sys->lastAudioPTS;
es_out_Control( p_demux->out, ES_OUT_SET_PCR,
p_block_in->i_pts );
}
es_out_Send( p_demux->out, p_sys->p_audio, p_block_in );
}
else if( subrec_type == 0x09 )
{
/* DTiVo AC3 Audio Data with PES Header */
/* ================================================ */
if ( subrec_type == 0x09 )
{
esOffset1 = find_es_header( ty_AC3AudioPacket,
p_block_in->p_buffer, 5 );
......@@ -765,14 +852,8 @@ static int Demux( demux_t *p_demux )
l_rec_size) == -1)
{
/* partial PES header found, nothing else. we're done. */
p_sys->i_cur_rec++;
return 1;
}
/* set PCR before we send (if PTS found) */
if( p_block_in->i_pts > 0 )
{
es_out_Control( p_demux->out, ES_OUT_SET_PCR,
p_block_in->i_pts );
block_Release(p_block_in);
return 0;
}
/* S2 DTivo has invalid long AC3 packets */
if (p_sys->tivo_series == TIVO_SERIES2) {
......@@ -783,14 +864,30 @@ static int Demux( demux_t *p_demux )
p_sys->l_ac3_pkt_size = p_block_in->i_buffer;
}
}
es_out_Send( p_demux->out, p_sys->p_audio, p_block_in );
}
} /* end "if audio" */
/* ================================================================ */
/* Closed Caption */
/* ================================================================ */
else if ( rec_type == 0x01 )
else
{
/* Unsupported/Unknown */
block_Release(p_block_in);
return 0;
}
/* set PCR before we send (if PTS found) */
if( p_block_in->i_pts > 0 )
es_out_Control( p_demux->out, ES_OUT_SET_PCR,
p_block_in->i_pts );
/* Send data */
es_out_Send( p_demux->out, p_sys->p_audio, p_block_in );
return 0;
}
static int DemuxRecCc( demux_t *p_demux, ty_rec_hdr_t *rec_hdr, block_t *p_block_in )
{
uint8_t lastCC[ 16 ];
if( p_block_in )
block_Release(p_block_in);
/*msg_Dbg(p_demux, "CC1 %02x %02x [%c%c]", rec_hdr->ex1,
rec_hdr->ex2, rec_hdr->ex1, rec_hdr->ex2 );*/
......@@ -808,9 +905,16 @@ static int Demux( demux_t *p_demux )
* teletext type of subtitles (only supports the full-sentence type) */
/*p_block_in = block_NewEmpty(); ????
es_out_Send( p_demux->out, p_sys->p_subt_es, p_block_in );*/
}
else if ( rec_type == 0x02 )
{
return 0;
}
static int DemuxRecXds( demux_t *p_demux, ty_rec_hdr_t *rec_hdr, block_t *p_block_in )
{
uint8_t lastXDS[ 16 ];
if( p_block_in )
block_Release(p_block_in);
/*msg_Dbg(p_demux, "CC2 %02x %02x", rec_hdr->ex1, rec_hdr->ex2 );*/
/* construct a 'user-data' MPEG packet */
......@@ -826,27 +930,7 @@ static int Demux( demux_t *p_demux )
/* not sure what to send, because VLC doesn't support this?? */
/*p_block_in = block_NewEmpty(); ????
es_out_Send( p_demux->out, p_sys->p_audio, p_block_in );*/
}
/* ================================================================ */
/* Tivo data services (e.g. "thumbs-up to record!") useless for us */
/* ================================================================ */
else if ( rec_type == 0x03 )
{
}
/* ================================================================ */
/* Unknown, but seen regularly */
/* ================================================================ */
else if ( rec_type == 0x05 )
{
}
else
{
msg_Dbg(p_demux, "Invalid record type 0x%02x", rec_type );
if (p_block_in) block_Release(p_block_in);
invalidType++;
}
p_sys->i_cur_rec++;
return 1;
return 0;
}
......@@ -1108,65 +1192,6 @@ static void parse_master(demux_t *p_demux)
}
static int Control(demux_t *p_demux, int i_query, va_list args)
{
demux_sys_t *p_sys = p_demux->p_sys;
double f, *pf;
int64_t i64, *p_i64;
/*msg_Info(p_demux, "control cmd %d", i_query);*/
switch( i_query )
{
case DEMUX_GET_POSITION:
/* arg is 0.0 - 1.0 percent of overall file position */
if( ( i64 = p_sys->i_stream_size ) > 0 )
{
pf = (double*) va_arg( args, double* );
*pf = (double)stream_Tell( p_demux->s ) / (double) i64;
return VLC_SUCCESS;
}
return VLC_EGENERIC;
case DEMUX_SET_POSITION:
/* arg is 0.0 - 1.0 percent of overall file position */
f = (double) va_arg( args, double );
/* msg_Dbg(p_demux, "Control - set position to %2.3f", f); */
if ((i64 = p_sys->i_stream_size) > 0)
return ty_stream_seek_pct(p_demux, f);
return VLC_EGENERIC;
case DEMUX_GET_TIME:
/* return TiVo timestamp */
p_i64 = (int64_t *) va_arg(args, int64_t *);
//*p_i64 = p_sys->lastAudioPTS - p_sys->firstAudioPTS;
//*p_i64 = (p_sys->l_last_ty_pts / 1000) + (p_sys->lastAudioPTS -
// p_sys->l_last_ty_pts_sync);
*p_i64 = (p_sys->l_last_ty_pts / 1000);
return VLC_SUCCESS;
case DEMUX_GET_LENGTH: /* length of program in microseconds, 0 if unk */
/* size / bitrate */
p_i64 = (int64_t *) va_arg(args, int64_t *);
*p_i64 = 0;
return VLC_SUCCESS;
case DEMUX_SET_TIME: /* arg is time in microsecs */
i64 = (int64_t) va_arg( args, int64_t );
return ty_stream_seek_time(p_demux, i64 * 1000);
case DEMUX_GET_FPS:
default:
return VLC_EGENERIC;
}
}
/* ======================================================================== */
static void Close( vlc_object_t *p_this )
{
demux_sys_t *p_sys = ((demux_t *) p_this)->p_sys;
free(p_sys->rec_hdrs);
free(p_sys);
}
/* ======================================================================== */
/* "Peek" at some chunks. Skip over the Part header if we find it.
* We parse the peeked data and determine audio type,
......@@ -1394,6 +1419,7 @@ static int get_chunk_header(demux_t *p_demux)
/* read the record headers into a temp buffer */
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;
return 0;
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment