X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fdemux%2Fogg.c;h=2ba2b01cee39457a50da26725d1da8a43159f296;hb=07ffb2e1441db6de8ba93e7eada994e50d97e601;hp=89cc449d2f8e81af1b16640753bcd152af2ac781;hpb=dbfd268dd7e7438a7958916374e9ec576e6a98f5;p=vlc diff --git a/modules/demux/ogg.c b/modules/demux/ogg.c index 89cc449d2f..2ba2b01cee 100644 --- a/modules/demux/ogg.c +++ b/modules/demux/ogg.c @@ -46,15 +46,15 @@ static int Open ( vlc_object_t * ); static void Close( vlc_object_t * ); -vlc_module_begin(); - set_shortname ( "OGG" ); - set_description( N_("OGG demuxer" ) ); - set_category( CAT_INPUT ); - set_subcategory( SUBCAT_INPUT_DEMUX ); - set_capability( "demux", 50 ); - set_callbacks( Open, Close ); - add_shortcut( "ogg" ); -vlc_module_end(); +vlc_module_begin () + set_shortname ( "OGG" ) + set_description( N_("OGG demuxer" ) ) + set_category( CAT_INPUT ) + set_subcategory( SUBCAT_INPUT_DEMUX ) + set_capability( "demux", 50 ) + set_callbacks( Open, Close ) + add_shortcut( "ogg" ) +vlc_module_end () /***************************************************************************** @@ -86,14 +86,14 @@ typedef struct logical_stream_s mtime_t i_previous_pcr; /* Misc */ - int b_reinit; + bool 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; + int i_secondary_header_packets; } logical_stream_t; @@ -111,27 +111,32 @@ struct demux_sys_t mtime_t i_pcr; /* stream state */ + int i_bos; int i_eos; /* bitrate */ int i_bitrate; + + /* after reading all headers, the first data page is stuffed into the relevant stream, ready to use */ + bool b_page_waiting; }; /* OggDS headers for the new header format (used in ogm files) */ -typedef struct stream_header_video +typedef struct { ogg_int32_t width; ogg_int32_t height; -} stream_header_video; +} stream_header_video_t; -typedef struct stream_header_audio +typedef struct { ogg_int16_t channels; + ogg_int16_t padding; ogg_int16_t blockalign; ogg_int32_t avgbytespersec; -} stream_header_audio; +} stream_header_audio_t; -typedef struct stream_header +typedef struct { char streamtype[8]; char subtype[4]; @@ -144,15 +149,16 @@ typedef struct stream_header ogg_int32_t buffersize; ogg_int16_t bits_per_sample; + ogg_int16_t padding; union { /* Video specific */ - stream_header_video video; + stream_header_video_t video; /* Audio specific */ - stream_header_audio audio; + stream_header_audio_t audio; } sh; -} stream_header; +} stream_header_t; #define OGG_BLOCK_SIZE 4096 @@ -189,7 +195,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 @@ -221,10 +227,12 @@ 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; return VLC_SUCCESS; } @@ -285,46 +293,66 @@ 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, &oggpage ) != VLC_SUCCESS ) + return 0; /* EOF */ + + /* Test for End of Stream */ + if( ogg_page_eos( &oggpage ) ) + 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( ogg_stream_pagein( &p_stream->os, &oggpage ) != 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') && 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') && 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_FOURCC('c','m','m','l') ) { - p_stream->secondary_header_packets = 0; + p_stream->i_secondary_header_packets = 0; } } @@ -336,7 +364,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 { @@ -364,11 +392,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]; @@ -382,9 +415,7 @@ static int Demux( demux_t * p_demux ) } if( p_sys->i_pcr >= 0 ) - { es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_pcr ); - } return 1; } @@ -415,17 +446,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, @@ -521,6 +562,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 ) @@ -621,8 +663,7 @@ static void Ogg_DecodePacket( demux_t *p_demux, 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 ); @@ -630,8 +671,11 @@ 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 ); + + /* we're not at BOS anymore for this logical stream */ + p_ogg->i_bos--; } } else @@ -672,17 +716,21 @@ 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, p_stream->i_pcr ); + } } } @@ -816,8 +864,6 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) ogg_page oggpage; int i_stream; -#define p_stream p_ogg->pp_stream[p_ogg->i_streams - 1] - while( Ogg_ReadPage( p_demux, &oggpage ) == VLC_SUCCESS ) { if( ogg_page_bos( &oggpage ) ) @@ -827,25 +873,17 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) * We found the beginning of our first logical stream. */ while( ogg_page_bos( &oggpage ) ) { - logical_stream_t **pp_sav = p_ogg->pp_stream; - - p_ogg->i_streams++; - p_ogg->pp_stream = - realloc( p_ogg->pp_stream, p_ogg->i_streams * - sizeof(logical_stream_t *) ); - if( !p_ogg->pp_stream ) - { - p_ogg->pp_stream = pp_sav; - p_ogg->i_streams--; - return VLC_ENOMEM; - } + logical_stream_t *p_stream; p_stream = malloc( sizeof(logical_stream_t) ); if( !p_stream ) return VLC_ENOMEM; + + TAB_APPEND( p_ogg->i_streams, p_ogg->pp_stream, p_stream ); + 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; es_format_Init( &p_stream->fmt, 0, 0 ); es_format_Init( &p_stream->fmt_old, 0, 0 ); @@ -855,7 +893,7 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) 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 */ + * the codec type of this Ogg bitstream */ if( ogg_stream_pagein( &p_stream->os, &oggpage ) < 0 ) { /* error. stream version mismatch perhaps */ @@ -931,8 +969,14 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) else if( oggpacket.bytes >= 5 && ! memcmp( oggpacket.packet, "BBCD\x00", 5 ) ) { - 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 && @@ -1082,15 +1126,27 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) p_ogg->i_streams--; } } - else if( (*oggpacket.packet & PACKET_TYPE_BITS ) - == PACKET_TYPE_HEADER && - oggpacket.bytes >= (int)sizeof(stream_header)+1 ) + else if( (*oggpacket.packet & PACKET_TYPE_BITS ) == PACKET_TYPE_HEADER && + oggpacket.bytes >= 56+1 ) { - stream_header *st = (stream_header *)(oggpacket.packet+1); + stream_header_t tmp; + stream_header_t *st = &tmp; + + memcpy( st->streamtype, &oggpacket.packet[1+0], 8 ); + memcpy( st->subtype, &oggpacket.packet[1+8], 4 ); + st->size = GetDWLE( &oggpacket.packet[1+12] ); + st->time_unit = GetQWLE( &oggpacket.packet[1+16] ); + st->samples_per_unit = GetQWLE( &oggpacket.packet[1+24] ); + st->default_len = GetDWLE( &oggpacket.packet[1+32] ); + st->buffersize = GetDWLE( &oggpacket.packet[1+36] ); + st->bits_per_sample = GetWLE( &oggpacket.packet[1+40] ); // (padding 2) /* Check for video header (new format) */ if( !strncmp( st->streamtype, "video", 5 ) ) { + st->sh.video.width = GetDWLE( &oggpacket.packet[1+44] ); + st->sh.video.height = GetDWLE( &oggpacket.packet[1+48] ); + p_stream->fmt.i_cat = VIDEO_ES; /* We need to get rid of the header packet */ @@ -1103,16 +1159,13 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) (char *)&p_stream->fmt.i_codec ); p_stream->fmt.video.i_frame_rate = 10000000; - p_stream->fmt.video.i_frame_rate_base = - GetQWLE(&st->time_unit); - p_stream->f_rate = 10000000.0 / - GetQWLE(&st->time_unit); - p_stream->fmt.video.i_bits_per_pixel = - GetWLE(&st->bits_per_sample); - p_stream->fmt.video.i_width = - GetDWLE(&st->sh.video.width); - p_stream->fmt.video.i_height = - GetDWLE(&st->sh.video.height); + p_stream->fmt.video.i_frame_rate_base = st->time_unit; + if( st->time_unit <= 0 ) + st->time_unit = 400000; + p_stream->f_rate = 10000000.0 / st->time_unit; + p_stream->fmt.video.i_bits_per_pixel = st->bits_per_sample; + p_stream->fmt.video.i_width = st->sh.video.width; + p_stream->fmt.video.i_height = st->sh.video.height; msg_Dbg( p_demux, "fps: %f, width:%i; height:%i, bitcount:%i", @@ -1125,17 +1178,24 @@ 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_format_tag; + st->sh.audio.channels = GetWLE( &oggpacket.packet[1+44] ); + st->sh.audio.blockalign = GetWLE( &oggpacket.packet[1+48] ); + st->sh.audio.avgbytespersec = GetDWLE( &oggpacket.packet[1+52] ); + p_stream->fmt.i_cat = AUDIO_ES; /* We need to get rid of the header packet */ ogg_stream_packetout( &p_stream->os, &oggpacket ); - p_stream->fmt.i_extra = GetQWLE(&st->size) - sizeof(stream_header); - if( p_stream->fmt.i_extra > 0 && - p_stream->fmt.i_extra < oggpacket.bytes - 1 - sizeof(stream_header) ) + i_extra_size = st->size - 56; + + if( i_extra_size > 0 && + i_extra_size < oggpacket.bytes - 1 - 56 ) { + p_stream->fmt.i_extra = i_extra_size; p_stream->fmt.p_extra = malloc( p_stream->fmt.i_extra ); if( p_stream->fmt.p_extra ) memcpy( p_stream->fmt.p_extra, st + 1, @@ -1147,16 +1207,13 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) memcpy( p_buffer, st->subtype, 4 ); p_buffer[4] = '\0'; i_format_tag = strtol(p_buffer,NULL,16); - p_stream->fmt.audio.i_channels = - GetWLE(&st->sh.audio.channels); - p_stream->f_rate = p_stream->fmt.audio.i_rate = - GetQWLE(&st->samples_per_unit); - p_stream->fmt.i_bitrate = - GetDWLE(&st->sh.audio.avgbytespersec) * 8; - p_stream->fmt.audio.i_blockalign = - GetWLE(&st->sh.audio.blockalign); - p_stream->fmt.audio.i_bitspersample = - GetWLE(&st->bits_per_sample); + p_stream->fmt.audio.i_channels = st->sh.audio.channels; + if( st->time_unit <= 0 ) + st->time_unit = 10000000; + p_stream->f_rate = p_stream->fmt.audio.i_rate = st->samples_per_unit * 10000000 / st->time_unit; + p_stream->fmt.i_bitrate = st->sh.audio.avgbytespersec * 8; + p_stream->fmt.audio.i_blockalign = st->sh.audio.blockalign; + p_stream->fmt.audio.i_bitspersample = st->bits_per_sample; wf_tag_to_fourcc( i_format_tag, &p_stream->fmt.i_codec, 0 ); @@ -1188,7 +1245,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->f_rate = 1000; /* granulepos is in milisec */ + p_stream->f_rate = 1000; /* granulepos is in millisec */ } else { @@ -1219,6 +1276,16 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) 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. */ @@ -1227,6 +1294,7 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) if( ogg_stream_pagein( &p_ogg->pp_stream[i_stream]->os, &oggpage ) == 0 ) { + p_ogg->b_page_waiting = true; break; } } @@ -1234,7 +1302,6 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) return VLC_SUCCESS; } } -#undef p_stream return VLC_EGENERIC; } @@ -1280,7 +1347,14 @@ 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_FOURCC( 'm', 'p', 'g', 'a' ) || + p_stream->fmt.i_codec == VLC_FOURCC( 'a', '5', '2', ' ' ) ) + 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') ) @@ -1293,7 +1367,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 ) @@ -1376,7 +1450,7 @@ static bool Ogg_IsVorbisFormatCompatible( const es_format_t *p_new, const es_for } static bool Ogg_LogicalStreamResetEsFormat( demux_t *p_demux, logical_stream_t *p_stream ) { - bool b_compatible; + bool b_compatible = false; if( !p_stream->fmt_old.i_cat || !p_stream->fmt_old.i_codec ) return true; @@ -1513,7 +1587,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; @@ -1553,27 +1630,27 @@ 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 */ } else { - for (n=0;n<16;++n) + for( n = 0; n < 16; ++n ) oggpack_read(&opb,8); } } @@ -1612,7 +1689,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 @@ -1629,7 +1706,7 @@ static void Ogg_ReadAnnodexHeader( vlc_object_t *p_this, 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; @@ -1687,29 +1764,43 @@ static void Ogg_ReadAnnodexHeader( vlc_object_t *p_this, 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 */ @@ -1724,43 +1815,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_FOURCC( 'd','r','a','c' ); + + return true; }