Merge commit 'f7986239f4dbec91c743c4c5eb0a2339bd325bf6'
[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, int discard);
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, 0);
99
100     return ret;
101 }
102
103 static int ogg_restore(AVFormatContext *s, int discard)
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     if (!discard) {
116
117         for (i = 0; i < ogg->nstreams; i++)
118             av_freep(&ogg->streams[i].buf);
119
120         avio_seek(bc, ost->pos, SEEK_SET);
121         ogg->page_pos = -1;
122         ogg->curidx   = ost->curidx;
123         ogg->nstreams = ost->nstreams;
124         if ((err = av_reallocp_array(&ogg->streams, ogg->nstreams,
125                                      sizeof(*ogg->streams))) < 0) {
126             ogg->nstreams = 0;
127             return err;
128         } else
129             memcpy(ogg->streams, ost->streams,
130                    ost->nstreams * sizeof(*ogg->streams));
131     }
132
133     av_free(ost);
134
135     return 0;
136 }
137
138 static int ogg_reset(AVFormatContext *s)
139 {
140     struct ogg *ogg = s->priv_data;
141     int i;
142     int64_t start_pos = avio_tell(s->pb);
143
144     for (i = 0; i < ogg->nstreams; i++) {
145         struct ogg_stream *os = ogg->streams + i;
146         os->bufpos     = 0;
147         os->pstart     = 0;
148         os->psize      = 0;
149         os->granule    = -1;
150         os->lastpts    = AV_NOPTS_VALUE;
151         os->lastdts    = AV_NOPTS_VALUE;
152         os->sync_pos   = -1;
153         os->page_pos   = 0;
154         os->nsegs      = 0;
155         os->segp       = 0;
156         os->incomplete = 0;
157         os->got_data = 0;
158         if (start_pos <= s->internal->data_offset) {
159             os->lastpts = 0;
160         }
161         os->end_trimming = 0;
162         av_freep(&os->new_metadata);
163         os->new_metadata_size = 0;
164     }
165
166     ogg->page_pos = -1;
167     ogg->curidx = -1;
168
169     return 0;
170 }
171
172 static const struct ogg_codec *ogg_find_codec(uint8_t *buf, int size)
173 {
174     int i;
175
176     for (i = 0; ogg_codecs[i]; i++)
177         if (size >= ogg_codecs[i]->magicsize &&
178             !memcmp(buf, ogg_codecs[i]->magic, ogg_codecs[i]->magicsize))
179             return ogg_codecs[i];
180
181     return NULL;
182 }
183
184 /**
185  * Replace the current stream with a new one. This is a typical webradio
186  * situation where a new audio stream spawn (identified with a new serial) and
187  * must replace the previous one (track switch).
188  */
189 static int ogg_replace_stream(AVFormatContext *s, uint32_t serial, int nsegs)
190 {
191     struct ogg *ogg = s->priv_data;
192     struct ogg_stream *os;
193     const struct ogg_codec *codec;
194     int i = 0;
195
196     if (s->pb->seekable) {
197         uint8_t magic[8];
198         int64_t pos = avio_tell(s->pb);
199         avio_skip(s->pb, nsegs);
200         avio_read(s->pb, magic, sizeof(magic));
201         avio_seek(s->pb, pos, SEEK_SET);
202         codec = ogg_find_codec(magic, sizeof(magic));
203         if (!codec) {
204             av_log(s, AV_LOG_ERROR, "Cannot identify new stream\n");
205             return AVERROR_INVALIDDATA;
206         }
207         for (i = 0; i < ogg->nstreams; i++) {
208             if (ogg->streams[i].codec == codec)
209                 break;
210         }
211         if (i >= ogg->nstreams)
212             return ogg_new_stream(s, serial);
213     } else if (ogg->nstreams != 1) {
214         avpriv_report_missing_feature(s, "Changing stream parameters in multistream ogg");
215         return AVERROR_PATCHWELCOME;
216     }
217
218     os = &ogg->streams[i];
219
220     os->serial  = serial;
221     return i;
222
223 #if 0
224     buf     = os->buf;
225     bufsize = os->bufsize;
226     codec   = os->codec;
227
228     if (!ogg->state || ogg->state->streams[i].private != os->private)
229         av_freep(&ogg->streams[i].private);
230
231     /* Set Ogg stream settings similar to what is done in ogg_new_stream(). We
232      * also re-use the ogg_stream allocated buffer */
233     memset(os, 0, sizeof(*os));
234     os->serial  = serial;
235     os->bufsize = bufsize;
236     os->buf     = buf;
237     os->header  = -1;
238     os->codec   = codec;
239
240     return i;
241 #endif
242 }
243
244 static int ogg_new_stream(AVFormatContext *s, uint32_t serial)
245 {
246     struct ogg *ogg = s->priv_data;
247     int idx         = ogg->nstreams;
248     AVStream *st;
249     struct ogg_stream *os;
250     size_t size;
251
252     if (ogg->state) {
253         av_log(s, AV_LOG_ERROR, "New streams are not supposed to be added "
254                "in between Ogg context save/restore operations.\n");
255         return AVERROR_BUG;
256     }
257
258     /* Allocate and init a new Ogg Stream */
259     if (av_size_mult(ogg->nstreams + 1, sizeof(*ogg->streams), &size) < 0 ||
260         !(os = av_realloc(ogg->streams, size)))
261         return AVERROR(ENOMEM);
262     ogg->streams = os;
263     os           = ogg->streams + idx;
264     memset(os, 0, sizeof(*os));
265     os->serial        = serial;
266     os->bufsize       = DECODER_BUFFER_SIZE;
267     os->buf           = av_malloc(os->bufsize + AV_INPUT_BUFFER_PADDING_SIZE);
268     os->header        = -1;
269     os->start_granule = OGG_NOGRANULE_VALUE;
270     if (!os->buf)
271         return AVERROR(ENOMEM);
272
273     /* Create the associated AVStream */
274     st = avformat_new_stream(s, NULL);
275     if (!st) {
276         av_freep(&os->buf);
277         return AVERROR(ENOMEM);
278     }
279     st->id = idx;
280     avpriv_set_pts_info(st, 64, 1, 1000000);
281
282     ogg->nstreams++;
283     return idx;
284 }
285
286 static int ogg_new_buf(struct ogg *ogg, int idx)
287 {
288     struct ogg_stream *os = ogg->streams + idx;
289     uint8_t *nb = av_malloc(os->bufsize + AV_INPUT_BUFFER_PADDING_SIZE);
290     int size = os->bufpos - os->pstart;
291
292     if (!nb)
293         return AVERROR(ENOMEM);
294
295     if (os->buf) {
296         memcpy(nb, os->buf + os->pstart, size);
297         av_free(os->buf);
298     }
299
300     os->buf    = nb;
301     os->bufpos = size;
302     os->pstart = 0;
303
304     return 0;
305 }
306
307 static int data_packets_seen(const struct ogg *ogg)
308 {
309     int i;
310
311     for (i = 0; i < ogg->nstreams; i++)
312         if (ogg->streams[i].got_data)
313             return 1;
314     return 0;
315 }
316
317 static int ogg_read_page(AVFormatContext *s, int *sid)
318 {
319     AVIOContext *bc = s->pb;
320     struct ogg *ogg = s->priv_data;
321     struct ogg_stream *os;
322     int ret, i = 0;
323     int flags, nsegs;
324     uint64_t gp;
325     uint32_t serial;
326     int size, idx;
327     uint8_t sync[4];
328     int sp = 0;
329
330     ret = avio_read(bc, sync, 4);
331     if (ret < 4)
332         return ret < 0 ? ret : AVERROR_EOF;
333
334     do {
335         int c;
336
337         if (sync[sp & 3] == 'O' &&
338             sync[(sp + 1) & 3] == 'g' &&
339             sync[(sp + 2) & 3] == 'g' && sync[(sp + 3) & 3] == 'S')
340             break;
341
342         if(!i && bc->seekable && ogg->page_pos > 0) {
343             memset(sync, 0, 4);
344             avio_seek(bc, ogg->page_pos+4, SEEK_SET);
345             ogg->page_pos = -1;
346         }
347
348         c = avio_r8(bc);
349
350         if (avio_feof(bc))
351             return AVERROR_EOF;
352
353         sync[sp++ & 3] = c;
354     } while (i++ < MAX_PAGE_SIZE);
355
356     if (i >= MAX_PAGE_SIZE) {
357         av_log(s, AV_LOG_INFO, "cannot find sync word\n");
358         return AVERROR_INVALIDDATA;
359     }
360
361     if (avio_r8(bc) != 0) {      /* version */
362         av_log (s, AV_LOG_ERROR, "ogg page, unsupported version\n");
363         return AVERROR_INVALIDDATA;
364     }
365
366     flags  = avio_r8(bc);
367     gp     = avio_rl64(bc);
368     serial = avio_rl32(bc);
369     avio_skip(bc, 8); /* seq, crc */
370     nsegs  = avio_r8(bc);
371
372     idx = ogg_find_stream(ogg, serial);
373     if (idx < 0) {
374         if (data_packets_seen(ogg))
375             idx = ogg_replace_stream(s, serial, nsegs);
376         else
377             idx = ogg_new_stream(s, serial);
378
379         if (idx < 0) {
380             av_log(s, AV_LOG_ERROR, "failed to create or replace stream\n");
381             return idx;
382         }
383     }
384
385     os = ogg->streams + idx;
386     ogg->page_pos =
387     os->page_pos = avio_tell(bc) - 27;
388
389     if (os->psize > 0) {
390         ret = ogg_new_buf(ogg, idx);
391         if (ret < 0)
392             return ret;
393     }
394
395     ret = avio_read(bc, os->segments, nsegs);
396     if (ret < nsegs)
397         return ret < 0 ? ret : AVERROR_EOF;
398
399     os->nsegs = nsegs;
400     os->segp  = 0;
401
402     size = 0;
403     for (i = 0; i < nsegs; i++)
404         size += os->segments[i];
405
406     if (!(flags & OGG_FLAG_BOS))
407         os->got_data = 1;
408
409     if (flags & OGG_FLAG_CONT || os->incomplete) {
410         if (!os->psize) {
411             // If this is the very first segment we started
412             // playback in the middle of a continuation packet.
413             // Discard it since we missed the start of it.
414             while (os->segp < os->nsegs) {
415                 int seg = os->segments[os->segp++];
416                 os->pstart += seg;
417                 if (seg < 255)
418                     break;
419             }
420             os->sync_pos = os->page_pos;
421         }
422     } else {
423         os->psize    = 0;
424         os->sync_pos = os->page_pos;
425     }
426
427     if (os->bufsize - os->bufpos < size) {
428         uint8_t *nb = av_malloc((os->bufsize *= 2) + AV_INPUT_BUFFER_PADDING_SIZE);
429         if (!nb)
430             return AVERROR(ENOMEM);
431         memcpy(nb, os->buf, os->bufpos);
432         av_free(os->buf);
433         os->buf = nb;
434     }
435
436     ret = avio_read(bc, os->buf + os->bufpos, size);
437     if (ret < size)
438         return ret < 0 ? ret : AVERROR_EOF;
439
440     os->bufpos += size;
441     os->granule = gp;
442     os->flags   = flags;
443
444     memset(os->buf + os->bufpos, 0, AV_INPUT_BUFFER_PADDING_SIZE);
445     if (sid)
446         *sid = idx;
447
448     return 0;
449 }
450
451 /**
452  * @brief find the next Ogg packet
453  * @param *sid is set to the stream for the packet or -1 if there is
454  *             no matching stream, in that case assume all other return
455  *             values to be uninitialized.
456  * @return negative value on error or EOF.
457  */
458 static int ogg_packet(AVFormatContext *s, int *sid, int *dstart, int *dsize,
459                       int64_t *fpos)
460 {
461     struct ogg *ogg = s->priv_data;
462     int idx, i, ret;
463     struct ogg_stream *os;
464     int complete = 0;
465     int segp     = 0, psize = 0;
466
467     av_log(s, AV_LOG_TRACE, "ogg_packet: curidx=%i\n", ogg->curidx);
468     if (sid)
469         *sid = -1;
470
471     do {
472         idx = ogg->curidx;
473
474         while (idx < 0) {
475             ret = ogg_read_page(s, &idx);
476             if (ret < 0)
477                 return ret;
478         }
479
480         os = ogg->streams + idx;
481
482         av_log(s, AV_LOG_TRACE, "ogg_packet: idx=%d pstart=%d psize=%d segp=%d nsegs=%d\n",
483                 idx, os->pstart, os->psize, os->segp, os->nsegs);
484
485         if (!os->codec) {
486             if (os->header < 0) {
487                 os->codec = ogg_find_codec(os->buf, os->bufpos);
488                 if (!os->codec) {
489                     av_log(s, AV_LOG_WARNING, "Codec not found\n");
490                     os->header = 0;
491                     return 0;
492                 }
493             } else {
494                 return 0;
495             }
496         }
497
498         segp  = os->segp;
499         psize = os->psize;
500
501         while (os->segp < os->nsegs) {
502             int ss = os->segments[os->segp++];
503             os->psize += ss;
504             if (ss < 255) {
505                 complete = 1;
506                 break;
507             }
508         }
509
510         if (!complete && os->segp == os->nsegs) {
511             ogg->curidx    = -1;
512             // Do not set incomplete for empty packets.
513             // Together with the code in ogg_read_page
514             // that discards all continuation of empty packets
515             // we would get an infinite loop.
516             os->incomplete = !!os->psize;
517         }
518     } while (!complete);
519
520
521     if (os->granule == -1)
522         av_log(s, AV_LOG_WARNING,
523                "Page at %"PRId64" is missing granule\n",
524                os->page_pos);
525
526     ogg->curidx    = idx;
527     os->incomplete = 0;
528
529     if (os->header) {
530         os->header = os->codec->header(s, idx);
531         if (!os->header) {
532             os->segp  = segp;
533             os->psize = psize;
534
535             // We have reached the first non-header packet in this stream.
536             // Unfortunately more header packets may still follow for others,
537             // but if we continue with header parsing we may lose data packets.
538             ogg->headers = 1;
539
540             // Update the header state for all streams and
541             // compute the data_offset.
542             if (!s->internal->data_offset)
543                 s->internal->data_offset = os->sync_pos;
544
545             for (i = 0; i < ogg->nstreams; i++) {
546                 struct ogg_stream *cur_os = ogg->streams + i;
547
548                 // if we have a partial non-header packet, its start is
549                 // obviously at or after the data start
550                 if (cur_os->incomplete)
551                     s->internal->data_offset = FFMIN(s->internal->data_offset, cur_os->sync_pos);
552             }
553         } else {
554             os->nb_header++;
555             os->pstart += os->psize;
556             os->psize   = 0;
557         }
558     } else {
559         os->pflags    = 0;
560         os->pduration = 0;
561         if (os->codec && os->codec->packet)
562             os->codec->packet(s, idx);
563         if (sid)
564             *sid = idx;
565         if (dstart)
566             *dstart = os->pstart;
567         if (dsize)
568             *dsize = os->psize;
569         if (fpos)
570             *fpos = os->sync_pos;
571         os->pstart  += os->psize;
572         os->psize    = 0;
573         if(os->pstart == os->bufpos)
574             os->bufpos = os->pstart = 0;
575         os->sync_pos = os->page_pos;
576     }
577
578     // determine whether there are more complete packets in this page
579     // if not, the page's granule will apply to this packet
580     os->page_end = 1;
581     for (i = os->segp; i < os->nsegs; i++)
582         if (os->segments[i] < 255) {
583             os->page_end = 0;
584             break;
585         }
586
587     if (os->segp == os->nsegs)
588         ogg->curidx = -1;
589
590     return 0;
591 }
592
593 static int ogg_get_length(AVFormatContext *s)
594 {
595     struct ogg *ogg = s->priv_data;
596     int i, ret;
597     int64_t size, end;
598     int streams_left=0;
599
600     if (!s->pb->seekable)
601         return 0;
602
603 // already set
604     if (s->duration != AV_NOPTS_VALUE)
605         return 0;
606
607     size = avio_size(s->pb);
608     if (size < 0)
609         return 0;
610     end = size > MAX_PAGE_SIZE ? size - MAX_PAGE_SIZE : 0;
611
612     ret = ogg_save(s);
613     if (ret < 0)
614         return ret;
615     avio_seek(s->pb, end, SEEK_SET);
616     ogg->page_pos = -1;
617
618     while (!ogg_read_page(s, &i)) {
619         if (ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
620             ogg->streams[i].codec) {
621             s->streams[i]->duration =
622                 ogg_gptopts(s, i, ogg->streams[i].granule, NULL);
623             if (s->streams[i]->start_time != AV_NOPTS_VALUE) {
624                 s->streams[i]->duration -= s->streams[i]->start_time;
625                 streams_left-= (ogg->streams[i].got_start==-1);
626                 ogg->streams[i].got_start= 1;
627             } else if(!ogg->streams[i].got_start) {
628                 ogg->streams[i].got_start= -1;
629                 streams_left++;
630             }
631         }
632     }
633
634     ogg_restore(s, 0);
635
636     ret = ogg_save(s);
637     if (ret < 0)
638         return ret;
639
640     avio_seek (s->pb, s->internal->data_offset, SEEK_SET);
641     ogg_reset(s);
642     while (streams_left > 0 && !ogg_packet(s, &i, NULL, NULL, NULL)) {
643         int64_t pts;
644         if (i < 0) continue;
645         pts = ogg_calc_pts(s, i, NULL);
646         if (pts != AV_NOPTS_VALUE && s->streams[i]->start_time == AV_NOPTS_VALUE && !ogg->streams[i].got_start) {
647             s->streams[i]->duration -= pts;
648             ogg->streams[i].got_start= 1;
649             streams_left--;
650         }else if(s->streams[i]->start_time != AV_NOPTS_VALUE && !ogg->streams[i].got_start) {
651             ogg->streams[i].got_start= 1;
652             streams_left--;
653         }
654     }
655     ogg_restore (s, 0);
656
657     return 0;
658 }
659
660 static int ogg_read_close(AVFormatContext *s)
661 {
662     struct ogg *ogg = s->priv_data;
663     int i;
664
665     for (i = 0; i < ogg->nstreams; i++) {
666         av_freep(&ogg->streams[i].buf);
667         if (ogg->streams[i].codec &&
668             ogg->streams[i].codec->cleanup) {
669             ogg->streams[i].codec->cleanup(s, i);
670         }
671         av_freep(&ogg->streams[i].private);
672         av_freep(&ogg->streams[i].new_metadata);
673     }
674
675     ogg->nstreams = 0;
676
677     av_freep(&ogg->streams);
678     return 0;
679 }
680
681 static int ogg_read_header(AVFormatContext *s)
682 {
683     struct ogg *ogg = s->priv_data;
684     int ret, i;
685
686     ogg->curidx = -1;
687
688     //linear headers seek from start
689     do {
690         ret = ogg_packet(s, NULL, NULL, NULL, NULL);
691         if (ret < 0) {
692             ogg_read_close(s);
693             return ret;
694         }
695     } while (!ogg->headers);
696     av_log(s, AV_LOG_TRACE, "found headers\n");
697
698     for (i = 0; i < ogg->nstreams; i++) {
699         struct ogg_stream *os = ogg->streams + i;
700
701         if (ogg->streams[i].header < 0) {
702             av_log(s, AV_LOG_ERROR, "Header parsing failed for stream %d\n", i);
703             ogg->streams[i].codec = NULL;
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]->codec->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 a 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]->codec->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 };