64a88261e3fe2eaa37ef3f1e68869afe5a5b34e7
[ffmpeg.git] / libavformat / oggdec.c
1 /*
2  * Ogg bitstream support
3  * Luca Barbato <lu_zero@gentoo.org>
4  * Based on tcvp implementation
5  */
6
7 /*
8     Copyright (C) 2005  Michael Ahlberg, Måns Rullgård
9
10     Permission is hereby granted, free of charge, to any person
11     obtaining a copy of this software and associated documentation
12     files (the "Software"), to deal in the Software without
13     restriction, including without limitation the rights to use, copy,
14     modify, merge, publish, distribute, sublicense, and/or sell copies
15     of the Software, and to permit persons to whom the Software is
16     furnished to do so, subject to the following conditions:
17
18     The above copyright notice and this permission notice shall be
19     included in all copies or substantial portions of the Software.
20
21     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
25     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
26     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28     DEALINGS IN THE SOFTWARE.
29  */
30
31 #include <stdio.h>
32 #include "libavutil/avassert.h"
33 #include "libavutil/intreadwrite.h"
34 #include "oggdec.h"
35 #include "avformat.h"
36 #include "internal.h"
37 #include "vorbiscomment.h"
38
39 #define MAX_PAGE_SIZE 65307
40 #define DECODER_BUFFER_SIZE MAX_PAGE_SIZE
41
42 static const struct ogg_codec * const ogg_codecs[] = {
43     &ff_skeleton_codec,
44     &ff_daala_codec,
45     &ff_dirac_codec,
46     &ff_speex_codec,
47     &ff_vorbis_codec,
48     &ff_theora_codec,
49     &ff_flac_codec,
50     &ff_celt_codec,
51     &ff_opus_codec,
52     &ff_vp8_codec,
53     &ff_old_dirac_codec,
54     &ff_old_flac_codec,
55     &ff_ogm_video_codec,
56     &ff_ogm_audio_codec,
57     &ff_ogm_text_codec,
58     &ff_ogm_old_codec,
59     NULL
60 };
61
62 static int64_t ogg_calc_pts(AVFormatContext *s, int idx, int64_t *dts);
63 static int ogg_new_stream(AVFormatContext *s, uint32_t serial);
64 static int ogg_restore(AVFormatContext *s);
65
66 //FIXME We could avoid some structure duplication
67 static int ogg_save(AVFormatContext *s)
68 {
69     struct ogg *ogg = s->priv_data;
70     struct ogg_state *ost =
71         av_malloc(sizeof(*ost) + (ogg->nstreams - 1) * sizeof(*ogg->streams));
72     int i;
73     int ret = 0;
74
75     if (!ost)
76         return AVERROR(ENOMEM);
77
78     ost->pos      = avio_tell(s->pb);
79     ost->curidx   = ogg->curidx;
80     ost->next     = ogg->state;
81     ost->nstreams = ogg->nstreams;
82     memcpy(ost->streams, ogg->streams, ogg->nstreams * sizeof(*ogg->streams));
83
84     for (i = 0; i < ogg->nstreams; i++) {
85         struct ogg_stream *os = ogg->streams + i;
86         os->buf = av_mallocz(os->bufsize + AV_INPUT_BUFFER_PADDING_SIZE);
87         if (os->buf)
88             memcpy(os->buf, ost->streams[i].buf, os->bufpos);
89         else
90             ret = AVERROR(ENOMEM);
91         os->new_metadata      = NULL;
92         os->new_metadata_size = 0;
93     }
94
95     ogg->state = ost;
96
97     if (ret < 0)
98         ogg_restore(s);
99
100     return ret;
101 }
102
103 static int ogg_restore(AVFormatContext *s)
104 {
105     struct ogg *ogg = s->priv_data;
106     AVIOContext *bc = s->pb;
107     struct ogg_state *ost = ogg->state;
108     int i, err;
109
110     if (!ost)
111         return 0;
112
113     ogg->state = ost->next;
114
115         for (i = 0; i < ogg->nstreams; i++)
116             av_freep(&ogg->streams[i].buf);
117
118         avio_seek(bc, ost->pos, SEEK_SET);
119         ogg->page_pos = -1;
120         ogg->curidx   = ost->curidx;
121         ogg->nstreams = ost->nstreams;
122         if ((err = av_reallocp_array(&ogg->streams, ogg->nstreams,
123                                      sizeof(*ogg->streams))) < 0) {
124             ogg->nstreams = 0;
125             return err;
126         } else
127             memcpy(ogg->streams, ost->streams,
128                    ost->nstreams * sizeof(*ogg->streams));
129
130     av_free(ost);
131
132     return 0;
133 }
134
135 static int ogg_reset(AVFormatContext *s)
136 {
137     struct ogg *ogg = s->priv_data;
138     int i;
139     int64_t start_pos = avio_tell(s->pb);
140
141     for (i = 0; i < ogg->nstreams; i++) {
142         struct ogg_stream *os = ogg->streams + i;
143         os->bufpos     = 0;
144         os->pstart     = 0;
145         os->psize      = 0;
146         os->granule    = -1;
147         os->lastpts    = AV_NOPTS_VALUE;
148         os->lastdts    = AV_NOPTS_VALUE;
149         os->sync_pos   = -1;
150         os->page_pos   = 0;
151         os->nsegs      = 0;
152         os->segp       = 0;
153         os->incomplete = 0;
154         os->got_data = 0;
155         if (start_pos <= s->internal->data_offset) {
156             os->lastpts = 0;
157         }
158         os->end_trimming = 0;
159         av_freep(&os->new_metadata);
160         os->new_metadata_size = 0;
161     }
162
163     ogg->page_pos = -1;
164     ogg->curidx = -1;
165
166     return 0;
167 }
168
169 static const struct ogg_codec *ogg_find_codec(uint8_t *buf, int size)
170 {
171     int i;
172
173     for (i = 0; ogg_codecs[i]; i++)
174         if (size >= ogg_codecs[i]->magicsize &&
175             !memcmp(buf, ogg_codecs[i]->magic, ogg_codecs[i]->magicsize))
176             return ogg_codecs[i];
177
178     return NULL;
179 }
180
181 /**
182  * Replace the current stream with a new one. This is a typical webradio
183  * situation where a new audio stream spawn (identified with a new serial) and
184  * must replace the previous one (track switch).
185  */
186 static int ogg_replace_stream(AVFormatContext *s, uint32_t serial, int nsegs)
187 {
188     struct ogg *ogg = s->priv_data;
189     struct ogg_stream *os;
190     const struct ogg_codec *codec;
191     int i = 0;
192
193     if (s->pb->seekable) {
194         uint8_t magic[8];
195         int64_t pos = avio_tell(s->pb);
196         avio_skip(s->pb, nsegs);
197         avio_read(s->pb, magic, sizeof(magic));
198         avio_seek(s->pb, pos, SEEK_SET);
199         codec = ogg_find_codec(magic, sizeof(magic));
200         if (!codec) {
201             av_log(s, AV_LOG_ERROR, "Cannot identify new stream\n");
202             return AVERROR_INVALIDDATA;
203         }
204         for (i = 0; i < ogg->nstreams; i++) {
205             if (ogg->streams[i].codec == codec)
206                 break;
207         }
208         if (i >= ogg->nstreams)
209             return ogg_new_stream(s, serial);
210     } else if (ogg->nstreams != 1) {
211         avpriv_report_missing_feature(s, "Changing stream parameters in multistream ogg");
212         return AVERROR_PATCHWELCOME;
213     }
214
215     os = &ogg->streams[i];
216
217     os->serial  = serial;
218     return i;
219
220 #if 0
221     buf     = os->buf;
222     bufsize = os->bufsize;
223     codec   = os->codec;
224
225     if (!ogg->state || ogg->state->streams[i].private != os->private)
226         av_freep(&ogg->streams[i].private);
227
228     /* Set Ogg stream settings similar to what is done in ogg_new_stream(). We
229      * also re-use the ogg_stream allocated buffer */
230     memset(os, 0, sizeof(*os));
231     os->serial  = serial;
232     os->bufsize = bufsize;
233     os->buf     = buf;
234     os->header  = -1;
235     os->codec   = codec;
236
237     return i;
238 #endif
239 }
240
241 static int ogg_new_stream(AVFormatContext *s, uint32_t serial)
242 {
243     struct ogg *ogg = s->priv_data;
244     int idx         = ogg->nstreams;
245     AVStream *st;
246     struct ogg_stream *os;
247     size_t size;
248
249     if (ogg->state) {
250         av_log(s, AV_LOG_ERROR, "New streams are not supposed to be added "
251                "in between Ogg context save/restore operations.\n");
252         return AVERROR_BUG;
253     }
254
255     /* Allocate and init a new Ogg Stream */
256     if (av_size_mult(ogg->nstreams + 1, sizeof(*ogg->streams), &size) < 0 ||
257         !(os = av_realloc(ogg->streams, size)))
258         return AVERROR(ENOMEM);
259     ogg->streams = os;
260     os           = ogg->streams + idx;
261     memset(os, 0, sizeof(*os));
262     os->serial        = serial;
263     os->bufsize       = DECODER_BUFFER_SIZE;
264     os->buf           = av_malloc(os->bufsize + AV_INPUT_BUFFER_PADDING_SIZE);
265     os->header        = -1;
266     os->start_granule = OGG_NOGRANULE_VALUE;
267     if (!os->buf)
268         return AVERROR(ENOMEM);
269
270     /* Create the associated AVStream */
271     st = avformat_new_stream(s, NULL);
272     if (!st) {
273         av_freep(&os->buf);
274         return AVERROR(ENOMEM);
275     }
276     st->id = idx;
277     avpriv_set_pts_info(st, 64, 1, 1000000);
278
279     ogg->nstreams++;
280     return idx;
281 }
282
283 static int ogg_new_buf(struct ogg *ogg, int idx)
284 {
285     struct ogg_stream *os = ogg->streams + idx;
286     uint8_t *nb = av_malloc(os->bufsize + AV_INPUT_BUFFER_PADDING_SIZE);
287     int size = os->bufpos - os->pstart;
288
289     if (!nb)
290         return AVERROR(ENOMEM);
291
292     if (os->buf) {
293         memcpy(nb, os->buf + os->pstart, size);
294         av_free(os->buf);
295     }
296
297     os->buf    = nb;
298     os->bufpos = size;
299     os->pstart = 0;
300
301     return 0;
302 }
303
304 static int data_packets_seen(const struct ogg *ogg)
305 {
306     int i;
307
308     for (i = 0; i < ogg->nstreams; i++)
309         if (ogg->streams[i].got_data)
310             return 1;
311     return 0;
312 }
313
314 static int ogg_read_page(AVFormatContext *s, int *sid)
315 {
316     AVIOContext *bc = s->pb;
317     struct ogg *ogg = s->priv_data;
318     struct ogg_stream *os;
319     int ret, i = 0;
320     int flags, nsegs;
321     uint64_t gp;
322     uint32_t serial;
323     int size, idx;
324     uint8_t sync[4];
325     int sp = 0;
326
327     ret = avio_read(bc, sync, 4);
328     if (ret < 4)
329         return ret < 0 ? ret : AVERROR_EOF;
330
331     do {
332         int c;
333
334         if (sync[sp & 3] == 'O' &&
335             sync[(sp + 1) & 3] == 'g' &&
336             sync[(sp + 2) & 3] == 'g' && sync[(sp + 3) & 3] == 'S')
337             break;
338
339         if(!i && bc->seekable && ogg->page_pos > 0) {
340             memset(sync, 0, 4);
341             avio_seek(bc, ogg->page_pos+4, SEEK_SET);
342             ogg->page_pos = -1;
343         }
344
345         c = avio_r8(bc);
346
347         if (avio_feof(bc))
348             return AVERROR_EOF;
349
350         sync[sp++ & 3] = c;
351     } while (i++ < MAX_PAGE_SIZE);
352
353     if (i >= MAX_PAGE_SIZE) {
354         av_log(s, AV_LOG_INFO, "cannot find sync word\n");
355         return AVERROR_INVALIDDATA;
356     }
357
358     if (avio_r8(bc) != 0) {      /* version */
359         av_log (s, AV_LOG_ERROR, "ogg page, unsupported version\n");
360         return AVERROR_INVALIDDATA;
361     }
362
363     flags  = avio_r8(bc);
364     gp     = avio_rl64(bc);
365     serial = avio_rl32(bc);
366     avio_skip(bc, 8); /* seq, crc */
367     nsegs  = avio_r8(bc);
368
369     idx = ogg_find_stream(ogg, serial);
370     if (idx < 0) {
371         if (data_packets_seen(ogg))
372             idx = ogg_replace_stream(s, serial, nsegs);
373         else
374             idx = ogg_new_stream(s, serial);
375
376         if (idx < 0) {
377             av_log(s, AV_LOG_ERROR, "failed to create or replace stream\n");
378             return idx;
379         }
380     }
381
382     os = ogg->streams + idx;
383     ogg->page_pos =
384     os->page_pos = avio_tell(bc) - 27;
385
386     if (os->psize > 0) {
387         ret = ogg_new_buf(ogg, idx);
388         if (ret < 0)
389             return ret;
390     }
391
392     ret = avio_read(bc, os->segments, nsegs);
393     if (ret < nsegs)
394         return ret < 0 ? ret : AVERROR_EOF;
395
396     os->nsegs = nsegs;
397     os->segp  = 0;
398
399     size = 0;
400     for (i = 0; i < nsegs; i++)
401         size += os->segments[i];
402
403     if (!(flags & OGG_FLAG_BOS))
404         os->got_data = 1;
405
406     if (flags & OGG_FLAG_CONT || os->incomplete) {
407         if (!os->psize) {
408             // If this is the very first segment we started
409             // playback in the middle of a continuation packet.
410             // Discard it since we missed the start of it.
411             while (os->segp < os->nsegs) {
412                 int seg = os->segments[os->segp++];
413                 os->pstart += seg;
414                 if (seg < 255)
415                     break;
416             }
417             os->sync_pos = os->page_pos;
418         }
419     } else {
420         os->psize    = 0;
421         os->sync_pos = os->page_pos;
422     }
423
424     if (os->bufsize - os->bufpos < size) {
425         uint8_t *nb = av_malloc((os->bufsize *= 2) + AV_INPUT_BUFFER_PADDING_SIZE);
426         if (!nb)
427             return AVERROR(ENOMEM);
428         memcpy(nb, os->buf, os->bufpos);
429         av_free(os->buf);
430         os->buf = nb;
431     }
432
433     ret = avio_read(bc, os->buf + os->bufpos, size);
434     if (ret < size)
435         return ret < 0 ? ret : AVERROR_EOF;
436
437     os->bufpos += size;
438     os->granule = gp;
439     os->flags   = flags;
440
441     memset(os->buf + os->bufpos, 0, AV_INPUT_BUFFER_PADDING_SIZE);
442     if (sid)
443         *sid = idx;
444
445     return 0;
446 }
447
448 /**
449  * @brief find the next Ogg packet
450  * @param *sid is set to the stream for the packet or -1 if there is
451  *             no matching stream, in that case assume all other return
452  *             values to be uninitialized.
453  * @return negative value on error or EOF.
454  */
455 static int ogg_packet(AVFormatContext *s, int *sid, int *dstart, int *dsize,
456                       int64_t *fpos)
457 {
458     struct ogg *ogg = s->priv_data;
459     int idx, i, ret;
460     struct ogg_stream *os;
461     int complete = 0;
462     int segp     = 0, psize = 0;
463
464     av_log(s, AV_LOG_TRACE, "ogg_packet: curidx=%i\n", ogg->curidx);
465     if (sid)
466         *sid = -1;
467
468     do {
469         idx = ogg->curidx;
470
471         while (idx < 0) {
472             ret = ogg_read_page(s, &idx);
473             if (ret < 0)
474                 return ret;
475         }
476
477         os = ogg->streams + idx;
478
479         av_log(s, AV_LOG_TRACE, "ogg_packet: idx=%d pstart=%d psize=%d segp=%d nsegs=%d\n",
480                 idx, os->pstart, os->psize, os->segp, os->nsegs);
481
482         if (!os->codec) {
483             if (os->header < 0) {
484                 os->codec = ogg_find_codec(os->buf, os->bufpos);
485                 if (!os->codec) {
486                     av_log(s, AV_LOG_WARNING, "Codec not found\n");
487                     os->header = 0;
488                     return 0;
489                 }
490             } else {
491                 return 0;
492             }
493         }
494
495         segp  = os->segp;
496         psize = os->psize;
497
498         while (os->segp < os->nsegs) {
499             int ss = os->segments[os->segp++];
500             os->psize += ss;
501             if (ss < 255) {
502                 complete = 1;
503                 break;
504             }
505         }
506
507         if (!complete && os->segp == os->nsegs) {
508             ogg->curidx    = -1;
509             // Do not set incomplete for empty packets.
510             // Together with the code in ogg_read_page
511             // that discards all continuation of empty packets
512             // we would get an infinite loop.
513             os->incomplete = !!os->psize;
514         }
515     } while (!complete);
516
517
518     if (os->granule == -1)
519         av_log(s, AV_LOG_WARNING,
520                "Page at %"PRId64" is missing granule\n",
521                os->page_pos);
522
523     ogg->curidx    = idx;
524     os->incomplete = 0;
525
526     if (os->header) {
527         os->header = os->codec->header(s, idx);
528         if (!os->header) {
529             os->segp  = segp;
530             os->psize = psize;
531
532             // We have reached the first non-header packet in this stream.
533             // Unfortunately more header packets may still follow for others,
534             // but if we continue with header parsing we may lose data packets.
535             ogg->headers = 1;
536
537             // Update the header state for all streams and
538             // compute the data_offset.
539             if (!s->internal->data_offset)
540                 s->internal->data_offset = os->sync_pos;
541
542             for (i = 0; i < ogg->nstreams; i++) {
543                 struct ogg_stream *cur_os = ogg->streams + i;
544
545                 // if we have a partial non-header packet, its start is
546                 // obviously at or after the data start
547                 if (cur_os->incomplete)
548                     s->internal->data_offset = FFMIN(s->internal->data_offset, cur_os->sync_pos);
549             }
550         } else {
551             os->nb_header++;
552             os->pstart += os->psize;
553             os->psize   = 0;
554         }
555     } else {
556         os->pflags    = 0;
557         os->pduration = 0;
558         if (os->codec && os->codec->packet)
559             os->codec->packet(s, idx);
560         if (sid)
561             *sid = idx;
562         if (dstart)
563             *dstart = os->pstart;
564         if (dsize)
565             *dsize = os->psize;
566         if (fpos)
567             *fpos = os->sync_pos;
568         os->pstart  += os->psize;
569         os->psize    = 0;
570         if(os->pstart == os->bufpos)
571             os->bufpos = os->pstart = 0;
572         os->sync_pos = os->page_pos;
573     }
574
575     // determine whether there are more complete packets in this page
576     // if not, the page's granule will apply to this packet
577     os->page_end = 1;
578     for (i = os->segp; i < os->nsegs; i++)
579         if (os->segments[i] < 255) {
580             os->page_end = 0;
581             break;
582         }
583
584     if (os->segp == os->nsegs)
585         ogg->curidx = -1;
586
587     return 0;
588 }
589
590 static int ogg_get_length(AVFormatContext *s)
591 {
592     struct ogg *ogg = s->priv_data;
593     int i, ret;
594     int64_t size, end;
595     int streams_left=0;
596
597     if (!s->pb->seekable)
598         return 0;
599
600 // already set
601     if (s->duration != AV_NOPTS_VALUE)
602         return 0;
603
604     size = avio_size(s->pb);
605     if (size < 0)
606         return 0;
607     end = size > MAX_PAGE_SIZE ? size - MAX_PAGE_SIZE : 0;
608
609     ret = ogg_save(s);
610     if (ret < 0)
611         return ret;
612     avio_seek(s->pb, end, SEEK_SET);
613     ogg->page_pos = -1;
614
615     while (!ogg_read_page(s, &i)) {
616         if (ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
617             ogg->streams[i].codec) {
618             s->streams[i]->duration =
619                 ogg_gptopts(s, i, ogg->streams[i].granule, NULL);
620             if (s->streams[i]->start_time != AV_NOPTS_VALUE) {
621                 s->streams[i]->duration -= s->streams[i]->start_time;
622                 streams_left-= (ogg->streams[i].got_start==-1);
623                 ogg->streams[i].got_start= 1;
624             } else if(!ogg->streams[i].got_start) {
625                 ogg->streams[i].got_start= -1;
626                 streams_left++;
627             }
628         }
629     }
630
631     ogg_restore(s);
632
633     ret = ogg_save(s);
634     if (ret < 0)
635         return ret;
636
637     avio_seek (s->pb, s->internal->data_offset, SEEK_SET);
638     ogg_reset(s);
639     while (streams_left > 0 && !ogg_packet(s, &i, NULL, NULL, NULL)) {
640         int64_t pts;
641         if (i < 0) continue;
642         pts = ogg_calc_pts(s, i, NULL);
643         if (s->streams[i]->duration == AV_NOPTS_VALUE)
644             continue;
645         if (pts != AV_NOPTS_VALUE && s->streams[i]->start_time == AV_NOPTS_VALUE && !ogg->streams[i].got_start) {
646             s->streams[i]->duration -= pts;
647             ogg->streams[i].got_start= 1;
648             streams_left--;
649         }else if(s->streams[i]->start_time != AV_NOPTS_VALUE && !ogg->streams[i].got_start) {
650             ogg->streams[i].got_start= 1;
651             streams_left--;
652         }
653     }
654     ogg_restore (s);
655
656     return 0;
657 }
658
659 static int ogg_read_close(AVFormatContext *s)
660 {
661     struct ogg *ogg = s->priv_data;
662     int i;
663
664     for (i = 0; i < ogg->nstreams; i++) {
665         av_freep(&ogg->streams[i].buf);
666         if (ogg->streams[i].codec &&
667             ogg->streams[i].codec->cleanup) {
668             ogg->streams[i].codec->cleanup(s, i);
669         }
670         av_freep(&ogg->streams[i].private);
671         av_freep(&ogg->streams[i].new_metadata);
672     }
673
674     ogg->nstreams = 0;
675
676     av_freep(&ogg->streams);
677     return 0;
678 }
679
680 static int ogg_read_header(AVFormatContext *s)
681 {
682     struct ogg *ogg = s->priv_data;
683     int ret, i;
684
685     ogg->curidx = -1;
686
687     //linear headers seek from start
688     do {
689         ret = ogg_packet(s, NULL, NULL, NULL, NULL);
690         if (ret < 0) {
691             ogg_read_close(s);
692             return ret;
693         }
694     } while (!ogg->headers);
695     av_log(s, AV_LOG_TRACE, "found headers\n");
696
697     for (i = 0; i < ogg->nstreams; i++) {
698         struct ogg_stream *os = ogg->streams + i;
699
700         if (ogg->streams[i].header < 0) {
701             av_log(s, AV_LOG_ERROR, "Header parsing failed for stream %d\n", i);
702             ogg->streams[i].codec = NULL;
703             av_freep(&ogg->streams[i].private);
704         } else if (os->codec && os->nb_header < os->codec->nb_header) {
705             av_log(s, AV_LOG_WARNING,
706                    "Headers mismatch for stream %d: "
707                    "expected %d received %d.\n",
708                    i, os->codec->nb_header, os->nb_header);
709             if (s->error_recognition & AV_EF_EXPLODE)
710                 return AVERROR_INVALIDDATA;
711         }
712         if (os->start_granule != OGG_NOGRANULE_VALUE)
713             os->lastpts = s->streams[i]->start_time =
714                 ogg_gptopts(s, i, os->start_granule, NULL);
715     }
716
717     //linear granulepos seek from end
718     ret = ogg_get_length(s);
719     if (ret < 0) {
720         ogg_read_close(s);
721         return ret;
722     }
723
724     return 0;
725 }
726
727 static int64_t ogg_calc_pts(AVFormatContext *s, int idx, int64_t *dts)
728 {
729     struct ogg *ogg       = s->priv_data;
730     struct ogg_stream *os = ogg->streams + idx;
731     int64_t pts           = AV_NOPTS_VALUE;
732
733     if (dts)
734         *dts = AV_NOPTS_VALUE;
735
736     if (os->lastpts != AV_NOPTS_VALUE) {
737         pts         = os->lastpts;
738         os->lastpts = AV_NOPTS_VALUE;
739     }
740     if (os->lastdts != AV_NOPTS_VALUE) {
741         if (dts)
742             *dts = os->lastdts;
743         os->lastdts = AV_NOPTS_VALUE;
744     }
745     if (os->page_end) {
746         if (os->granule != -1LL) {
747             if (os->codec && os->codec->granule_is_start)
748                 pts = ogg_gptopts(s, idx, os->granule, dts);
749             else
750                 os->lastpts = ogg_gptopts(s, idx, os->granule, &os->lastdts);
751             os->granule = -1LL;
752         }
753     }
754     return pts;
755 }
756
757 static void ogg_validate_keyframe(AVFormatContext *s, int idx, int pstart, int psize)
758 {
759     struct ogg *ogg = s->priv_data;
760     struct ogg_stream *os = ogg->streams + idx;
761     int invalid = 0;
762     if (psize) {
763         switch (s->streams[idx]->codecpar->codec_id) {
764         case AV_CODEC_ID_THEORA:
765             invalid = !!(os->pflags & AV_PKT_FLAG_KEY) != !(os->buf[pstart] & 0x40);
766         break;
767         case AV_CODEC_ID_VP8:
768             invalid = !!(os->pflags & AV_PKT_FLAG_KEY) != !(os->buf[pstart] & 1);
769         }
770         if (invalid) {
771             os->pflags ^= AV_PKT_FLAG_KEY;
772             av_log(s, AV_LOG_WARNING, "Broken file, %skeyframe not correctly marked.\n",
773                    (os->pflags & AV_PKT_FLAG_KEY) ? "" : "non-");
774         }
775     }
776 }
777
778 static int ogg_read_packet(AVFormatContext *s, AVPacket *pkt)
779 {
780     struct ogg *ogg;
781     struct ogg_stream *os;
782     int idx, ret;
783     int pstart, psize;
784     int64_t fpos, pts, dts;
785
786     if (s->io_repositioned) {
787         ogg_reset(s);
788         s->io_repositioned = 0;
789     }
790
791     //Get an ogg packet
792 retry:
793     do {
794         ret = ogg_packet(s, &idx, &pstart, &psize, &fpos);
795         if (ret < 0)
796             return ret;
797     } while (idx < 0 || !s->streams[idx]);
798
799     ogg = s->priv_data;
800     os  = ogg->streams + idx;
801
802     // pflags might not be set until after this
803     pts = ogg_calc_pts(s, idx, &dts);
804     ogg_validate_keyframe(s, idx, pstart, psize);
805
806     if (os->keyframe_seek && !(os->pflags & AV_PKT_FLAG_KEY))
807         goto retry;
808     os->keyframe_seek = 0;
809
810     //Alloc a pkt
811     ret = av_new_packet(pkt, psize);
812     if (ret < 0)
813         return ret;
814     pkt->stream_index = idx;
815     memcpy(pkt->data, os->buf + pstart, psize);
816
817     pkt->pts      = pts;
818     pkt->dts      = dts;
819     pkt->flags    = os->pflags;
820     pkt->duration = os->pduration;
821     pkt->pos      = fpos;
822
823     if (os->end_trimming) {
824         uint8_t *side_data = av_packet_new_side_data(pkt,
825                                                      AV_PKT_DATA_SKIP_SAMPLES,
826                                                      10);
827         if(!side_data)
828             goto fail;
829         AV_WL32(side_data + 4, os->end_trimming);
830         os->end_trimming = 0;
831     }
832
833     if (os->new_metadata) {
834         uint8_t *side_data = av_packet_new_side_data(pkt,
835                                                      AV_PKT_DATA_METADATA_UPDATE,
836                                                      os->new_metadata_size);
837         if(!side_data)
838             goto fail;
839
840         memcpy(side_data, os->new_metadata, os->new_metadata_size);
841         av_freep(&os->new_metadata);
842         os->new_metadata_size = 0;
843     }
844
845     return psize;
846 fail:
847     av_packet_unref(pkt);
848     return AVERROR(ENOMEM);
849 }
850
851 static int64_t ogg_read_timestamp(AVFormatContext *s, int stream_index,
852                                   int64_t *pos_arg, int64_t pos_limit)
853 {
854     struct ogg *ogg = s->priv_data;
855     AVIOContext *bc = s->pb;
856     int64_t pts     = AV_NOPTS_VALUE;
857     int64_t keypos  = -1;
858     int i;
859     int pstart, psize;
860     avio_seek(bc, *pos_arg, SEEK_SET);
861     ogg_reset(s);
862
863     while (   avio_tell(bc) <= pos_limit
864            && !ogg_packet(s, &i, &pstart, &psize, pos_arg)) {
865         if (i == stream_index) {
866             struct ogg_stream *os = ogg->streams + stream_index;
867             // Do not trust the last timestamps of an ogm video
868             if (    (os->flags & OGG_FLAG_EOS)
869                 && !(os->flags & OGG_FLAG_BOS)
870                 && os->codec == &ff_ogm_video_codec)
871                 continue;
872             pts = ogg_calc_pts(s, i, NULL);
873             ogg_validate_keyframe(s, i, pstart, psize);
874             if (os->pflags & AV_PKT_FLAG_KEY) {
875                 keypos = *pos_arg;
876             } else if (os->keyframe_seek) {
877                 // if we had a previous keyframe but no pts for it,
878                 // return that keyframe with this pts value.
879                 if (keypos >= 0)
880                     *pos_arg = keypos;
881                 else
882                     pts = AV_NOPTS_VALUE;
883             }
884         }
885         if (pts != AV_NOPTS_VALUE)
886             break;
887     }
888     ogg_reset(s);
889     return pts;
890 }
891
892 static int ogg_read_seek(AVFormatContext *s, int stream_index,
893                          int64_t timestamp, int flags)
894 {
895     struct ogg *ogg       = s->priv_data;
896     struct ogg_stream *os = ogg->streams + stream_index;
897     int ret;
898
899     av_assert0(stream_index < ogg->nstreams);
900     // Ensure everything is reset even when seeking via
901     // the generated index.
902     ogg_reset(s);
903
904     // Try seeking to a keyframe first. If this fails (very possible),
905     // av_seek_frame will fall back to ignoring keyframes
906     if (s->streams[stream_index]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO
907         && !(flags & AVSEEK_FLAG_ANY))
908         os->keyframe_seek = 1;
909
910     ret = ff_seek_frame_binary(s, stream_index, timestamp, flags);
911     ogg_reset(s);
912     os  = ogg->streams + stream_index;
913     if (ret < 0)
914         os->keyframe_seek = 0;
915     return ret;
916 }
917
918 static int ogg_probe(AVProbeData *p)
919 {
920     if (!memcmp("OggS", p->buf, 5) && p->buf[5] <= 0x7)
921         return AVPROBE_SCORE_MAX;
922     return 0;
923 }
924
925 AVInputFormat ff_ogg_demuxer = {
926     .name           = "ogg",
927     .long_name      = NULL_IF_CONFIG_SMALL("Ogg"),
928     .priv_data_size = sizeof(struct ogg),
929     .read_probe     = ogg_probe,
930     .read_header    = ogg_read_header,
931     .read_packet    = ogg_read_packet,
932     .read_close     = ogg_read_close,
933     .read_seek      = ogg_read_seek,
934     .read_timestamp = ogg_read_timestamp,
935     .extensions     = "ogg",
936     .flags          = AVFMT_GENERIC_INDEX | AVFMT_TS_DISCONT | AVFMT_NOBINSEARCH,
937 };