X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fdemux%2Fogg.c;h=4c50f6d2c8a07447e568957d360e946d74a4e1a7;hb=dea4f0a1b9ca2132ac32b2b31b0b6063a03c8bc0;hp=2a85c3f27626b73f13e5034cd078ff6f3465bb6c;hpb=05492281965ed211badf7e1f4c2220be720d3356;p=vlc diff --git a/modules/demux/ogg.c b/modules/demux/ogg.c index 2a85c3f276..4c50f6d2c8 100644 --- a/modules/demux/ogg.c +++ b/modules/demux/ogg.c @@ -39,6 +39,11 @@ #include #include +#include "xiph.h" +#include "vorbis.h" +#include "kate_categories.h" +#include "ogg.h" +#include "oggseek.h" /***************************************************************************** * Module descriptor @@ -60,62 +65,6 @@ vlc_module_end () /***************************************************************************** * Definitions of structures and functions used by this plugins *****************************************************************************/ -typedef struct logical_stream_s -{ - ogg_stream_state os; /* logical stream of packets */ - - es_format_t fmt; - es_format_t fmt_old; /* format of old ES is reused */ - es_out_id_t *p_es; - double f_rate; - - int i_serial_no; - - /* the header of some logical streams (eg vorbis) contain essential - * data for the decoder. We back them up here in case we need to re-feed - * them to the decoder. */ - int b_force_backup; - int i_packets_backup; - uint8_t *p_headers; - int i_headers; - - /* program clock reference (in units of 90kHz) derived from the previous - * granulepos */ - mtime_t i_pcr; - mtime_t i_interpolated_pcr; - mtime_t i_previous_pcr; - - /* Misc */ - int b_reinit; - int i_granule_shift; - - /* kate streams have the number of headers in the ID header */ - int i_kate_num_headers; - - /* for Annodex logical bitstreams */ - int secondary_header_packets; - -} logical_stream_t; - -struct demux_sys_t -{ - ogg_sync_state oy; /* sync and verify incoming physical bitstream */ - - int i_streams; /* number of logical bitstreams */ - logical_stream_t **pp_stream; /* pointer to an array of logical streams */ - - logical_stream_t *p_old_stream; /* pointer to a old logical stream to avoid recreating it */ - - /* program clock reference (in units of 90kHz) derived from the pcr of - * the sub-streams */ - mtime_t i_pcr; - - /* stream state */ - int i_eos; - - /* bitrate */ - int i_bitrate; -}; /* OggDS headers for the new header format (used in ogm files) */ typedef struct @@ -156,7 +105,6 @@ typedef struct } sh; } stream_header_t; -#define OGG_BLOCK_SIZE 4096 /* Some defines from OggDS */ #define PACKET_TYPE_HEADER 0x01 @@ -184,6 +132,9 @@ static void Ogg_EndOfStream( demux_t *p_demux ); static void Ogg_LogicalStreamDelete( demux_t *p_demux, logical_stream_t *p_stream ); static bool Ogg_LogicalStreamResetEsFormat( demux_t *p_demux, logical_stream_t *p_stream ); +/* */ +static void Ogg_ExtractMeta( demux_t *p_demux, vlc_fourcc_t i_codec, const uint8_t *p_headers, int i_headers ); + /* Logical bitstream headers */ static void Ogg_ReadTheoraHeader( logical_stream_t *, ogg_packet * ); static void Ogg_ReadVorbisHeader( logical_stream_t *, ogg_packet * ); @@ -191,7 +142,7 @@ static void Ogg_ReadSpeexHeader( logical_stream_t *, ogg_packet * ); static void Ogg_ReadKateHeader( logical_stream_t *, ogg_packet * ); static void Ogg_ReadFlacHeader( demux_t *, logical_stream_t *, ogg_packet * ); static void Ogg_ReadAnnodexHeader( vlc_object_t *, logical_stream_t *, ogg_packet * ); -static void Ogg_ReadDiracHeader( logical_stream_t *, ogg_packet * ); +static bool Ogg_ReadDiracHeader( logical_stream_t *, ogg_packet * ); /***************************************************************************** * Open: initializes ogg demux structures @@ -223,10 +174,15 @@ static int Open( vlc_object_t * p_this ) p_sys->p_old_stream = NULL; /* Begnning of stream, tell the demux to look for elementary streams. */ + p_sys->i_bos = 0; p_sys->i_eos = 0; /* Initialize the Ogg physical bitstream parser */ ogg_sync_init( &p_sys->oy ); + p_sys->b_page_waiting = false; + + /* */ + p_sys->p_meta = NULL; return VLC_SUCCESS; } @@ -258,9 +214,9 @@ static void Close( vlc_object_t *p_this ) static int Demux( demux_t * p_demux ) { demux_sys_t *p_sys = p_demux->p_sys; - ogg_page oggpage; ogg_packet oggpacket; int i_stream; + bool b_skipping = false; if( p_sys->i_eos == p_sys->i_streams ) @@ -287,49 +243,93 @@ static int Demux( demux_t * p_demux ) } /* - * Demux an ogg page from the stream + * The first data page of a physical stream is stored in the relevant logical stream + * in Ogg_FindLogicalStreams. Therefore, we must not read a page and only update the + * stream it belongs to if we haven't processed this first page yet. If we do, we + * will only process that first page whenever we find the second page for this stream. + * While this is fine for Vorbis and Theora, which are continuous codecs, which means + * the second page will arrive real quick, this is not fine for Kate, whose second + * data page will typically arrive much later. + * This means it is now possible to seek right at the start of a stream where the last + * logical stream is Kate, without having to wait for the second data page to unblock + * the first one, which is the one that triggers the 'no more headers to backup' code. + * And, as we all know, seeking without having backed up all headers is bad, since the + * codec will fail to initialize if it's missing its headers. */ - if( Ogg_ReadPage( p_demux, &oggpage ) != VLC_SUCCESS ) + if( !p_sys->b_page_waiting) { - return 0; /* EOF */ + /* + * Demux an ogg page from the stream + */ + if( Ogg_ReadPage( p_demux, &p_sys->current_page ) != VLC_SUCCESS ) + return 0; /* EOF */ + + /* Test for End of Stream */ + if( ogg_page_eos( &p_sys->current_page ) ) + p_sys->i_eos++; } - /* Test for End of Stream */ - if( ogg_page_eos( &oggpage ) ) p_sys->i_eos++; - for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ ) { logical_stream_t *p_stream = p_sys->pp_stream[i_stream]; - if( ogg_stream_pagein( &p_stream->os, &oggpage ) != 0 ) - continue; + /* if we've just pulled page, look for the right logical stream */ + if( !p_sys->b_page_waiting ) + { + if( p_sys->i_streams == 1 && + ogg_page_serialno( &p_sys->current_page ) != p_stream->os.serialno ) + { + msg_Err( p_demux, "Broken Ogg stream (serialno) mismatch" ); + ogg_stream_reset_serialno( &p_stream->os, ogg_page_serialno( &p_sys->current_page ) ); + + p_stream->b_reinit = true; + p_stream->i_pcr = -1; + p_stream->i_interpolated_pcr = -1; + es_out_Control( p_demux->out, ES_OUT_RESET_PCR ); + } + + if( ogg_stream_pagein( &p_stream->os, &p_sys->current_page ) != 0 ) + { + continue; + } + + } while( ogg_stream_packetout( &p_stream->os, &oggpacket ) > 0 ) { /* Read info from any secondary header packets, if there are any */ - if( p_stream->secondary_header_packets > 0 ) + if( p_stream->i_secondary_header_packets > 0 ) { - if( p_stream->fmt.i_codec == VLC_FOURCC('t','h','e','o') && + if( p_stream->fmt.i_codec == VLC_CODEC_THEORA && oggpacket.bytes >= 7 && ! memcmp( oggpacket.packet, "\x80theora", 7 ) ) { Ogg_ReadTheoraHeader( p_stream, &oggpacket ); - p_stream->secondary_header_packets = 0; + p_stream->i_secondary_header_packets = 0; } - else if( p_stream->fmt.i_codec == VLC_FOURCC('v','o','r','b') && + else if( p_stream->fmt.i_codec == VLC_CODEC_VORBIS && oggpacket.bytes >= 7 && ! memcmp( oggpacket.packet, "\x01vorbis", 7 ) ) { Ogg_ReadVorbisHeader( p_stream, &oggpacket ); - p_stream->secondary_header_packets = 0; + p_stream->i_secondary_header_packets = 0; } - else if ( p_stream->fmt.i_codec == VLC_FOURCC('c','m','m','l') ) + else if( p_stream->fmt.i_codec == VLC_CODEC_CMML ) { - p_stream->secondary_header_packets = 0; + p_stream->i_secondary_header_packets = 0; } + + /* update start of data pointer */ + p_stream->i_data_start = stream_Tell( p_demux->s ); + } + /* If any streams have i_skip_frames, only decode (pre-roll) + * for those streams */ + if ( b_skipping && p_stream->i_skip_frames == 0 ) continue; + + if( p_stream->b_reinit ) { /* If synchro is re-initialized we need to drop all the packets @@ -338,7 +338,7 @@ static int Demux( demux_t * p_demux ) if( p_stream->i_pcr >= 0 ) { - p_stream->b_reinit = 0; + p_stream->b_reinit = false; } else { @@ -347,9 +347,9 @@ static int Demux( demux_t * p_demux ) } /* An Ogg/vorbis packet contains an end date granulepos */ - if( p_stream->fmt.i_codec == VLC_FOURCC( 'v','o','r','b' ) || - p_stream->fmt.i_codec == VLC_FOURCC( 's','p','x',' ' ) || - p_stream->fmt.i_codec == VLC_FOURCC( 'f','l','a','c' ) ) + if( p_stream->fmt.i_codec == VLC_CODEC_VORBIS || + p_stream->fmt.i_codec == VLC_CODEC_SPEEX || + p_stream->fmt.i_codec == VLC_CODEC_FLAC ) { if( ogg_stream_packetout( &p_stream->os, &oggpacket ) > 0 ) { @@ -358,7 +358,7 @@ static int Demux( demux_t * p_demux ) else { es_out_Control( p_demux->out, ES_OUT_SET_PCR, - p_stream->i_pcr ); + VLC_TS_0 + p_stream->i_pcr ); } continue; } @@ -366,11 +366,16 @@ static int Demux( demux_t * p_demux ) Ogg_DecodePacket( p_demux, p_stream, &oggpacket ); } - break; + + if( !p_sys->b_page_waiting ) + break; } - i_stream = 0; p_sys->i_pcr = -1; - for( ; i_stream < p_sys->i_streams; i_stream++ ) + /* if a page was waiting, it's now processed */ + p_sys->b_page_waiting = false; + + p_sys->i_pcr = -1; + for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ ) { logical_stream_t *p_stream = p_sys->pp_stream[i_stream]; @@ -383,10 +388,8 @@ static int Demux( demux_t * p_demux ) p_sys->i_pcr = p_stream->i_interpolated_pcr; } - if( p_sys->i_pcr >= 0 ) - { - es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_pcr ); - } + if( p_sys->i_pcr >= 0 && ! b_skipping ) + es_out_Control( p_demux->out, ES_OUT_SET_PCR, VLC_TS_0 + p_sys->i_pcr ); return 1; } @@ -397,12 +400,19 @@ static int Demux( 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; + vlc_meta_t *p_meta; int64_t *pi64; bool *pb_bool; int i; switch( i_query ) { + case DEMUX_GET_META: + p_meta = (vlc_meta_t *)va_arg( args, vlc_meta_t* ); + if( p_sys->p_meta ) + vlc_meta_Merge( p_meta, p_sys->p_meta ); + return VLC_SUCCESS; + case DEMUX_HAS_UNSUPPORTED_META: pb_bool = (bool*)va_arg( args, bool* ); *pb_bool = true; @@ -417,17 +427,27 @@ static int Control( demux_t *p_demux, int i_query, va_list args ) return VLC_EGENERIC; case DEMUX_SET_POSITION: + /* forbid seeking if we haven't initialized all logical bitstreams yet; + if we allowed, some headers would not get backed up and decoder init + would fail, making that logical stream unusable */ + if( p_sys->i_bos > 0 ) + { + return VLC_EGENERIC; + } + for( i = 0; i < p_sys->i_streams; i++ ) { logical_stream_t *p_stream = p_sys->pp_stream[i]; /* we'll trash all the data until we find the next pcr */ - p_stream->b_reinit = 1; + p_stream->b_reinit = true; p_stream->i_pcr = -1; p_stream->i_interpolated_pcr = -1; ogg_stream_reset( &p_stream->os ); } ogg_sync_reset( &p_sys->oy ); + /* XXX The break/return is missing on purpose as + * demux_vaControlHelper will do the last part of the job */ default: return demux_vaControlHelper( p_demux->s, 0, -1, p_sys->i_bitrate, @@ -449,9 +469,9 @@ static int Ogg_ReadPage( demux_t *p_demux, ogg_page *p_oggpage ) while( ogg_sync_pageout( &p_ogg->oy, p_oggpage ) != 1 ) { - p_buffer = ogg_sync_buffer( &p_ogg->oy, OGG_BLOCK_SIZE ); + p_buffer = ogg_sync_buffer( &p_ogg->oy, OGGSEEK_BYTES_TO_READ ); - i_read = stream_Read( p_demux->s, p_buffer, OGG_BLOCK_SIZE ); + i_read = stream_Read( p_demux->s, p_buffer, OGGSEEK_BYTES_TO_READ ); if( i_read <= 0 ) return VLC_EGENERIC; @@ -471,18 +491,18 @@ static void Ogg_UpdatePCR( logical_stream_t *p_stream, /* Convert the granulepos into a pcr */ if( p_oggpacket->granulepos >= 0 ) { - if( p_stream->fmt.i_codec == VLC_FOURCC( 't','h','e','o' ) || - p_stream->fmt.i_codec == VLC_FOURCC( 'k','a','t','e' ) ) + if( p_stream->fmt.i_codec == VLC_CODEC_THEORA || + p_stream->fmt.i_codec == VLC_CODEC_KATE ) { ogg_int64_t iframe = p_oggpacket->granulepos >> p_stream->i_granule_shift; ogg_int64_t pframe = p_oggpacket->granulepos - ( iframe << p_stream->i_granule_shift ); - p_stream->i_pcr = ( iframe + pframe ) * INT64_C(1000000) - / p_stream->f_rate; + p_stream->i_pcr = ( iframe + pframe - p_stream->i_keyframe_offset ) + * INT64_C(1000000) / p_stream->f_rate; } - else if( p_stream->fmt.i_codec == VLC_FOURCC( 'd','r','a','c' ) ) + else if( p_stream->fmt.i_codec == VLC_CODEC_DIRAC ) { ogg_int64_t i_dts = p_oggpacket->granulepos >> 31; /* NB, OggDirac granulepos values are in units of 2*picturerate */ @@ -494,6 +514,7 @@ static void Ogg_UpdatePCR( logical_stream_t *p_stream, / p_stream->f_rate; } + p_stream->i_pcr += 1; p_stream->i_interpolated_pcr = p_stream->i_pcr; } else @@ -523,6 +544,7 @@ static void Ogg_DecodePacket( demux_t *p_demux, bool b_selected; int i_header_len = 0; mtime_t i_pts = -1, i_interpolated_pts; + demux_sys_t *p_ogg = p_demux->p_sys; /* Sanity check */ if( !p_oggpacket->bytes ) @@ -544,7 +566,7 @@ static void Ogg_DecodePacket( demux_t *p_demux, return; } - if( p_stream->fmt.i_codec == VLC_FOURCC( 's','u','b','t' ) && + if( p_stream->fmt.i_codec == VLC_CODEC_SUBT && p_oggpacket->packet[0] & PACKET_TYPE_BITS ) return; /* Check the ES is selected */ @@ -553,20 +575,18 @@ static void Ogg_DecodePacket( demux_t *p_demux, if( p_stream->b_force_backup ) { - uint8_t *p_sav; - bool b_store_size = true; - bool b_store_num_headers = false; - + bool b_xiph; p_stream->i_packets_backup++; switch( p_stream->fmt.i_codec ) { - case VLC_FOURCC( 'v','o','r','b' ): - case VLC_FOURCC( 's','p','x',' ' ): - case VLC_FOURCC( 't','h','e','o' ): + case VLC_CODEC_VORBIS: + case VLC_CODEC_SPEEX: + case VLC_CODEC_THEORA: if( p_stream->i_packets_backup == 3 ) p_stream->b_force_backup = 0; + b_xiph = true; break; - case VLC_FOURCC( 'f','l','a','c' ): + case VLC_CODEC_FLAC: if( !p_stream->fmt.audio.i_rate && p_stream->i_packets_backup == 2 ) { Ogg_ReadFlacHeader( p_demux, p_stream, p_oggpacket ); @@ -581,50 +601,53 @@ static void Ogg_DecodePacket( demux_t *p_demux, p_oggpacket->bytes -= 9; } } - b_store_size = false; + b_xiph = false; break; - case VLC_FOURCC( 'k','a','t','e' ): - if( p_stream->i_packets_backup == 1) - b_store_num_headers = true; + case VLC_CODEC_KATE: if( p_stream->i_packets_backup == p_stream->i_kate_num_headers ) p_stream->b_force_backup = 0; + b_xiph = true; break; default: p_stream->b_force_backup = 0; + b_xiph = false; break; } /* Backup the ogg packet (likely an header packet) */ - p_stream->p_headers = - realloc( p_sav = p_stream->p_headers, p_stream->i_headers + - p_oggpacket->bytes + (b_store_size ? 2 : 0) + (b_store_num_headers ? 1 : 0) ); - if( p_stream->p_headers ) + if( !b_xiph ) { - uint8_t *p_extra = p_stream->p_headers + p_stream->i_headers; - - if( b_store_num_headers ) + void *p_org = p_stream->p_headers; + p_stream->i_headers += p_oggpacket->bytes; + p_stream->p_headers = realloc( p_stream->p_headers, p_stream->i_headers ); + if( p_stream->p_headers ) { - /* Kate streams store the number of headers in the first header, - so we can't just test for 3 as Vorbis/Theora */ - *(p_extra++) = p_stream->i_kate_num_headers; + memcpy( (unsigned char *)p_stream->p_headers + p_stream->i_headers - p_oggpacket->bytes, + p_oggpacket->packet, p_stream->i_headers ); } - if( b_store_size ) + else { - *(p_extra++) = p_oggpacket->bytes >> 8; - *(p_extra++) = p_oggpacket->bytes & 0xFF; + p_stream->i_headers = 0; + p_stream->p_headers = NULL; + free( p_org ); } - memcpy( p_extra, p_oggpacket->packet, p_oggpacket->bytes ); - p_stream->i_headers += p_oggpacket->bytes + (b_store_size ? 2 : 0) + (b_store_num_headers ? 1 : 0); - + } + else if( xiph_AppendHeaders( &p_stream->i_headers, &p_stream->p_headers, + p_oggpacket->bytes, p_oggpacket->packet ) ) + { + p_stream->i_headers = 0; + p_stream->p_headers = NULL; + } + if( p_stream->i_headers > 0 ) + { if( !p_stream->b_force_backup ) { /* Last header received, commit changes */ free( p_stream->fmt.p_extra ); p_stream->fmt.i_extra = p_stream->i_headers; - p_stream->fmt.p_extra = - realloc( p_stream->fmt.p_extra, p_stream->i_headers ); + p_stream->fmt.p_extra = malloc( p_stream->i_headers ); if( p_stream->fmt.p_extra ) memcpy( p_stream->fmt.p_extra, p_stream->p_headers, p_stream->i_headers ); @@ -632,22 +655,25 @@ static void Ogg_DecodePacket( demux_t *p_demux, p_stream->fmt.i_extra = 0; if( Ogg_LogicalStreamResetEsFormat( p_demux, p_stream ) ) - es_out_Control( p_demux->out, ES_OUT_SET_FMT, + es_out_Control( p_demux->out, ES_OUT_SET_ES_FMT, p_stream->p_es, &p_stream->fmt ); + + if( p_stream->i_headers > 0 ) + Ogg_ExtractMeta( p_demux, p_stream->fmt.i_codec, + p_stream->p_headers, p_stream->i_headers ); + + /* we're not at BOS anymore for this logical stream */ + p_ogg->i_bos--; } } - else - { - p_stream->p_headers = p_sav; - } b_selected = false; /* Discard the header packet */ } /* Convert the pcr into a pts */ - if( p_stream->fmt.i_codec == VLC_FOURCC( 'v','o','r','b' ) || - p_stream->fmt.i_codec == VLC_FOURCC( 's','p','x',' ' ) || - p_stream->fmt.i_codec == VLC_FOURCC( 'f','l','a','c' ) ) + if( p_stream->fmt.i_codec == VLC_CODEC_VORBIS || + p_stream->fmt.i_codec == VLC_CODEC_SPEEX || + p_stream->fmt.i_codec == VLC_CODEC_FLAC ) { if( p_stream->i_pcr >= 0 ) { @@ -660,7 +686,7 @@ static void Ogg_DecodePacket( demux_t *p_demux, /* Call the pace control */ es_out_Control( p_demux->out, ES_OUT_SET_PCR, - p_stream->i_pcr ); + VLC_TS_0 + p_stream->i_pcr ); } p_stream->i_previous_pcr = p_stream->i_pcr; @@ -674,23 +700,27 @@ static void Ogg_DecodePacket( demux_t *p_demux, i_interpolated_pts = p_stream->i_interpolated_pcr; Ogg_UpdatePCR( p_stream, p_oggpacket ); - if( p_stream->i_pcr >= 0 ) + /* SPU streams are typically discontinuous, do not mind large gaps */ + if( p_stream->fmt.i_cat != SPU_ES ) { - /* This is for streams where the granulepos of the header packets - * doesn't match these of the data packets (eg. ogg web radios). */ - if( p_stream->i_previous_pcr == 0 && - p_stream->i_pcr > 3 * DEFAULT_PTS_DELAY ) + if( p_stream->i_pcr >= 0 ) { - es_out_Control( p_demux->out, ES_OUT_RESET_PCR ); + /* This is for streams where the granulepos of the header packets + * doesn't match these of the data packets (eg. ogg web radios). */ + if( p_stream->i_previous_pcr == 0 && + p_stream->i_pcr > 3 * DEFAULT_PTS_DELAY ) + { + es_out_Control( p_demux->out, ES_OUT_RESET_PCR ); - /* Call the pace control */ - es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_stream->i_pcr ); + /* Call the pace control */ + es_out_Control( p_demux->out, ES_OUT_SET_PCR, VLC_TS_0 + p_stream->i_pcr ); + } } } - if( p_stream->fmt.i_codec != VLC_FOURCC( 'v','o','r','b' ) && - p_stream->fmt.i_codec != VLC_FOURCC( 's','p','x',' ' ) && - p_stream->fmt.i_codec != VLC_FOURCC( 'f','l','a','c' ) && + if( p_stream->fmt.i_codec != VLC_CODEC_VORBIS && + p_stream->fmt.i_codec != VLC_CODEC_SPEEX && + p_stream->fmt.i_codec != VLC_CODEC_FLAC && p_stream->i_pcr >= 0 ) { p_stream->i_previous_pcr = p_stream->i_pcr; @@ -711,10 +741,19 @@ static void Ogg_DecodePacket( demux_t *p_demux, if( !( p_block = block_New( p_demux, p_oggpacket->bytes ) ) ) return; + + /* may need to preroll video frames after a seek */ + if ( p_stream->i_skip_frames > 0 ) + { + p_block->i_flags |= BLOCK_FLAG_PREROLL; + p_stream->i_skip_frames--; + } + + /* Normalize PTS */ - if( i_pts == 0 ) i_pts = 1; - else if( i_pts == -1 && i_interpolated_pts == 0 ) i_pts = 1; - else if( i_pts == -1 ) i_pts = 0; + if( i_pts == 0 ) i_pts = VLC_TS_0; + else if( i_pts == -1 && i_interpolated_pts == 0 ) i_pts = VLC_TS_0; + else if( i_pts == -1 ) i_pts = VLC_TS_INVALID; if( p_stream->fmt.i_cat == AUDIO_ES ) p_block->i_dts = p_block->i_pts = i_pts; @@ -723,9 +762,15 @@ static void Ogg_DecodePacket( demux_t *p_demux, p_block->i_dts = p_block->i_pts = i_pts; p_block->i_length = 0; } - else if( p_stream->fmt.i_codec == VLC_FOURCC( 't','h','e','o' ) ) + else if( p_stream->fmt.i_codec == VLC_CODEC_THEORA ) + { p_block->i_dts = p_block->i_pts = i_pts; - else if( p_stream->fmt.i_codec == VLC_FOURCC( 'd','r','a','c' ) ) + if( (p_oggpacket->granulepos & ((1<i_granule_shift)-1)) == 0 ) + { + p_block->i_flags |= BLOCK_FLAG_TYPE_I; + } + } + else if( p_stream->fmt.i_codec == VLC_CODEC_DIRAC ) { ogg_int64_t dts = p_oggpacket->granulepos >> 31; ogg_int64_t delay = (p_oggpacket->granulepos >> 9) & 0x1fff; @@ -733,31 +778,33 @@ static void Ogg_DecodePacket( demux_t *p_demux, uint64_t u_pnum = dts + delay; p_block->i_dts = p_stream->i_pcr; - p_block->i_pts = 0; + p_block->i_pts = VLC_TS_INVALID; /* NB, OggDirac granulepos values are in units of 2*picturerate */ + + /* granulepos for dirac is possibly broken, this value should be ignored */ if( -1 != p_oggpacket->granulepos ) p_block->i_pts = u_pnum * INT64_C(1000000) / p_stream->f_rate / 2; } else { p_block->i_dts = i_pts; - p_block->i_pts = 0; + p_block->i_pts = VLC_TS_INVALID; } - if( p_stream->fmt.i_codec != VLC_FOURCC( 'v','o','r','b' ) && - p_stream->fmt.i_codec != VLC_FOURCC( 's','p','x',' ' ) && - p_stream->fmt.i_codec != VLC_FOURCC( 'f','l','a','c' ) && - p_stream->fmt.i_codec != VLC_FOURCC( 't','a','r','k' ) && - p_stream->fmt.i_codec != VLC_FOURCC( 't','h','e','o' ) && - p_stream->fmt.i_codec != VLC_FOURCC( 'c','m','m','l' ) && - p_stream->fmt.i_codec != VLC_FOURCC( 'd','r','a','c' ) && - p_stream->fmt.i_codec != VLC_FOURCC( 'k','a','t','e' ) ) + if( p_stream->fmt.i_codec != VLC_CODEC_VORBIS && + p_stream->fmt.i_codec != VLC_CODEC_SPEEX && + p_stream->fmt.i_codec != VLC_CODEC_FLAC && + p_stream->fmt.i_codec != VLC_CODEC_TARKIN && + p_stream->fmt.i_codec != VLC_CODEC_THEORA && + p_stream->fmt.i_codec != VLC_CODEC_CMML && + p_stream->fmt.i_codec != VLC_CODEC_DIRAC && + p_stream->fmt.i_codec != VLC_CODEC_KATE ) { /* We remove the header from the packet */ i_header_len = (*p_oggpacket->packet & PACKET_LEN_BITS01) >> 6; i_header_len |= (*p_oggpacket->packet & PACKET_LEN_BITS2) << 1; - if( p_stream->fmt.i_codec == VLC_FOURCC( 's','u','b','t' )) + if( p_stream->fmt.i_codec == VLC_CODEC_SUBT) { /* But with subtitles we need to retrieve the duration first */ int i, lenbytes = 0; @@ -787,7 +834,7 @@ static void Ogg_DecodePacket( demux_t *p_demux, p_block->i_buffer = 0; } - if( p_stream->fmt.i_codec == VLC_FOURCC( 't','a','r','k' ) ) + if( p_stream->fmt.i_codec == VLC_CODEC_TARKIN ) { /* FIXME: the biggest hack I've ever done */ msg_Warn( p_demux, "tarkin pts: %"PRId64", granule: %"PRId64, @@ -815,19 +862,22 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) { demux_sys_t *p_ogg = p_demux->p_sys ; ogg_packet oggpacket; - ogg_page oggpage; int i_stream; - while( Ogg_ReadPage( p_demux, &oggpage ) == VLC_SUCCESS ) + p_ogg->i_total_length = stream_Size ( p_demux->s ); + msg_Dbg( p_demux, "File length is %"PRId64" bytes", p_ogg->i_total_length ); + + + while( Ogg_ReadPage( p_demux, &p_ogg->current_page ) == VLC_SUCCESS ) { - if( ogg_page_bos( &oggpage ) ) + + if( ogg_page_bos( &p_ogg->current_page ) ) { /* All is wonderful in our fine fine little world. * We found the beginning of our first logical stream. */ - while( ogg_page_bos( &oggpage ) ) + while( ogg_page_bos( &p_ogg->current_page ) ) { - logical_stream_t **pp_sav = p_ogg->pp_stream; logical_stream_t *p_stream; p_stream = malloc( sizeof(logical_stream_t) ); @@ -838,18 +888,23 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) memset( p_stream, 0, sizeof(logical_stream_t) ); p_stream->p_headers = 0; - p_stream->secondary_header_packets = 0; + p_stream->i_secondary_header_packets = 0; + + p_stream->i_keyframe_offset = 0; + p_stream->i_skip_frames = 0; + + p_stream->i_data_start = 0; es_format_Init( &p_stream->fmt, 0, 0 ); es_format_Init( &p_stream->fmt_old, 0, 0 ); /* Setup the logical stream */ - p_stream->i_serial_no = ogg_page_serialno( &oggpage ); + p_stream->i_serial_no = ogg_page_serialno( &p_ogg->current_page ); ogg_stream_init( &p_stream->os, p_stream->i_serial_no ); /* Extract the initial header from the first page and verify - * the codec type of tis Ogg bitstream */ - if( ogg_stream_pagein( &p_stream->os, &oggpage ) < 0 ) + * the codec type of this Ogg bitstream */ + if( ogg_stream_pagein( &p_stream->os, &p_ogg->current_page ) < 0 ) { /* error. stream version mismatch perhaps */ msg_Err( p_demux, "error reading first page of " @@ -889,7 +944,7 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) p_stream->b_force_backup = 1; p_stream->fmt.i_cat = AUDIO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 'f','l','a','c' ); + p_stream->fmt.i_codec = VLC_CODEC_FLAC; } /* Check for Flac header (>= version 1.1.1) */ else if( oggpacket.bytes >= 13 && oggpacket.packet[0] ==0x7F && @@ -906,7 +961,7 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) p_stream->b_force_backup = 1; p_stream->fmt.i_cat = AUDIO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 'f','l','a','c' ); + p_stream->fmt.i_codec = VLC_CODEC_FLAC; oggpacket.packet += 13; oggpacket.bytes -= 13; Ogg_ReadFlacHeader( p_demux, p_stream, &oggpacket ); } @@ -921,11 +976,19 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) p_stream->fmt.i_bitrate, p_stream->f_rate ); } /* Check for Dirac header */ - else if( oggpacket.bytes >= 5 && - ! memcmp( oggpacket.packet, "BBCD\x00", 5 ) ) + else if( ( oggpacket.bytes >= 5 && + ! memcmp( oggpacket.packet, "BBCD\x00", 5 ) ) || + ( oggpacket.bytes >= 9 && + ! memcmp( oggpacket.packet, "KW-DIRAC\x00", 9 ) ) ) { - Ogg_ReadDiracHeader( p_stream, &oggpacket ); - msg_Dbg( p_demux, "found dirac header" ); + if( Ogg_ReadDiracHeader( p_stream, &oggpacket ) ) + msg_Dbg( p_demux, "found dirac header" ); + else + { + msg_Warn( p_demux, "found dirac header isn't decodable" ); + free( p_stream ); + p_ogg->i_streams--; + } } /* Check for Tarkin header */ else if( oggpacket.bytes >= 7 && @@ -935,7 +998,7 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) msg_Dbg( p_demux, "found tarkin header" ); p_stream->fmt.i_cat = VIDEO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 't','a','r','k' ); + p_stream->fmt.i_codec = VLC_CODEC_TARKIN; /* Cheat and get additionnal info ;) */ oggpack_readinit( &opb, oggpacket.packet, oggpacket.bytes); @@ -1016,7 +1079,7 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) /* Check for audio header (old format) */ else if( GetDWLE((oggpacket.packet+96)) == 0x05589F81 ) { - unsigned int i_extra_size; + int i_extra_size; unsigned int i_format_tag; p_stream->fmt.i_cat = AUDIO_ES; @@ -1127,7 +1190,7 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) else if( !strncmp( st->streamtype, "audio", 5 ) ) { char p_buffer[5]; - unsigned int i_extra_size; + int i_extra_size; int i_format_tag; st->sh.audio.channels = GetWLE( &oggpacket.packet[1+44] ); @@ -1193,7 +1256,7 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) msg_Dbg( p_demux, "found text subtitles header" ); p_stream->fmt.i_cat = SPU_ES; - p_stream->fmt.i_codec = VLC_FOURCC('s','u','b','t'); + p_stream->fmt.i_codec = VLC_CODEC_SUBT; p_stream->f_rate = 1000; /* granulepos is in millisec */ } else @@ -1221,18 +1284,29 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) p_ogg->i_streams--; } - if( Ogg_ReadPage( p_demux, &oggpage ) != VLC_SUCCESS ) + if( Ogg_ReadPage( p_demux, &p_ogg->current_page ) != VLC_SUCCESS ) return VLC_EGENERIC; } + /* we'll need to get all headers for all of those streams + that we have to backup headers for */ + p_ogg->i_bos = 0; + for( i_stream = 0; i_stream < p_ogg->i_streams; i_stream++ ) + { + if( p_ogg->pp_stream[i_stream]->b_force_backup ) + p_ogg->i_bos++; + } + + /* This is the first data page, which means we are now finished * with the initial pages. We just need to store it in the relevant * bitstream. */ for( i_stream = 0; i_stream < p_ogg->i_streams; i_stream++ ) { if( ogg_stream_pagein( &p_ogg->pp_stream[i_stream]->os, - &oggpage ) == 0 ) + &p_ogg->current_page ) == 0 ) { + p_ogg->b_page_waiting = true; break; } } @@ -1270,6 +1344,9 @@ static int Ogg_BeginningOfStream( demux_t *p_demux ) p_stream->p_es = NULL; + /* initialise kframe index */ + p_stream->idx=NULL; + /* Try first to reuse an old ES */ if( p_old_stream && p_old_stream->fmt.i_cat == p_stream->fmt.i_cat && @@ -1285,10 +1362,17 @@ static int Ogg_BeginningOfStream( demux_t *p_demux ) } if( !p_stream->p_es ) + { + /* Better be safe than sorry when possible with ogm */ + if( p_stream->fmt.i_codec == VLC_CODEC_MPGA || + p_stream->fmt.i_codec == VLC_CODEC_A52 ) + p_stream->fmt.b_packetized = false; + p_stream->p_es = es_out_Add( p_demux->out, &p_stream->fmt ); + } // TODO: something to do here ? - if( p_stream->fmt.i_codec == VLC_FOURCC('c','m','m','l') ) + if( p_stream->fmt.i_codec == VLC_CODEC_CMML ) { /* Set the CMML stream active */ es_out_Control( p_demux->out, ES_OUT_SET_ES, p_stream->p_es ); @@ -1298,7 +1382,7 @@ static int Ogg_BeginningOfStream( demux_t *p_demux ) p_stream->i_pcr = p_stream->i_previous_pcr = p_stream->i_interpolated_pcr = -1; - p_stream->b_reinit = 0; + p_stream->b_reinit = false; } if( p_ogg->p_old_stream ) @@ -1308,6 +1392,11 @@ static int Ogg_BeginningOfStream( demux_t *p_demux ) Ogg_LogicalStreamDelete( p_demux, p_ogg->p_old_stream ); p_ogg->p_old_stream = NULL; } + + + /* get total frame count for video stream; we will need this for seeking */ + p_ogg->i_total_frames = 0; + return VLC_SUCCESS; } @@ -1327,6 +1416,11 @@ static void Ogg_EndOfStream( demux_t *p_demux ) p_ogg->i_bitrate = 0; p_ogg->i_streams = 0; p_ogg->pp_stream = NULL; + + /* */ + if( p_ogg->p_meta ) + vlc_meta_Delete( p_ogg->p_meta ); + p_ogg->p_meta = NULL; } /** @@ -1343,6 +1437,11 @@ static void Ogg_LogicalStreamDelete( demux_t *p_demux, logical_stream_t *p_strea es_format_Clean( &p_stream->fmt_old ); es_format_Clean( &p_stream->fmt ); + if ( p_stream->idx != NULL) + { + oggseek_index_entries_free( p_stream->idx ); + } + free( p_stream ); } /** @@ -1351,33 +1450,34 @@ static void Ogg_LogicalStreamDelete( demux_t *p_demux, logical_stream_t *p_strea */ static bool Ogg_IsVorbisFormatCompatible( const es_format_t *p_new, const es_format_t *p_old ) { - int i_new = 0; - int i_old = 0; - int i; - - for( i = 0; i < 3; i++ ) + unsigned pi_new_size[XIPH_MAX_HEADER_COUNT]; + void *pp_new_data[XIPH_MAX_HEADER_COUNT]; + unsigned i_new_count; + if( xiph_SplitHeaders(pi_new_size, pp_new_data, &i_new_count, p_new->i_extra, p_new->p_extra ) ) + i_new_count = 0; + + unsigned pi_old_size[XIPH_MAX_HEADER_COUNT]; + void *pp_old_data[XIPH_MAX_HEADER_COUNT]; + unsigned i_old_count; + if( xiph_SplitHeaders(pi_old_size, pp_old_data, &i_old_count, p_old->i_extra, p_old->p_extra ) ) + i_old_count = 0; + + bool b_match = i_new_count == i_old_count; + for( unsigned i = 0; i < i_new_count && b_match; i++ ) { - const uint8_t *p_new_extra = ( const uint8_t*)p_new->p_extra + i_new; - const uint8_t *p_old_extra = ( const uint8_t*)p_old->p_extra + i_old; - - if( p_new->i_extra < i_new+2 || p_old->i_extra < i_old+2 ) - return false; - - const int i_new_size = GetWBE( &p_new_extra[0] ); - const int i_old_size = GetWBE( &p_old_extra[0] ); - - if( i != 1 ) /* Ignore vorbis comment */ - { - if( i_new_size != i_old_size ) - return false; - if( memcmp( &p_new_extra[2], &p_old_extra[2], i_new_size ) ) - return false; - } - - i_new += 2 + i_new_size; - i_old += 2 + i_old_size; + /* Ignore vorbis comment */ + if( i == 1 ) + continue; + if( pi_new_size[i] != pi_old_size[i] || + memcmp( pp_new_data[i], pp_old_data[i], pi_new_size[i] ) ) + b_match = false; } - return true; + + for( unsigned i = 0; i < i_new_count; i++ ) + free( pp_new_data[i] ); + for( unsigned i = 0; i < i_old_count; i++ ) + free( pp_old_data[i] ); + return b_match; } static bool Ogg_LogicalStreamResetEsFormat( demux_t *p_demux, logical_stream_t *p_stream ) { @@ -1386,7 +1486,7 @@ static bool Ogg_LogicalStreamResetEsFormat( demux_t *p_demux, logical_stream_t * return true; /* Only vorbis is supported */ - if( p_stream->fmt.i_codec == VLC_FOURCC( 'v','o','r','b' ) ) + if( p_stream->fmt.i_codec == VLC_CODEC_VORBIS ) b_compatible = Ogg_IsVorbisFormatCompatible( &p_stream->fmt, &p_stream->fmt_old ); if( !b_compatible ) @@ -1394,6 +1494,60 @@ static bool Ogg_LogicalStreamResetEsFormat( demux_t *p_demux, logical_stream_t * return !b_compatible; } +static void Ogg_ExtractXiphMeta( demux_t *p_demux, const void *p_headers, unsigned i_headers, unsigned i_skip ) +{ + demux_sys_t *p_ogg = p_demux->p_sys; + + unsigned pi_size[XIPH_MAX_HEADER_COUNT]; + void *pp_data[XIPH_MAX_HEADER_COUNT]; + unsigned i_count; + if( xiph_SplitHeaders( pi_size, pp_data, &i_count, i_headers, p_headers ) ) + return; + + /* TODO how to handle multiple comments properly ? */ + if( i_count >= 2 && pi_size[1] > i_skip ) + vorbis_ParseComment( &p_ogg->p_meta, (uint8_t*)pp_data[1] + i_skip, pi_size[1] - i_skip ); + + for( unsigned i = 0; i < i_count; i++ ) + free( pp_data[i] ); +} +static void Ogg_ExtractMeta( demux_t *p_demux, vlc_fourcc_t i_codec, const uint8_t *p_headers, int i_headers ) +{ + demux_sys_t *p_ogg = p_demux->p_sys; + + switch( i_codec ) + { + /* 3 headers with the 2° one being the comments */ + case VLC_CODEC_VORBIS: + Ogg_ExtractXiphMeta( p_demux, p_headers, i_headers, 1+6 ); + break; + case VLC_CODEC_THEORA: + Ogg_ExtractXiphMeta( p_demux, p_headers, i_headers, 1+6 ); + break; + case VLC_CODEC_SPEEX: + Ogg_ExtractXiphMeta( p_demux, p_headers, i_headers, 0 ); + break; + + /* N headers with the 2° one being the comments */ + case VLC_CODEC_KATE: + /* 1 byte for header type, 7 bytes for magic, 1 reserved zero byte */ + Ogg_ExtractXiphMeta( p_demux, p_headers, i_headers, 1+7+1 ); + break; + + /* TODO */ + case VLC_CODEC_FLAC: + msg_Warn( p_demux, "Ogg_ExtractMeta does not support %4.4s", (const char*)&i_codec ); + break; + + /* No meta data */ + case VLC_CODEC_CMML: /* CMML is XML text, doesn't have Vorbis comments */ + case VLC_CODEC_DIRAC: + default: + break; + } + if( p_ogg->p_meta ) + p_demux->info.i_update |= INPUT_UPDATE_META; +} static void Ogg_ReadTheoraHeader( logical_stream_t *p_stream, ogg_packet *p_oggpacket ) @@ -1402,9 +1556,13 @@ static void Ogg_ReadTheoraHeader( logical_stream_t *p_stream, int i_fps_numerator; int i_fps_denominator; int i_keyframe_frequency_force; + int i_major; + int i_minor; + int i_subminor; + int i_version; p_stream->fmt.i_cat = VIDEO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 't','h','e','o' ); + p_stream->fmt.i_codec = VLC_CODEC_THEORA; /* Signal that we want to keep a backup of the theora * stream headers. They will be used when switching between @@ -1414,9 +1572,11 @@ static void Ogg_ReadTheoraHeader( logical_stream_t *p_stream, /* Cheat and get additionnal info ;) */ bs_init( &bitstream, p_oggpacket->packet, p_oggpacket->bytes ); bs_skip( &bitstream, 56 ); - bs_read( &bitstream, 8 ); /* major version num */ - bs_read( &bitstream, 8 ); /* minor version num */ - bs_read( &bitstream, 8 ); /* subminor version num */ + + i_major = bs_read( &bitstream, 8 ); /* major version num */ + i_minor = bs_read( &bitstream, 8 ); /* minor version num */ + i_subminor = bs_read( &bitstream, 8 ); /* subminor version num */ + bs_read( &bitstream, 16 ) /*<< 4*/; /* width */ bs_read( &bitstream, 16 ) /*<< 4*/; /* height */ bs_read( &bitstream, 24 ); /* frame width */ @@ -1447,6 +1607,14 @@ static void Ogg_ReadTheoraHeader( logical_stream_t *p_stream, i_keyframe_frequency_force >>= 1; } + i_version = i_major * 1000000 + i_minor * 1000 + i_subminor; + p_stream->i_keyframe_offset = 0; + + if ( i_version >= 3002001 ) + { + p_stream->i_keyframe_offset = 1; + } + p_stream->f_rate = ((float)i_fps_numerator) / i_fps_denominator; } @@ -1456,7 +1624,7 @@ static void Ogg_ReadVorbisHeader( logical_stream_t *p_stream, oggpack_buffer opb; p_stream->fmt.i_cat = AUDIO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 'v','o','r','b' ); + p_stream->fmt.i_codec = VLC_CODEC_VORBIS; /* Signal that we want to keep a backup of the vorbis * stream headers. They will be used when switching between @@ -1479,7 +1647,7 @@ static void Ogg_ReadSpeexHeader( logical_stream_t *p_stream, oggpack_buffer opb; p_stream->fmt.i_cat = AUDIO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 's','p','x',' ' ); + p_stream->fmt.i_codec = VLC_CODEC_SPEEX; /* Signal that we want to keep a backup of the speex * stream headers. They will be used when switching between @@ -1518,7 +1686,10 @@ static void Ogg_ReadFlacHeader( demux_t *p_demux, logical_stream_t *p_stream, msg_Dbg( p_demux, "FLAC header, channels: %i, rate: %i", p_stream->fmt.audio.i_channels, (int)p_stream->f_rate ); } - else msg_Dbg( p_demux, "FLAC STREAMINFO metadata too short" ); + else + { + msg_Dbg( p_demux, "FLAC STREAMINFO metadata too short" ); + } /* Fake this as the last metadata block */ *((uint8_t*)p_oggpacket->packet) |= 0x80; @@ -1537,9 +1708,10 @@ static void Ogg_ReadKateHeader( logical_stream_t *p_stream, int32_t gnum; int32_t gden; int n; + char *psz_desc; p_stream->fmt.i_cat = SPU_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 'k','a','t','e' ); + p_stream->fmt.i_codec = VLC_CODEC_KATE; /* Signal that we want to keep a backup of the kate * stream headers. They will be used when switching between @@ -1558,27 +1730,35 @@ static void Ogg_ReadKateHeader( logical_stream_t *p_stream, p_stream->f_rate = (double)gnum/gden; p_stream->fmt.psz_language = malloc(16); - if (p_stream->fmt.psz_language) + if( p_stream->fmt.psz_language ) { - for (n=0;n<16;++n) + for( n = 0; n < 16; n++ ) p_stream->fmt.psz_language[n] = oggpack_read(&opb,8); p_stream->fmt.psz_language[15] = 0; /* just in case */ } else { - for (n=0;n<16;++n) + for( n = 0; n < 16; n++ ) oggpack_read(&opb,8); } p_stream->fmt.psz_description = malloc(16); - if (p_stream->fmt.psz_description) + if( p_stream->fmt.psz_description ) { - for (n=0;n<16;++n) + for( n = 0; n < 16; n++ ) p_stream->fmt.psz_description[n] = oggpack_read(&opb,8); p_stream->fmt.psz_description[15] = 0; /* just in case */ + + /* Now find a localized user readable description for this category */ + psz_desc = strdup(FindKateCategoryName(p_stream->fmt.psz_description)); + if( psz_desc ) + { + free( p_stream->fmt.psz_description ); + p_stream->fmt.psz_description = psz_desc; + } } else { - for (n=0;n<16;++n) + for( n = 0; n < 16; n++ ) oggpack_read(&opb,8); } } @@ -1617,7 +1797,7 @@ static void Ogg_ReadAnnodexHeader( vlc_object_t *p_this, granule_rate_numerator = GetQWLE( &p_oggpacket->packet[8] ); granule_rate_denominator = GetQWLE( &p_oggpacket->packet[16] ); - p_stream->secondary_header_packets = + p_stream->i_secondary_header_packets = GetDWLE( &p_oggpacket->packet[24] ); /* we are guaranteed that the first header field will be @@ -1628,13 +1808,13 @@ static void Ogg_ReadAnnodexHeader( vlc_object_t *p_this, uint8_t *p = memchr( &p_oggpacket->packet[42], '\r', p_oggpacket->bytes - 1 ); if( p && p[0] == '\r' && p[1] == '\n' ) - sscanf( (char*)(&p_oggpacket->packet[42]), "%1024s\r\n", + sscanf( (char*)(&p_oggpacket->packet[42]), "%1023s\r\n", content_type_string ); } msg_Dbg( p_this, "AnxData packet info: %"PRId64" / %"PRId64", %d, ``%s''", granule_rate_numerator, granule_rate_denominator, - p_stream->secondary_header_packets, content_type_string ); + p_stream->i_secondary_header_packets, content_type_string ); p_stream->f_rate = (float) granule_rate_numerator / (float) granule_rate_denominator; @@ -1650,21 +1830,21 @@ static void Ogg_ReadAnnodexHeader( vlc_object_t *p_this, else if( !strncmp(content_type_string, "audio/x-vorbis", 14) ) { p_stream->fmt.i_cat = AUDIO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 'v','o','r','b' ); + p_stream->fmt.i_codec = VLC_CODEC_VORBIS; p_stream->b_force_backup = 1; } else if( !strncmp(content_type_string, "audio/x-speex", 14) ) { p_stream->fmt.i_cat = AUDIO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 's','p','x',' ' ); + p_stream->fmt.i_codec = VLC_CODEC_SPEEX; p_stream->b_force_backup = 1; } else if( !strncmp(content_type_string, "video/x-theora", 14) ) { p_stream->fmt.i_cat = VIDEO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 't','h','e','o' ); + p_stream->fmt.i_codec = VLC_CODEC_THEORA; p_stream->b_force_backup = 1; } @@ -1679,42 +1859,56 @@ static void Ogg_ReadAnnodexHeader( vlc_object_t *p_this, { /* n.b. MPEG streams are unsupported right now */ p_stream->fmt.i_cat = VIDEO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 'm','p','g','v' ); + p_stream->fmt.i_codec = VLC_CODEC_MPGV; } else if( !strncmp(content_type_string, "text/x-cmml", 11) ) { ogg_stream_packetout( &p_stream->os, p_oggpacket ); p_stream->fmt.i_cat = SPU_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 'c','m','m','l' ); + p_stream->fmt.i_codec = VLC_CODEC_CMML; } } } static uint32_t dirac_uint( bs_t *p_bs ) { - uint32_t count = 0, value = 0; - while( !bs_read ( p_bs, 1 ) ) { - count++; - value <<= 1; - value |= bs_read ( p_bs, 1 ); - } - - return (1<fmt.i_cat = VIDEO_ES; - p_stream->fmt.i_codec = VLC_FOURCC( 'd','r','a','c' ); - p_stream->i_granule_shift = 32; + p_stream->i_granule_shift = 22; /* not 32 */ /* Backing up stream headers is not required -- seqhdrs are repeated * thoughout the stream at suitable decoding start points */ @@ -1729,43 +1923,51 @@ static void Ogg_ReadDiracHeader( logical_stream_t *p_stream, dirac_uint( &bs ); /* level */ uint32_t u_video_format = dirac_uint( &bs ); /* index */ + if( u_video_format >= u_dirac_vidfmt_frate ) + { + /* don't know how to parse this ogg dirac stream */ + return false; + } - if (dirac_bool( &bs )) { + if( dirac_bool( &bs ) ) + { dirac_uint( &bs ); /* frame_width */ dirac_uint( &bs ); /* frame_height */ } - if (dirac_bool( &bs )) { + if( dirac_bool( &bs ) ) + { dirac_uint( &bs ); /* chroma_format */ } - if (dirac_bool( &bs )) { - if (dirac_bool( &bs )) { /* interlaced */ - dirac_bool( &bs ); /* top_field_first */ - } - } - - static const struct { - uint32_t u_n /* numerator */, u_d /* denominator */; - } dirac_frate_tbl[] = { /* table 10.3 */ - {1,1}, /* this first value is never used */ - {24000,1001}, {24,1}, {25,1}, {30000,1001}, {30,1}, - {50,1}, {60000,1001}, {60,1}, {15000,1001}, {25,2}, - }; - static const uint32_t dirac_vidfmt_frate[] = { /* table C.1 */ - 1, 9, 10, 9, 10, 9, 10, 4, 3, 7, 6, 4, 3, 7, 6, 2, 2, 7, 6, 7, 6, - }; + if( dirac_bool( &bs ) ) + { + dirac_uint( &bs ); /* scan_format */ + } - uint32_t u_n = dirac_frate_tbl[dirac_vidfmt_frate[u_video_format]].u_n; - uint32_t u_d = dirac_frate_tbl[dirac_vidfmt_frate[u_video_format]].u_d; - if (dirac_bool( &bs )) { - uint32_t frame_rate_index = dirac_uint( &bs ); - u_n = dirac_frate_tbl[frame_rate_index].u_n; - u_d = dirac_frate_tbl[frame_rate_index].u_d; - if (frame_rate_index == 0) { + uint32_t u_n = p_dirac_frate_tbl[pu_dirac_vidfmt_frate[u_video_format]].u_n; + uint32_t u_d = p_dirac_frate_tbl[pu_dirac_vidfmt_frate[u_video_format]].u_d; + if( dirac_bool( &bs ) ) + { + uint32_t u_frame_rate_index = dirac_uint( &bs ); + if( u_frame_rate_index >= u_dirac_frate_tbl ) + { + /* something is wrong with this stream */ + return false; + } + u_n = p_dirac_frate_tbl[u_frame_rate_index].u_n; + u_d = p_dirac_frate_tbl[u_frame_rate_index].u_d; + if( u_frame_rate_index == 0 ) + { u_n = dirac_uint( &bs ); /* frame_rate_numerator */ u_d = dirac_uint( &bs ); /* frame_rate_denominator */ } } p_stream->f_rate = (float) u_n / u_d; + + /* probably is an ogg dirac es */ + p_stream->fmt.i_cat = VIDEO_ES; + p_stream->fmt.i_codec = VLC_CODEC_DIRAC; + + return true; }