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