git.sesse.net Git - vlc/blob - modules/demux/ogg.c

   1 /*****************************************************************************
   2  * ogg.c : ogg stream demux module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2001-2007 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
   8  *          Andre Pang <Andre.Pang@csiro.au> (Annodex support)
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_plugin.h>
  34 #include <vlc_access.h>
  35 #include <vlc_demux.h>
  36 #include <vlc_meta.h>
  37 #include <vlc_input.h>
  38
  39 #include <ogg/ogg.h>
  40
  41 #include <vlc_codecs.h>
  42 #include <vlc_bits.h>
  43 #include "xiph.h"
  44 #include "xiph_metadata.h"
  45 #include "ogg.h"
  46 #include "oggseek.h"
  47
  48 /*****************************************************************************
  49  * Module descriptor
  50  *****************************************************************************/
  51 static int  Open ( vlc_object_t * );
  52 static void Close( vlc_object_t * );
  53
  54 vlc_module_begin ()
  55     set_shortname ( "OGG" )
  56     set_description( N_("OGG demuxer" ) )
  57     set_category( CAT_INPUT )
  58     set_subcategory( SUBCAT_INPUT_DEMUX )
  59     set_capability( "demux", 50 )
  60     set_callbacks( Open, Close )
  61     add_shortcut( "ogg" )
  62 vlc_module_end ()
  63
  64
  65 /*****************************************************************************
  66  * Definitions of structures and functions used by this plugins
  67  *****************************************************************************/
  68
  69 /* OggDS headers for the new header format (used in ogm files) */
  70 typedef struct
  71 {
  72     ogg_int32_t width;
  73     ogg_int32_t height;
  74 } stream_header_video_t;
  75
  76 typedef struct
  77 {
  78     ogg_int16_t channels;
  79     ogg_int16_t padding;
  80     ogg_int16_t blockalign;
  81     ogg_int32_t avgbytespersec;
  82 } stream_header_audio_t;
  83
  84 typedef struct
  85 {
  86     char        streamtype[8];
  87     char        subtype[4];
  88
  89     ogg_int32_t size;                               /* size of the structure */
  90
  91     ogg_int64_t time_unit;                              /* in reference time */
  92     ogg_int64_t samples_per_unit;
  93     ogg_int32_t default_len;                                /* in media time */
  94
  95     ogg_int32_t buffersize;
  96     ogg_int16_t bits_per_sample;
  97     ogg_int16_t padding;
  98
  99     union
 100     {
 101         /* Video specific */
 102         stream_header_video_t video;
 103         /* Audio specific */
 104         stream_header_audio_t audio;
 105     } sh;
 106 } stream_header_t;
 107
 108 /*****************************************************************************
 109  * Local prototypes
 110  *****************************************************************************/
 111 static int  Demux  ( demux_t * );
 112 static int  Control( demux_t *, int, va_list );
 113
 114 /* Bitstream manipulation */
 115 static int  Ogg_ReadPage     ( demux_t *, ogg_page * );
 116 static void Ogg_UpdatePCR    ( demux_t *, logical_stream_t *, ogg_packet * );
 117 static void Ogg_DecodePacket ( demux_t *, logical_stream_t *, ogg_packet * );
 118 static int  Ogg_OpusPacketDuration( logical_stream_t *, ogg_packet * );
 119
 120 static void Ogg_CreateES( demux_t *p_demux );
 121 static int Ogg_BeginningOfStream( demux_t *p_demux );
 122 static int Ogg_FindLogicalStreams( demux_t *p_demux );
 123 static void Ogg_EndOfStream( demux_t *p_demux );
 124
 125 /* */
 126 static void Ogg_LogicalStreamDelete( demux_t *p_demux, logical_stream_t *p_stream );
 127 static bool Ogg_LogicalStreamResetEsFormat( demux_t *p_demux, logical_stream_t *p_stream );
 128
 129 /* */
 130 static void Ogg_ExtractMeta( demux_t *p_demux, es_format_t *p_fmt, const uint8_t *p_headers, int i_headers );
 131
 132 /* Logical bitstream headers */
 133 static void Ogg_ReadTheoraHeader( logical_stream_t *, ogg_packet * );
 134 static void Ogg_ReadVorbisHeader( logical_stream_t *, ogg_packet * );
 135 static void Ogg_ReadSpeexHeader( logical_stream_t *, ogg_packet * );
 136 static void Ogg_ReadOpusHeader( logical_stream_t *, ogg_packet * );
 137 static void Ogg_ReadKateHeader( logical_stream_t *, ogg_packet * );
 138 static void Ogg_ReadFlacHeader( demux_t *, logical_stream_t *, ogg_packet * );
 139 static void Ogg_ReadAnnodexHeader( demux_t *, logical_stream_t *, ogg_packet * );
 140 static bool Ogg_ReadDiracHeader( logical_stream_t *, ogg_packet * );
 141 static bool Ogg_ReadVP8Header( demux_t *, logical_stream_t *, ogg_packet * );
 142 static void Ogg_ReadSkeletonHeader( demux_t *, logical_stream_t *, ogg_packet * );
 143
 144 /* Skeleton */
 145 static void Ogg_ReadSkeletonBones( demux_t *, ogg_packet * );
 146 static void Ogg_ReadSkeletonIndex( demux_t *, ogg_packet * );
 147 static void Ogg_FreeSkeleton( ogg_skeleton_t * );
 148 static void Ogg_ApplySkeleton( logical_stream_t * );
 149
 150 static void fill_channels_info(audio_format_t *audio)
 151 {
 152     static const int pi_channels_map[9] =
 153     {
 154         0,
 155         AOUT_CHAN_CENTER,
 156         AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
 157         AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
 158         AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
 159             | AOUT_CHAN_REARRIGHT,
 160         AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 161             | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
 162         AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 163             | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE,
 164         AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 165             | AOUT_CHAN_REARCENTER | AOUT_CHAN_MIDDLELEFT
 166             | AOUT_CHAN_MIDDLERIGHT | AOUT_CHAN_LFE,
 167         AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER | AOUT_CHAN_REARLEFT
 168             | AOUT_CHAN_REARRIGHT | AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT
 169             | AOUT_CHAN_LFE,
 170     };
 171
 172     unsigned chans = audio->i_channels;
 173     if (chans < sizeof(pi_channels_map) / sizeof(pi_channels_map[0]))
 174         audio->i_physical_channels =
 175         audio->i_original_channels = pi_channels_map[chans];
 176 }
 177
 178 /* Special TS value: don't send or derive any pts/pcr from it.
 179    Represents TS state prior first known valid timestamp */
 180 #define VLC_TS_UNKNOWN (VLC_TS_INVALID - 1)
 181
 182 /*****************************************************************************
 183  * Open: initializes ogg demux structures
 184  *****************************************************************************/
 185 static int Open( vlc_object_t * p_this )
 186 {
 187     demux_t *p_demux = (demux_t *)p_this;
 188     demux_sys_t    *p_sys;
 189     const uint8_t  *p_peek;
 190
 191     /* Check if we are dealing with an ogg stream */
 192     if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) return VLC_EGENERIC;
 193     if( !p_demux->b_force && memcmp( p_peek, "OggS", 4 ) )
 194     {
 195         return VLC_EGENERIC;
 196     }
 197
 198     /* */
 199     p_demux->p_sys = p_sys = calloc( 1, sizeof( demux_sys_t ) );
 200     if( !p_sys )
 201         return VLC_ENOMEM;
 202
 203     p_sys->i_length = -1;
 204     p_sys->b_preparsing_done = false;
 205
 206     stream_Control( p_demux->s, ACCESS_GET_PTS_DELAY, & p_sys->i_access_delay );
 207
 208     /* Set exported functions */
 209     p_demux->pf_demux = Demux;
 210     p_demux->pf_control = Control;
 211
 212     /* Initialize the Ogg physical bitstream parser */
 213     ogg_sync_init( &p_sys->oy );
 214
 215     /* */
 216     TAB_INIT( p_sys->i_seekpoints, p_sys->pp_seekpoints );
 217
 218
 219     while ( !p_sys->b_preparsing_done && p_demux->pf_demux( p_demux ) > 0 )
 220     {}
 221
 222     return VLC_SUCCESS;
 223 }
 224
 225 /*****************************************************************************
 226  * Close: frees unused data
 227  *****************************************************************************/
 228 static void Close( vlc_object_t *p_this )
 229 {
 230     demux_t *p_demux = (demux_t *)p_this;
 231     demux_sys_t *p_sys = p_demux->p_sys  ;
 232
 233     /* Cleanup the bitstream parser */
 234     ogg_sync_clear( &p_sys->oy );
 235
 236     Ogg_EndOfStream( p_demux );
 237
 238     if( p_sys->p_old_stream )
 239         Ogg_LogicalStreamDelete( p_demux, p_sys->p_old_stream );
 240
 241     free( p_sys );
 242 }
 243
 244 /*****************************************************************************
 245  * Demux: reads and demuxes data packets
 246  *****************************************************************************
 247  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
 248  *****************************************************************************/
 249 static int Demux( demux_t * p_demux )
 250 {
 251     demux_sys_t *p_sys = p_demux->p_sys;
 252     ogg_packet  oggpacket;
 253     int         i_stream;
 254     bool b_skipping = false;
 255     bool b_canseek;
 256
 257     int i_active_streams = p_sys->i_streams;
 258     for ( int i=0; i < p_sys->i_streams; i++ )
 259     {
 260         if ( p_sys->pp_stream[i]->b_finished )
 261             i_active_streams--;
 262     }
 263
 264     if ( i_active_streams == 0 )
 265     {
 266         if ( p_sys->i_streams ) /* All finished */
 267         {
 268             msg_Dbg( p_demux, "end of a group of logical streams" );
 269             /* We keep the ES to try reusing it in Ogg_BeginningOfStream
 270              * only 1 ES is supported (common case for ogg web radio) */
 271             if( p_sys->i_streams == 1 )
 272             {
 273                 p_sys->p_old_stream = p_sys->pp_stream[0];
 274                 TAB_CLEAN( p_sys->i_streams, p_sys->pp_stream );
 275             }
 276             Ogg_EndOfStream( p_demux );
 277             p_sys->b_chained_boundary = true;
 278         }
 279
 280         if( Ogg_BeginningOfStream( p_demux ) != VLC_SUCCESS )
 281             return 0;
 282
 283         msg_Dbg( p_demux, "beginning of a group of logical streams" );
 284
 285         if ( !p_sys->b_chained_boundary )
 286         {
 287             /* Find the real duration */
 288             stream_Control( p_demux->s, STREAM_CAN_SEEK, &b_canseek );
 289             if ( b_canseek )
 290                 Oggseek_ProbeEnd( p_demux );
 291         }
 292         else
 293         {
 294             p_sys->b_chained_boundary = false;
 295         }
 296     }
 297
 298     if ( p_sys->b_preparsing_done && !p_sys->b_es_created )
 299     {
 300         Ogg_CreateES( p_demux );
 301         p_sys->b_es_created = true;
 302     }
 303
 304     /*
 305      * The first data page of a physical stream is stored in the relevant logical stream
 306      * in Ogg_FindLogicalStreams. Therefore, we must not read a page and only update the
 307      * stream it belongs to if we haven't processed this first page yet. If we do, we
 308      * will only process that first page whenever we find the second page for this stream.
 309      * While this is fine for Vorbis and Theora, which are continuous codecs, which means
 310      * the second page will arrive real quick, this is not fine for Kate, whose second
 311      * data page will typically arrive much later.
 312      * This means it is now possible to seek right at the start of a stream where the last
 313      * logical stream is Kate, without having to wait for the second data page to unblock
 314      * the first one, which is the one that triggers the 'no more headers to backup' code.
 315      * And, as we all know, seeking without having backed up all headers is bad, since the
 316      * codec will fail to initialize if it's missing its headers.
 317      */
 318     if( !p_sys->b_page_waiting)
 319     {
 320         /*
 321          * Demux an ogg page from the stream
 322          */
 323         if( Ogg_ReadPage( p_demux, &p_sys->current_page ) != VLC_SUCCESS )
 324             return 0; /* EOF */
 325         /* Test for End of Stream */
 326         if( ogg_page_eos( &p_sys->current_page ) )
 327         {
 328             /* If we delayed restarting encoders/SET_ES_FMT for more
 329              * skeleton provided configuration */
 330             if ( p_sys->p_skelstream )
 331             {
 332                 if ( p_sys->p_skelstream->i_serial_no == ogg_page_serialno(&p_sys->current_page) )
 333                 {
 334                     msg_Dbg( p_demux, "End of Skeleton" );
 335                     p_sys->b_preparsing_done = true;
 336                     for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
 337                     {
 338                         logical_stream_t *p_stream = p_sys->pp_stream[i_stream];
 339                         Ogg_ApplySkeleton( p_stream );
 340                     }
 341                 }
 342             }
 343
 344             for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
 345             {
 346                 if ( p_sys->pp_stream[i_stream]->i_serial_no == ogg_page_serialno( &p_sys->current_page ) )
 347                 {
 348                     p_sys->pp_stream[i_stream]->b_finished = true;
 349                     break;
 350                 }
 351             }
 352         }
 353     }
 354
 355     b_skipping = false;
 356     for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
 357     {
 358         b_skipping |= p_sys->pp_stream[i_stream]->i_skip_frames;
 359     }
 360
 361     for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
 362     {
 363         logical_stream_t *p_stream = p_sys->pp_stream[i_stream];
 364
 365         /* if we've just pulled page, look for the right logical stream */
 366         if( !p_sys->b_page_waiting )
 367         {
 368             if( p_sys->i_streams == 1 &&
 369                 ogg_page_serialno( &p_sys->current_page ) != p_stream->os.serialno )
 370             {
 371                 msg_Err( p_demux, "Broken Ogg stream (serialno) mismatch" );
 372                 ogg_stream_reset_serialno( &p_stream->os, ogg_page_serialno( &p_sys->current_page ) );
 373
 374                 p_stream->b_reinit = true;
 375                 p_stream->i_pcr = VLC_TS_UNKNOWN;
 376                 p_stream->i_interpolated_pcr = VLC_TS_UNKNOWN;
 377                 p_stream->i_previous_granulepos = -1;
 378                 es_out_Control( p_demux->out, ES_OUT_SET_PCR, VLC_TS_0);
 379             }
 380
 381             /* Does fail if serialno differs */
 382             if( ogg_stream_pagein( &p_stream->os, &p_sys->current_page ) != 0 )
 383             {
 384                 continue;
 385             }
 386
 387         }
 388
 389         /* clear the finished flag if pages after eos (ex: after a seek) */
 390         if ( ! ogg_page_eos( &p_sys->current_page ) ) p_stream->b_finished = false;
 391
 392         DemuxDebug(
 393             if ( p_stream->fmt.i_cat == VIDEO_ES )
 394                 msg_Dbg(p_demux, "DEMUX READ pageno %ld g%"PRId64" (%d packets) cont %d %ld bytes",
 395                     ogg_page_pageno( &p_sys->current_page ),
 396                     ogg_page_granulepos( &p_sys->current_page ),
 397                     ogg_page_packets( &p_sys->current_page ),
 398                     ogg_page_continued(&p_sys->current_page),
 399                     p_sys->current_page.body_len )
 400         );
 401
 402         while( ogg_stream_packetout( &p_stream->os, &oggpacket ) > 0 )
 403         {
 404             /* Read info from any secondary header packets, if there are any */
 405             if( p_stream->i_secondary_header_packets > 0 )
 406             {
 407                 if( p_stream->fmt.i_codec == VLC_CODEC_THEORA &&
 408                         oggpacket.bytes >= 7 &&
 409                         ! memcmp( oggpacket.packet, "\x80theora", 7 ) )
 410                 {
 411                     Ogg_ReadTheoraHeader( p_stream, &oggpacket );
 412                     p_stream->i_secondary_header_packets = 0;
 413                 }
 414                 else if( p_stream->fmt.i_codec == VLC_CODEC_VORBIS &&
 415                         oggpacket.bytes >= 7 &&
 416                         ! memcmp( oggpacket.packet, "\x01vorbis", 7 ) )
 417                 {
 418                     Ogg_ReadVorbisHeader( p_stream, &oggpacket );
 419                     p_stream->i_secondary_header_packets = 0;
 420                 }
 421                 else if( p_stream->fmt.i_codec == VLC_CODEC_CMML )
 422                 {
 423                     p_stream->i_secondary_header_packets = 0;
 424                 }
 425
 426                 /* update start of data pointer */
 427                 p_stream->i_data_start = stream_Tell( p_demux->s );
 428             }
 429
 430             /* If any streams have i_skip_frames, only decode (pre-roll)
 431              *  for those streams, but don't skip headers */
 432             if ( b_skipping && p_stream->i_skip_frames == 0
 433                  && p_stream->i_secondary_header_packets ) continue;
 434
 435             if( p_stream->b_reinit )
 436             {
 437                 if ( Oggseek_PacketPCRFixup( p_stream, &p_sys->current_page,
 438                                          &oggpacket ) )
 439                 {
 440                     DemuxDebug( msg_Dbg( p_demux, "PCR fixup for %"PRId64,
 441                              ogg_page_granulepos( &p_sys->current_page ) ) );
 442                 }
 443                 else
 444                 {
 445                     /* If synchro is re-initialized we need to drop all the packets
 446                          * until we find a new dated one. */
 447                     Ogg_UpdatePCR( p_demux, p_stream, &oggpacket );
 448                 }
 449
 450                 if( p_stream->i_pcr >= 0 )
 451                 {
 452                     p_stream->b_reinit = false;
 453                     /* For Opus, trash the first 80 ms of decoded output as
 454                        well, to avoid blowing out speakers if we get unlucky.
 455                        Opus predicts content from prior frames, which can go
 456                        badly if we seek right where the stream goes from very
 457                        quiet to very loud. It will converge after a bit. */
 458                     if( p_stream->fmt.i_codec == VLC_CODEC_OPUS )
 459                     {
 460                         ogg_int64_t start_time;
 461                         int duration;
 462                         p_stream->i_skip_frames = 80*48;
 463                         /* Make sure we never play audio from within the
 464                            pre-skip at the beginning of the stream. */
 465                         duration =
 466                             Ogg_OpusPacketDuration( p_stream, &oggpacket );
 467                         start_time = p_stream->i_previous_granulepos;
 468                         if( duration > 0 )
 469                         {
 470                             start_time = start_time > duration ?
 471                                 start_time - duration : 0;
 472                         }
 473                         if( p_stream->i_pre_skip > start_time )
 474                         {
 475                             p_stream->i_skip_frames +=
 476                                 p_stream->i_pre_skip - start_time;
 477                         }
 478                     }
 479                 }
 480                 else
 481                 {
 482                     DemuxDebug(
 483                         msg_Dbg(p_demux, "DEMUX DROPS PACKET (? / %d) pageno %ld granule %"PRId64,
 484                             ogg_page_packets( &p_sys->current_page ),
 485                             ogg_page_pageno( &p_sys->current_page ), oggpacket.granulepos );
 486                     );
 487
 488                     p_stream->i_interpolated_pcr = -1;
 489                     p_stream->i_previous_granulepos = -1;
 490                     continue;
 491                 }
 492
 493                 /* An Ogg/vorbis packet contains an end date granulepos */
 494                 if( p_stream->fmt.i_codec == VLC_CODEC_VORBIS ||
 495                     p_stream->fmt.i_codec == VLC_CODEC_SPEEX ||
 496                     p_stream->fmt.i_codec == VLC_CODEC_OPUS ||
 497                     p_stream->fmt.i_codec == VLC_CODEC_VP8 ||
 498                     p_stream->fmt.i_codec == VLC_CODEC_FLAC )
 499                 {
 500                     if( ogg_stream_packetout( &p_stream->os, &oggpacket ) > 0 )
 501                     {
 502                         Ogg_DecodePacket( p_demux, p_stream, &oggpacket );
 503                     }
 504                     else
 505                     {
 506                         es_out_Control( p_demux->out, ES_OUT_SET_PCR,
 507                                         VLC_TS_0 + p_stream->i_pcr );
 508                     }
 509                     continue;
 510                 }
 511             }
 512
 513             DemuxDebug( if ( p_sys->b_seeked )
 514             {
 515                 if ( Ogg_IsKeyFrame( p_stream, &oggpacket ) )
 516                      msg_Dbg(p_demux, "** DEMUX ON KEYFRAME **" );
 517
 518                 ogg_int64_t iframe = ogg_page_granulepos( &p_sys->current_page ) >> p_stream->i_granule_shift;
 519                 ogg_int64_t pframe = ogg_page_granulepos( &p_sys->current_page ) - ( iframe << p_stream->i_granule_shift );
 520
 521                 msg_Dbg(p_demux, "DEMUX PACKET (size %d) IS at iframe %"PRId64" pageno %ld pframe %"PRId64" OFFSET %"PRId64" PACKET NO %"PRId64" skipleft=%d",
 522                         ogg_page_packets( &p_sys->current_page ),
 523                         iframe, ogg_page_pageno( &p_sys->current_page ), pframe, p_sys->i_input_position, oggpacket.packetno, p_stream->i_skip_frames );
 524             })
 525
 526             Ogg_DecodePacket( p_demux, p_stream, &oggpacket );
 527         }
 528
 529         DemuxDebug( p_sys->b_seeked = false; )
 530
 531         if( !p_sys->b_page_waiting )
 532             break;
 533     }
 534
 535     /* if a page was waiting, it's now processed */
 536     p_sys->b_page_waiting = false;
 537
 538     if ( p_sys->p_skelstream && !p_sys->p_skelstream->b_finished )
 539         p_sys->b_preparsing_done = false;
 540     else
 541         p_sys->b_preparsing_done = true;
 542
 543     /* We will consider the lowest PCR among tracks, because the audio core badly
 544      * handles PCR rewind (mute)
 545      */
 546     mtime_t i_pcr_candidate = VLC_TS_INVALID;
 547     for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
 548     {
 549         logical_stream_t *p_stream = p_sys->pp_stream[i_stream];
 550
 551         if ( p_sys->b_preparsing_done && p_stream->b_initializing )
 552         {
 553             /* We have 1 or more streams needing more than 1 page for preparsing */
 554             p_sys->b_preparsing_done = false;
 555         }
 556
 557         if( p_stream->fmt.i_cat == SPU_ES )
 558             continue;
 559         if( p_stream->i_interpolated_pcr < VLC_TS_0 )
 560             continue;
 561         if ( p_stream->b_finished || p_stream->b_initializing )
 562             continue;
 563
 564         if( i_pcr_candidate < VLC_TS_0
 565             || p_stream->i_interpolated_pcr <= i_pcr_candidate )
 566         {
 567             i_pcr_candidate = p_stream->i_interpolated_pcr;
 568         }
 569     }
 570
 571     if ( i_pcr_candidate > VLC_TS_INVALID && p_sys->i_pcr != i_pcr_candidate )
 572     {
 573         if ( p_sys->i_streams == 1 && p_sys->i_access_delay )
 574         {
 575             int64_t i_pcr_jitter = i_pcr_candidate - p_sys->i_pcr;
 576             if ( i_pcr_jitter > p_sys->i_pcr_jitter )
 577             {
 578                 p_sys->i_pcr_jitter = i_pcr_jitter;
 579                 if ( p_sys->i_access_delay < i_pcr_jitter )
 580                     msg_Warn( p_demux, "Consider increasing access caching variable from %"PRId64" to >%"PRId64,
 581                               p_sys->i_access_delay / 1000, i_pcr_jitter / 1000 );
 582             }
 583         }
 584         p_sys->i_pcr = i_pcr_candidate;
 585         if( ! b_skipping )
 586             es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_pcr );
 587     }
 588
 589     return 1;
 590 }
 591
 592 static void Ogg_ResetStreamHelper( demux_sys_t *p_sys )
 593 {
 594     for( int i = 0; i < p_sys->i_streams; i++ )
 595     {
 596         logical_stream_t *p_stream = p_sys->pp_stream[i];
 597
 598         /* we'll trash all the data until we find the next pcr */
 599         p_stream->b_reinit = true;
 600         p_stream->i_pcr = VLC_TS_UNKNOWN;
 601         p_stream->i_interpolated_pcr = VLC_TS_UNKNOWN;
 602         p_stream->i_previous_granulepos = -1;
 603         ogg_stream_reset( &p_stream->os );
 604     }
 605     ogg_sync_reset( &p_sys->oy );
 606 }
 607
 608 static logical_stream_t * Ogg_GetSelectedStream( demux_t *p_demux )
 609 {
 610     demux_sys_t *p_sys = p_demux->p_sys;
 611     logical_stream_t *p_stream = NULL;
 612     for( int i=0; i<p_sys->i_streams; i++ )
 613     {
 614         logical_stream_t *p_candidate = p_sys->pp_stream[i];
 615         if ( !p_candidate->p_es ) continue;
 616
 617         bool b_selected = false;
 618         es_out_Control( p_demux->out, ES_OUT_GET_ES_STATE,
 619                         p_candidate->p_es, &b_selected );
 620         if ( !b_selected ) continue;
 621
 622         if ( !p_stream && p_candidate->fmt.i_cat == AUDIO_ES )
 623         {
 624             p_stream = p_candidate;
 625             continue; /* Try to find video anyway */
 626         }
 627
 628         if ( p_candidate->fmt.i_cat == VIDEO_ES )
 629         {
 630             p_stream = p_candidate;
 631             break;
 632         }
 633     }
 634     return p_stream;
 635 }
 636
 637 /*****************************************************************************
 638  * Control:
 639  *****************************************************************************/
 640 static int Control( demux_t *p_demux, int i_query, va_list args )
 641 {
 642     demux_sys_t *p_sys  = p_demux->p_sys;
 643     vlc_meta_t *p_meta;
 644     int64_t *pi64, i64;
 645     double *pf, f;
 646     bool *pb_bool, b;
 647
 648     switch( i_query )
 649     {
 650         case DEMUX_GET_META:
 651             p_meta = (vlc_meta_t *)va_arg( args, vlc_meta_t* );
 652             if( p_sys->p_meta )
 653                 vlc_meta_Merge( p_meta, p_sys->p_meta );
 654             return VLC_SUCCESS;
 655
 656         case DEMUX_HAS_UNSUPPORTED_META:
 657             pb_bool = (bool*)va_arg( args, bool* );
 658             *pb_bool = true;
 659             return VLC_SUCCESS;
 660
 661         case DEMUX_GET_TIME:
 662             pi64 = (int64_t*)va_arg( args, int64_t * );
 663             *pi64 = p_sys->i_pcr;
 664             return VLC_SUCCESS;
 665
 666         case DEMUX_SET_TIME:
 667             i64 = (int64_t)va_arg( args, int64_t );
 668             logical_stream_t *p_stream = Ogg_GetSelectedStream( p_demux );
 669             if ( !p_stream )
 670             {
 671                 msg_Err( p_demux, "No selected seekable stream found" );
 672                 return VLC_EGENERIC;
 673             }
 674             stream_Control( p_demux->s, STREAM_CAN_FASTSEEK, &b );
 675             if ( Oggseek_BlindSeektoAbsoluteTime( p_demux, p_stream, i64, b ) )
 676             {
 677                 Ogg_ResetStreamHelper( p_sys );
 678                 es_out_Control( p_demux->out, ES_OUT_SET_NEXT_DISPLAY_TIME,
 679                                 VLC_TS_0 + i64 );
 680                 return VLC_SUCCESS;
 681             }
 682             else
 683                 return VLC_EGENERIC;
 684
 685         case DEMUX_GET_ATTACHMENTS:
 686         {
 687             input_attachment_t ***ppp_attach =
 688                 (input_attachment_t***)va_arg( args, input_attachment_t*** );
 689             int *pi_int = (int*)va_arg( args, int * );
 690
 691             if( p_sys->i_attachments <= 0 )
 692                 return VLC_EGENERIC;
 693
 694             *pi_int = p_sys->i_attachments;
 695             *ppp_attach = xmalloc( sizeof(input_attachment_t*) * p_sys->i_attachments );
 696             for( int i = 0; i < p_sys->i_attachments; i++ )
 697                 (*ppp_attach)[i] = vlc_input_attachment_Duplicate( p_sys->attachments[i] );
 698             return VLC_SUCCESS;
 699         }
 700
 701         case DEMUX_GET_POSITION:
 702             pf = (double*)va_arg( args, double * );
 703             if( p_sys->i_length > 0 )
 704             {
 705                 *pf =  (double) p_sys->i_pcr /
 706                        (double) ( p_sys->i_length * (mtime_t)1000000 );
 707             }
 708             else if( stream_Size( p_demux->s ) > 0 )
 709             {
 710                 i64 = stream_Tell( p_demux->s );
 711                 *pf = (double) i64 / stream_Size( p_demux->s );
 712             }
 713             else *pf = 0.0;
 714             return VLC_SUCCESS;
 715
 716         case DEMUX_SET_POSITION:
 717             /* forbid seeking if we haven't initialized all logical bitstreams yet;
 718                if we allowed, some headers would not get backed up and decoder init
 719                would fail, making that logical stream unusable */
 720             for ( int i=0; i< p_sys->i_streams; i++ )
 721             {
 722                 if ( p_sys->pp_stream[i]->b_initializing )
 723                     return VLC_EGENERIC;
 724             }
 725
 726             p_stream = Ogg_GetSelectedStream( p_demux );
 727             if ( !p_stream )
 728             {
 729                 msg_Err( p_demux, "No selected seekable stream found" );
 730                 return VLC_EGENERIC;
 731             }
 732
 733             stream_Control( p_demux->s, STREAM_CAN_FASTSEEK, &b );
 734
 735             f = (double)va_arg( args, double );
 736             if ( p_sys->i_length <= 0 || !b /* || ! ACCESS_CAN_FASTSEEK */ )
 737             {
 738                 Ogg_ResetStreamHelper( p_sys );
 739                 Oggseek_BlindSeektoPosition( p_demux, p_stream, f, b );
 740                 return VLC_SUCCESS;
 741             }
 742
 743             assert( p_sys->i_length > 0 );
 744             i64 = CLOCK_FREQ * p_sys->i_length * f;
 745             Ogg_ResetStreamHelper( p_sys );
 746             if ( Oggseek_SeektoAbsolutetime( p_demux, p_stream, i64 ) >= 0 )
 747             {
 748                 es_out_Control( p_demux->out, ES_OUT_SET_NEXT_DISPLAY_TIME,
 749                                 VLC_TS_0 + i64 );
 750                 return VLC_SUCCESS;
 751             }
 752
 753             return VLC_EGENERIC;
 754
 755         case DEMUX_GET_LENGTH:
 756             if ( p_sys->i_length < 0 )
 757                 return demux_vaControlHelper( p_demux->s, 0, -1, p_sys->i_bitrate,
 758                                               1, i_query, args );
 759             pi64 = (int64_t*)va_arg( args, int64_t * );
 760             *pi64 = p_sys->i_length * 1000000;
 761             return VLC_SUCCESS;
 762
 763         case DEMUX_GET_TITLE_INFO:
 764         {
 765             input_title_t ***ppp_title = (input_title_t***)va_arg( args, input_title_t*** );
 766             int *pi_int    = (int*)va_arg( args, int* );
 767             int *pi_title_offset = (int*)va_arg( args, int* );
 768             int *pi_seekpoint_offset = (int*)va_arg( args, int* );
 769
 770             if( p_sys->i_seekpoints > 0 )
 771             {
 772                 *pi_int = 1;
 773                 *ppp_title = malloc( sizeof( input_title_t* ) );
 774                 input_title_t *p_title = (*ppp_title)[0] = vlc_input_title_New();
 775                 for( int i = 0; i < p_sys->i_seekpoints; i++ )
 776                 {
 777                     seekpoint_t *p_seekpoint_copy = vlc_seekpoint_Duplicate( p_sys->pp_seekpoints[i] );
 778                     if ( likely( p_seekpoint_copy ) )
 779                         TAB_APPEND( p_title->i_seekpoint, p_title->seekpoint, p_seekpoint_copy );
 780                 }
 781                 *pi_title_offset = 0;
 782                 *pi_seekpoint_offset = 0;
 783             }
 784             return VLC_SUCCESS;
 785         }
 786         case DEMUX_SET_TITLE:
 787         {
 788             const int i_title = (int)va_arg( args, int );
 789             if( i_title > 1 )
 790                 return VLC_EGENERIC;
 791             return VLC_SUCCESS;
 792         }
 793         case DEMUX_SET_SEEKPOINT:
 794         {
 795             const int i_seekpoint = (int)va_arg( args, int );
 796             if( i_seekpoint > p_sys->i_seekpoints )
 797                 return VLC_EGENERIC;
 798
 799             for ( int i=0; i< p_sys->i_streams; i++ )
 800             {
 801                 if ( p_sys->pp_stream[i]->b_initializing )
 802                     return VLC_EGENERIC;
 803             }
 804
 805             i64 = p_sys->pp_seekpoints[i_seekpoint]->i_time_offset;
 806
 807             p_stream = Ogg_GetSelectedStream( p_demux );
 808             if ( !p_stream )
 809             {
 810                 msg_Err( p_demux, "No selected seekable stream found" );
 811                 return VLC_EGENERIC;
 812             }
 813
 814             stream_Control( p_demux->s, STREAM_CAN_FASTSEEK, &b );
 815             if ( Oggseek_BlindSeektoAbsoluteTime( p_demux, p_stream, i64, b ) )
 816             {
 817                 Ogg_ResetStreamHelper( p_sys );
 818                 es_out_Control( p_demux->out, ES_OUT_SET_NEXT_DISPLAY_TIME,
 819                                 VLC_TS_0 + i64 );
 820                 p_demux->info.i_update |= INPUT_UPDATE_SEEKPOINT;
 821                 p_demux->info.i_seekpoint = i_seekpoint;
 822                 return VLC_SUCCESS;
 823             }
 824             else
 825                 return VLC_EGENERIC;
 826         }
 827
 828         default:
 829             return demux_vaControlHelper( p_demux->s, 0, -1, p_sys->i_bitrate,
 830                                            1, i_query, args );
 831     }
 832 }
 833
 834 /****************************************************************************
 835  * Ogg_ReadPage: Read a full Ogg page from the physical bitstream.
 836  ****************************************************************************
 837  * Returns VLC_SUCCESS if a page has been read. An error might happen if we
 838  * are at the end of stream.
 839  ****************************************************************************/
 840 static int Ogg_ReadPage( demux_t *p_demux, ogg_page *p_oggpage )
 841 {
 842     demux_sys_t *p_ogg = p_demux->p_sys  ;
 843     int i_read = 0;
 844     char *p_buffer;
 845
 846     while( ogg_sync_pageout( &p_ogg->oy, p_oggpage ) != 1 )
 847     {
 848         p_buffer = ogg_sync_buffer( &p_ogg->oy, OGGSEEK_BYTES_TO_READ );
 849
 850         i_read = stream_Read( p_demux->s, p_buffer, OGGSEEK_BYTES_TO_READ );
 851         if( i_read <= 0 )
 852             return VLC_EGENERIC;
 853
 854         ogg_sync_wrote( &p_ogg->oy, i_read );
 855     }
 856
 857     return VLC_SUCCESS;
 858 }
 859
 860 /****************************************************************************
 861  * Ogg_UpdatePCR: update the PCR (90kHz program clock reference) for the
 862  *                current stream.
 863  ****************************************************************************/
 864 static void Ogg_UpdatePCR( demux_t *p_demux, logical_stream_t *p_stream,
 865                            ogg_packet *p_oggpacket )
 866 {
 867     demux_sys_t *p_ogg = p_demux->p_sys;
 868     p_stream->i_end_trim = 0;
 869
 870     /* Convert the granulepos into a pcr */
 871     if ( p_oggpacket->granulepos == 0 )
 872     {
 873         /* We're in headers, and we haven't parsed 1st data packet yet */
 874         p_stream->i_pcr = VLC_TS_UNKNOWN;
 875         p_stream->i_interpolated_pcr = VLC_TS_UNKNOWN;
 876     }
 877     else if( p_oggpacket->granulepos > 0 )
 878     {
 879         if( p_stream->fmt.i_codec == VLC_CODEC_THEORA ||
 880             p_stream->fmt.i_codec == VLC_CODEC_KATE ||
 881             p_stream->fmt.i_codec == VLC_CODEC_VP8 ||
 882             p_stream->fmt.i_codec == VLC_CODEC_DIRAC )
 883         {
 884             p_stream->i_pcr = Oggseek_GranuleToAbsTimestamp( p_stream,
 885                                                 p_oggpacket->granulepos, true );
 886         }
 887         else
 888         {
 889             ogg_int64_t sample;
 890             sample = p_oggpacket->granulepos;
 891             if( p_oggpacket->e_o_s &&
 892                 p_stream->fmt.i_codec == VLC_CODEC_OPUS &&
 893                 p_stream->i_previous_granulepos >= 0 )
 894             {
 895                 int duration;
 896                 duration = Ogg_OpusPacketDuration( p_stream, p_oggpacket );
 897                 if( duration > 0 )
 898                 {
 899                     ogg_int64_t end_sample;
 900                     end_sample = p_stream->i_previous_granulepos + duration;
 901                     if( end_sample > sample )
 902                         p_stream->i_end_trim = (int)(end_sample - sample);
 903                 }
 904             }
 905             if (sample >= p_stream->i_pre_skip)
 906                 sample -= p_stream->i_pre_skip;
 907             else
 908                 sample = 0;
 909             p_stream->i_pcr = sample * CLOCK_FREQ / p_stream->f_rate;
 910         }
 911
 912         if ( !p_ogg->i_pcr_offset )
 913             p_stream->i_pcr += VLC_TS_0;
 914         else
 915             p_stream->i_pcr += p_ogg->i_pcr_offset;
 916         p_stream->i_interpolated_pcr = p_stream->i_pcr;
 917     }
 918     else
 919     {
 920         int duration;
 921         p_stream->i_pcr = VLC_TS_INVALID;
 922
 923         /* no granulepos available, try to interpolate the pcr.
 924          * If we can't then don't touch the old value. */
 925         if( p_stream->fmt.i_cat == VIDEO_ES )
 926             /* 1 frame per packet */
 927             p_stream->i_interpolated_pcr += (CLOCK_FREQ / p_stream->f_rate);
 928         else if( p_stream->fmt.i_codec == VLC_CODEC_OPUS &&
 929                  p_stream->i_previous_granulepos > 0 &&
 930                  ( duration =
 931                      Ogg_OpusPacketDuration( p_stream, p_oggpacket ) ) > 0 )
 932         {
 933             ogg_int64_t sample;
 934             p_oggpacket->granulepos =
 935                 p_stream->i_previous_granulepos + duration;
 936             sample = p_oggpacket->granulepos;
 937             if (sample >= p_stream->i_pre_skip)
 938                 sample -= p_stream->i_pre_skip;
 939             else
 940                 sample = 0;
 941             p_stream->i_interpolated_pcr =
 942                 VLC_TS_0 + sample * CLOCK_FREQ / p_stream->f_rate;
 943             p_stream->i_interpolated_pcr += p_ogg->i_pcr_offset;
 944         }
 945         else if( p_stream->fmt.i_bitrate && p_stream->i_pcr > VLC_TS_UNKNOWN )
 946         {
 947             p_stream->i_interpolated_pcr +=
 948                 ( p_oggpacket->bytes * CLOCK_FREQ /
 949                   p_stream->fmt.i_bitrate / 8 );
 950             p_stream->i_interpolated_pcr += p_ogg->i_pcr_offset;
 951         }
 952     }
 953     p_stream->i_previous_granulepos = p_oggpacket->granulepos;
 954 }
 955
 956 /****************************************************************************
 957  * Ogg_DecodePacket: Decode an Ogg packet.
 958  ****************************************************************************/
 959 static void Ogg_DecodePacket( demux_t *p_demux,
 960                               logical_stream_t *p_stream,
 961                               ogg_packet *p_oggpacket )
 962 {
 963     block_t *p_block;
 964     bool b_selected;
 965     int i_header_len = 0;
 966     mtime_t i_pts = VLC_TS_UNKNOWN;
 967     demux_sys_t *p_ogg = p_demux->p_sys;
 968
 969     if( p_oggpacket->bytes >= 7 &&
 970         ! memcmp ( p_oggpacket->packet, "Annodex", 7 ) )
 971     {
 972         /* it's an Annodex packet -- skip it (do nothing) */
 973         return;
 974     }
 975     else if( p_oggpacket->bytes >= 7 &&
 976         ! memcmp ( p_oggpacket->packet, "AnxData", 7 ) )
 977     {
 978         /* it's an AnxData packet -- skip it (do nothing) */
 979         return;
 980     }
 981     else if( p_oggpacket->bytes >= 8 &&
 982         ! memcmp ( p_oggpacket->packet, "fisbone", 8 ) )
 983     {
 984         Ogg_ReadSkeletonBones( p_demux, p_oggpacket );
 985         return;
 986     }
 987     else if( p_oggpacket->bytes >= 6 &&
 988         ! memcmp ( p_oggpacket->packet, "index", 6 ) )
 989     {
 990         Ogg_ReadSkeletonIndex( p_demux, p_oggpacket );
 991         return;
 992     }
 993     else if( p_stream->fmt.i_codec == VLC_CODEC_VP8 &&
 994              p_oggpacket->bytes >= 7 &&
 995              !memcmp( p_oggpacket->packet, "OVP80\x02\x20", 7 ) )
 996     {
 997         Ogg_ReadVP8Header( p_demux, p_stream, p_oggpacket );
 998         return;
 999     }
1000
1001     if( p_stream->fmt.i_codec == VLC_CODEC_SUBT && p_oggpacket->bytes > 0 &&
1002         p_oggpacket->packet[0] & PACKET_TYPE_BITS ) return;
1003
1004     /* Check the ES is selected */
1005     if ( !p_stream->p_es )
1006         b_selected = true;
1007     else
1008         es_out_Control( p_demux->out, ES_OUT_GET_ES_STATE,
1009                         p_stream->p_es, &b_selected );
1010
1011     if( p_stream->b_force_backup )
1012     {
1013         bool b_xiph;
1014         p_stream->i_packets_backup++;
1015         switch( p_stream->fmt.i_codec )
1016         {
1017         case VLC_CODEC_VORBIS:
1018         case VLC_CODEC_THEORA:
1019             if( p_stream->i_packets_backup == 3 )
1020                 p_stream->b_force_backup = false;
1021             b_xiph = true;
1022             break;
1023
1024         case VLC_CODEC_SPEEX:
1025             if( p_stream->i_packets_backup == 2 + p_stream->i_extra_headers_packets )
1026                 p_stream->b_force_backup = false;
1027             b_xiph = true;
1028             break;
1029
1030         case VLC_CODEC_OPUS:
1031             if( p_stream->i_packets_backup == 2 )
1032                 p_stream->b_force_backup = false;
1033             b_xiph = true;
1034             break;
1035
1036         case VLC_CODEC_FLAC:
1037             if( !p_stream->fmt.audio.i_rate && p_stream->i_packets_backup == 2 )
1038             {
1039                 Ogg_ReadFlacHeader( p_demux, p_stream, p_oggpacket );
1040                 p_stream->b_force_backup = false;
1041             }
1042             else if( p_stream->fmt.audio.i_rate )
1043             {
1044                 p_stream->b_force_backup = false;
1045                 if( p_oggpacket->bytes >= 9 )
1046                 {
1047                     p_oggpacket->packet += 9;
1048                     p_oggpacket->bytes -= 9;
1049                 }
1050             }
1051             b_xiph = false;
1052             break;
1053
1054         case VLC_CODEC_KATE:
1055             if( p_stream->i_packets_backup == p_stream->i_kate_num_headers )
1056                 p_stream->b_force_backup = false;
1057             b_xiph = true;
1058             break;
1059
1060         default:
1061             p_stream->b_force_backup = false;
1062             b_xiph = false;
1063             break;
1064         }
1065
1066         /* Backup the ogg packet (likely an header packet) */
1067         if( !b_xiph )
1068         {
1069             void *p_org = p_stream->p_headers;
1070             p_stream->i_headers += p_oggpacket->bytes;
1071             p_stream->p_headers = realloc( p_stream->p_headers, p_stream->i_headers );
1072             if( p_stream->p_headers )
1073             {
1074                 memcpy( (unsigned char *)p_stream->p_headers + p_stream->i_headers - p_oggpacket->bytes,
1075                         p_oggpacket->packet, p_oggpacket->bytes );
1076             }
1077             else
1078             {
1079 #warning Memory leak
1080                 p_stream->i_headers = 0;
1081                 p_stream->p_headers = NULL;
1082                 free( p_org );
1083             }
1084         }
1085         else if( xiph_AppendHeaders( &p_stream->i_headers, &p_stream->p_headers,
1086                                      p_oggpacket->bytes, p_oggpacket->packet ) )
1087         {
1088             p_stream->i_headers = 0;
1089             p_stream->p_headers = NULL;
1090         }
1091         if( p_stream->i_headers > 0 )
1092         {
1093             if( !p_stream->b_force_backup )
1094             {
1095                 /* Last header received, commit changes */
1096                 free( p_stream->fmt.p_extra );
1097
1098                 p_stream->fmt.i_extra = p_stream->i_headers;
1099                 p_stream->fmt.p_extra = malloc( p_stream->i_headers );
1100                 if( p_stream->fmt.p_extra )
1101                     memcpy( p_stream->fmt.p_extra, p_stream->p_headers,
1102                             p_stream->i_headers );
1103                 else
1104                     p_stream->fmt.i_extra = 0;
1105
1106                 if( p_stream->i_headers > 0 )
1107                     Ogg_ExtractMeta( p_demux, & p_stream->fmt,
1108                                      p_stream->p_headers, p_stream->i_headers );
1109
1110                 /* we're not at BOS anymore for this logical stream */
1111                 p_stream->b_initializing = false;
1112             }
1113         }
1114
1115         b_selected = false; /* Discard the header packet */
1116     }
1117     else
1118         p_stream->b_initializing = false;
1119
1120     /* Convert the pcr into a pts */
1121     if( p_stream->fmt.i_codec == VLC_CODEC_VORBIS ||
1122         p_stream->fmt.i_codec == VLC_CODEC_SPEEX ||
1123         p_stream->fmt.i_codec == VLC_CODEC_OPUS ||
1124         p_stream->fmt.i_codec == VLC_CODEC_VP8 ||
1125         p_stream->fmt.i_codec == VLC_CODEC_FLAC )
1126     {
1127         if( p_stream->i_pcr > VLC_TS_INVALID )
1128         {
1129             p_stream->i_previous_pcr = p_stream->i_pcr;
1130             /* The granulepos is the end date of the sample */
1131             i_pts = p_stream->i_pcr;
1132         }
1133     }
1134
1135     /* Convert the granulepos into the next pcr */
1136     Ogg_UpdatePCR( p_demux, p_stream, p_oggpacket );
1137
1138     if( p_stream->fmt.i_codec != VLC_CODEC_VORBIS &&
1139         p_stream->fmt.i_codec != VLC_CODEC_SPEEX &&
1140         p_stream->fmt.i_codec != VLC_CODEC_OPUS &&
1141         p_stream->fmt.i_codec != VLC_CODEC_VP8 &&
1142         p_stream->fmt.i_codec != VLC_CODEC_FLAC &&
1143         p_stream->i_pcr >= 0 )
1144     {
1145         p_stream->i_previous_pcr = p_stream->i_pcr;
1146
1147         /* The granulepos is the start date of the sample */
1148         i_pts = p_stream->i_pcr;
1149     }
1150
1151     if( !b_selected )
1152     {
1153         /* This stream isn't currently selected so we don't need to decode it,
1154          * but we did need to store its pcr as it might be selected later on */
1155         return;
1156     }
1157
1158     if( !( p_block = block_Alloc( p_oggpacket->bytes ) ) ) return;
1159
1160
1161     /* may need to preroll after a seek */
1162     if ( p_stream->i_skip_frames > 0 )
1163     {
1164         if( p_stream->fmt.i_codec == VLC_CODEC_OPUS )
1165         {
1166             int duration;
1167             duration = Ogg_OpusPacketDuration( p_stream, p_oggpacket );
1168             if( p_stream->i_skip_frames > duration )
1169             {
1170                 p_block->i_flags |= BLOCK_FLAG_PREROLL;
1171                 p_block->i_nb_samples = 0;
1172                 p_stream->i_skip_frames -= duration;
1173             }
1174             else
1175             {
1176                 p_block->i_nb_samples = duration - p_stream->i_skip_frames;
1177                 if( p_stream->i_previous_granulepos >=
1178                     p_block->i_nb_samples + p_stream->i_pre_skip )
1179                 {
1180                     i_pts = VLC_TS_0 + (p_stream->i_previous_granulepos
1181                         - p_block->i_nb_samples - p_stream->i_pre_skip) *
1182                         CLOCK_FREQ / p_stream->f_rate;
1183                 }
1184                 p_stream->i_skip_frames = 0;
1185             }
1186         }
1187         else
1188         {
1189             p_block->i_flags |= BLOCK_FLAG_PREROLL;
1190             p_stream->i_skip_frames--;
1191         }
1192     }
1193     else if( p_stream->fmt.i_codec == VLC_CODEC_OPUS )
1194         p_block->i_nb_samples = Ogg_OpusPacketDuration( p_stream, p_oggpacket );
1195
1196     /* Normalize PTS */
1197     if( i_pts == VLC_TS_UNKNOWN )
1198         i_pts = VLC_TS_INVALID;
1199
1200     if( p_stream->fmt.i_cat == AUDIO_ES )
1201     {
1202         p_block->i_dts = p_block->i_pts = i_pts;
1203         /* Blatant abuse of the i_length field. */
1204         p_block->i_length = p_stream->i_end_trim;
1205     }
1206     else if( p_stream->fmt.i_cat == SPU_ES )
1207     {
1208         p_block->i_dts = p_block->i_pts = i_pts;
1209         p_block->i_length = 0;
1210     }
1211     else if( p_stream->fmt.i_codec == VLC_CODEC_THEORA )
1212     {
1213         p_block->i_dts = p_block->i_pts = i_pts;
1214         if( (p_oggpacket->granulepos & ((1<<p_stream->i_granule_shift)-1)) == 0 )
1215         {
1216             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1217         }
1218     }
1219     else if( p_stream->fmt.i_codec == VLC_CODEC_DIRAC )
1220     {
1221         ogg_int64_t dts = p_oggpacket->granulepos >> 31;
1222         ogg_int64_t delay = (p_oggpacket->granulepos >> 9) & 0x1fff;
1223
1224         uint64_t u_pnum = dts + delay;
1225
1226         p_block->i_dts = p_stream->i_pcr;
1227         p_block->i_pts = VLC_TS_INVALID;
1228         /* NB, OggDirac granulepos values are in units of 2*picturerate */
1229
1230         /* granulepos for dirac is possibly broken, this value should be ignored */
1231         if( -1 != p_oggpacket->granulepos )
1232             p_block->i_pts = u_pnum * CLOCK_FREQ / p_stream->f_rate / 2;
1233     }
1234     else if( p_stream->fmt.i_codec == VLC_CODEC_VP8 )
1235     {
1236         p_block->i_pts = p_stream->i_interpolated_pcr;
1237         p_block->i_dts = p_block->i_pts;
1238         if( p_oggpacket->granulepos > 0 && Ogg_IsKeyFrame( p_stream, p_oggpacket ) )
1239         {
1240             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1241         }
1242     }
1243     else
1244     {
1245         p_block->i_dts = i_pts;
1246         p_block->i_pts = VLC_TS_INVALID;
1247     }
1248
1249     if( p_stream->fmt.i_codec != VLC_CODEC_VORBIS &&
1250         p_stream->fmt.i_codec != VLC_CODEC_SPEEX &&
1251         p_stream->fmt.i_codec != VLC_CODEC_OPUS &&
1252         p_stream->fmt.i_codec != VLC_CODEC_VP8 &&
1253         p_stream->fmt.i_codec != VLC_CODEC_FLAC &&
1254         p_stream->fmt.i_codec != VLC_CODEC_TARKIN &&
1255         p_stream->fmt.i_codec != VLC_CODEC_THEORA &&
1256         p_stream->fmt.i_codec != VLC_CODEC_CMML &&
1257         p_stream->fmt.i_codec != VLC_CODEC_DIRAC &&
1258         p_stream->fmt.i_codec != VLC_CODEC_KATE )
1259     {
1260         if( p_oggpacket->bytes <= 0 )
1261         {
1262             msg_Dbg( p_demux, "discarding 0 sized packet" );
1263             block_Release( p_block );
1264             return;
1265         }
1266         /* We remove the header from the packet */
1267         i_header_len = (*p_oggpacket->packet & PACKET_LEN_BITS01) >> 6;
1268         i_header_len |= (*p_oggpacket->packet & PACKET_LEN_BITS2) << 1;
1269
1270         if( p_stream->fmt.i_codec == VLC_CODEC_SUBT)
1271         {
1272             /* But with subtitles we need to retrieve the duration first */
1273             int i, lenbytes = 0;
1274
1275             if( i_header_len > 0 && p_oggpacket->bytes >= i_header_len + 1 )
1276             {
1277                 for( i = 0, lenbytes = 0; i < i_header_len; i++ )
1278                 {
1279                     lenbytes = lenbytes << 8;
1280                     lenbytes += *(p_oggpacket->packet + i_header_len - i);
1281                 }
1282             }
1283             if( p_oggpacket->bytes - 1 - i_header_len > 2 ||
1284                 ( p_oggpacket->packet[i_header_len + 1] != ' ' &&
1285                   p_oggpacket->packet[i_header_len + 1] != 0 &&
1286                   p_oggpacket->packet[i_header_len + 1] != '\n' &&
1287                   p_oggpacket->packet[i_header_len + 1] != '\r' ) )
1288             {
1289                 p_block->i_length = (mtime_t)lenbytes * 1000;
1290             }
1291         }
1292
1293         i_header_len++;
1294         if( p_block->i_buffer >= (unsigned int)i_header_len )
1295             p_block->i_buffer -= i_header_len;
1296         else
1297             p_block->i_buffer = 0;
1298     }
1299
1300
1301     if( p_stream->fmt.i_codec == VLC_CODEC_TARKIN )
1302     {
1303         /* FIXME: the biggest hack I've ever done */
1304         msg_Warn( p_demux, "tarkin pts: %"PRId64", granule: %"PRId64,
1305                   p_block->i_pts, p_block->i_dts );
1306         msleep(10000);
1307     }
1308
1309     memcpy( p_block->p_buffer, p_oggpacket->packet + i_header_len,
1310             p_oggpacket->bytes - i_header_len );
1311
1312     if ( p_ogg->i_streams == 1 && p_block->i_pts > VLC_TS_INVALID && p_ogg->i_pcr < VLC_TS_0 )
1313     {
1314         p_ogg->i_pcr = p_block->i_pts;
1315         es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_ogg->i_pcr );
1316     }
1317
1318     if ( p_stream->p_es )
1319     {
1320         /* Because ES creation is delayed for preparsing */
1321         if ( p_stream->p_preparse_block )
1322         {
1323             es_out_Send( p_demux->out, p_stream->p_es, p_stream->p_preparse_block );
1324             p_stream->p_preparse_block = NULL;
1325         }
1326         es_out_Send( p_demux->out, p_stream->p_es, p_block );
1327     }
1328     else
1329         block_ChainAppend( & p_stream->p_preparse_block, p_block );
1330 }
1331
1332 /* Re-implemented to avoid linking against libopus from the demuxer. */
1333 static int Ogg_OpusPacketDuration( logical_stream_t *p_stream,
1334                                    ogg_packet *p_oggpacket )
1335 {
1336     static const int silk_fs_div[4] = { 6000, 3000, 1500, 1000 };
1337     int toc;
1338     int nframes;
1339     int frame_size;
1340     int nsamples;
1341     int i_rate;
1342     if( p_oggpacket->bytes < 1 )
1343         return VLC_EGENERIC;
1344     toc = p_oggpacket->packet[0];
1345     switch( toc&3 )
1346     {
1347         case 0:
1348             nframes = 1;
1349             break;
1350         case 1:
1351         case 2:
1352             nframes = 2;
1353             break;
1354         default:
1355             if( p_oggpacket->bytes < 2 )
1356                 return VLC_EGENERIC;
1357             nframes = p_oggpacket->packet[1]&0x3F;
1358             break;
1359     }
1360     i_rate = (int)p_stream->fmt.audio.i_rate;
1361     if( toc&0x80 )
1362         frame_size = (i_rate << (toc >> 3 & 3)) / 400;
1363     else if( ( toc&0x60 ) == 0x60 )
1364         frame_size = i_rate/(100 >> (toc >> 3 & 1));
1365     else
1366         frame_size = i_rate*60 / silk_fs_div[toc >> 3 & 3];
1367     nsamples = nframes*frame_size;
1368     if( nsamples*25 > i_rate*3 )
1369         return VLC_EGENERIC;
1370     return nsamples;
1371 }
1372
1373 /****************************************************************************
1374  * Ogg_FindLogicalStreams: Find the logical streams embedded in the physical
1375  *                         stream and fill p_ogg.
1376  *****************************************************************************
1377  * The initial page of a logical stream is marked as a 'bos' page.
1378  * Furthermore, the Ogg specification mandates that grouped bitstreams begin
1379  * together and all of the initial pages must appear before any data pages.
1380  *
1381  * On success this function returns VLC_SUCCESS.
1382  ****************************************************************************/
1383 static int Ogg_FindLogicalStreams( demux_t *p_demux )
1384 {
1385     demux_sys_t *p_ogg = p_demux->p_sys  ;
1386     ogg_packet oggpacket;
1387     int i_stream = 0;
1388
1389     p_ogg->i_total_length = stream_Size ( p_demux->s );
1390     msg_Dbg( p_demux, "File length is %"PRId64" bytes", p_ogg->i_total_length );
1391
1392
1393     while( Ogg_ReadPage( p_demux, &p_ogg->current_page ) == VLC_SUCCESS )
1394     {
1395
1396         if( ogg_page_bos( &p_ogg->current_page ) )
1397         {
1398
1399             /* All is wonderful in our fine fine little world.
1400              * We found the beginning of our first logical stream. */
1401             while( ogg_page_bos( &p_ogg->current_page ) )
1402             {
1403                 logical_stream_t *p_stream;
1404
1405                 p_stream = malloc( sizeof(logical_stream_t) );
1406                 if( unlikely( !p_stream ) )
1407                     return VLC_ENOMEM;
1408
1409                 TAB_APPEND( p_ogg->i_streams, p_ogg->pp_stream, p_stream );
1410
1411                 memset( p_stream, 0, sizeof(logical_stream_t) );
1412
1413                 es_format_Init( &p_stream->fmt, 0, 0 );
1414                 es_format_Init( &p_stream->fmt_old, 0, 0 );
1415                 p_stream->b_initializing = true;
1416
1417                 /* Setup the logical stream */
1418                 p_stream->i_serial_no = ogg_page_serialno( &p_ogg->current_page );
1419                 ogg_stream_init( &p_stream->os, p_stream->i_serial_no );
1420
1421                 /* Extract the initial header from the first page and verify
1422                  * the codec type of this Ogg bitstream */
1423                 if( ogg_stream_pagein( &p_stream->os, &p_ogg->current_page ) < 0 )
1424                 {
1425                     /* error. stream version mismatch perhaps */
1426                     msg_Err( p_demux, "error reading first page of "
1427                              "Ogg bitstream data" );
1428                     return VLC_EGENERIC;
1429                 }
1430
1431                 /* FIXME: check return value */
1432                 ogg_stream_packetpeek( &p_stream->os, &oggpacket );
1433
1434                 /* Check for Vorbis header */
1435                 if( oggpacket.bytes >= 7 &&
1436                     ! memcmp( oggpacket.packet, "\x01vorbis", 7 ) )
1437                 {
1438                     Ogg_ReadVorbisHeader( p_stream, &oggpacket );
1439                     msg_Dbg( p_demux, "found vorbis header" );
1440                 }
1441                 /* Check for Speex header */
1442                 else if( oggpacket.bytes >= 5 &&
1443                     ! memcmp( oggpacket.packet, "Speex", 5 ) )
1444                 {
1445                     Ogg_ReadSpeexHeader( p_stream, &oggpacket );
1446                     msg_Dbg( p_demux, "found speex header, channels: %i, "
1447                              "rate: %i,  bitrate: %i",
1448                              p_stream->fmt.audio.i_channels,
1449                              (int)p_stream->f_rate, p_stream->fmt.i_bitrate );
1450                 }
1451                 /* Check for Opus header */
1452                 else if( oggpacket.bytes >= 8 &&
1453                     ! memcmp( oggpacket.packet, "OpusHead", 8 ) )
1454                 {
1455                     Ogg_ReadOpusHeader( p_stream, &oggpacket );
1456                     msg_Dbg( p_demux, "found opus header, channels: %i, "
1457                              "pre-skip: %i",
1458                              p_stream->fmt.audio.i_channels,
1459                              (int)p_stream->i_pre_skip);
1460                     p_stream->i_skip_frames = p_stream->i_pre_skip;
1461                 }
1462                 /* Check for Flac header (< version 1.1.1) */
1463                 else if( oggpacket.bytes >= 4 &&
1464                     ! memcmp( oggpacket.packet, "fLaC", 4 ) )
1465                 {
1466                     msg_Dbg( p_demux, "found FLAC header" );
1467
1468                     /* Grrrr!!!! Did they really have to put all the
1469                      * important info in the second header packet!!!
1470                      * (STREAMINFO metadata is in the following packet) */
1471                     p_stream->b_force_backup = true;
1472
1473                     p_stream->fmt.i_cat = AUDIO_ES;
1474                     p_stream->fmt.i_codec = VLC_CODEC_FLAC;
1475                 }
1476                 /* Check for Flac header (>= version 1.1.1) */
1477                 else if( oggpacket.bytes >= 13 && oggpacket.packet[0] ==0x7F &&
1478                     ! memcmp( &oggpacket.packet[1], "FLAC", 4 ) &&
1479                     ! memcmp( &oggpacket.packet[9], "fLaC", 4 ) )
1480                 {
1481                     int i_packets = ((int)oggpacket.packet[7]) << 8 |
1482                         oggpacket.packet[8];
1483                     msg_Dbg( p_demux, "found FLAC header version %i.%i "
1484                              "(%i header packets)",
1485                              oggpacket.packet[5], oggpacket.packet[6],
1486                              i_packets );
1487
1488                     p_stream->b_force_backup = true;
1489
1490                     p_stream->fmt.i_cat = AUDIO_ES;
1491                     p_stream->fmt.i_codec = VLC_CODEC_FLAC;
1492                     oggpacket.packet += 13; oggpacket.bytes -= 13;
1493                     Ogg_ReadFlacHeader( p_demux, p_stream, &oggpacket );
1494                 }
1495                 /* Check for Theora header */
1496                 else if( oggpacket.bytes >= 7 &&
1497                          ! memcmp( oggpacket.packet, "\x80theora", 7 ) )
1498                 {
1499                     Ogg_ReadTheoraHeader( p_stream, &oggpacket );
1500
1501                     msg_Dbg( p_demux,
1502                              "found theora header, bitrate: %i, rate: %f",
1503                              p_stream->fmt.i_bitrate, p_stream->f_rate );
1504                 }
1505                 /* Check for Dirac header */
1506                 else if( ( oggpacket.bytes >= 5 &&
1507                            ! memcmp( oggpacket.packet, "BBCD\x00", 5 ) ) ||
1508                          ( oggpacket.bytes >= 9 &&
1509                            ! memcmp( oggpacket.packet, "KW-DIRAC\x00", 9 ) ) )
1510                 {
1511                     if( Ogg_ReadDiracHeader( p_stream, &oggpacket ) )
1512                         msg_Dbg( p_demux, "found dirac header" );
1513                     else
1514                     {
1515                         msg_Warn( p_demux, "found dirac header isn't decodable" );
1516                         free( p_stream );
1517                         p_ogg->i_streams--;
1518                     }
1519                 }
1520                 /* Check for Tarkin header */
1521                 else if( oggpacket.bytes >= 7 &&
1522                          ! memcmp( &oggpacket.packet[1], "tarkin", 6 ) )
1523                 {
1524                     oggpack_buffer opb;
1525
1526                     msg_Dbg( p_demux, "found tarkin header" );
1527                     p_stream->fmt.i_cat = VIDEO_ES;
1528                     p_stream->fmt.i_codec = VLC_CODEC_TARKIN;
1529
1530                     /* Cheat and get additionnal info ;) */
1531                     oggpack_readinit( &opb, oggpacket.packet, oggpacket.bytes);
1532                     oggpack_adv( &opb, 88 );
1533                     oggpack_adv( &opb, 104 );
1534                     p_stream->fmt.i_bitrate = oggpack_read( &opb, 32 );
1535                     p_stream->f_rate = 2; /* FIXME */
1536                     msg_Dbg( p_demux,
1537                              "found tarkin header, bitrate: %i, rate: %f",
1538                              p_stream->fmt.i_bitrate, p_stream->f_rate );
1539                 }
1540                 /* Check for VP8 header */
1541                 else if( oggpacket.bytes >= 26 &&
1542                          ! memcmp( oggpacket.packet, "OVP80", 5 ) )
1543                 {
1544                     if ( Ogg_ReadVP8Header( p_demux, p_stream, &oggpacket ) )
1545                         msg_Dbg( p_demux, "found VP8 header "
1546                              "fps: %f, width:%i; height:%i",
1547                              p_stream->f_rate,
1548                              p_stream->fmt.video.i_width,
1549                              p_stream->fmt.video.i_height );
1550                     else
1551                         p_stream->fmt.i_cat = UNKNOWN_ES;
1552                 }
1553                 /* Check for Annodex header */
1554                 else if( oggpacket.bytes >= 7 &&
1555                          ! memcmp( oggpacket.packet, "Annodex", 7 ) )
1556                 {
1557                     Ogg_ReadAnnodexHeader( p_demux, p_stream, &oggpacket );
1558                     /* kill annodex track */
1559                     free( p_stream );
1560                     p_ogg->i_streams--;
1561                 }
1562                 /* Check for Annodex header */
1563                 else if( oggpacket.bytes >= 7 &&
1564                          ! memcmp( oggpacket.packet, "AnxData", 7 ) )
1565                 {
1566                     Ogg_ReadAnnodexHeader( p_demux, p_stream, &oggpacket );
1567                 }
1568                 /* Check for Kate header */
1569                 else if( oggpacket.bytes >= 8 &&
1570                     ! memcmp( &oggpacket.packet[1], "kate\0\0\0", 7 ) )
1571                 {
1572                     Ogg_ReadKateHeader( p_stream, &oggpacket );
1573                     msg_Dbg( p_demux, "found kate header" );
1574                 }
1575                 /* Check for OggDS */
1576                 else if( oggpacket.bytes >= 142 &&
1577                          !memcmp( &oggpacket.packet[1],
1578                                    "Direct Show Samples embedded in Ogg", 35 ))
1579                 {
1580                     /* Old header type */
1581                     p_stream->b_oggds = true;
1582                     /* Check for video header (old format) */
1583                     if( GetDWLE((oggpacket.packet+96)) == 0x05589f80 &&
1584                         oggpacket.bytes >= 184 )
1585                     {
1586                         p_stream->fmt.i_cat = VIDEO_ES;
1587                         p_stream->fmt.i_codec =
1588                             VLC_FOURCC( oggpacket.packet[68],
1589                                         oggpacket.packet[69],
1590                                         oggpacket.packet[70],
1591                                         oggpacket.packet[71] );
1592                         msg_Dbg( p_demux, "found video header of type: %.4s",
1593                                  (char *)&p_stream->fmt.i_codec );
1594
1595                         p_stream->fmt.video.i_frame_rate = 10000000;
1596                         p_stream->fmt.video.i_frame_rate_base =
1597                             GetQWLE((oggpacket.packet+164));
1598                         p_stream->f_rate = 10000000.0 /
1599                             GetQWLE((oggpacket.packet+164));
1600                         p_stream->fmt.video.i_bits_per_pixel =
1601                             GetWLE((oggpacket.packet+182));
1602                         if( !p_stream->fmt.video.i_bits_per_pixel )
1603                             /* hack, FIXME */
1604                             p_stream->fmt.video.i_bits_per_pixel = 24;
1605                         p_stream->fmt.video.i_width =
1606                             GetDWLE((oggpacket.packet+176));
1607                         p_stream->fmt.video.i_height =
1608                             GetDWLE((oggpacket.packet+180));
1609
1610                         msg_Dbg( p_demux,
1611                                  "fps: %f, width:%i; height:%i, bitcount:%i",
1612                                  p_stream->f_rate,
1613                                  p_stream->fmt.video.i_width,
1614                                  p_stream->fmt.video.i_height,
1615                                  p_stream->fmt.video.i_bits_per_pixel);
1616
1617                     }
1618                     /* Check for audio header (old format) */
1619                     else if( GetDWLE((oggpacket.packet+96)) == 0x05589F81 )
1620                     {
1621                         int i_extra_size;
1622                         unsigned int i_format_tag;
1623
1624                         p_stream->fmt.i_cat = AUDIO_ES;
1625
1626                         i_extra_size = GetWLE((oggpacket.packet+140));
1627                         if( i_extra_size > 0 && i_extra_size < oggpacket.bytes - 142 )
1628                         {
1629                             p_stream->fmt.i_extra = i_extra_size;
1630                             p_stream->fmt.p_extra = malloc( i_extra_size );
1631                             if( p_stream->fmt.p_extra )
1632                                 memcpy( p_stream->fmt.p_extra,
1633                                         oggpacket.packet + 142, i_extra_size );
1634                             else
1635                                 p_stream->fmt.i_extra = 0;
1636                         }
1637
1638                         i_format_tag = GetWLE((oggpacket.packet+124));
1639                         p_stream->fmt.audio.i_channels =
1640                             GetWLE((oggpacket.packet+126));
1641                         fill_channels_info(&p_stream->fmt.audio);
1642                         p_stream->f_rate = p_stream->fmt.audio.i_rate =
1643                             GetDWLE((oggpacket.packet+128));
1644                         p_stream->fmt.i_bitrate =
1645                             GetDWLE((oggpacket.packet+132)) * 8;
1646                         p_stream->fmt.audio.i_blockalign =
1647                             GetWLE((oggpacket.packet+136));
1648                         p_stream->fmt.audio.i_bitspersample =
1649                             GetWLE((oggpacket.packet+138));
1650
1651                         wf_tag_to_fourcc( i_format_tag,
1652                                           &p_stream->fmt.i_codec, 0 );
1653
1654                         if( p_stream->fmt.i_codec ==
1655                             VLC_FOURCC('u','n','d','f') )
1656                         {
1657                             p_stream->fmt.i_codec = VLC_FOURCC( 'm', 's',
1658                                 ( i_format_tag >> 8 ) & 0xff,
1659                                 i_format_tag & 0xff );
1660                         }
1661
1662                         msg_Dbg( p_demux, "found audio header of type: %.4s",
1663                                  (char *)&p_stream->fmt.i_codec );
1664                         msg_Dbg( p_demux, "audio:0x%4.4x channels:%d %dHz "
1665                                  "%dbits/sample %dkb/s",
1666                                  i_format_tag,
1667                                  p_stream->fmt.audio.i_channels,
1668                                  p_stream->fmt.audio.i_rate,
1669                                  p_stream->fmt.audio.i_bitspersample,
1670                                  p_stream->fmt.i_bitrate / 1024 );
1671
1672                     }
1673                     else
1674                     {
1675                         msg_Dbg( p_demux, "stream %d has an old header "
1676                             "but is of an unknown type", p_ogg->i_streams-1 );
1677                         free( p_stream );
1678                         p_ogg->i_streams--;
1679                     }
1680                 }
1681                 /* Check for OggDS */
1682                 else if( oggpacket.bytes >= 44+1 &&
1683                          (*oggpacket.packet & PACKET_TYPE_BITS ) == PACKET_TYPE_HEADER )
1684                 {
1685                     stream_header_t tmp;
1686                     stream_header_t *st = &tmp;
1687
1688                     p_stream->b_oggds = true;
1689
1690                     memcpy( st->streamtype, &oggpacket.packet[1+0], 8 );
1691                     memcpy( st->subtype, &oggpacket.packet[1+8], 4 );
1692                     st->size = GetDWLE( &oggpacket.packet[1+12] );
1693                     st->time_unit = GetQWLE( &oggpacket.packet[1+16] );
1694                     st->samples_per_unit = GetQWLE( &oggpacket.packet[1+24] );
1695                     st->default_len = GetDWLE( &oggpacket.packet[1+32] );
1696                     st->buffersize = GetDWLE( &oggpacket.packet[1+36] );
1697                     st->bits_per_sample = GetWLE( &oggpacket.packet[1+40] ); // (padding 2)
1698
1699                     /* Check for video header (new format) */
1700                     if( !strncmp( st->streamtype, "video", 5 ) &&
1701                         oggpacket.bytes >= 52+1 )
1702                     {
1703                         st->sh.video.width = GetDWLE( &oggpacket.packet[1+44] );
1704                         st->sh.video.height = GetDWLE( &oggpacket.packet[1+48] );
1705
1706                         p_stream->fmt.i_cat = VIDEO_ES;
1707
1708                         /* We need to get rid of the header packet */
1709                         ogg_stream_packetout( &p_stream->os, &oggpacket );
1710
1711                         p_stream->fmt.i_codec =
1712                             VLC_FOURCC( st->subtype[0], st->subtype[1],
1713                                         st->subtype[2], st->subtype[3] );
1714                         msg_Dbg( p_demux, "found video header of type: %.4s",
1715                                  (char *)&p_stream->fmt.i_codec );
1716
1717                         p_stream->fmt.video.i_frame_rate = 10000000;
1718                         p_stream->fmt.video.i_frame_rate_base = st->time_unit;
1719                         if( st->time_unit <= 0 )
1720                             st->time_unit = 400000;
1721                         p_stream->f_rate = 10000000.0 / st->time_unit;
1722                         p_stream->fmt.video.i_bits_per_pixel = st->bits_per_sample;
1723                         p_stream->fmt.video.i_width = st->sh.video.width;
1724                         p_stream->fmt.video.i_height = st->sh.video.height;
1725
1726                         msg_Dbg( p_demux,
1727                                  "fps: %f, width:%i; height:%i, bitcount:%i",
1728                                  p_stream->f_rate,
1729                                  p_stream->fmt.video.i_width,
1730                                  p_stream->fmt.video.i_height,
1731                                  p_stream->fmt.video.i_bits_per_pixel );
1732                     }
1733                     /* Check for audio header (new format) */
1734                     else if( !strncmp( st->streamtype, "audio", 5 ) &&
1735                              oggpacket.bytes >= 56+1 )
1736                     {
1737                         char p_buffer[5];
1738                         int i_extra_size;
1739                         int i_format_tag;
1740
1741                         st->sh.audio.channels = GetWLE( &oggpacket.packet[1+44] );
1742                         st->sh.audio.blockalign = GetWLE( &oggpacket.packet[1+48] );
1743                         st->sh.audio.avgbytespersec = GetDWLE( &oggpacket.packet[1+52] );
1744
1745                         p_stream->fmt.i_cat = AUDIO_ES;
1746
1747                         /* We need to get rid of the header packet */
1748                         ogg_stream_packetout( &p_stream->os, &oggpacket );
1749
1750                         i_extra_size = st->size - 56;
1751
1752                         if( i_extra_size > 0 &&
1753                             i_extra_size < oggpacket.bytes - 1 - 56 )
1754                         {
1755                             p_stream->fmt.i_extra = i_extra_size;
1756                             p_stream->fmt.p_extra = malloc( p_stream->fmt.i_extra );
1757                             if( p_stream->fmt.p_extra )
1758                                 memcpy( p_stream->fmt.p_extra, oggpacket.packet + 57,
1759                                         p_stream->fmt.i_extra );
1760                             else
1761                                 p_stream->fmt.i_extra = 0;
1762                         }
1763
1764                         memcpy( p_buffer, st->subtype, 4 );
1765                         p_buffer[4] = '\0';
1766                         i_format_tag = strtol(p_buffer,NULL,16);
1767                         p_stream->fmt.audio.i_channels = st->sh.audio.channels;
1768                         fill_channels_info(&p_stream->fmt.audio);
1769                         if( st->time_unit <= 0 )
1770                             st->time_unit = 10000000;
1771                         p_stream->f_rate = p_stream->fmt.audio.i_rate = st->samples_per_unit * 10000000 / st->time_unit;
1772                         p_stream->fmt.i_bitrate = st->sh.audio.avgbytespersec * 8;
1773                         p_stream->fmt.audio.i_blockalign = st->sh.audio.blockalign;
1774                         p_stream->fmt.audio.i_bitspersample = st->bits_per_sample;
1775
1776                         wf_tag_to_fourcc( i_format_tag,
1777                                           &p_stream->fmt.i_codec, 0 );
1778
1779                         if( p_stream->fmt.i_codec ==
1780                             VLC_FOURCC('u','n','d','f') )
1781                         {
1782                             p_stream->fmt.i_codec = VLC_FOURCC( 'm', 's',
1783                                 ( i_format_tag >> 8 ) & 0xff,
1784                                 i_format_tag & 0xff );
1785                         }
1786
1787                         msg_Dbg( p_demux, "found audio header of type: %.4s",
1788                                  (char *)&p_stream->fmt.i_codec );
1789                         msg_Dbg( p_demux, "audio:0x%4.4x channels:%d %dHz "
1790                                  "%dbits/sample %dkb/s",
1791                                  i_format_tag,
1792                                  p_stream->fmt.audio.i_channels,
1793                                  p_stream->fmt.audio.i_rate,
1794                                  p_stream->fmt.audio.i_bitspersample,
1795                                  p_stream->fmt.i_bitrate / 1024 );
1796                     }
1797                     /* Check for text (subtitles) header */
1798                     else if( !strncmp(st->streamtype, "text", 4) )
1799                     {
1800                         /* We need to get rid of the header packet */
1801                         ogg_stream_packetout( &p_stream->os, &oggpacket );
1802
1803                         msg_Dbg( p_demux, "found text subtitle header" );
1804                         p_stream->fmt.i_cat = SPU_ES;
1805                         p_stream->fmt.i_codec = VLC_CODEC_SUBT;
1806                         p_stream->f_rate = 1000; /* granulepos is in millisec */
1807                     }
1808                     else
1809                     {
1810                         msg_Dbg( p_demux, "stream %d has a header marker "
1811                             "but is of an unknown type", p_ogg->i_streams-1 );
1812                         free( p_stream );
1813                         p_ogg->i_streams--;
1814                     }
1815                 }
1816                 else if( oggpacket.bytes >= 8 &&
1817                              ! memcmp( oggpacket.packet, "fishead\0", 8 ) )
1818
1819                 {
1820                     /* Skeleton */
1821                     msg_Dbg( p_demux, "stream %d is a skeleton",
1822                                 p_ogg->i_streams-1 );
1823                     Ogg_ReadSkeletonHeader( p_demux, p_stream, &oggpacket );
1824                 }
1825                 else
1826                 {
1827                     msg_Dbg( p_demux, "stream %d is of unknown type",
1828                              p_ogg->i_streams-1 );
1829                     free( p_stream );
1830                     p_ogg->i_streams--;
1831                 }
1832
1833                 /* we'll need to get all headers */
1834                 p_ogg->pp_stream[i_stream]->b_initializing &= p_ogg->pp_stream[i_stream]->b_force_backup;
1835
1836                 if( Ogg_ReadPage( p_demux, &p_ogg->current_page ) != VLC_SUCCESS )
1837                     return VLC_EGENERIC;
1838             }
1839
1840             /* This is the first data page, which means we are now finished
1841              * with the initial pages. We just need to store it in the relevant
1842              * bitstream. */
1843             for( i_stream = 0; i_stream < p_ogg->i_streams; i_stream++ )
1844             {
1845                 if( ogg_stream_pagein( &p_ogg->pp_stream[i_stream]->os,
1846                                        &p_ogg->current_page ) == 0 )
1847                 {
1848                     p_ogg->b_page_waiting = true;
1849                     break;
1850                 }
1851             }
1852
1853             return VLC_SUCCESS;
1854         }
1855     }
1856
1857     return VLC_EGENERIC;
1858 }
1859
1860 /****************************************************************************
1861  * Ogg_CreateES: Creates all Elementary streams once headers are parsed
1862  ****************************************************************************/
1863 static void Ogg_CreateES( demux_t *p_demux )
1864 {
1865     demux_sys_t *p_ogg = p_demux->p_sys;
1866     logical_stream_t *p_old_stream = p_ogg->p_old_stream;
1867     int i_stream;
1868
1869     for( i_stream = 0 ; i_stream < p_ogg->i_streams; i_stream++ )
1870     {
1871         logical_stream_t *p_stream = p_ogg->pp_stream[i_stream];
1872
1873         if ( p_stream->p_es == NULL && !p_stream->b_finished )
1874         {
1875             /* Better be safe than sorry when possible with ogm */
1876             if( p_stream->fmt.i_codec == VLC_CODEC_MPGA ||
1877                 p_stream->fmt.i_codec == VLC_CODEC_A52 )
1878                 p_stream->fmt.b_packetized = false;
1879
1880             /* Try first to reuse an old ES */
1881             if( p_old_stream &&
1882                 p_old_stream->fmt.i_cat == p_stream->fmt.i_cat &&
1883                 p_old_stream->fmt.i_codec == p_stream->fmt.i_codec )
1884             {
1885                 msg_Dbg( p_demux, "will reuse old stream to avoid glitch" );
1886
1887                 p_stream->p_es = p_old_stream->p_es;
1888                 p_stream->b_finished = false;
1889                 p_stream->b_reinit = false;
1890                 p_stream->b_initializing = false;
1891                 bool b_resetdecoder = Ogg_LogicalStreamResetEsFormat( p_demux, p_stream );
1892                 es_format_Copy( &p_stream->fmt_old, &p_old_stream->fmt );
1893
1894                 p_old_stream->p_es = NULL;
1895                 p_old_stream = NULL;
1896                 if ( b_resetdecoder )
1897                 {
1898                     es_out_Control( p_demux->out, ES_OUT_SET_ES_FMT,
1899                                     p_stream->p_es, &p_stream->fmt );
1900                 }
1901             }
1902             else
1903             {
1904                 p_stream->p_es = es_out_Add( p_demux->out, &p_stream->fmt );
1905             }
1906
1907             // TODO: something to do here ?
1908             if( p_stream->fmt.i_codec == VLC_CODEC_CMML )
1909             {
1910                 /* Set the CMML stream active */
1911                 es_out_Control( p_demux->out, ES_OUT_SET_ES, p_stream->p_es );
1912             }
1913         }
1914     }
1915
1916     if( p_ogg->p_old_stream )
1917     {
1918         if( p_ogg->p_old_stream->p_es )
1919             msg_Dbg( p_demux, "old stream not reused" );
1920         Ogg_LogicalStreamDelete( p_demux, p_ogg->p_old_stream );
1921         p_ogg->p_old_stream = NULL;
1922     }
1923 }
1924
1925 /****************************************************************************
1926  * Ogg_BeginningOfStream: Look for Beginning of Stream ogg pages and add
1927  *                        Elementary streams.
1928  ****************************************************************************/
1929 static int Ogg_BeginningOfStream( demux_t *p_demux )
1930 {
1931     demux_sys_t *p_ogg = p_demux->p_sys  ;
1932     int i_stream;
1933
1934     /* Find the logical streams embedded in the physical stream and
1935      * initialize our p_ogg structure. */
1936     if( Ogg_FindLogicalStreams( p_demux ) != VLC_SUCCESS )
1937     {
1938         msg_Warn( p_demux, "couldn't find any ogg logical stream" );
1939         return VLC_EGENERIC;
1940     }
1941
1942     p_ogg->i_bitrate = 0;
1943
1944     for( i_stream = 0 ; i_stream < p_ogg->i_streams; i_stream++ )
1945     {
1946         logical_stream_t *p_stream = p_ogg->pp_stream[i_stream];
1947
1948         p_stream->p_es = NULL;
1949
1950         /* initialise kframe index */
1951         p_stream->idx=NULL;
1952
1953         if ( p_stream->fmt.i_bitrate == 0  &&
1954              ( p_stream->fmt.i_cat == VIDEO_ES ||
1955                p_stream->fmt.i_cat == AUDIO_ES ) )
1956             p_ogg->b_partial_bitrate = true;
1957         else
1958             p_ogg->i_bitrate += p_stream->fmt.i_bitrate;
1959
1960         p_stream->i_pcr = p_stream->i_previous_pcr =
1961             p_stream->i_interpolated_pcr = VLC_TS_UNKNOWN;
1962         p_stream->b_reinit = false;
1963     }
1964
1965     /* get total frame count for video stream; we will need this for seeking */
1966     p_ogg->i_total_frames = 0;
1967
1968     return VLC_SUCCESS;
1969 }
1970
1971 /****************************************************************************
1972  * Ogg_EndOfStream: clean up the ES when an End of Stream is detected.
1973  ****************************************************************************/
1974 static void Ogg_EndOfStream( demux_t *p_demux )
1975 {
1976     demux_sys_t *p_ogg = p_demux->p_sys  ;
1977     int i_stream;
1978
1979     for( i_stream = 0 ; i_stream < p_ogg->i_streams; i_stream++ )
1980         Ogg_LogicalStreamDelete( p_demux, p_ogg->pp_stream[i_stream] );
1981     free( p_ogg->pp_stream );
1982
1983     /* Reinit p_ogg */
1984     p_ogg->i_bitrate = 0;
1985     p_ogg->i_streams = 0;
1986     p_ogg->pp_stream = NULL;
1987     p_ogg->skeleton.major = 0;
1988     p_ogg->skeleton.minor = 0;
1989     p_ogg->b_preparsing_done = false;
1990     p_ogg->b_es_created = false;
1991     p_ogg->i_pcr_offset = p_ogg->i_pcr;
1992
1993     /* */
1994     if( p_ogg->p_meta )
1995         vlc_meta_Delete( p_ogg->p_meta );
1996     p_ogg->p_meta = NULL;
1997
1998     for ( int i=0; i < p_ogg->i_seekpoints; i++ )
1999     {
2000         if ( p_ogg->pp_seekpoints[i] )
2001             vlc_seekpoint_Delete( p_ogg->pp_seekpoints[i] );
2002     }
2003     TAB_CLEAN( p_ogg->i_seekpoints, p_ogg->pp_seekpoints );
2004     p_ogg->i_seekpoints = 0;
2005 }
2006
2007 /**
2008  * This function delete and release all data associated to a logical_stream_t
2009  */
2010 static void Ogg_LogicalStreamDelete( demux_t *p_demux, logical_stream_t *p_stream )
2011 {
2012     if( p_stream->p_es )
2013         es_out_Del( p_demux->out, p_stream->p_es );
2014
2015     ogg_stream_clear( &p_stream->os );
2016     free( p_stream->p_headers );
2017
2018     es_format_Clean( &p_stream->fmt_old );
2019     es_format_Clean( &p_stream->fmt );
2020
2021     if ( p_stream->idx != NULL)
2022     {
2023         oggseek_index_entries_free( p_stream->idx );
2024     }
2025
2026     Ogg_FreeSkeleton( p_stream->p_skel );
2027     p_stream->p_skel = NULL;
2028     if ( p_demux->p_sys->p_skelstream == p_stream )
2029         p_demux->p_sys->p_skelstream = NULL;
2030
2031     /* Shouldn't happen */
2032     if ( unlikely( p_stream->p_preparse_block ) )
2033     {
2034         block_ChainRelease( p_stream->p_preparse_block );
2035         p_stream->p_preparse_block = NULL;
2036     }
2037
2038     free( p_stream );
2039 }
2040 /**
2041  * This function check if a we need to reset a decoder in case we are
2042  * reusing an old ES
2043  */
2044 static bool Ogg_IsVorbisFormatCompatible( const es_format_t *p_new, const es_format_t *p_old )
2045 {
2046     unsigned pi_new_size[XIPH_MAX_HEADER_COUNT];
2047     void     *pp_new_data[XIPH_MAX_HEADER_COUNT];
2048     unsigned i_new_count;
2049     if( xiph_SplitHeaders(pi_new_size, pp_new_data, &i_new_count, p_new->i_extra, p_new->p_extra ) )
2050         i_new_count = 0;
2051
2052     unsigned pi_old_size[XIPH_MAX_HEADER_COUNT];
2053     void     *pp_old_data[XIPH_MAX_HEADER_COUNT];
2054     unsigned i_old_count;
2055     if( xiph_SplitHeaders(pi_old_size, pp_old_data, &i_old_count, p_old->i_extra, p_old->p_extra ) )
2056         i_old_count = 0;
2057
2058     bool b_match = i_new_count == i_old_count;
2059     for( unsigned i = 0; i < i_new_count && b_match; i++ )
2060     {
2061         /* Ignore vorbis comment */
2062         if( i == 1 )
2063             continue;
2064         if( pi_new_size[i] != pi_old_size[i] ||
2065             memcmp( pp_new_data[i], pp_old_data[i], pi_new_size[i] ) )
2066             b_match = false;
2067     }
2068
2069     return b_match;
2070 }
2071
2072 static bool Ogg_IsOpusFormatCompatible( const es_format_t *p_new,
2073                                         const es_format_t *p_old )
2074 {
2075     unsigned pi_new_size[XIPH_MAX_HEADER_COUNT];
2076     void     *pp_new_data[XIPH_MAX_HEADER_COUNT];
2077     unsigned i_new_count;
2078     if( xiph_SplitHeaders(pi_new_size, pp_new_data, &i_new_count, p_new->i_extra, p_new->p_extra ) )
2079         i_new_count = 0;
2080     unsigned pi_old_size[XIPH_MAX_HEADER_COUNT];
2081     void     *pp_old_data[XIPH_MAX_HEADER_COUNT];
2082     unsigned i_old_count;
2083     if( xiph_SplitHeaders(pi_old_size, pp_old_data, &i_old_count, p_old->i_extra, p_old->p_extra ) )
2084         i_old_count = 0;
2085     bool b_match = false;
2086     if( i_new_count == i_old_count && i_new_count > 0 )
2087     {
2088         static const unsigned char default_map[2] = { 0, 1 };
2089         unsigned char *p_old_head;
2090         unsigned char *p_new_head;
2091         const unsigned char *p_old_map;
2092         const unsigned char *p_new_map;
2093         int i_old_channel_count;
2094         int i_new_channel_count;
2095         int i_old_stream_count;
2096         int i_new_stream_count;
2097         int i_old_coupled_count;
2098         int i_new_coupled_count;
2099         p_old_head = (unsigned char *)pp_old_data[0];
2100         i_old_channel_count = i_old_stream_count = i_old_coupled_count = 0;
2101         p_old_map = default_map;
2102         if( pi_old_size[0] >= 19 && p_old_head[8] <= 15 )
2103         {
2104             i_old_channel_count = p_old_head[9];
2105             switch( p_old_head[18] )
2106             {
2107                 case 0:
2108                     i_old_stream_count = 1;
2109                     i_old_coupled_count = i_old_channel_count - 1;
2110                     break;
2111                 case 1:
2112                     if( pi_old_size[0] >= 21U + i_old_channel_count )
2113                     {
2114                         i_old_stream_count = p_old_head[19];
2115                         i_old_coupled_count = p_old_head[20];
2116                         p_old_map = p_old_head + 21;
2117                     }
2118                     break;
2119             }
2120         }
2121         p_new_head = (unsigned char *)pp_new_data[0];
2122         i_new_channel_count = i_new_stream_count = i_new_coupled_count = 0;
2123         p_new_map = default_map;
2124         if( pi_new_size[0] >= 19 && p_new_head[8] <= 15 )
2125         {
2126             i_new_channel_count = p_new_head[9];
2127             switch( p_new_head[18] )
2128             {
2129                 case 0:
2130                     i_new_stream_count = 1;
2131                     i_new_coupled_count = i_new_channel_count - 1;
2132                     break;
2133                 case 1:
2134                     if( pi_new_size[0] >= 21U + i_new_channel_count )
2135                     {
2136                         i_new_stream_count = p_new_head[19];
2137                         i_new_coupled_count = p_new_head[20];
2138                         p_new_map = p_new_head+21;
2139                     }
2140                     break;
2141             }
2142         }
2143         b_match = i_old_channel_count == i_new_channel_count &&
2144                   i_old_stream_count == i_new_stream_count &&
2145                   i_old_coupled_count == i_new_coupled_count &&
2146                   memcmp(p_old_map, p_new_map,
2147                       i_new_channel_count*sizeof(*p_new_map)) == 0;
2148     }
2149
2150     return b_match;
2151 }
2152
2153 static bool Ogg_LogicalStreamResetEsFormat( demux_t *p_demux, logical_stream_t *p_stream )
2154 {
2155     bool b_compatible = false;
2156     if( !p_stream->fmt_old.i_cat || !p_stream->fmt_old.i_codec )
2157         return true;
2158
2159     /* Only Vorbis and Opus are supported. */
2160     if( p_stream->fmt.i_codec == VLC_CODEC_VORBIS )
2161         b_compatible = Ogg_IsVorbisFormatCompatible( &p_stream->fmt, &p_stream->fmt_old );
2162     else if( p_stream->fmt.i_codec == VLC_CODEC_OPUS )
2163         b_compatible = Ogg_IsOpusFormatCompatible( &p_stream->fmt, &p_stream->fmt_old );
2164
2165     if( !b_compatible )
2166         msg_Warn( p_demux, "cannot reuse old stream, resetting the decoder" );
2167
2168     return !b_compatible;
2169 }
2170
2171 static void Ogg_ExtractComments( demux_t *p_demux, es_format_t *p_fmt,
2172                                  const void *p_headers, unsigned i_headers )
2173 {
2174     demux_sys_t *p_ogg = p_demux->p_sys;
2175     int i_cover_score = 0;
2176     int i_cover_idx = 0;
2177     float pf_replay_gain[AUDIO_REPLAY_GAIN_MAX];
2178     float pf_replay_peak[AUDIO_REPLAY_GAIN_MAX];
2179     for(int i=0; i< AUDIO_REPLAY_GAIN_MAX; i++ )
2180     {
2181         pf_replay_gain[i] = 0;
2182         pf_replay_peak[i] = 0;
2183     }
2184     vorbis_ParseComment( &p_ogg->p_meta, p_headers, i_headers,
2185                          &p_ogg->i_attachments, &p_ogg->attachments,
2186                          &i_cover_score, &i_cover_idx,
2187                          &p_ogg->i_seekpoints, &p_ogg->pp_seekpoints,
2188                          &pf_replay_gain, &pf_replay_peak );
2189     if( p_ogg->p_meta != NULL && i_cover_idx < p_ogg->i_attachments )
2190     {
2191         char psz_url[128];
2192         snprintf( psz_url, sizeof(psz_url), "attachment://%s",
2193                   p_ogg->attachments[i_cover_idx]->psz_name );
2194         vlc_meta_Set( p_ogg->p_meta, vlc_meta_ArtworkURL, psz_url );
2195     }
2196
2197     for ( int i=0; i<AUDIO_REPLAY_GAIN_MAX;i++ )
2198     {
2199         if ( pf_replay_gain[i] != 0 )
2200         {
2201             p_fmt->audio_replay_gain.pb_gain[i] = true;
2202             p_fmt->audio_replay_gain.pf_gain[i] = pf_replay_gain[i];
2203             msg_Dbg( p_demux, "setting replay gain %d to %f", i, pf_replay_gain[i] );
2204         }
2205         if ( pf_replay_peak[i] != 0 )
2206         {
2207             p_fmt->audio_replay_gain.pb_peak[i] = true;
2208             p_fmt->audio_replay_gain.pf_peak[i] = pf_replay_peak[i];
2209             msg_Dbg( p_demux, "setting replay peak %d to %f", i, pf_replay_gain[i] );
2210         }
2211     }
2212
2213     if( p_ogg->i_seekpoints > 1 )
2214     {
2215         p_demux->info.i_update |= INPUT_UPDATE_TITLE_LIST;
2216     }
2217 }
2218
2219 static void Ogg_ExtractXiphMeta( demux_t *p_demux, es_format_t *p_fmt,
2220                                  const void *p_headers, unsigned i_headers, unsigned i_skip )
2221 {
2222     unsigned pi_size[XIPH_MAX_HEADER_COUNT];
2223     void     *pp_data[XIPH_MAX_HEADER_COUNT];
2224     unsigned i_count;
2225
2226     if( xiph_SplitHeaders( pi_size, pp_data, &i_count, i_headers, p_headers ) )
2227         return;
2228     /* TODO how to handle multiple comments properly ? */
2229     if( i_count >= 2 && pi_size[1] > i_skip )
2230     {
2231         Ogg_ExtractComments( p_demux, p_fmt, (uint8_t*)pp_data[1] + i_skip, pi_size[1] - i_skip );
2232     }
2233 }
2234
2235 static void Ogg_ExtractMeta( demux_t *p_demux, es_format_t *p_fmt, const uint8_t *p_headers, int i_headers )
2236 {
2237     demux_sys_t *p_ogg = p_demux->p_sys;
2238
2239     switch( p_fmt->i_codec )
2240     {
2241     /* 3 headers with the 2° one being the comments */
2242     case VLC_CODEC_VORBIS:
2243     case VLC_CODEC_THEORA:
2244         Ogg_ExtractXiphMeta( p_demux, p_fmt, p_headers, i_headers, 1+6 );
2245         break;
2246     case VLC_CODEC_OPUS:
2247         Ogg_ExtractXiphMeta( p_demux, p_fmt, p_headers, i_headers, 8 );
2248         break;
2249     case VLC_CODEC_SPEEX:
2250         Ogg_ExtractXiphMeta( p_demux, p_fmt, p_headers, i_headers, 0 );
2251         break;
2252     case VLC_CODEC_VP8:
2253         Ogg_ExtractComments( p_demux, p_fmt, p_headers, i_headers );
2254         break;
2255     /* N headers with the 2° one being the comments */
2256     case VLC_CODEC_KATE:
2257         /* 1 byte for header type, 7 bytes for magic, 1 reserved zero byte */
2258         Ogg_ExtractXiphMeta( p_demux, p_fmt, p_headers, i_headers, 1+7+1 );
2259         break;
2260
2261     /* TODO */
2262     case VLC_CODEC_FLAC:
2263         msg_Warn( p_demux, "Ogg_ExtractMeta does not support %4.4s", (const char*)&p_fmt->i_codec );
2264         break;
2265
2266     /* No meta data */
2267     case VLC_CODEC_CMML: /* CMML is XML text, doesn't have Vorbis comments */
2268     case VLC_CODEC_DIRAC:
2269     default:
2270         break;
2271     }
2272     if( p_ogg->p_meta )
2273         p_demux->info.i_update |= INPUT_UPDATE_META;
2274 }
2275
2276 static void Ogg_ReadTheoraHeader( logical_stream_t *p_stream,
2277                                   ogg_packet *p_oggpacket )
2278 {
2279     bs_t bitstream;
2280     int i_fps_numerator;
2281     int i_fps_denominator;
2282     int i_keyframe_frequency_force;
2283     int i_major;
2284     int i_minor;
2285     int i_subminor;
2286     int i_version;
2287
2288     p_stream->fmt.i_cat = VIDEO_ES;
2289     p_stream->fmt.i_codec = VLC_CODEC_THEORA;
2290
2291     /* Signal that we want to keep a backup of the theora
2292      * stream headers. They will be used when switching between
2293      * audio streams. */
2294     p_stream->b_force_backup = true;
2295
2296     /* Cheat and get additionnal info ;) */
2297     bs_init( &bitstream, p_oggpacket->packet, p_oggpacket->bytes );
2298     bs_skip( &bitstream, 56 );
2299
2300     i_major = bs_read( &bitstream, 8 ); /* major version num */
2301     i_minor = bs_read( &bitstream, 8 ); /* minor version num */
2302     i_subminor = bs_read( &bitstream, 8 ); /* subminor version num */
2303
2304     bs_read( &bitstream, 16 ) /*<< 4*/; /* width */
2305     bs_read( &bitstream, 16 ) /*<< 4*/; /* height */
2306     bs_read( &bitstream, 24 ); /* frame width */
2307     bs_read( &bitstream, 24 ); /* frame height */
2308     bs_read( &bitstream, 8 ); /* x offset */
2309     bs_read( &bitstream, 8 ); /* y offset */
2310
2311     i_fps_numerator = bs_read( &bitstream, 32 );
2312     i_fps_denominator = bs_read( &bitstream, 32 );
2313     i_fps_denominator = __MAX( i_fps_denominator, 1 );
2314     bs_read( &bitstream, 24 ); /* aspect_numerator */
2315     bs_read( &bitstream, 24 ); /* aspect_denominator */
2316
2317     p_stream->fmt.video.i_frame_rate = i_fps_numerator;
2318     p_stream->fmt.video.i_frame_rate_base = i_fps_denominator;
2319
2320     bs_read( &bitstream, 8 ); /* colorspace */
2321     p_stream->fmt.i_bitrate = bs_read( &bitstream, 24 );
2322     bs_read( &bitstream, 6 ); /* quality */
2323
2324     i_keyframe_frequency_force = 1 << bs_read( &bitstream, 5 );
2325
2326     /* granule_shift = i_log( frequency_force -1 ) */
2327     p_stream->i_granule_shift = 0;
2328     i_keyframe_frequency_force--;
2329     while( i_keyframe_frequency_force )
2330     {
2331         p_stream->i_granule_shift++;
2332         i_keyframe_frequency_force >>= 1;
2333     }
2334
2335     i_version = i_major * 1000000 + i_minor * 1000 + i_subminor;
2336     p_stream->i_keyframe_offset = 0;
2337     p_stream->f_rate = ((float)i_fps_numerator) / i_fps_denominator;
2338
2339     if ( i_version >= 3002001 )
2340     {
2341         p_stream->i_keyframe_offset = 1;
2342     }
2343 }
2344
2345 static void Ogg_ReadVorbisHeader( logical_stream_t *p_stream,
2346                                   ogg_packet *p_oggpacket )
2347 {
2348     oggpack_buffer opb;
2349
2350     p_stream->fmt.i_cat = AUDIO_ES;
2351     p_stream->fmt.i_codec = VLC_CODEC_VORBIS;
2352
2353     /* Signal that we want to keep a backup of the vorbis
2354      * stream headers. They will be used when switching between
2355      * audio streams. */
2356     p_stream->b_force_backup = true;
2357
2358     /* Cheat and get additionnal info ;) */
2359     oggpack_readinit( &opb, p_oggpacket->packet, p_oggpacket->bytes);
2360     oggpack_adv( &opb, 88 );
2361     p_stream->fmt.audio.i_channels = oggpack_read( &opb, 8 );
2362     fill_channels_info(&p_stream->fmt.audio);
2363     p_stream->f_rate = p_stream->fmt.audio.i_rate =
2364         oggpack_read( &opb, 32 );
2365     oggpack_adv( &opb, 32 );
2366     p_stream->fmt.i_bitrate = oggpack_read( &opb, 32 ); /* is signed 32 */
2367     if( p_stream->fmt.i_bitrate > INT32_MAX ) p_stream->fmt.i_bitrate = 0;
2368 }
2369
2370 static void Ogg_ReadSpeexHeader( logical_stream_t *p_stream,
2371                                  ogg_packet *p_oggpacket )
2372 {
2373     oggpack_buffer opb;
2374
2375     p_stream->fmt.i_cat = AUDIO_ES;
2376     p_stream->fmt.i_codec = VLC_CODEC_SPEEX;
2377
2378     /* Signal that we want to keep a backup of the speex
2379      * stream headers. They will be used when switching between
2380      * audio streams. */
2381     p_stream->b_force_backup = true;
2382
2383     /* Cheat and get additionnal info ;) */
2384     oggpack_readinit( &opb, p_oggpacket->packet, p_oggpacket->bytes);
2385     oggpack_adv( &opb, 224 );
2386     oggpack_adv( &opb, 32 ); /* speex_version_id */
2387     oggpack_adv( &opb, 32 ); /* header_size */
2388     p_stream->f_rate = p_stream->fmt.audio.i_rate = oggpack_read( &opb, 32 );
2389     oggpack_adv( &opb, 32 ); /* mode */
2390     oggpack_adv( &opb, 32 ); /* mode_bitstream_version */
2391     p_stream->fmt.audio.i_channels = oggpack_read( &opb, 32 );
2392     fill_channels_info(&p_stream->fmt.audio);
2393     p_stream->fmt.i_bitrate = oggpack_read( &opb, 32 );
2394     oggpack_adv( &opb, 32 ); /* frame_size */
2395     oggpack_adv( &opb, 32 ); /* vbr */
2396     oggpack_adv( &opb, 32 ); /* frames_per_packet */
2397     p_stream->i_extra_headers_packets = oggpack_read( &opb, 32 ); /* extra_headers */
2398 }
2399
2400 static void Ogg_ReadOpusHeader( logical_stream_t *p_stream,
2401                                 ogg_packet *p_oggpacket )
2402 {
2403     oggpack_buffer opb;
2404
2405     p_stream->fmt.i_cat = AUDIO_ES;
2406     p_stream->fmt.i_codec = VLC_CODEC_OPUS;
2407
2408     /* Signal that we want to keep a backup of the opus
2409      * stream headers. They will be used when switching between
2410      * audio streams. */
2411     p_stream->b_force_backup = true;
2412
2413     /* All OggOpus streams are timestamped at 48kHz and
2414      * can be played at 48kHz. */
2415     p_stream->f_rate = p_stream->fmt.audio.i_rate = 48000;
2416     p_stream->fmt.i_bitrate = 0;
2417
2418     /* Cheat and get additional info ;) */
2419     oggpack_readinit( &opb, p_oggpacket->packet, p_oggpacket->bytes);
2420     oggpack_adv( &opb, 64 );
2421     oggpack_adv( &opb, 8 ); /* version_id */
2422     p_stream->fmt.audio.i_channels = oggpack_read( &opb, 8 );
2423     fill_channels_info(&p_stream->fmt.audio);
2424     p_stream->i_pre_skip = oggpack_read( &opb, 16 );
2425 }
2426
2427 static void Ogg_ReadFlacHeader( demux_t *p_demux, logical_stream_t *p_stream,
2428                                 ogg_packet *p_oggpacket )
2429 {
2430     /* Parse the STREAMINFO metadata */
2431     bs_t s;
2432
2433     bs_init( &s, p_oggpacket->packet, p_oggpacket->bytes );
2434
2435     bs_read( &s, 1 );
2436     if( p_oggpacket->bytes > 0 && bs_read( &s, 7 ) != 0 )
2437     {
2438         msg_Dbg( p_demux, "Invalid FLAC STREAMINFO metadata" );
2439         return;
2440     }
2441
2442     if( bs_read( &s, 24 ) >= 34 /*size STREAMINFO*/ )
2443     {
2444         bs_skip( &s, 80 );
2445         p_stream->f_rate = p_stream->fmt.audio.i_rate = bs_read( &s, 20 );
2446         p_stream->fmt.audio.i_channels = bs_read( &s, 3 ) + 1;
2447         fill_channels_info(&p_stream->fmt.audio);
2448
2449         msg_Dbg( p_demux, "FLAC header, channels: %i, rate: %i",
2450                  p_stream->fmt.audio.i_channels, (int)p_stream->f_rate );
2451     }
2452     else
2453     {
2454         msg_Dbg( p_demux, "FLAC STREAMINFO metadata too short" );
2455     }
2456
2457     /* Fake this as the last metadata block */
2458     *((uint8_t*)p_oggpacket->packet) |= 0x80;
2459 }
2460
2461 static void Ogg_ReadKateHeader( logical_stream_t *p_stream,
2462                                 ogg_packet *p_oggpacket )
2463 {
2464     oggpack_buffer opb;
2465     int32_t gnum;
2466     int32_t gden;
2467     int n;
2468     char *psz_desc;
2469
2470     p_stream->fmt.i_cat = SPU_ES;
2471     p_stream->fmt.i_codec = VLC_CODEC_KATE;
2472
2473     /* Signal that we want to keep a backup of the kate
2474      * stream headers. They will be used when switching between
2475      * kate streams. */
2476     p_stream->b_force_backup = true;
2477
2478     /* Cheat and get additionnal info ;) */
2479     oggpack_readinit( &opb, p_oggpacket->packet, p_oggpacket->bytes);
2480     oggpack_adv( &opb, 11*8 ); /* packet type, kate magic, version */
2481     p_stream->i_kate_num_headers = oggpack_read( &opb, 8 );
2482     oggpack_adv( &opb, 3*8 );
2483     p_stream->i_granule_shift = oggpack_read( &opb, 8 );
2484     oggpack_adv( &opb, 8*8 ); /* reserved */
2485     gnum = oggpack_read( &opb, 32 );
2486     gden = oggpack_read( &opb, 32 );
2487     p_stream->f_rate = (double)gnum/gden;
2488
2489     p_stream->fmt.psz_language = malloc(16);
2490     if( p_stream->fmt.psz_language )
2491     {
2492         for( n = 0; n < 16; n++ )
2493             p_stream->fmt.psz_language[n] = oggpack_read(&opb,8);
2494         p_stream->fmt.psz_language[15] = 0; /* just in case */
2495     }
2496     else
2497     {
2498         for( n = 0; n < 16; n++ )
2499             oggpack_read(&opb,8);
2500     }
2501     p_stream->fmt.psz_description = malloc(16);
2502     if( p_stream->fmt.psz_description )
2503     {
2504         for( n = 0; n < 16; n++ )
2505             p_stream->fmt.psz_description[n] = oggpack_read(&opb,8);
2506         p_stream->fmt.psz_description[15] = 0; /* just in case */
2507
2508         /* Now find a localized user readable description for this category */
2509         psz_desc = strdup(FindKateCategoryName(p_stream->fmt.psz_description));
2510         if( psz_desc )
2511         {
2512             free( p_stream->fmt.psz_description );
2513             p_stream->fmt.psz_description = psz_desc;
2514         }
2515     }
2516     else
2517     {
2518         for( n = 0; n < 16; n++ )
2519             oggpack_read(&opb,8);
2520     }
2521 }
2522
2523 static bool Ogg_ReadVP8Header( demux_t *p_demux, logical_stream_t *p_stream,
2524                                ogg_packet *p_oggpacket )
2525 {
2526     switch( p_oggpacket->packet[5] )
2527     {
2528     /* STREAMINFO */
2529     case 0x01:
2530         /* Mapping version */
2531         if ( p_oggpacket->packet[6] != 0x01 || p_oggpacket->packet[7] != 0x00 )
2532             return false;
2533         p_stream->fmt.i_cat = VIDEO_ES;
2534         p_stream->fmt.i_codec = VLC_CODEC_VP8;
2535         p_stream->i_granule_shift = 32;
2536         p_stream->fmt.video.i_width = GetWBE( &p_oggpacket->packet[8] );
2537         p_stream->fmt.video.i_height = GetWBE( &p_oggpacket->packet[10] );
2538         p_stream->fmt.video.i_sar_num = GetDWBE( &p_oggpacket->packet[12 - 1] ) & 0x0FFF;
2539         p_stream->fmt.video.i_sar_den = GetDWBE( &p_oggpacket->packet[15 - 1] ) & 0x0FFF;
2540         p_stream->fmt.video.i_frame_rate = GetDWBE( &p_oggpacket->packet[18] );
2541         p_stream->fmt.video.i_frame_rate_base = GetDWBE( &p_oggpacket->packet[22] );
2542         p_stream->f_rate = (double) p_stream->fmt.video.i_frame_rate / p_stream->fmt.video.i_frame_rate_base;
2543         return true;
2544     /* METADATA */
2545     case 0x02:
2546         Ogg_ExtractMeta( p_demux, & p_stream->fmt,
2547                          p_oggpacket->packet + 7, p_oggpacket->bytes - 7 );
2548         return true;
2549     default:
2550         return false;
2551     }
2552 }
2553
2554 static void Ogg_ApplyContentType( logical_stream_t *p_stream, const char* psz_value,
2555                                   bool *b_force_backup, bool *b_packet_out )
2556 {
2557     if( !strncmp(psz_value, "audio/x-wav", 11) )
2558     {
2559         /* n.b. WAVs are unsupported right now */
2560         p_stream->fmt.i_cat = UNKNOWN_ES;
2561         free( p_stream->fmt.psz_description );
2562         p_stream->fmt.psz_description = strdup("WAV Audio (Unsupported)");
2563     }
2564     else if( !strncmp(psz_value, "audio/x-vorbis", 14) ||
2565              !strncmp(psz_value, "audio/vorbis", 12) )
2566     {
2567         p_stream->fmt.i_cat = AUDIO_ES;
2568         p_stream->fmt.i_codec = VLC_CODEC_VORBIS;
2569
2570         *b_force_backup = true;
2571     }
2572     else if( !strncmp(psz_value, "audio/x-speex", 13) ||
2573              !strncmp(psz_value, "audio/speex", 11) )
2574     {
2575         p_stream->fmt.i_cat = AUDIO_ES;
2576         p_stream->fmt.i_codec = VLC_CODEC_SPEEX;
2577
2578         *b_force_backup = true;
2579     }
2580     else if( !strncmp(psz_value, "audio/flac", 10) )
2581     {
2582         p_stream->fmt.i_cat = AUDIO_ES;
2583         p_stream->fmt.i_codec = VLC_CODEC_FLAC;
2584
2585         *b_force_backup = true;
2586     }
2587     else if( !strncmp(psz_value, "video/x-theora", 14) ||
2588              !strncmp(psz_value, "video/theora", 12) )
2589     {
2590         p_stream->fmt.i_cat = VIDEO_ES;
2591         p_stream->fmt.i_codec = VLC_CODEC_THEORA;
2592
2593         *b_force_backup = true;
2594     }
2595     else if( !strncmp(psz_value, "video/x-xvid", 12) )
2596     {
2597         p_stream->fmt.i_cat = VIDEO_ES;
2598         p_stream->fmt.i_codec = VLC_FOURCC( 'x','v','i','d' );
2599
2600         *b_force_backup = true;
2601     }
2602     else if( !strncmp(psz_value, "video/mpeg", 10) )
2603     {
2604         /* n.b. MPEG streams are unsupported right now */
2605         p_stream->fmt.i_cat = VIDEO_ES;
2606         p_stream->fmt.i_codec = VLC_CODEC_MPGV;
2607     }
2608     else if( !strncmp(psz_value, "text/x-cmml", 11) ||
2609              !strncmp(psz_value, "text/cmml", 9) )
2610     {
2611         p_stream->fmt.i_cat = SPU_ES;
2612         p_stream->fmt.i_codec = VLC_CODEC_CMML;
2613         *b_packet_out = true;
2614     }
2615     else if( !strncmp(psz_value, "application/kate", 16) )
2616     {
2617         /* ??? */
2618         p_stream->fmt.i_cat = UNKNOWN_ES;
2619         free( p_stream->fmt.psz_description );
2620         p_stream->fmt.psz_description = strdup("OGG Kate Overlay (Unsupported)");
2621     }
2622     else if( !strncmp(psz_value, "video/x-vp8", 11) )
2623     {
2624         p_stream->fmt.i_cat = VIDEO_ES;
2625         p_stream->fmt.i_codec = VLC_CODEC_VP8;
2626     }
2627 }
2628
2629 static void Ogg_ReadAnnodexHeader( demux_t *p_demux,
2630                                    logical_stream_t *p_stream,
2631                                    ogg_packet *p_oggpacket )
2632 {
2633     if( p_oggpacket->bytes >= 28 &&
2634         !memcmp( p_oggpacket->packet, "Annodex", 7 ) )
2635     {
2636         oggpack_buffer opb;
2637
2638         uint16_t major_version;
2639         uint16_t minor_version;
2640         uint64_t timebase_numerator;
2641         uint64_t timebase_denominator;
2642
2643         Ogg_ReadTheoraHeader( p_stream, p_oggpacket );
2644
2645         oggpack_readinit( &opb, p_oggpacket->packet, p_oggpacket->bytes);
2646         oggpack_adv( &opb, 8*8 ); /* "Annodex\0" header */
2647         major_version = oggpack_read( &opb, 2*8 ); /* major version */
2648         minor_version = oggpack_read( &opb, 2*8 ); /* minor version */
2649         timebase_numerator = GetQWLE( &p_oggpacket->packet[16] );
2650         timebase_denominator = GetQWLE( &p_oggpacket->packet[24] );
2651
2652         msg_Dbg( p_demux, "Annodex info: version %"PRIu16".%"PRIu16" "
2653                           "Timebase  %"PRId64" / %"PRId64,
2654                           major_version, minor_version,
2655                           timebase_numerator, timebase_denominator );
2656     }
2657     else if( p_oggpacket->bytes >= 42 &&
2658              !memcmp( p_oggpacket->packet, "AnxData", 7 ) )
2659     {
2660         uint64_t granule_rate_numerator;
2661         uint64_t granule_rate_denominator;
2662         char content_type_string[1024];
2663
2664         /* Read in Annodex header fields */
2665
2666         granule_rate_numerator = GetQWLE( &p_oggpacket->packet[8] );
2667         granule_rate_denominator = GetQWLE( &p_oggpacket->packet[16] );
2668         p_stream->i_secondary_header_packets =
2669             GetDWLE( &p_oggpacket->packet[24] );
2670
2671         /* we are guaranteed that the first header field will be
2672          * the content-type (by the Annodex standard) */
2673         content_type_string[0] = '\0';
2674         if( !strncasecmp( (char*)(&p_oggpacket->packet[28]), "Content-Type: ", 14 ) )
2675         {
2676             uint8_t *p = memchr( &p_oggpacket->packet[42], '\r',
2677                                  p_oggpacket->bytes - 1 );
2678             if( p && p[0] == '\r' && p[1] == '\n' )
2679                 sscanf( (char*)(&p_oggpacket->packet[42]), "%1023s\r\n",
2680                         content_type_string );
2681         }
2682
2683         msg_Dbg( p_demux, "AnxData packet info: %"PRId64" / %"PRId64", %d, ``%s''",
2684                  granule_rate_numerator, granule_rate_denominator,
2685                  p_stream->i_secondary_header_packets, content_type_string );
2686
2687         p_stream->f_rate = (float) granule_rate_numerator /
2688             (float) granule_rate_denominator;
2689
2690         /* What type of file do we have?
2691          * strcmp is safe to use here because we've extracted
2692          * content_type_string from the stream manually */
2693         bool b_dopacketout = false;
2694         Ogg_ApplyContentType( p_stream, content_type_string,
2695                               &p_stream->b_force_backup, &b_dopacketout );
2696         if ( b_dopacketout ) ogg_stream_packetout( &p_stream->os, p_oggpacket );
2697     }
2698 }
2699
2700 static void Ogg_ReadSkeletonHeader( demux_t *p_demux, logical_stream_t *p_stream,
2701                                     ogg_packet *p_oggpacket )
2702 {
2703     p_demux->p_sys->p_skelstream = p_stream;
2704     /* There can be only 1 skeleton for streams */
2705     p_demux->p_sys->skeleton.major = GetWLE( &p_oggpacket->packet[8] );
2706     p_demux->p_sys->skeleton.minor = GetWLE( &p_oggpacket->packet[10] );
2707     if ( asprintf( & p_stream->fmt.psz_description,
2708                         "OGG Skeleton version %" PRIu16 ".%" PRIu16,
2709                         p_demux->p_sys->skeleton.major,
2710                         p_demux->p_sys->skeleton.minor ) < 0 )
2711         p_stream->fmt.psz_description = NULL;
2712 }
2713
2714 static void Ogg_ReadSkeletonBones( demux_t *p_demux, ogg_packet *p_oggpacket )
2715 {
2716     if ( p_demux->p_sys->skeleton.major < 3 || p_oggpacket->bytes < 52 ) return;
2717
2718     /* Find the matching stream for this skeleton data */
2719     ogg_int32_t i_serialno = GetDWLE( &p_oggpacket->packet[12] );
2720     logical_stream_t *p_target_stream = NULL;
2721     for ( int i=0; i< p_demux->p_sys->i_streams; i++ )
2722     {
2723         if ( p_demux->p_sys->pp_stream[i]->i_serial_no == i_serialno )
2724         {
2725             p_target_stream = p_demux->p_sys->pp_stream[i];
2726             break;
2727         }
2728     }
2729     if ( !p_target_stream ) return;
2730
2731     ogg_skeleton_t *p_skel = p_target_stream->p_skel;
2732     if ( !p_skel )
2733     {
2734         p_skel = malloc( sizeof( ogg_skeleton_t ) );
2735         if ( !p_skel ) return;
2736         TAB_INIT( p_skel->i_messages, p_skel->ppsz_messages );
2737         p_skel->p_index = NULL;
2738         p_target_stream->p_skel = p_skel;
2739     }
2740
2741     const unsigned char *p_messages = p_oggpacket->packet + 8 + GetDWLE( &p_oggpacket->packet[8] );
2742     const unsigned char *p_boundary = p_oggpacket->packet + p_oggpacket->bytes;
2743     const unsigned char *p = p_messages;
2744     while ( p <= p_boundary - 1 && p > p_oggpacket->packet )
2745     {
2746         if ( *p == 0x0D && *(p+1) == 0x0A )
2747         {
2748             char *psz_message = strndup( (const char *) p_messages,
2749                                          p - p_messages );
2750             if ( psz_message )
2751             {
2752                 msg_Dbg( p_demux, "stream %" PRId32 " [%s]", i_serialno, psz_message );
2753                 TAB_APPEND( p_skel->i_messages, p_skel->ppsz_messages, psz_message );
2754             }
2755             if ( p < p_boundary - 1 ) p_messages = p + 2;
2756         }
2757         p++;
2758     }
2759
2760 }
2761
2762 /* Unpacks the 7bit variable encoding used in skeleton indexes */
2763 unsigned const char * Read7BitsVariableLE( unsigned const char *p_begin,
2764                                            unsigned const char *p_end,
2765                                            uint64_t *pi_value )
2766 {
2767     int i_shift = 0;
2768     int64_t i_read = 0;
2769     *pi_value = 0;
2770
2771     while ( p_begin < p_end )
2772     {
2773         i_read = *p_begin & 0x7F; /* High bit is start of integer */
2774         *pi_value = *pi_value | ( i_read << i_shift );
2775         i_shift += 7;
2776         if ( (*p_begin++ & 0x80) == 0x80 ) break; /* see prev */
2777     }
2778
2779     *pi_value = GetQWLE( pi_value );
2780     return p_begin;
2781 }
2782
2783 static void Ogg_ReadSkeletonIndex( demux_t *p_demux, ogg_packet *p_oggpacket )
2784 {
2785     if ( p_demux->p_sys->skeleton.major < 4
2786          || p_oggpacket->bytes < 44 /* Need at least 1 index value (42+1+1) */
2787     ) return;
2788
2789     /* Find the matching stream for this skeleton data */
2790     int32_t i_serialno = GetDWLE( &p_oggpacket->packet[6] );
2791     logical_stream_t *p_stream = NULL;
2792     for ( int i=0; i< p_demux->p_sys->i_streams; i++ )
2793     {
2794         if ( p_demux->p_sys->pp_stream[i]->i_serial_no == i_serialno )
2795         {
2796             p_stream = p_demux->p_sys->pp_stream[i];
2797             break;
2798         }
2799     }
2800     if ( !p_stream ) return;
2801     uint64_t i_keypoints = GetQWLE( &p_oggpacket->packet[10] );
2802     msg_Dbg( p_demux, "%" PRIi64 " index data for %" PRIi32, i_keypoints, i_serialno );
2803     if ( !i_keypoints ) return;
2804
2805     p_stream->p_skel->i_indexstampden = GetQWLE( &p_oggpacket->packet[18] );
2806     p_stream->p_skel->i_indexfirstnum = GetQWLE( &p_oggpacket->packet[24] );
2807     p_stream->p_skel->i_indexlastnum = GetQWLE( &p_oggpacket->packet[32] );
2808     unsigned const char *p_fwdbyte = &p_oggpacket->packet[42];
2809     unsigned const char *p_boundary = p_oggpacket->packet + p_oggpacket->bytes;
2810     uint64_t i_offset = 0;
2811     uint64_t i_time = 0;
2812     uint64_t i_keypoints_found = 0;
2813
2814     while( p_fwdbyte < p_boundary && i_keypoints_found < i_keypoints )
2815     {
2816         uint64_t i_val;
2817         p_fwdbyte = Read7BitsVariableLE( p_fwdbyte, p_boundary, &i_val );
2818         i_offset += i_val;
2819         p_fwdbyte = Read7BitsVariableLE( p_fwdbyte, p_boundary, &i_val );
2820         i_time += i_val * p_stream->p_skel->i_indexstampden;
2821         i_keypoints_found++;
2822     }
2823
2824     if ( i_keypoints_found != i_keypoints )
2825     {
2826         msg_Warn( p_demux, "Invalid Index: missing entries" );
2827         return;
2828     }
2829
2830     p_stream->p_skel->p_index = malloc( p_oggpacket->bytes - 42 );
2831     if ( !p_stream->p_skel->p_index ) return;
2832     memcpy( p_stream->p_skel->p_index, &p_oggpacket->packet[42],
2833             p_oggpacket->bytes - 42 );
2834     p_stream->p_skel->i_index = i_keypoints_found;
2835     p_stream->p_skel->i_index_size = p_oggpacket->bytes - 42;
2836 }
2837
2838 static void Ogg_FreeSkeleton( ogg_skeleton_t *p_skel )
2839 {
2840     if ( !p_skel ) return;
2841     for ( int i=0; i< p_skel->i_messages; i++ )
2842         free( p_skel->ppsz_messages[i] );
2843     TAB_CLEAN( p_skel->i_messages, p_skel->ppsz_messages );
2844     free( p_skel->p_index );
2845     free( p_skel );
2846 }
2847
2848 static void Ogg_ApplySkeleton( logical_stream_t *p_stream )
2849 {
2850     if ( !p_stream->p_skel ) return;
2851     for ( int i=0; i< p_stream->p_skel->i_messages; i++ )
2852     {
2853         const char *psz_message = p_stream->p_skel->ppsz_messages[i];
2854         if ( ! strncmp( "Name: ", psz_message, 6 ) )
2855         {
2856             free( p_stream->fmt.psz_description );
2857             p_stream->fmt.psz_description = strdup( psz_message + 6 );
2858         }
2859         else if ( ! strncmp("Content-Type: ", psz_message, 14 ) )
2860         {
2861             bool b_foo;
2862             Ogg_ApplyContentType( p_stream, psz_message + 14, &b_foo, &b_foo );
2863         }
2864     }
2865 }
2866
2867 /* Return true if there's a skeleton exact match */
2868 bool Ogg_GetBoundsUsingSkeletonIndex( logical_stream_t *p_stream, int64_t i_time,
2869                                       int64_t *pi_lower, int64_t *pi_upper )
2870 {
2871     if ( !p_stream || !p_stream->p_skel || !p_stream->p_skel->p_index )
2872         return false;
2873
2874     /* Validate range */
2875     if ( i_time < p_stream->p_skel->i_indexfirstnum
2876                 * p_stream->p_skel->i_indexstampden ||
2877          i_time > p_stream->p_skel->i_indexlastnum
2878                 * p_stream->p_skel->i_indexstampden ) return false;
2879
2880     /* Then Lookup its index */
2881     unsigned const char *p_fwdbyte = p_stream->p_skel->p_index;
2882     struct
2883     {
2884         int64_t i_pos;
2885         int64_t i_time;
2886     } current = { 0, 0 }, prev = { -1, -1 };
2887
2888     uint64_t i_keypoints_found = 0;
2889
2890     while( p_fwdbyte < p_fwdbyte + p_stream->p_skel->i_index_size
2891            && i_keypoints_found < p_stream->p_skel->i_index )
2892     {
2893         uint64_t i_val;
2894         p_fwdbyte = Read7BitsVariableLE( p_fwdbyte,
2895                         p_fwdbyte + p_stream->p_skel->i_index_size, &i_val );
2896         current.i_pos += i_val;
2897         p_fwdbyte = Read7BitsVariableLE( p_fwdbyte,
2898                         p_fwdbyte + p_stream->p_skel->i_index_size, &i_val );
2899         current.i_time += i_val * p_stream->p_skel->i_indexstampden;
2900         if ( current.i_pos < 0 || current.i_time < 0 ) break;
2901
2902         i_keypoints_found++;
2903
2904         if ( i_time <= current.i_time )
2905         {
2906             *pi_lower = prev.i_pos;
2907             *pi_upper = current.i_pos;
2908             return ( i_time == current.i_time );
2909         }
2910         prev = current;
2911     }
2912     return false;
2913 }
2914
2915 static uint32_t dirac_uint( bs_t *p_bs )
2916 {
2917     uint32_t u_count = 0, u_value = 0;
2918
2919     while( !bs_eof( p_bs ) && !bs_read( p_bs, 1 ) )
2920     {
2921         u_count++;
2922         u_value <<= 1;
2923         u_value |= bs_read( p_bs, 1 );
2924     }
2925
2926     return (1<<u_count) - 1 + u_value;
2927 }
2928
2929 static int dirac_bool( bs_t *p_bs )
2930 {
2931     return bs_read( p_bs, 1 );
2932 }
2933
2934 static bool Ogg_ReadDiracHeader( logical_stream_t *p_stream,
2935                                  ogg_packet *p_oggpacket )
2936 {
2937     static const struct {
2938         uint32_t u_n /* numerator */, u_d /* denominator */;
2939     } p_dirac_frate_tbl[] = { /* table 10.3 */
2940         {1,1}, /* this first value is never used */
2941         {24000,1001}, {24,1}, {25,1}, {30000,1001}, {30,1},
2942         {50,1}, {60000,1001}, {60,1}, {15000,1001}, {25,2},
2943     };
2944     static const size_t u_dirac_frate_tbl = sizeof(p_dirac_frate_tbl)/sizeof(*p_dirac_frate_tbl);
2945
2946     static const uint32_t pu_dirac_vidfmt_frate[] = { /* table C.1 */
2947         1, 9, 10, 9, 10, 9, 10, 4, 3, 7, 6, 4, 3, 7, 6, 2, 2, 7, 6, 7, 6,
2948     };
2949     static const size_t u_dirac_vidfmt_frate = sizeof(pu_dirac_vidfmt_frate)/sizeof(*pu_dirac_vidfmt_frate);
2950
2951     bs_t bs;
2952
2953     p_stream->i_granule_shift = 22; /* not 32 */
2954
2955     /* Backing up stream headers is not required -- seqhdrs are repeated
2956      * thoughout the stream at suitable decoding start points */
2957     p_stream->b_force_backup = false;
2958
2959     /* read in useful bits from sequence header */
2960     bs_init( &bs, p_oggpacket->packet, p_oggpacket->bytes );
2961     bs_skip( &bs, 13*8); /* parse_info_header */
2962     dirac_uint( &bs ); /* major_version */
2963     dirac_uint( &bs ); /* minor_version */
2964     dirac_uint( &bs ); /* profile */
2965     dirac_uint( &bs ); /* level */
2966
2967     uint32_t u_video_format = dirac_uint( &bs ); /* index */
2968     if( u_video_format >= u_dirac_vidfmt_frate )
2969     {
2970         /* don't know how to parse this ogg dirac stream */
2971         return false;
2972     }
2973
2974     if( dirac_bool( &bs ) )
2975     {
2976         dirac_uint( &bs ); /* frame_width */
2977         dirac_uint( &bs ); /* frame_height */
2978     }
2979
2980     if( dirac_bool( &bs ) )
2981     {
2982         dirac_uint( &bs ); /* chroma_format */
2983     }
2984
2985     if( dirac_bool( &bs ) )
2986     {
2987         dirac_uint( &bs ); /* scan_format */
2988     }
2989
2990     uint32_t u_n = p_dirac_frate_tbl[pu_dirac_vidfmt_frate[u_video_format]].u_n;
2991     uint32_t u_d = p_dirac_frate_tbl[pu_dirac_vidfmt_frate[u_video_format]].u_d;
2992     if( dirac_bool( &bs ) )
2993     {
2994         uint32_t u_frame_rate_index = dirac_uint( &bs );
2995         if( u_frame_rate_index >= u_dirac_frate_tbl )
2996         {
2997             /* something is wrong with this stream */
2998             return false;
2999         }
3000         u_n = p_dirac_frate_tbl[u_frame_rate_index].u_n;
3001         u_d = p_dirac_frate_tbl[u_frame_rate_index].u_d;
3002         if( u_frame_rate_index == 0 )
3003         {
3004             u_n = dirac_uint( &bs ); /* frame_rate_numerator */
3005             u_d = dirac_uint( &bs ); /* frame_rate_denominator */
3006         }
3007     }
3008     p_stream->f_rate = (float) u_n / u_d;
3009
3010     /* probably is an ogg dirac es */
3011     p_stream->fmt.i_cat = VIDEO_ES;
3012     p_stream->fmt.i_codec = VLC_CODEC_DIRAC;
3013
3014     return true;
3015 }