X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fdemux%2Fogg.c;h=9b86a25fd9eb3adf8a6b48b3bf9289e0ef51ebef;hb=132030acbbe9d9d69bed8e1382515a0060e9bf45;hp=cc9d1a321c03aa35e93c7aa5f967327be3cebf39;hpb=449fd28aaf007c6411251dae9d0dbfdc65b135d1;p=vlc diff --git a/modules/demux/ogg.c b/modules/demux/ogg.c index cc9d1a321c..9b86a25fd9 100644 --- a/modules/demux/ogg.c +++ b/modules/demux/ogg.c @@ -29,7 +29,8 @@ # include "config.h" #endif -#include +#include +#include #include #include #include @@ -47,10 +48,10 @@ static void Close( vlc_object_t * ); vlc_module_begin(); set_shortname ( "OGG" ); - set_description( _("OGG demuxer" ) ); + set_description( N_("OGG demuxer" ) ); set_category( CAT_INPUT ); set_subcategory( SUBCAT_INPUT_DEMUX ); - set_capability( "demux2", 50 ); + set_capability( "demux", 50 ); set_callbacks( Open, Close ); add_shortcut( "ogg" ); vlc_module_end(); @@ -85,7 +86,10 @@ typedef struct logical_stream_s /* Misc */ int b_reinit; - int i_theora_keyframe_granule_shift; + 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; @@ -175,8 +179,11 @@ static void Ogg_EndOfStream( demux_t *p_demux ); static void Ogg_ReadTheoraHeader( logical_stream_t *, ogg_packet * ); static void Ogg_ReadVorbisHeader( logical_stream_t *, ogg_packet * ); 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 uint32_t Ogg_ReadDiracPictureNumber( ogg_packet *p_oggpacket ); /***************************************************************************** * Open: initializes ogg demux structures @@ -359,7 +366,6 @@ static int Demux( demux_t * p_demux ) es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_pcr ); } - return 1; } @@ -402,7 +408,7 @@ static int Control( demux_t *p_demux, int i_query, va_list args ) ogg_sync_reset( &p_sys->oy ); default: - return demux2_vaControlHelper( p_demux->s, 0, -1, p_sys->i_bitrate, + return demux_vaControlHelper( p_demux->s, 0, -1, p_sys->i_bitrate, 1, i_query, args ); } } @@ -443,19 +449,21 @@ 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' ) ) + if( p_stream->fmt.i_codec == VLC_FOURCC( 't','h','e','o' ) || + p_stream->fmt.i_codec == VLC_FOURCC( 'd','r','a','c' ) || + p_stream->fmt.i_codec == VLC_FOURCC( 'k','a','t','e' ) ) { - p_stream->i_pcr = p_oggpacket->granulepos * I64C(1000000) + 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; } else { - ogg_int64_t iframe = p_oggpacket->granulepos >> - p_stream->i_theora_keyframe_granule_shift; - ogg_int64_t pframe = p_oggpacket->granulepos - - ( iframe << p_stream->i_theora_keyframe_granule_shift ); - - p_stream->i_pcr = ( iframe + pframe ) * I64C(1000000) + p_stream->i_pcr = p_oggpacket->granulepos * INT64_C(1000000) / p_stream->f_rate; } @@ -469,10 +477,10 @@ static void Ogg_UpdatePCR( logical_stream_t *p_stream, * If we can't then don't touch the old value. */ if( p_stream->fmt.i_cat == VIDEO_ES ) /* 1 frame per packet */ - p_stream->i_interpolated_pcr += (I64C(1000000) / p_stream->f_rate); + p_stream->i_interpolated_pcr += (INT64_C(1000000) / p_stream->f_rate); else if( p_stream->fmt.i_bitrate ) p_stream->i_interpolated_pcr += - ( p_oggpacket->bytes * I64C(1000000) / + ( p_oggpacket->bytes * INT64_C(1000000) / p_stream->fmt.i_bitrate / 8 ); } } @@ -520,6 +528,7 @@ static void Ogg_DecodePacket( demux_t *p_demux, { uint8_t *p_extra; bool b_store_size = true; + bool b_store_num_headers = false; p_stream->i_packets_backup++; switch( p_stream->fmt.i_codec ) @@ -548,6 +557,12 @@ static void Ogg_DecodePacket( demux_t *p_demux, b_store_size = false; break; + case VLC_FOURCC( 'k','a','t','e' ): + if( p_stream->i_packets_backup == 1) + b_store_num_headers = true; + if( p_stream->i_packets_backup == p_stream->i_kate_num_headers ) p_stream->b_force_backup = 0; + break; + default: p_stream->b_force_backup = 0; break; @@ -556,15 +571,21 @@ static void Ogg_DecodePacket( demux_t *p_demux, /* Backup the ogg packet (likely an header packet) */ p_stream->p_headers = realloc( p_stream->p_headers, p_stream->i_headers + - p_oggpacket->bytes + (b_store_size ? 2 : 0) ); + p_oggpacket->bytes + (b_store_size ? 2 : 0) + (b_store_num_headers ? 1 : 0) ); p_extra = p_stream->p_headers + p_stream->i_headers; + if( b_store_num_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; + } if( b_store_size ) { *(p_extra++) = p_oggpacket->bytes >> 8; *(p_extra++) = p_oggpacket->bytes & 0xFF; } memcpy( p_extra, p_oggpacket->packet, p_oggpacket->bytes ); - p_stream->i_headers += p_oggpacket->bytes + (b_store_size ? 2 : 0); + p_stream->i_headers += p_oggpacket->bytes + (b_store_size ? 2 : 0) + (b_store_num_headers ? 1 : 0); if( !p_stream->b_force_backup ) { @@ -662,6 +683,18 @@ static void Ogg_DecodePacket( demux_t *p_demux, } else if( p_stream->fmt.i_codec == VLC_FOURCC( 't','h','e','o' ) ) p_block->i_dts = p_block->i_pts = i_pts; + else if( p_stream->fmt.i_codec == VLC_FOURCC( 'd','r','a','c' ) ) + { + /* every packet[1] in the stream contains a picture, there may + * be header cruft infront of it though + * [1] EXCEPT the BOS page/packet */ + uint32_t u_pnum = Ogg_ReadDiracPictureNumber( p_oggpacket ); + + if ( u_pnum != 0xffffffff ) { + p_block->i_dts = + p_block->i_pts = (u_pnum * INT64_C(1000000) / p_stream->f_rate); + } + } else { p_block->i_dts = i_pts; @@ -673,7 +706,9 @@ static void Ogg_DecodePacket( demux_t *p_demux, 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( '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' ) ) { /* We remove the header from the packet */ i_header_len = (*p_oggpacket->packet & PACKET_LEN_BITS01) >> 6; @@ -712,7 +747,7 @@ static void Ogg_DecodePacket( demux_t *p_demux, if( p_stream->fmt.i_codec == VLC_FOURCC( 't','a','r','k' ) ) { /* FIXME: the biggest hack I've ever done */ - msg_Warn( p_demux, "tarkin pts: "I64Fd", granule: "I64Fd, + msg_Warn( p_demux, "tarkin pts: %"PRId64", granule: %"PRId64, p_block->i_pts, p_block->i_dts ); msleep(10000); } @@ -840,6 +875,13 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) "found theora header, bitrate: %i, rate: %f", p_stream->fmt.i_bitrate, p_stream->f_rate ); } + /* Check for Dirac header */ + else if( oggpacket.bytes >= 5 && + ! memcmp( oggpacket.packet, "BBCD\x00", 5 ) ) + { + Ogg_ReadDiracHeader( p_stream, &oggpacket ); + msg_Dbg( p_demux, "found dirac header" ); + } /* Check for Tarkin header */ else if( oggpacket.bytes >= 7 && ! memcmp( &oggpacket.packet[1], "tarkin", 6 ) ) @@ -877,6 +919,13 @@ static int Ogg_FindLogicalStreams( demux_t *p_demux ) Ogg_ReadAnnodexHeader( VLC_OBJECT(p_demux), p_stream, &oggpacket ); } + /* Check for Kate header */ + else if( oggpacket.bytes >= 8 && + ! memcmp( &oggpacket.packet[1], "kate\0\0\0", 7 ) ) + { + Ogg_ReadKateHeader( p_stream, &oggpacket ); + msg_Dbg( p_demux, "found kate header" ); + } else if( oggpacket.bytes >= 142 && !memcmp( &oggpacket.packet[1], "Direct Show Samples embedded in Ogg", 35 )) @@ -1157,6 +1206,7 @@ static int Ogg_BeginningOfStream( demux_t *p_demux ) #define p_stream p_ogg->pp_stream[i_stream] 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') ) { /* Set the CMML stream active */ @@ -1249,11 +1299,11 @@ static void Ogg_ReadTheoraHeader( logical_stream_t *p_stream, i_keyframe_frequency_force = 1 << bs_read( &bitstream, 5 ); /* granule_shift = i_log( frequency_force -1 ) */ - p_stream->i_theora_keyframe_granule_shift = 0; + p_stream->i_granule_shift = 0; i_keyframe_frequency_force--; while( i_keyframe_frequency_force ) { - p_stream->i_theora_keyframe_granule_shift++; + p_stream->i_granule_shift++; i_keyframe_frequency_force >>= 1; } @@ -1340,6 +1390,59 @@ static void Ogg_ReadFlacHeader( demux_t *p_demux, logical_stream_t *p_stream, } } +static void Ogg_ReadKateHeader( logical_stream_t *p_stream, + ogg_packet *p_oggpacket ) +{ + oggpack_buffer opb; + int32_t gnum; + int32_t gden; + int n; + + p_stream->fmt.i_cat = SPU_ES; + p_stream->fmt.i_codec = VLC_FOURCC( 'k','a','t','e' ); + + /* Signal that we want to keep a backup of the kate + * stream headers. They will be used when switching between + * kate streams. */ + p_stream->b_force_backup = 1; + + /* Cheat and get additionnal info ;) */ + oggpack_readinit( &opb, p_oggpacket->packet, p_oggpacket->bytes); + oggpack_adv( &opb, 11*8 ); /* packet type, kate magic, version */ + p_stream->i_kate_num_headers = oggpack_read( &opb, 8 ); + oggpack_adv( &opb, 3*8 ); + p_stream->i_granule_shift = oggpack_read( &opb, 8 ); + oggpack_adv( &opb, 8*8 ); /* reserved */ + gnum = oggpack_read( &opb, 32 ); + gden = oggpack_read( &opb, 32 ); + p_stream->f_rate = (double)gnum/gden; + + p_stream->fmt.psz_language = malloc(16); + if (p_stream->fmt.psz_language) + { + 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) + oggpack_read(&opb,8); + } + p_stream->fmt.psz_description = malloc(16); + if (p_stream->fmt.psz_description) + { + 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) + oggpack_read(&opb,8); + } +} + static void Ogg_ReadAnnodexHeader( vlc_object_t *p_this, logical_stream_t *p_stream, ogg_packet *p_oggpacket ) @@ -1389,7 +1492,7 @@ static void Ogg_ReadAnnodexHeader( vlc_object_t *p_this, content_type_string ); } - msg_Dbg( p_this, "AnxData packet info: "I64Fd" / "I64Fd", %d, ``%s''", + 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 ); @@ -1446,3 +1549,104 @@ static void Ogg_ReadAnnodexHeader( vlc_object_t *p_this, } } } + +/* every packet[1] in the stream contains a picture, there may + * be header cruft infront of it though + * [1] EXCEPT the BOS page/packet */ +static uint32_t Ogg_ReadDiracPictureNumber( ogg_packet *p_oggpacket ) +{ + uint32_t u_pos = 4; + /* protect against falling off the edge */ + while ( u_pos + 13 < p_oggpacket->bytes ) { + /* find the picture startcode */ + if ( p_oggpacket->packet[u_pos] & 0x08 ) { + return GetDWBE( p_oggpacket->packet + u_pos + 9 ); + } + /* skip to the next dirac parse unit */ + uint32_t u_npo = GetDWBE( p_oggpacket->packet + u_pos + 1 ); + if (u_npo == 0) + u_npo = 13; + u_pos += u_npo; + } + return -1; +} + +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; + + /* Backing up stream headers is not required -- seqhdrs are repeated + * thoughout the stream at suitable decoding start points */ + p_stream->b_force_backup = 0; + + /* read in useful bits from sequence header */ + bs_init( &bs, p_oggpacket->packet, p_oggpacket->bytes ); + bs_skip( &bs, 13*8); /* parse_info_header */ + dirac_uint( &bs ); /* major_version */ + dirac_uint( &bs ); /* minor_version */ + dirac_uint( &bs ); /* profile */ + dirac_uint( &bs ); /* level */ + + uint32_t u_video_format = dirac_uint( &bs ); /* index */ + + if (dirac_bool( &bs )) { + dirac_uint( &bs ); /* frame_width */ + dirac_uint( &bs ); /* frame_height */ + } + + 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, + }; + + 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) { + 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; +}