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