X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fdemux%2Fogg.c;h=dbd734523b728b5d57dc212bc79506321d02e303;hb=730a93d46d103cb76dcd50929865167241c19f9c;hp=4f60e0147b7932454685736ce9ee7e0c0a68e1ce;hpb=a1e813777408263806ec177c14eedcfe871d6160;p=vlc diff --git a/modules/demux/ogg.c b/modules/demux/ogg.c index 4f60e0147b..dbd734523b 100644 --- a/modules/demux/ogg.c +++ b/modules/demux/ogg.c @@ -1,16 +1,17 @@ /***************************************************************************** - * ogg.c : ogg stream input module for vlc + * ogg.c : ogg stream demux module for vlc ***************************************************************************** - * Copyright (C) 2001 VideoLAN - * $Id: ogg.c,v 1.22 2003/03/30 18:14:37 gbazin Exp $ + * Copyright (C) 2001-2007 the VideoLAN team + * $Id$ * * Authors: Gildas Bazin - * + * Andre Pang (Annodex support) + * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the @@ -18,64 +19,80 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ /***************************************************************************** * Preamble *****************************************************************************/ -#include /* malloc(), free() */ -#include - -#include -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif -#include +#include +#include +#include +#include +#include #include -#include /* BITMAPINFOHEADER, WAVEFORMATEX */ +#include +#include + +/***************************************************************************** + * Module descriptor + *****************************************************************************/ +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(); -#define OGG_BLOCK_SIZE 4096 -#define PAGES_READ_ONCE 1 /***************************************************************************** - * Definitions of structures and functions used by this plugins + * Definitions of structures and functions used by this plugins *****************************************************************************/ typedef struct logical_stream_s { ogg_stream_state os; /* logical stream of packets */ - int i_serial_no; - int i_cat; /* AUDIO_ES, VIDEO_ES */ - int i_activated; - vlc_fourcc_t i_fourcc; - vlc_fourcc_t i_codec; + es_format_t fmt; + es_out_id_t *p_es; + double f_rate; - es_descriptor_t *p_es; - int b_selected; /* newly selected */ + 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; - ogg_packet *p_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; - /* info from logical streams */ - double f_rate; - int i_bitrate; + /* Misc */ int b_reinit; + int i_granule_shift; + + /* kate streams have the number of headers in the ID header */ + int i_kate_num_headers; - /* codec specific stuff */ - BITMAPINFOHEADER *p_bih; - WAVEFORMATEX *p_wf; - int i_theora_keyframe_granule_shift; + /* for Annodex logical bitstreams */ + int secondary_header_packets; } logical_stream_t; @@ -86,18 +103,15 @@ struct demux_sys_t int i_streams; /* number of logical bitstreams */ logical_stream_t **pp_stream; /* pointer to an array of logical streams */ - /* current audio and video es */ - logical_stream_t *p_stream_video; - logical_stream_t *p_stream_audio; - logical_stream_t *p_stream_spu; - /* program clock reference (in units of 90kHz) derived from the pcr of * the sub-streams */ mtime_t i_pcr; - mtime_t i_old_pcr; - int b_seekable; - int b_reinit; + /* stream state */ + int i_eos; + + /* bitrate */ + int i_bitrate; }; /* OggDS headers for the new header format (used in ogm files) */ @@ -106,7 +120,7 @@ typedef struct stream_header_video ogg_int32_t width; ogg_int32_t height; } stream_header_video; - + typedef struct stream_header_audio { ogg_int16_t channels; @@ -137,6 +151,8 @@ typedef struct stream_header } sh; } stream_header; +#define OGG_BLOCK_SIZE 4096 + /* Some defines from OggDS */ #define PACKET_TYPE_HEADER 0x01 #define PACKET_TYPE_BITS 0x07 @@ -144,133 +160,257 @@ typedef struct stream_header #define PACKET_LEN_BITS2 0x02 #define PACKET_IS_SYNCPOINT 0x08 -/* Some functions to manipulate memory */ -static uint16_t GetWLE( uint8_t *p_buff ) -{ - return( (p_buff[0]) + ( p_buff[1] <<8 ) ); -} - -static uint32_t GetDWLE( uint8_t *p_buff ) -{ - return( p_buff[0] + ( p_buff[1] <<8 ) + - ( p_buff[2] <<16 ) + ( p_buff[3] <<24 ) ); -} - -static uint64_t GetQWLE( uint8_t *p_buff ) -{ - return( GetDWLE( p_buff ) + ( ((uint64_t)GetDWLE( p_buff + 4 )) << 32 ) ); -} /***************************************************************************** * Local prototypes *****************************************************************************/ -static int Activate ( vlc_object_t * ); -static void Deactivate( vlc_object_t * ); -static int Demux ( input_thread_t * ); - -/* Stream managment */ -static int Ogg_StreamStart ( input_thread_t *, demux_sys_t *, int ); -static void Ogg_StreamStop ( input_thread_t *, demux_sys_t *, int ); +static int Demux ( demux_t * ); +static int Control( demux_t *, int, va_list ); /* Bitstream manipulation */ -static int Ogg_Check ( input_thread_t *p_input ); -static int Ogg_ReadPage ( input_thread_t *, demux_sys_t *, ogg_page * ); +static int Ogg_ReadPage ( demux_t *, ogg_page * ); static void Ogg_UpdatePCR ( logical_stream_t *, ogg_packet * ); -static void Ogg_DecodePacket ( input_thread_t *p_input, - logical_stream_t *p_stream, ogg_packet * ); -static int Ogg_FindLogicalStreams( input_thread_t *p_input, - demux_sys_t *p_ogg ); +static void Ogg_DecodePacket ( demux_t *, logical_stream_t *, ogg_packet * ); + +static int Ogg_BeginningOfStream( demux_t *p_demux ); +static int Ogg_FindLogicalStreams( demux_t *p_demux ); +static void Ogg_EndOfStream( demux_t *p_demux ); + +/* Logical bitstream headers */ +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 ); /***************************************************************************** - * Module descriptor + * Open: initializes ogg demux structures *****************************************************************************/ -vlc_module_begin(); - set_description( _("ogg stream demuxer" ) ); - set_capability( "demux", 50 ); - set_callbacks( Activate, Deactivate ); - add_shortcut( "ogg" ); -vlc_module_end(); +static int Open( vlc_object_t * p_this ) +{ + demux_t *p_demux = (demux_t *)p_this; + demux_sys_t *p_sys; + const uint8_t *p_peek; + + + /* Check if we are dealing with an ogg stream */ + if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) return VLC_EGENERIC; + if( !p_demux->b_force && memcmp( p_peek, "OggS", 4 ) ) + { + return VLC_EGENERIC; + } + + /* Set exported functions */ + p_demux->pf_demux = Demux; + p_demux->pf_control = Control; + p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) ); + + memset( p_sys, 0, sizeof( demux_sys_t ) ); + p_sys->i_bitrate = 0; + p_sys->pp_stream = NULL; + + /* Begnning of stream, tell the demux to look for elementary streams. */ + p_sys->i_eos = 0; + + /* Initialize the Ogg physical bitstream parser */ + ogg_sync_init( &p_sys->oy ); + + return VLC_SUCCESS; +} /***************************************************************************** - * Stream managment + * Close: frees unused data *****************************************************************************/ -static int Ogg_StreamStart( input_thread_t *p_input, - demux_sys_t *p_ogg, int i_stream ) +static void Close( vlc_object_t *p_this ) { -#define p_stream p_ogg->pp_stream[i_stream] - if( !p_stream->p_es ) - { - msg_Warn( p_input, "stream[%d] unselectable", i_stream ); - return( 0 ); - } - if( p_stream->i_activated ) + demux_t *p_demux = (demux_t *)p_this; + demux_sys_t *p_sys = p_demux->p_sys ; + + /* Cleanup the bitstream parser */ + ogg_sync_clear( &p_sys->oy ); + + Ogg_EndOfStream( p_demux ); + + free( p_sys ); +} + +/***************************************************************************** + * Demux: reads and demuxes data packets + ***************************************************************************** + * Returns -1 in case of error, 0 in case of EOF, 1 otherwise + *****************************************************************************/ +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; + + + if( p_sys->i_eos == p_sys->i_streams ) { - msg_Warn( p_input, "stream[%d] already selected", i_stream ); - return( 1 ); + if( p_sys->i_eos ) + { + msg_Dbg( p_demux, "end of a group of logical streams" ); + Ogg_EndOfStream( p_demux ); + } + + p_sys->i_eos = 0; + if( Ogg_BeginningOfStream( p_demux ) != VLC_SUCCESS ) return 0; + + msg_Dbg( p_demux, "beginning of a group of logical streams" ); + es_out_Control( p_demux->out, ES_OUT_RESET_PCR ); } - if( !p_stream->p_es->p_decoder_fifo ) + /* + * Demux an ogg page from the stream + */ + if( Ogg_ReadPage( p_demux, &oggpage ) != VLC_SUCCESS ) { - vlc_mutex_lock( &p_input->stream.stream_lock ); - input_SelectES( p_input, p_stream->p_es ); - vlc_mutex_unlock( &p_input->stream.stream_lock ); + return 0; /* EOF */ } - p_stream->i_activated = p_stream->p_es->p_decoder_fifo ? 1 : 0; - /* Feed the backup header to the decoder */ - if( !p_stream->b_force_backup ) + /* 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++ ) { - int i; - for( i = 0; i < p_stream->i_packets_backup; i++ ) + logical_stream_t *p_stream = p_sys->pp_stream[i_stream]; + + if( ogg_stream_pagein( &p_stream->os, &oggpage ) != 0 ) + continue; + + while( ogg_stream_packetout( &p_stream->os, &oggpacket ) > 0 ) { - Ogg_DecodePacket( p_input, p_stream, - &p_stream->p_packets_backup[i] ); + /* Read info from any secondary header packets, if there are any */ + if( p_stream->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; + } + 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; + } + else if ( p_stream->fmt.i_codec == VLC_FOURCC('c','m','m','l') ) + { + p_stream->secondary_header_packets = 0; + } + } + + if( p_stream->b_reinit ) + { + /* If synchro is re-initialized we need to drop all the packets + * until we find a new dated one. */ + Ogg_UpdatePCR( p_stream, &oggpacket ); + + if( p_stream->i_pcr >= 0 ) + { + p_stream->b_reinit = 0; + } + else + { + p_stream->i_interpolated_pcr = -1; + continue; + } + + /* 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( ogg_stream_packetout( &p_stream->os, &oggpacket ) > 0 ) + { + Ogg_DecodePacket( p_demux, p_stream, &oggpacket ); + } + else + { + es_out_Control( p_demux->out, ES_OUT_SET_PCR, + p_stream->i_pcr ); + } + continue; + } + } + + Ogg_DecodePacket( p_demux, p_stream, &oggpacket ); } + break; } - return( p_stream->i_activated ); -#undef p_stream -} + i_stream = 0; p_sys->i_pcr = -1; + for( ; i_stream < p_sys->i_streams; i_stream++ ) + { + logical_stream_t *p_stream = p_sys->pp_stream[i_stream]; -static void Ogg_StreamStop( input_thread_t *p_input, - demux_sys_t *p_ogg, int i_stream ) -{ -#define p_stream p_ogg->pp_stream[i_stream] + if( p_stream->fmt.i_cat == SPU_ES ) + continue; + if( p_stream->i_interpolated_pcr < 0 ) + continue; - if( !p_stream->i_activated ) - { - msg_Warn( p_input, "stream[%d] already unselected", i_stream ); - return; + if( p_sys->i_pcr < 0 || p_stream->i_interpolated_pcr < p_sys->i_pcr ) + p_sys->i_pcr = p_stream->i_interpolated_pcr; } - if( p_stream->p_es->p_decoder_fifo ) + if( p_sys->i_pcr >= 0 ) { - vlc_mutex_lock( &p_input->stream.stream_lock ); - input_UnselectES( p_input, p_stream->p_es ); - vlc_mutex_unlock( &p_input->stream.stream_lock ); + es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_pcr ); } - p_stream->i_activated = 0; - -#undef p_stream + return 1; } -/**************************************************************************** - * Ogg_Check: Check we are dealing with an ogg stream. - ****************************************************************************/ -static int Ogg_Check( input_thread_t *p_input ) +/***************************************************************************** + * Control: + *****************************************************************************/ +static int Control( demux_t *p_demux, int i_query, va_list args ) { - u8 *p_peek; - int i_size = input_Peek( p_input, &p_peek, 4 ); + demux_sys_t *p_sys = p_demux->p_sys; + int64_t *pi64; + bool *pb_bool; + int i; - /* Check for the Ogg capture pattern */ - if( !(i_size>3) || !(p_peek[0] == 'O') || !(p_peek[1] == 'g') || - !(p_peek[2] == 'g') || !(p_peek[3] == 'S') ) - return VLC_EGENERIC; + switch( i_query ) + { + case DEMUX_HAS_UNSUPPORTED_META: + pb_bool = (bool*)va_arg( args, bool* ); + *pb_bool = true; + return VLC_SUCCESS; - /* FIXME: Capture pattern might not be enough so we can also check for the - * the first complete page */ + case DEMUX_GET_TIME: + pi64 = (int64_t*)va_arg( args, int64_t * ); + *pi64 = p_sys->i_pcr; + return VLC_SUCCESS; - return VLC_SUCCESS; + case DEMUX_SET_TIME: + return VLC_EGENERIC; + + case DEMUX_SET_POSITION: + 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->i_pcr = -1; + p_stream->i_interpolated_pcr = -1; + ogg_stream_reset( &p_stream->os ); + } + ogg_sync_reset( &p_sys->oy ); + + default: + return demux_vaControlHelper( p_demux->s, 0, -1, p_sys->i_bitrate, + 1, i_query, args ); + } } /**************************************************************************** @@ -279,23 +419,21 @@ static int Ogg_Check( input_thread_t *p_input ) * Returns VLC_SUCCESS if a page has been read. An error might happen if we * are at the end of stream. ****************************************************************************/ -static int Ogg_ReadPage( input_thread_t *p_input, demux_sys_t *p_ogg, - ogg_page *p_oggpage ) +static int Ogg_ReadPage( demux_t *p_demux, ogg_page *p_oggpage ) { + demux_sys_t *p_ogg = p_demux->p_sys ; int i_read = 0; - data_packet_t *p_data; - byte_t *p_buffer; + char *p_buffer; while( ogg_sync_pageout( &p_ogg->oy, p_oggpage ) != 1 ) { - i_read = input_SplitBuffer( p_input, &p_data, OGG_BLOCK_SIZE ); + p_buffer = ogg_sync_buffer( &p_ogg->oy, OGG_BLOCK_SIZE ); + + i_read = stream_Read( p_demux->s, p_buffer, OGG_BLOCK_SIZE ); if( i_read <= 0 ) return VLC_EGENERIC; - p_buffer = ogg_sync_buffer( &p_ogg->oy, i_read ); - p_input->p_vlc->pf_memcpy( p_buffer, p_data->p_payload_start, i_read ); ogg_sync_wrote( &p_ogg->oy, i_read ); - input_DeletePacket( p_input->p_method_data, p_data ); } return VLC_SUCCESS; @@ -308,23 +446,24 @@ static int Ogg_ReadPage( input_thread_t *p_input, demux_sys_t *p_ogg, static void Ogg_UpdatePCR( logical_stream_t *p_stream, ogg_packet *p_oggpacket ) { - - /* Convert the next granulepos into a pcr */ + /* Convert the granulepos into a pcr */ if( p_oggpacket->granulepos >= 0 ) { - if( p_stream->i_fourcc != 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 * 90000 + 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 ) * 90000 + p_stream->i_pcr = p_oggpacket->granulepos * INT64_C(1000000) / p_stream->f_rate; } @@ -332,144 +471,291 @@ static void Ogg_UpdatePCR( logical_stream_t *p_stream, } else { - /* FIXME: ffmpeg doesn't like null pts */ - if( p_stream->i_cat == VIDEO_ES ) - /* 1 frame per packet */ - p_stream->i_pcr += (90000 / p_stream->f_rate); - else - p_stream->i_pcr = -1; + p_stream->i_pcr = -1; /* no granulepos available, try to interpolate the pcr. * If we can't then don't touch the old value. */ - if( p_stream->i_bitrate ) - p_stream->i_interpolated_pcr += ( p_oggpacket->bytes * 90000 - / p_stream->i_bitrate / 8 ); + if( p_stream->fmt.i_cat == VIDEO_ES ) + /* 1 frame per packet */ + 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 * INT64_C(1000000) / + p_stream->fmt.i_bitrate / 8 ); } } /**************************************************************************** * Ogg_DecodePacket: Decode an Ogg packet. ****************************************************************************/ -static void Ogg_DecodePacket( input_thread_t *p_input, +static void Ogg_DecodePacket( demux_t *p_demux, logical_stream_t *p_stream, ogg_packet *p_oggpacket ) { - pes_packet_t *p_pes; - data_packet_t *p_data; - vlc_bool_t b_trash = VLC_FALSE; + block_t *p_block; + bool b_selected; int i_header_len = 0; + mtime_t i_pts = -1, i_interpolated_pts; - if( p_stream->b_force_backup ) + /* Sanity check */ + if( !p_oggpacket->bytes ) { - /* Backup the ogg packet (likely an header packet) */ - ogg_packet *p_packet_backup; - p_stream->i_packets_backup++; - p_stream->p_packets_backup = - realloc( p_stream->p_packets_backup, p_stream->i_packets_backup * - sizeof(ogg_packet) ); + msg_Dbg( p_demux, "discarding 0 sized packet" ); + return; + } - p_packet_backup = - &p_stream->p_packets_backup[p_stream->i_packets_backup - 1]; + if( p_oggpacket->bytes >= 7 && + ! memcmp ( p_oggpacket->packet, "Annodex", 7 ) ) + { + /* it's an Annodex packet -- skip it (do nothing) */ + return; + } + else if( p_oggpacket->bytes >= 7 && + ! memcmp ( p_oggpacket->packet, "AnxData", 7 ) ) + { + /* it's an AnxData packet -- skip it (do nothing) */ + return; + } + + if( p_stream->fmt.i_codec == VLC_FOURCC( 's','u','b','t' ) && + p_oggpacket->packet[0] & PACKET_TYPE_BITS ) return; - p_packet_backup->bytes = p_oggpacket->bytes; - p_packet_backup->granulepos = p_oggpacket->granulepos; - p_packet_backup->packet = malloc( p_oggpacket->bytes ); - if( !p_packet_backup->packet ) return; - memcpy( p_packet_backup->packet, p_oggpacket->packet, - p_oggpacket->bytes ); + /* Check the ES is selected */ + es_out_Control( p_demux->out, ES_OUT_GET_ES_STATE, + p_stream->p_es, &b_selected ); - switch( p_stream->i_fourcc ) + if( p_stream->b_force_backup ) + { + 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 ) { case VLC_FOURCC( 'v','o','r','b' ): - if( p_stream->i_packets_backup == 3 ) p_stream->b_force_backup = 0; - break; + case VLC_FOURCC( 's','p','x',' ' ): + case VLC_FOURCC( 't','h','e','o' ): + if( p_stream->i_packets_backup == 3 ) p_stream->b_force_backup = 0; + break; + + case VLC_FOURCC( 'f','l','a','c' ): + if( !p_stream->fmt.audio.i_rate && p_stream->i_packets_backup == 2 ) + { + Ogg_ReadFlacHeader( p_demux, p_stream, p_oggpacket ); + p_stream->b_force_backup = 0; + } + else if( p_stream->fmt.audio.i_rate ) + { + p_stream->b_force_backup = 0; + if( p_oggpacket->bytes >= 9 ) + { + p_oggpacket->packet += 9; + p_oggpacket->bytes -= 9; + } + } + 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; + p_stream->b_force_backup = 0; + break; + } + + /* 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) + (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) + (b_store_num_headers ? 1 : 0); + + if( !p_stream->b_force_backup ) + { + /* Last header received, commit changes */ + p_stream->fmt.i_extra = p_stream->i_headers; + p_stream->fmt.p_extra = + realloc( p_stream->fmt.p_extra, p_stream->i_headers ); + memcpy( p_stream->fmt.p_extra, p_stream->p_headers, + p_stream->i_headers ); + es_out_Control( p_demux->out, ES_OUT_SET_FMT, + p_stream->p_es, &p_stream->fmt ); } + + b_selected = false; /* Discard the header packet */ } - vlc_mutex_lock( &p_input->stream.control.control_lock ); - if( p_stream->i_cat == AUDIO_ES && p_input->stream.control.b_mute ) + /* 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' ) ) { - b_trash = VLC_TRUE; + if( p_stream->i_pcr >= 0 ) + { + /* 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 ); + } + + p_stream->i_previous_pcr = p_stream->i_pcr; + + /* The granulepos is the end date of the sample */ + i_pts = p_stream->i_pcr; + } } - vlc_mutex_unlock( &p_input->stream.control.control_lock ); - if( !p_stream->p_es->p_decoder_fifo || b_trash ) + /* Convert the granulepos into the next pcr */ + i_interpolated_pts = p_stream->i_interpolated_pcr; + Ogg_UpdatePCR( p_stream, p_oggpacket ); + + if( p_stream->i_pcr >= 0 ) { - /* This stream isn't currently selected so we don't need to decode it, - * but we do need to store its pcr as it might be selected later on. */ - Ogg_UpdatePCR( p_stream, p_oggpacket ); + /* 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 ); - return; + /* Call the pace control */ + es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_stream->i_pcr ); + } } - if( !( p_pes = input_NewPES( p_input->p_method_data ) ) ) + 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->i_pcr >= 0 ) { - return; + p_stream->i_previous_pcr = p_stream->i_pcr; + + /* The granulepos is the start date of the sample */ + i_pts = p_stream->i_pcr; } - if( !( p_data = input_NewPacket( p_input->p_method_data, - p_oggpacket->bytes ) ) ) + + if( !b_selected ) { - input_DeletePES( p_input->p_method_data, p_pes ); + /* This stream isn't currently selected so we don't need to decode it, + * but we did need to store its pcr as it might be selected later on */ return; } - /* Convert the pcr into a pts */ - if( p_stream->i_cat != SPU_ES ) + if( p_oggpacket->bytes <= 0 ) + return; + + if( !( p_block = block_New( p_demux, p_oggpacket->bytes ) ) ) return; + + /* 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( p_stream->fmt.i_cat == AUDIO_ES ) + p_block->i_dts = p_block->i_pts = i_pts; + else if( p_stream->fmt.i_cat == SPU_ES ) + { + 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' ) ) + p_block->i_dts = p_block->i_pts = i_pts; + else if( p_stream->fmt.i_codec == VLC_FOURCC( 'd','r','a','c' ) ) { - p_pes->i_pts = ( p_stream->i_pcr < 0 ) ? 0 : - input_ClockGetTS( p_input, p_input->stream.p_selected_program, - p_stream->i_pcr ); + /* 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 { - /* Of course subtitles had to be different! */ - p_pes->i_pts = ( p_oggpacket->granulepos < 0 ) ? 0 : - input_ClockGetTS( p_input, p_input->stream.p_selected_program, - p_oggpacket->granulepos * 90000 / - p_stream->f_rate ); + p_block->i_dts = i_pts; + p_block->i_pts = 0; } - /* Convert the next granulepos into a pcr */ - Ogg_UpdatePCR( p_stream, p_oggpacket ); - - p_pes->i_nb_data = 1; - p_pes->i_dts = p_oggpacket->granulepos; - p_pes->p_first = p_pes->p_last = p_data; - p_pes->i_pes_size = p_oggpacket->bytes; - - if( p_stream->i_fourcc != VLC_FOURCC( 'v','o','r','b' ) && - p_stream->i_fourcc != VLC_FOURCC( 't','a','r','k' ) && - p_stream->i_fourcc != VLC_FOURCC( 't','h','e','o' ) ) + 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' ) ) { - /* Remove the header from the packet */ + /* 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; - i_header_len++; - p_pes->i_pes_size -= i_header_len; - p_pes->i_dts = 0; + if( p_stream->fmt.i_codec == VLC_FOURCC( 's','u','b','t' )) + { + /* But with subtitles we need to retrieve the duration first */ + int i, lenbytes = 0; + + if( i_header_len > 0 && p_oggpacket->bytes >= i_header_len + 1 ) + { + for( i = 0, lenbytes = 0; i < i_header_len; i++ ) + { + lenbytes = lenbytes << 8; + lenbytes += *(p_oggpacket->packet + i_header_len - i); + } + } + if( p_oggpacket->bytes - 1 - i_header_len > 2 || + ( p_oggpacket->packet[i_header_len + 1] != ' ' && + p_oggpacket->packet[i_header_len + 1] != 0 && + p_oggpacket->packet[i_header_len + 1] != '\n' && + p_oggpacket->packet[i_header_len + 1] != '\r' ) ) + { + p_block->i_length = (mtime_t)lenbytes * 1000; + } + } + + i_header_len++; + if( p_block->i_buffer >= (unsigned int)i_header_len ) + p_block->i_buffer -= i_header_len; + else + p_block->i_buffer = 0; } - if( p_stream->i_fourcc == VLC_FOURCC( 't','a','r','k' ) ) + if( p_stream->fmt.i_codec == VLC_FOURCC( 't','a','r','k' ) ) { /* FIXME: the biggest hack I've ever done */ - msg_Warn( p_input, "tark pts: "I64Fd", granule: "I64Fd, - p_pes->i_pts, p_pes->i_dts ); + msg_Warn( p_demux, "tarkin pts: %"PRId64", granule: %"PRId64, + p_block->i_pts, p_block->i_dts ); msleep(10000); } - memcpy( p_data->p_payload_start, - p_oggpacket->packet + i_header_len, + memcpy( p_block->p_buffer, p_oggpacket->packet + i_header_len, p_oggpacket->bytes - i_header_len ); - p_data->p_payload_end = p_data->p_payload_start + p_pes->i_pes_size; - p_data->b_discard_payload = 0; - - input_DecodePES( p_stream->p_es->p_decoder_fifo, p_pes ); + es_out_Send( p_demux->out, p_stream->p_es, p_block ); } /**************************************************************************** @@ -482,13 +768,16 @@ static void Ogg_DecodePacket( input_thread_t *p_input, * * On success this function returns VLC_SUCCESS. ****************************************************************************/ -static int Ogg_FindLogicalStreams( input_thread_t *p_input, demux_sys_t *p_ogg) +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_input, p_ogg, &oggpage ) == VLC_SUCCESS ) +#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 ) ) { @@ -502,10 +791,12 @@ static int Ogg_FindLogicalStreams( input_thread_t *p_input, demux_sys_t *p_ogg) realloc( p_ogg->pp_stream, p_ogg->i_streams * sizeof(logical_stream_t *) ); -#define p_stream p_ogg->pp_stream[p_ogg->i_streams - 1] - p_stream = malloc( sizeof(logical_stream_t) ); memset( p_stream, 0, sizeof(logical_stream_t) ); + p_stream->p_headers = 0; + p_stream->secondary_header_packets = 0; + + es_format_Init( &p_stream->fmt, 0, 0 ); /* Setup the logical stream */ p_stream->i_serial_no = ogg_page_serialno( &oggpage ); @@ -516,7 +807,7 @@ static int Ogg_FindLogicalStreams( input_thread_t *p_input, demux_sys_t *p_ogg) if( ogg_stream_pagein( &p_stream->os, &oggpage ) < 0 ) { /* error. stream version mismatch perhaps */ - msg_Err( p_input, "Error reading first page of " + msg_Err( p_demux, "error reading first page of " "Ogg bitstream data" ); return VLC_EGENERIC; } @@ -526,140 +817,117 @@ static int Ogg_FindLogicalStreams( input_thread_t *p_input, demux_sys_t *p_ogg) /* Check for Vorbis header */ if( oggpacket.bytes >= 7 && - ! strncmp( &oggpacket.packet[1], "vorbis", 6 ) ) + ! memcmp( oggpacket.packet, "\x01vorbis", 7 ) ) { - oggpack_buffer opb; + Ogg_ReadVorbisHeader( p_stream, &oggpacket ); + msg_Dbg( p_demux, "found vorbis header" ); + } + /* Check for Speex header */ + else if( oggpacket.bytes >= 5 && + ! memcmp( oggpacket.packet, "Speex", 5 ) ) + { + Ogg_ReadSpeexHeader( p_stream, &oggpacket ); + msg_Dbg( p_demux, "found speex header, channels: %i, " + "rate: %i, bitrate: %i", + p_stream->fmt.audio.i_channels, + (int)p_stream->f_rate, p_stream->fmt.i_bitrate ); + } + /* Check for Flac header (< version 1.1.1) */ + else if( oggpacket.bytes >= 4 && + ! memcmp( oggpacket.packet, "fLaC", 4 ) ) + { + msg_Dbg( p_demux, "found FLAC header" ); + + /* Grrrr!!!! Did they really have to put all the + * important info in the second header packet!!! + * (STREAMINFO metadata is in the following packet) */ + p_stream->b_force_backup = 1; - msg_Dbg( p_input, "found vorbis header" ); - p_stream->i_cat = AUDIO_ES; - p_stream->i_fourcc = VLC_FOURCC( 'v','o','r','b' ); + p_stream->fmt.i_cat = AUDIO_ES; + p_stream->fmt.i_codec = VLC_FOURCC( 'f','l','a','c' ); + } + /* Check for Flac header (>= version 1.1.1) */ + else if( oggpacket.bytes >= 13 && oggpacket.packet[0] ==0x7F && + ! memcmp( &oggpacket.packet[1], "FLAC", 4 ) && + ! memcmp( &oggpacket.packet[9], "fLaC", 4 ) ) + { + int i_packets = ((int)oggpacket.packet[7]) << 8 | + oggpacket.packet[8]; + msg_Dbg( p_demux, "found FLAC header version %i.%i " + "(%i header packets)", + oggpacket.packet[5], oggpacket.packet[6], + i_packets ); - /* Signal that we want to keep a backup of the vorbis - * stream headers. They will be used when switching between - * audio streams. */ p_stream->b_force_backup = 1; - /* Cheat and get additionnal info ;) */ - oggpack_readinit( &opb, oggpacket.packet, oggpacket.bytes); - oggpack_adv( &opb, 96 ); - p_stream->f_rate = oggpack_read( &opb, 32 ); - oggpack_adv( &opb, 32 ); - p_stream->i_bitrate = oggpack_read( &opb, 32 ); - { - char title[sizeof("Stream") + 10]; - input_info_category_t *p_cat; - sprintf( title, "Stream %d", p_ogg->i_streams ); - p_cat = input_InfoCategory( p_input, title ); - input_AddInfo( p_cat, _("Type"), _("Audio") ); - input_AddInfo( p_cat, _("Codec"), _("Vorbis") ); - input_AddInfo( p_cat, _("Sample Rate"), "%f", - p_stream->f_rate ); - input_AddInfo( p_cat, _("Bit Rate"), "%d", - p_stream->i_bitrate ); - } + p_stream->fmt.i_cat = AUDIO_ES; + p_stream->fmt.i_codec = VLC_FOURCC( 'f','l','a','c' ); + oggpacket.packet += 13; oggpacket.bytes -= 13; + Ogg_ReadFlacHeader( p_demux, p_stream, &oggpacket ); } /* Check for Theora header */ else if( oggpacket.bytes >= 7 && - ! strncmp( &oggpacket.packet[1], "theora", 6 ) ) + ! memcmp( oggpacket.packet, "\x80theora", 7 ) ) { -#ifdef HAVE_OGGPACKB - oggpack_buffer opb; - int i_fps_numerator; - int i_fps_denominator; - int i_keyframe_frequency_force; -#endif - - msg_Dbg( p_input, "found theora header" ); -#ifdef HAVE_OGGPACKB - p_stream->i_cat = VIDEO_ES; - p_stream->i_fourcc = VLC_FOURCC( 't','h','e','o' ); - - /* Cheat and get additionnal info ;) */ - oggpackB_readinit(&opb, oggpacket.packet, oggpacket.bytes); - oggpackB_adv( &opb, 56 ); - oggpackB_read( &opb, 8 ); /* major version num */ - oggpackB_read( &opb, 8 ); /* minor version num */ - oggpackB_read( &opb, 8 ); /* subminor version num */ - oggpackB_read( &opb, 16 ) /*<< 4*/; /* width */ - oggpackB_read( &opb, 16 ) /*<< 4*/; /* height */ - i_fps_numerator = oggpackB_read( &opb, 32 ); - i_fps_denominator = oggpackB_read( &opb, 32 ); - oggpackB_read( &opb, 24 ); /* aspect_numerator */ - oggpackB_read( &opb, 24 ); /* aspect_denominator */ - i_keyframe_frequency_force = 1 << oggpackB_read( &opb, 5 ); - p_stream->i_bitrate = oggpackB_read( &opb, 24 ); - oggpackB_read(&opb,6); /* quality */ - - /* granule_shift = i_log( frequency_force -1 ) */ - p_stream->i_theora_keyframe_granule_shift = 0; - i_keyframe_frequency_force--; - while( i_keyframe_frequency_force ) - { - p_stream->i_theora_keyframe_granule_shift++; - i_keyframe_frequency_force >>= 1; - } + Ogg_ReadTheoraHeader( p_stream, &oggpacket ); - p_stream->f_rate = (float)i_fps_numerator / - i_fps_denominator; - msg_Dbg( p_input, + msg_Dbg( p_demux, "found theora header, bitrate: %i, rate: %f", - p_stream->i_bitrate, p_stream->f_rate ); - { - char title[sizeof("Stream") + 10]; - input_info_category_t *p_cat; - sprintf( title, "Stream %d", p_ogg->i_streams ); - p_cat = input_InfoCategory( p_input, title ); - input_AddInfo( p_cat, _("Type"), _("Video") ); - input_AddInfo( p_cat, _("Codec"), _("Theora") ); - input_AddInfo( p_cat, _("Frame Rate"), "%f", - p_stream->f_rate ); - input_AddInfo( p_cat, _("Bit Rate"), "%d", - p_stream->i_bitrate ); - } -#else /* HAVE_OGGPACKB */ - msg_Dbg( p_input, "the ogg demuxer has been compiled " - "without support for the oggpackB extension." - "The theora stream won't be decoded." ); - free( p_stream ); - p_ogg->i_streams--; - continue; -#endif /* HAVE_OGGPACKB */ + 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 && - ! strncmp( &oggpacket.packet[1], "tarkin", 6 ) ) + ! memcmp( &oggpacket.packet[1], "tarkin", 6 ) ) { oggpack_buffer opb; - msg_Dbg( p_input, "found tarkin header" ); - p_stream->i_cat = VIDEO_ES; - p_stream->i_fourcc = VLC_FOURCC( 't','a','r','k' ); + 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' ); /* Cheat and get additionnal info ;) */ oggpack_readinit( &opb, oggpacket.packet, oggpacket.bytes); oggpack_adv( &opb, 88 ); oggpack_adv( &opb, 104 ); - p_stream->i_bitrate = oggpack_read( &opb, 32 ); + p_stream->fmt.i_bitrate = oggpack_read( &opb, 32 ); p_stream->f_rate = 2; /* FIXME */ - msg_Dbg( p_input, + msg_Dbg( p_demux, "found tarkin header, bitrate: %i, rate: %f", - p_stream->i_bitrate, p_stream->f_rate ); - { - char title[sizeof("Stream") + 10]; - input_info_category_t *p_cat; - sprintf( title, "Stream %d", p_ogg->i_streams ); - p_cat = input_InfoCategory( p_input, title ); - input_AddInfo( p_cat, _("Type"), _("Video") ); - input_AddInfo( p_cat, _("Codec"), _("tarkin") ); - input_AddInfo( p_cat, _("Sample Rate"), "%f", - p_stream->f_rate ); - input_AddInfo( p_cat, _("Bit Rate"), "%d", - p_stream->i_bitrate ); - } - + p_stream->fmt.i_bitrate, p_stream->f_rate ); + } + /* Check for Annodex header */ + else if( oggpacket.bytes >= 7 && + ! memcmp( oggpacket.packet, "Annodex", 7 ) ) + { + Ogg_ReadAnnodexHeader( VLC_OBJECT(p_demux), p_stream, + &oggpacket ); + /* kill annodex track */ + free( p_stream ); + p_ogg->i_streams--; + } + /* Check for Annodex header */ + else if( oggpacket.bytes >= 7 && + ! memcmp( oggpacket.packet, "AnxData", 7 ) ) + { + 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 && - !strncmp( &oggpacket.packet[1], + !memcmp( &oggpacket.packet[1], "Direct Show Samples embedded in Ogg", 35 )) { /* Old header type */ @@ -668,172 +936,99 @@ static int Ogg_FindLogicalStreams( input_thread_t *p_input, demux_sys_t *p_ogg) if( GetDWLE((oggpacket.packet+96)) == 0x05589f80 && oggpacket.bytes >= 184 ) { - p_stream->i_cat = VIDEO_ES; - - p_stream->p_bih = (BITMAPINFOHEADER *) - malloc( sizeof(BITMAPINFOHEADER) ); - if( !p_stream->p_bih ) - { - /* Mem allocation error, just ignore the stream */ - free( p_stream ); - p_ogg->i_streams--; - continue; - } - p_stream->p_bih->biSize = sizeof(BITMAPINFOHEADER); - p_stream->p_bih->biCompression= p_stream->i_fourcc = + p_stream->fmt.i_cat = VIDEO_ES; + p_stream->fmt.i_codec = VLC_FOURCC( oggpacket.packet[68], oggpacket.packet[69], oggpacket.packet[70], oggpacket.packet[71] ); - msg_Dbg( p_input, "found video header of type: %.4s", - (char *)&p_stream->i_fourcc ); + msg_Dbg( p_demux, "found video header of type: %.4s", + (char *)&p_stream->fmt.i_codec ); + p_stream->fmt.video.i_frame_rate = 10000000; + p_stream->fmt.video.i_frame_rate_base = + GetQWLE((oggpacket.packet+164)); p_stream->f_rate = 10000000.0 / GetQWLE((oggpacket.packet+164)); - p_stream->p_bih->biBitCount = + p_stream->fmt.video.i_bits_per_pixel = GetWLE((oggpacket.packet+182)); - if( !p_stream->p_bih->biBitCount ) - p_stream->p_bih->biBitCount=24; // hack, FIXME - p_stream->p_bih->biWidth = + if( !p_stream->fmt.video.i_bits_per_pixel ) + /* hack, FIXME */ + p_stream->fmt.video.i_bits_per_pixel = 24; + p_stream->fmt.video.i_width = GetDWLE((oggpacket.packet+176)); - p_stream->p_bih->biHeight = + p_stream->fmt.video.i_height = GetDWLE((oggpacket.packet+180)); - p_stream->p_bih->biPlanes= 1 ; - p_stream->p_bih->biSizeImage = - (p_stream->p_bih->biBitCount >> 3) * - p_stream->p_bih->biWidth * - p_stream->p_bih->biHeight; - - msg_Dbg( p_input, - "fps: %f, width:%i; height:%i, bitcount:%i", - p_stream->f_rate, p_stream->p_bih->biWidth, - p_stream->p_bih->biHeight, - p_stream->p_bih->biBitCount); - { - char title[sizeof("Stream") + 10]; - input_info_category_t *p_cat; - sprintf( title, "Stream %d", p_ogg->i_streams ); - p_cat = input_InfoCategory( p_input, title ); - input_AddInfo( p_cat, _("Type"), _("Video") ); - input_AddInfo( p_cat, _("Codec"), "%.4s", - (char *)&p_stream->i_fourcc ); - input_AddInfo( p_cat, _("Frame Rate"), "%f", - p_stream->f_rate ); - input_AddInfo( p_cat, _("Bit Count"), "%d", - p_stream->p_bih->biBitCount ); - input_AddInfo( p_cat, _("Width"), "%d", - p_stream->p_bih->biWidth ); - input_AddInfo( p_cat, _("Height"), "%d", - p_stream->p_bih->biHeight ); - } - p_stream->i_bitrate = 0; + + msg_Dbg( p_demux, + "fps: %f, width:%i; height:%i, bitcount:%i", + p_stream->f_rate, + p_stream->fmt.video.i_width, + p_stream->fmt.video.i_height, + p_stream->fmt.video.i_bits_per_pixel); + } /* Check for audio header (old format) */ else if( GetDWLE((oggpacket.packet+96)) == 0x05589F81 ) { unsigned int i_extra_size; + unsigned int i_format_tag; - p_stream->i_cat = AUDIO_ES; + p_stream->fmt.i_cat = AUDIO_ES; i_extra_size = GetWLE((oggpacket.packet+140)); - - p_stream->p_wf = (WAVEFORMATEX *) - malloc( sizeof(WAVEFORMATEX) + i_extra_size ); - if( !p_stream->p_wf ) + if( i_extra_size ) { - /* Mem allocation error, just ignore the stream */ - free( p_stream ); - p_ogg->i_streams--; - continue; + p_stream->fmt.i_extra = i_extra_size; + p_stream->fmt.p_extra = malloc( i_extra_size ); + memcpy( p_stream->fmt.p_extra, + oggpacket.packet + 142, i_extra_size ); } - p_stream->p_wf->wFormatTag = - GetWLE((oggpacket.packet+124)); - p_stream->p_wf->nChannels = + i_format_tag = GetWLE((oggpacket.packet+124)); + p_stream->fmt.audio.i_channels = GetWLE((oggpacket.packet+126)); - p_stream->f_rate = p_stream->p_wf->nSamplesPerSec = + p_stream->f_rate = p_stream->fmt.audio.i_rate = GetDWLE((oggpacket.packet+128)); - p_stream->i_bitrate = p_stream->p_wf->nAvgBytesPerSec = - GetDWLE((oggpacket.packet+132)); - p_stream->i_bitrate *= 8; - p_stream->p_wf->nBlockAlign = + p_stream->fmt.i_bitrate = + GetDWLE((oggpacket.packet+132)) * 8; + p_stream->fmt.audio.i_blockalign = GetWLE((oggpacket.packet+136)); - p_stream->p_wf->wBitsPerSample = + p_stream->fmt.audio.i_bitspersample = GetWLE((oggpacket.packet+138)); - p_stream->p_wf->cbSize = i_extra_size; - if( i_extra_size > 0 ) - memcpy( p_stream->p_wf+sizeof(WAVEFORMATEX), - oggpacket.packet+142, i_extra_size ); + wf_tag_to_fourcc( i_format_tag, + &p_stream->fmt.i_codec, 0 ); - switch( p_stream->p_wf->wFormatTag ) + if( p_stream->fmt.i_codec == + VLC_FOURCC('u','n','d','f') ) { - case WAVE_FORMAT_PCM: - p_stream->i_fourcc = - VLC_FOURCC( 'a', 'r', 'a', 'w' ); - break; - case WAVE_FORMAT_MPEG: - case WAVE_FORMAT_MPEGLAYER3: - p_stream->i_fourcc = - VLC_FOURCC( 'm', 'p', 'g', 'a' ); - break; - case WAVE_FORMAT_A52: - p_stream->i_fourcc = - VLC_FOURCC( 'a', '5', '2', ' ' ); - break; - case WAVE_FORMAT_WMA1: - p_stream->i_fourcc = - VLC_FOURCC( 'w', 'm', 'a', '1' ); - break; - case WAVE_FORMAT_WMA2: - p_stream->i_fourcc = - VLC_FOURCC( 'w', 'm', 'a', '2' ); - break; - default: - p_stream->i_fourcc = VLC_FOURCC( 'm', 's', - ( p_stream->p_wf->wFormatTag >> 8 ) & 0xff, - p_stream->p_wf->wFormatTag & 0xff ); + p_stream->fmt.i_codec = VLC_FOURCC( 'm', 's', + ( i_format_tag >> 8 ) & 0xff, + i_format_tag & 0xff ); } - msg_Dbg( p_input, "found audio header of type: %.4s", - (char *)&p_stream->i_fourcc ); - msg_Dbg( p_input, "audio:0x%4.4x channels:%d %dHz " + msg_Dbg( p_demux, "found audio header of type: %.4s", + (char *)&p_stream->fmt.i_codec ); + msg_Dbg( p_demux, "audio:0x%4.4x channels:%d %dHz " "%dbits/sample %dkb/s", - p_stream->p_wf->wFormatTag, - p_stream->p_wf->nChannels, - p_stream->p_wf->nSamplesPerSec, - p_stream->p_wf->wBitsPerSample, - p_stream->p_wf->nAvgBytesPerSec * 8 / 1024 ); - { - char title[sizeof("Stream") + 10]; - input_info_category_t *p_cat; - sprintf( title, "Stream %d", p_ogg->i_streams ); - p_cat = input_InfoCategory( p_input, title ); - input_AddInfo( p_cat, _("Type"), _("Audio") ); - input_AddInfo( p_cat, _("Codec"), _("%.4s"), - (char *)&p_stream->i_fourcc ); - input_AddInfo( p_cat, _("Sample Rate"), "%d", - p_stream->p_wf->nSamplesPerSec ); - input_AddInfo( p_cat, _("Bit Rate"), "%d", - p_stream->p_wf->nAvgBytesPerSec * 8 - / 1024 ); - input_AddInfo( p_cat, _("Channels"), "%d", - p_stream->p_wf->nChannels ); - input_AddInfo( p_cat, _("Bits per Sample"), "%d", - p_stream->p_wf->wBitsPerSample ); - } + i_format_tag, + p_stream->fmt.audio.i_channels, + p_stream->fmt.audio.i_rate, + p_stream->fmt.audio.i_bitspersample, + p_stream->fmt.i_bitrate / 1024 ); } else { - msg_Dbg( p_input, "stream %d has an old header " + msg_Dbg( p_demux, "stream %d has an old header " "but is of an unknown type", p_ogg->i_streams-1 ); free( p_stream ); p_ogg->i_streams--; } } else if( (*oggpacket.packet & PACKET_TYPE_BITS ) - == PACKET_TYPE_HEADER && + == PACKET_TYPE_HEADER && oggpacket.bytes >= (int)sizeof(stream_header)+1 ) { stream_header *st = (stream_header *)(oggpacket.packet+1); @@ -841,160 +1036,91 @@ static int Ogg_FindLogicalStreams( input_thread_t *p_input, demux_sys_t *p_ogg) /* Check for video header (new format) */ if( !strncmp( st->streamtype, "video", 5 ) ) { - p_stream->i_cat = VIDEO_ES; + p_stream->fmt.i_cat = VIDEO_ES; /* We need to get rid of the header packet */ ogg_stream_packetout( &p_stream->os, &oggpacket ); - p_stream->p_bih = (BITMAPINFOHEADER *) - malloc( sizeof(BITMAPINFOHEADER) ); - if( !p_stream->p_bih ) - { - /* Mem allocation error, just ignore the stream */ - free( p_stream ); - p_ogg->i_streams--; - continue; - } - p_stream->p_bih->biSize = sizeof(BITMAPINFOHEADER); - p_stream->p_bih->biCompression= - p_stream->i_fourcc = VLC_FOURCC( st->subtype[0], - st->subtype[1], - st->subtype[2], - st->subtype[3] ); - msg_Dbg( p_input, "found video header of type: %.4s", - (char *)&p_stream->i_fourcc ); + p_stream->fmt.i_codec = + VLC_FOURCC( st->subtype[0], st->subtype[1], + st->subtype[2], st->subtype[3] ); + msg_Dbg( p_demux, "found video header of type: %.4s", + (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((uint8_t *)&st->time_unit); - p_stream->p_bih->biBitCount = - GetWLE((uint8_t *)&st->bits_per_sample); - p_stream->p_bih->biWidth = - GetDWLE((uint8_t *)&st->sh.video.width); - p_stream->p_bih->biHeight = - GetDWLE((uint8_t *)&st->sh.video.height); - p_stream->p_bih->biPlanes= 1 ; - p_stream->p_bih->biSizeImage = - (p_stream->p_bih->biBitCount >> 3) * - p_stream->p_bih->biWidth * - p_stream->p_bih->biHeight; - - msg_Dbg( p_input, - "fps: %f, width:%i; height:%i, bitcount:%i", - p_stream->f_rate, p_stream->p_bih->biWidth, - p_stream->p_bih->biHeight, - p_stream->p_bih->biBitCount); - - { - char title[sizeof("Stream") + 10]; - input_info_category_t *p_cat; - sprintf( title, "Stream %d", p_ogg->i_streams ); - p_cat = input_InfoCategory( p_input, title ); - input_AddInfo( p_cat, _("Type"), _("Video") ); - input_AddInfo( p_cat, _("Codec"), "%.4s", - (char *)&p_stream->i_fourcc ); - input_AddInfo( p_cat, _("Frame Rate"), "%f", - p_stream->f_rate ); - input_AddInfo( p_cat, _("Bit Count"), "%d", - p_stream->p_bih->biBitCount ); - input_AddInfo( p_cat, _("Width"), "%d", - p_stream->p_bih->biWidth ); - input_AddInfo( p_cat, _("Height"), "%d", - p_stream->p_bih->biHeight ); - } - p_stream->i_bitrate = 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); + + msg_Dbg( p_demux, + "fps: %f, width:%i; height:%i, bitcount:%i", + p_stream->f_rate, + p_stream->fmt.video.i_width, + p_stream->fmt.video.i_height, + p_stream->fmt.video.i_bits_per_pixel ); } /* Check for audio header (new format) */ else if( !strncmp( st->streamtype, "audio", 5 ) ) { char p_buffer[5]; + int i_format_tag; - p_stream->i_cat = AUDIO_ES; + 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->p_wf = (WAVEFORMATEX *) - malloc( sizeof(WAVEFORMATEX) ); - if( !p_stream->p_wf ) + p_stream->fmt.i_extra = GetQWLE(&st->size) - + sizeof(stream_header); + if( p_stream->fmt.i_extra ) { - /* Mem allocation error, just ignore the stream */ - free( p_stream ); - p_ogg->i_streams--; - continue; + p_stream->fmt.p_extra = + malloc( p_stream->fmt.i_extra ); + memcpy( p_stream->fmt.p_extra, st + 1, + p_stream->fmt.i_extra ); } memcpy( p_buffer, st->subtype, 4 ); p_buffer[4] = '\0'; - p_stream->p_wf->wFormatTag = strtol(p_buffer,NULL,16); - p_stream->p_wf->nChannels = - GetWLE((uint8_t *)&st->sh.audio.channels); - p_stream->f_rate = p_stream->p_wf->nSamplesPerSec = - GetQWLE((uint8_t *)&st->samples_per_unit); - p_stream->i_bitrate = p_stream->p_wf->nAvgBytesPerSec = - GetDWLE((uint8_t *)&st->sh.audio.avgbytespersec); - p_stream->i_bitrate *= 8; - p_stream->p_wf->nBlockAlign = - GetWLE((uint8_t *)&st->sh.audio.blockalign); - p_stream->p_wf->wBitsPerSample = - GetWLE((uint8_t *)&st->bits_per_sample); - p_stream->p_wf->cbSize = 0; - - switch( p_stream->p_wf->wFormatTag ) + 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); + + wf_tag_to_fourcc( i_format_tag, + &p_stream->fmt.i_codec, 0 ); + + if( p_stream->fmt.i_codec == + VLC_FOURCC('u','n','d','f') ) { - case WAVE_FORMAT_PCM: - p_stream->i_fourcc = - VLC_FOURCC( 'a', 'r', 'a', 'w' ); - break; - case WAVE_FORMAT_MPEG: - case WAVE_FORMAT_MPEGLAYER3: - p_stream->i_fourcc = - VLC_FOURCC( 'm', 'p', 'g', 'a' ); - break; - case WAVE_FORMAT_A52: - p_stream->i_fourcc = - VLC_FOURCC( 'a', '5', '2', ' ' ); - break; - case WAVE_FORMAT_WMA1: - p_stream->i_fourcc = - VLC_FOURCC( 'w', 'm', 'a', '1' ); - break; - case WAVE_FORMAT_WMA2: - p_stream->i_fourcc = - VLC_FOURCC( 'w', 'm', 'a', '2' ); - break; - default: - p_stream->i_fourcc = VLC_FOURCC( 'm', 's', - ( p_stream->p_wf->wFormatTag >> 8 ) & 0xff, - p_stream->p_wf->wFormatTag & 0xff ); + p_stream->fmt.i_codec = VLC_FOURCC( 'm', 's', + ( i_format_tag >> 8 ) & 0xff, + i_format_tag & 0xff ); } - msg_Dbg( p_input, "found audio header of type: %.4s", - (char *)&p_stream->i_fourcc ); - msg_Dbg( p_input, "audio:0x%4.4x channels:%d %dHz " + msg_Dbg( p_demux, "found audio header of type: %.4s", + (char *)&p_stream->fmt.i_codec ); + msg_Dbg( p_demux, "audio:0x%4.4x channels:%d %dHz " "%dbits/sample %dkb/s", - p_stream->p_wf->wFormatTag, - p_stream->p_wf->nChannels, - p_stream->p_wf->nSamplesPerSec, - p_stream->p_wf->wBitsPerSample, - p_stream->p_wf->nAvgBytesPerSec * 8 / 1024 ); - { - char title[sizeof("Stream") + 10]; - input_info_category_t *p_cat; - sprintf( title, "Stream %d", p_ogg->i_streams ); - p_cat = input_InfoCategory( p_input, title ); - input_AddInfo( p_cat, _("Type"), _("Audio") ); - input_AddInfo( p_cat, _("Codec"), "%.4s", - (char *)&p_stream->i_fourcc ); - input_AddInfo( p_cat, _("Sample Rate"), "%d", - p_stream->p_wf->nSamplesPerSec ); - input_AddInfo( p_cat, _("Bit Rate"), "%d", - p_stream->p_wf->nAvgBytesPerSec * 8 - / 1024 ); - input_AddInfo( p_cat, _("Channels"), "%d", - p_stream->p_wf->nChannels ); - input_AddInfo( p_cat, _("Bits per Sample"), "%d", - p_stream->p_wf->wBitsPerSample ); - } + i_format_tag, + p_stream->fmt.audio.i_channels, + p_stream->fmt.audio.i_rate, + p_stream->fmt.audio.i_bitspersample, + p_stream->fmt.i_bitrate / 1024 ); } /* Check for text (subtitles) header */ else if( !strncmp(st->streamtype, "text", 4) ) @@ -1002,31 +1128,37 @@ static int Ogg_FindLogicalStreams( input_thread_t *p_input, demux_sys_t *p_ogg) /* We need to get rid of the header packet */ ogg_stream_packetout( &p_stream->os, &oggpacket ); - msg_Dbg( p_input, "found text subtitles header" ); - p_stream->i_cat = SPU_ES; - p_stream->i_fourcc = - VLC_FOURCC( 's', 'u', 'b', 't' ); + 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 */ } else { - msg_Dbg( p_input, "stream %d has a header marker " + msg_Dbg( p_demux, "stream %d has a header marker " "but is of an unknown type", p_ogg->i_streams-1 ); free( p_stream ); p_ogg->i_streams--; } } + else if( oggpacket.bytes >= 7 && + ! memcmp( oggpacket.packet, "fishead", 7 ) ) + + { + /* Skeleton */ + msg_Dbg( p_demux, "stream %d is a skeleton", + p_ogg->i_streams-1 ); + /* FIXME: https://trac.videolan.org/vlc/ticket/1412 */ + } else { - msg_Dbg( p_input, "stream %d is of unknown type", + msg_Dbg( p_demux, "stream %d is of unknown type", p_ogg->i_streams-1 ); free( p_stream ); p_ogg->i_streams--; } -#undef p_stream - - if( Ogg_ReadPage( p_input, p_ogg, &oggpage ) != VLC_SUCCESS ) + if( Ogg_ReadPage( p_demux, &oggpage ) != VLC_SUCCESS ) return VLC_EGENERIC; } @@ -1041,373 +1173,478 @@ static int Ogg_FindLogicalStreams( input_thread_t *p_input, demux_sys_t *p_ogg) break; } } + return VLC_SUCCESS; } } +#undef p_stream + return VLC_EGENERIC; } -/***************************************************************************** - * Activate: initializes ogg demux structures - *****************************************************************************/ -static int Activate( vlc_object_t * p_this ) +/**************************************************************************** + * Ogg_BeginningOfStream: Look for Beginning of Stream ogg pages and add + * Elementary streams. + ****************************************************************************/ +static int Ogg_BeginningOfStream( demux_t *p_demux ) { - int i_stream, b_forced; - demux_sys_t *p_ogg; - input_thread_t *p_input = (input_thread_t *)p_this; - - p_input->p_demux_data = NULL; - b_forced = ( ( *p_input->psz_demux )&& - ( !strncmp( p_input->psz_demux, "ogg", 10 ) ) ) ? 1 : 0; - - /* Check if we are dealing with an ogg stream */ - if( !b_forced && ( Ogg_Check( p_input ) != VLC_SUCCESS ) ) - return -1; - - /* Allocate p_ogg */ - if( !( p_ogg = malloc( sizeof( demux_sys_t ) ) ) ) - { - msg_Err( p_input, "out of memory" ); - goto error; - } - memset( p_ogg, 0, sizeof( demux_sys_t ) ); - p_input->p_demux_data = p_ogg; - - p_ogg->i_pcr = 0; - p_ogg->b_seekable = ( ( p_input->stream.b_seekable ) - &&( p_input->stream.i_method == INPUT_METHOD_FILE ) ); - - /* Initialize the Ogg physical bitstream parser */ - ogg_sync_init( &p_ogg->oy ); + demux_sys_t *p_ogg = p_demux->p_sys ; + int i_stream; /* Find the logical streams embedded in the physical stream and * initialize our p_ogg structure. */ - if( Ogg_FindLogicalStreams( p_input, p_ogg ) != VLC_SUCCESS ) - { - msg_Err( p_input, "couldn't find an ogg logical stream" ); - goto error; - } - - /* Set the demux function */ - p_input->pf_demux = Demux; - - /* Initialize access plug-in structures. */ - if( p_input->i_mtu == 0 ) + if( Ogg_FindLogicalStreams( p_demux ) != VLC_SUCCESS ) { - /* Improve speed. */ - p_input->i_bufsize = INPUT_DEFAULT_BUFSIZE; + msg_Warn( p_demux, "couldn't find any ogg logical stream" ); + return VLC_EGENERIC; } - /* Create one program */ - vlc_mutex_lock( &p_input->stream.stream_lock ); - if( input_InitStream( p_input, 0 ) == -1) - { - vlc_mutex_unlock( &p_input->stream.stream_lock ); - msg_Err( p_input, "cannot init stream" ); - goto error; - } - if( input_AddProgram( p_input, 0, 0) == NULL ) - { - vlc_mutex_unlock( &p_input->stream.stream_lock ); - msg_Err( p_input, "cannot add program" ); - goto error; - } - p_input->stream.p_selected_program = p_input->stream.pp_programs[0]; - p_input->stream.i_mux_rate = 0; - vlc_mutex_unlock( &p_input->stream.stream_lock ); + p_ogg->i_bitrate = 0; for( i_stream = 0 ; i_stream < p_ogg->i_streams; i_stream++ ) { #define p_stream p_ogg->pp_stream[i_stream] - vlc_mutex_lock( &p_input->stream.stream_lock ); - p_stream->p_es = input_AddES( p_input, - p_input->stream.p_selected_program, - p_ogg->i_streams + 1, 0 ); - p_input->stream.i_mux_rate += (p_stream->i_bitrate / ( 8 * 50 )); - vlc_mutex_unlock( &p_input->stream.stream_lock ); - p_stream->p_es->i_stream_id = p_stream->p_es->i_id = i_stream; - p_stream->p_es->i_fourcc = p_stream->i_fourcc; - p_stream->p_es->i_cat = p_stream->i_cat; - p_stream->p_es->p_waveformatex = (void*)p_stream->p_wf; - p_stream->p_es->p_bitmapinfoheader = (void*)p_stream->p_bih; -#undef p_stream - } + p_stream->p_es = es_out_Add( p_demux->out, &p_stream->fmt ); - for( i_stream = 0; i_stream < p_ogg->i_streams; i_stream++ ) - { -#define p_stream p_ogg->pp_stream[i_stream] - switch( p_stream->p_es->i_cat ) + // TODO: something to do here ? + if( p_stream->fmt.i_codec == VLC_FOURCC('c','m','m','l') ) { - case( VIDEO_ES ): - if( (p_ogg->p_stream_video == NULL) ) - { - p_ogg->p_stream_video = p_stream; - /* TODO add test to see if a decoder has been found */ - Ogg_StreamStart( p_input, p_ogg, i_stream ); - } - break; - - case( AUDIO_ES ): - if( (p_ogg->p_stream_audio == NULL) ) - { - int i_audio = config_GetInt( p_input, "audio-channel" ); - if( i_audio == i_stream || i_audio <= 0 || - i_audio >= p_ogg->i_streams || - p_ogg->pp_stream[i_audio]->p_es->i_cat != AUDIO_ES ) - { - p_ogg->p_stream_audio = p_stream; - Ogg_StreamStart( p_input, p_ogg, i_stream ); - } - } - break; + /* Set the CMML stream active */ + es_out_Control( p_demux->out, ES_OUT_SET_ES, p_stream->p_es ); + } - case( SPU_ES ): - if( (p_ogg->p_stream_spu == NULL) ) - { - /* for spu, default is none */ - int i_spu = config_GetInt( p_input, "spu-channel" ); - if( i_spu < 0 || i_spu >= p_ogg->i_streams || - p_ogg->pp_stream[i_spu]->p_es->i_cat != SPU_ES ) - { - break; - } - else if( i_spu == i_stream ) - { - p_ogg->p_stream_spu = p_stream; - Ogg_StreamStart( p_input, p_ogg, i_stream ); - } - } - break; + p_ogg->i_bitrate += p_stream->fmt.i_bitrate; - default: - break; - } + p_stream->i_pcr = p_stream->i_previous_pcr = + p_stream->i_interpolated_pcr = -1; + p_stream->b_reinit = 0; #undef p_stream } - /* we select the first audio and video ES */ - vlc_mutex_lock( &p_input->stream.stream_lock ); - if( !p_ogg->p_stream_video ) + return VLC_SUCCESS; +} + +/**************************************************************************** + * Ogg_EndOfStream: clean up the ES when an End of Stream is detected. + ****************************************************************************/ +static void Ogg_EndOfStream( demux_t *p_demux ) +{ + demux_sys_t *p_ogg = p_demux->p_sys ; + int i_stream; + +#define p_stream p_ogg->pp_stream[i_stream] + for( i_stream = 0 ; i_stream < p_ogg->i_streams; i_stream++ ) { - msg_Warn( p_input, "no video stream found" ); + if( p_stream->p_es ) + es_out_Del( p_demux->out, p_stream->p_es ); + + p_ogg->i_bitrate -= p_stream->fmt.i_bitrate; + + ogg_stream_clear( &p_ogg->pp_stream[i_stream]->os ); + free( p_ogg->pp_stream[i_stream]->p_headers ); + + es_format_Clean( &p_stream->fmt ); + + free( p_ogg->pp_stream[i_stream] ); } - if( !p_ogg->p_stream_audio ) +#undef p_stream + + /* Reinit p_ogg */ + free( p_ogg->pp_stream ); + p_ogg->pp_stream = NULL; + p_ogg->i_streams = 0; +} + +static void Ogg_ReadTheoraHeader( logical_stream_t *p_stream, + ogg_packet *p_oggpacket ) +{ + bs_t bitstream; + int i_fps_numerator; + int i_fps_denominator; + int i_keyframe_frequency_force; + + p_stream->fmt.i_cat = VIDEO_ES; + p_stream->fmt.i_codec = VLC_FOURCC( 't','h','e','o' ); + + /* Signal that we want to keep a backup of the theora + * stream headers. They will be used when switching between + * audio streams. */ + p_stream->b_force_backup = 1; + + /* 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 */ + bs_read( &bitstream, 16 ) /*<< 4*/; /* width */ + bs_read( &bitstream, 16 ) /*<< 4*/; /* height */ + bs_read( &bitstream, 24 ); /* frame width */ + bs_read( &bitstream, 24 ); /* frame height */ + bs_read( &bitstream, 8 ); /* x offset */ + bs_read( &bitstream, 8 ); /* y offset */ + + i_fps_numerator = bs_read( &bitstream, 32 ); + i_fps_denominator = bs_read( &bitstream, 32 ); + bs_read( &bitstream, 24 ); /* aspect_numerator */ + bs_read( &bitstream, 24 ); /* aspect_denominator */ + + p_stream->fmt.video.i_frame_rate = i_fps_numerator; + p_stream->fmt.video.i_frame_rate_base = i_fps_denominator; + + bs_read( &bitstream, 8 ); /* colorspace */ + p_stream->fmt.i_bitrate = bs_read( &bitstream, 24 ); + bs_read( &bitstream, 6 ); /* quality */ + + i_keyframe_frequency_force = 1 << bs_read( &bitstream, 5 ); + + /* granule_shift = i_log( frequency_force -1 ) */ + p_stream->i_granule_shift = 0; + i_keyframe_frequency_force--; + while( i_keyframe_frequency_force ) { - msg_Warn( p_input, "no audio stream found!" ); + p_stream->i_granule_shift++; + i_keyframe_frequency_force >>= 1; } - p_input->stream.p_selected_program->b_is_ok = 1; - vlc_mutex_unlock( &p_input->stream.stream_lock ); - /* Call the pace control */ - input_ClockManageRef( p_input, - p_input->stream.p_selected_program, - p_ogg->i_pcr ); - - return 0; + p_stream->f_rate = ((float)i_fps_numerator) / i_fps_denominator; +} - error: - Deactivate( (vlc_object_t *)p_input ); - return -1; +static void Ogg_ReadVorbisHeader( logical_stream_t *p_stream, + ogg_packet *p_oggpacket ) +{ + oggpack_buffer opb; + + p_stream->fmt.i_cat = AUDIO_ES; + p_stream->fmt.i_codec = VLC_FOURCC( 'v','o','r','b' ); + + /* Signal that we want to keep a backup of the vorbis + * stream headers. They will be used when switching between + * audio streams. */ + p_stream->b_force_backup = 1; + + /* Cheat and get additionnal info ;) */ + oggpack_readinit( &opb, p_oggpacket->packet, p_oggpacket->bytes); + oggpack_adv( &opb, 88 ); + p_stream->fmt.audio.i_channels = oggpack_read( &opb, 8 ); + p_stream->f_rate = p_stream->fmt.audio.i_rate = + oggpack_read( &opb, 32 ); + oggpack_adv( &opb, 32 ); + p_stream->fmt.i_bitrate = oggpack_read( &opb, 32 ); +} +static void Ogg_ReadSpeexHeader( logical_stream_t *p_stream, + ogg_packet *p_oggpacket ) +{ + oggpack_buffer opb; + + p_stream->fmt.i_cat = AUDIO_ES; + p_stream->fmt.i_codec = VLC_FOURCC( 's','p','x',' ' ); + + /* Signal that we want to keep a backup of the speex + * stream headers. They will be used when switching between + * audio streams. */ + p_stream->b_force_backup = 1; + + /* Cheat and get additionnal info ;) */ + oggpack_readinit( &opb, p_oggpacket->packet, p_oggpacket->bytes); + oggpack_adv( &opb, 224 ); + oggpack_adv( &opb, 32 ); /* speex_version_id */ + oggpack_adv( &opb, 32 ); /* header_size */ + p_stream->f_rate = p_stream->fmt.audio.i_rate = oggpack_read( &opb, 32 ); + oggpack_adv( &opb, 32 ); /* mode */ + oggpack_adv( &opb, 32 ); /* mode_bitstream_version */ + p_stream->fmt.audio.i_channels = oggpack_read( &opb, 32 ); + p_stream->fmt.i_bitrate = oggpack_read( &opb, 32 ); } -/***************************************************************************** - * Deactivate: frees unused data - *****************************************************************************/ -static void Deactivate( vlc_object_t *p_this ) +static void Ogg_ReadFlacHeader( demux_t *p_demux, logical_stream_t *p_stream, + ogg_packet *p_oggpacket ) { - input_thread_t *p_input = (input_thread_t *)p_this; - demux_sys_t *p_ogg = (demux_sys_t *)p_input->p_demux_data ; - int i, j; + /* Parse the STREAMINFO metadata */ + bs_t s; - if( p_ogg ) - { - /* Cleanup the bitstream parser */ - ogg_sync_clear( &p_ogg->oy ); + bs_init( &s, p_oggpacket->packet, p_oggpacket->bytes ); - for( i = 0; i < p_ogg->i_streams; i++ ) + bs_read( &s, 1 ); + if( bs_read( &s, 7 ) == 0 ) + { + if( bs_read( &s, 24 ) >= 34 /*size STREAMINFO*/ ) { - ogg_stream_clear( &p_ogg->pp_stream[i]->os ); - for( j = 0; j < p_ogg->pp_stream[i]->i_packets_backup; j++ ) - { - free( p_ogg->pp_stream[i]->p_packets_backup[j].packet ); - } - if( p_ogg->pp_stream[i]->p_packets_backup) - free( p_ogg->pp_stream[i]->p_packets_backup ); -#if 0 /* hmmm, it's already freed in input_DelES() */ - if( p_ogg->pp_stream[i]->p_bih ) - free( p_ogg->pp_stream[i]->p_bih ); - if( p_ogg->pp_stream[i]->p_wf ) - free( p_ogg->pp_stream[i]->p_wf ); -#endif - free( p_ogg->pp_stream[i] ); + bs_skip( &s, 80 ); + p_stream->f_rate = p_stream->fmt.audio.i_rate = bs_read( &s, 20 ); + p_stream->fmt.audio.i_channels = bs_read( &s, 3 ) + 1; + + msg_Dbg( p_demux, "FLAC header, channels: %i, rate: %i", + p_stream->fmt.audio.i_channels, (int)p_stream->f_rate ); } - if( p_ogg->pp_stream ) free( p_ogg->pp_stream ); + else msg_Dbg( p_demux, "FLAC STREAMINFO metadata too short" ); - free( p_ogg ); + /* Fake this as the last metadata block */ + *((uint8_t*)p_oggpacket->packet) |= 0x80; + } + else + { + /* This ain't a STREAMINFO metadata */ + msg_Dbg( p_demux, "Invalid FLAC STREAMINFO metadata" ); } } -/***************************************************************************** - * Demux: reads and demuxes data packets - ***************************************************************************** - * Returns -1 in case of error, 0 in case of EOF, 1 otherwise - *****************************************************************************/ -static int Demux( input_thread_t * p_input ) +static void Ogg_ReadKateHeader( logical_stream_t *p_stream, + ogg_packet *p_oggpacket ) { - int i, i_stream, b_eos = 0; - ogg_page oggpage; - ogg_packet oggpacket; - demux_sys_t *p_ogg = (demux_sys_t *)p_input->p_demux_data; - -#define p_stream p_ogg->pp_stream[i_stream] - /* detect new selected/unselected streams */ - for( i_stream = 0; i_stream < p_ogg->i_streams; i_stream++ ) + 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) { - if( p_stream->p_es ) - { - if( p_stream->p_es->p_decoder_fifo && - !p_stream->i_activated ) - { - Ogg_StreamStart( p_input, p_ogg, i_stream ); - } - else - if( !p_stream->p_es->p_decoder_fifo && - p_stream->i_activated ) - { - Ogg_StreamStop( p_input, p_ogg, i_stream ); - } - } + 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 */ } - - /* search for new video and audio stream to select - * if current have been unselected */ - if( ( !p_ogg->p_stream_video ) - || ( !p_ogg->p_stream_video->p_es->p_decoder_fifo ) ) + else { - p_ogg->p_stream_video = NULL; - for( i_stream = 0; i_stream < p_ogg->i_streams; i_stream++ ) - { - if( ( p_stream->i_cat == VIDEO_ES ) - &&( p_stream->p_es->p_decoder_fifo ) ) - { - p_ogg->p_stream_video = p_stream; - break; - } - } + for (n=0;n<16;++n) + oggpack_read(&opb,8); } - if( ( !p_ogg->p_stream_audio ) - ||( !p_ogg->p_stream_audio->p_es->p_decoder_fifo ) ) + p_stream->fmt.psz_description = malloc(16); + if (p_stream->fmt.psz_description) { - p_ogg->p_stream_audio = NULL; - for( i_stream = 0; i_stream < p_ogg->i_streams; i_stream++ ) - { - if( ( p_stream->i_cat == AUDIO_ES ) - &&( p_stream->p_es->p_decoder_fifo ) ) - { - p_ogg->p_stream_audio = p_stream; - break; - } - } + 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); } +} - if( p_input->stream.p_selected_program->i_synchro_state == SYNCHRO_REINIT ) +static void Ogg_ReadAnnodexHeader( vlc_object_t *p_this, + logical_stream_t *p_stream, + ogg_packet *p_oggpacket ) +{ + if( p_oggpacket->bytes >= 28 && + !memcmp( p_oggpacket->packet, "Annodex", 7 ) ) { - msg_Warn( p_input, "synchro reinit" ); + oggpack_buffer opb; - /* An ogg packet does only contain the starting date of the next - * packet, not its own starting date. - * As a quick work around, we just skip an oggpage */ + uint16_t major_version; + uint16_t minor_version; + uint64_t timebase_numerator; + uint64_t timebase_denominator; - for( i_stream = 0; i_stream < p_ogg->i_streams; i_stream++ ) - { - /* we'll trash all the data until we find the next pcr */ - p_stream->b_reinit = 1; - p_stream->i_pcr = -1; - p_stream->i_interpolated_pcr = -1; - } - p_ogg->b_reinit = 1; + Ogg_ReadTheoraHeader( p_stream, p_oggpacket ); + + oggpack_readinit( &opb, p_oggpacket->packet, p_oggpacket->bytes); + oggpack_adv( &opb, 8*8 ); /* "Annodex\0" header */ + major_version = oggpack_read( &opb, 2*8 ); /* major version */ + minor_version = oggpack_read( &opb, 2*8 ); /* minor version */ + timebase_numerator = GetQWLE( &p_oggpacket->packet[16] ); + timebase_denominator = GetQWLE( &p_oggpacket->packet[24] ); } + else if( p_oggpacket->bytes >= 42 && + !memcmp( p_oggpacket->packet, "AnxData", 7 ) ) + { + uint64_t granule_rate_numerator; + uint64_t granule_rate_denominator; + char content_type_string[1024]; + /* Read in Annodex header fields */ - /* - * Demux ogg pages from the stream - */ - for( i = 0; i < PAGES_READ_ONCE || p_ogg->b_reinit; i++ ) - { - if( Ogg_ReadPage( p_input, p_ogg, &oggpage ) != VLC_SUCCESS ) + granule_rate_numerator = GetQWLE( &p_oggpacket->packet[8] ); + granule_rate_denominator = GetQWLE( &p_oggpacket->packet[16] ); + p_stream->secondary_header_packets = + GetDWLE( &p_oggpacket->packet[24] ); + + /* we are guaranteed that the first header field will be + * the content-type (by the Annodex standard) */ + content_type_string[0] = '\0'; + if( !strncasecmp( (char*)(&p_oggpacket->packet[28]), "Content-Type: ", 14 ) ) { - b_eos = 1; - break; + 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", + content_type_string ); } - for( i_stream = 0; i_stream < p_ogg->i_streams; i_stream++ ) + 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->f_rate = (float) granule_rate_numerator / + (float) granule_rate_denominator; + + /* What type of file do we have? + * strcmp is safe to use here because we've extracted + * content_type_string from the stream manually */ + if( !strncmp(content_type_string, "audio/x-wav", 11) ) + { + /* n.b. WAVs are unsupported right now */ + p_stream->fmt.i_cat = UNKNOWN_ES; + } + else if( !strncmp(content_type_string, "audio/x-vorbis", 14) ) { - if( ogg_stream_pagein( &p_stream->os, &oggpage ) != 0 ) - continue; + p_stream->fmt.i_cat = AUDIO_ES; + p_stream->fmt.i_codec = VLC_FOURCC( 'v','o','r','b' ); - while( ogg_stream_packetout( &p_stream->os, &oggpacket ) > 0 ) - { - if( !p_stream->p_es ) - { - break; - } + 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',' ' ); - if( p_stream->b_reinit ) - { - if( oggpacket.granulepos >= 0 ) - { - p_stream->b_reinit = 0; - - /* Convert the next granulepos into a pcr */ - Ogg_UpdatePCR( p_stream, &oggpacket ); - - /* Call the pace control to reinitialize - * the system clock */ - input_ClockManageRef( p_input, - p_input->stream.p_selected_program, - p_stream->i_pcr ); - - if( (!p_ogg->p_stream_video || - !p_ogg->p_stream_video->b_reinit) && - (!p_ogg->p_stream_audio || - !p_ogg->p_stream_audio->b_reinit) ) - { - p_ogg->b_reinit = 0; - } - } - continue; - } + 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' ); - Ogg_DecodePacket( p_input, p_stream, &oggpacket ); + p_stream->b_force_backup = 1; + } + else if( !strncmp(content_type_string, "video/x-xvid", 14) ) + { + p_stream->fmt.i_cat = VIDEO_ES; + p_stream->fmt.i_codec = VLC_FOURCC( 'x','v','i','d' ); - } + p_stream->b_force_backup = 1; + } + else if( !strncmp(content_type_string, "video/mpeg", 14) ) + { + /* 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' ); + } + 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' ); } } +} - i_stream = 0; - p_ogg->i_old_pcr = p_ogg->i_pcr; - p_ogg->i_pcr = p_stream->i_interpolated_pcr; - for( ; i_stream < p_ogg->i_streams; i_stream++ ) - { - if( p_stream->i_cat == SPU_ES ) - continue; - - if( p_stream->i_interpolated_pcr > 0 - && p_stream->i_interpolated_pcr < p_ogg->i_pcr ) - p_ogg->i_pcr = p_stream->i_interpolated_pcr; +/* 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; + /* find the picture startcode */ + while ( (p_oggpacket->packet[u_pos] & 0x08) == 0) { + /* skip to the next dirac parse unit */ + u_pos += GetDWBE( p_oggpacket->packet + u_pos + 1 ); + /* protect against falling off the edge */ + if ( u_pos > p_oggpacket->bytes ) + return -1; } -#undef p_stream - /* Sanity check for streams where the granulepos of the header packets - * don't match these of the data packets (eg. ogg web radios). */ - if( p_ogg->i_old_pcr == 0 && p_ogg->i_pcr > 1000000 ) - p_input->stream.p_selected_program->i_synchro_state = SYNCHRO_REINIT; + uint32_t u_pnum = GetDWBE( p_oggpacket->packet + u_pos + 9 ); - /* Call the pace control */ - input_ClockManageRef( p_input, p_input->stream.p_selected_program, - p_ogg->i_pcr ); + return u_pnum; +} + +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 */ + {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; }