smacker: fix integer overflow with pts_inc
[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
32 #include <stdio.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_vp8_codec,
51     &ff_old_dirac_codec,
52     &ff_old_flac_codec,
53     &ff_ogm_video_codec,
54     &ff_ogm_audio_codec,
55     &ff_ogm_text_codec,
56     &ff_ogm_old_codec,
57     NULL
58 };
59
60 //FIXME We could avoid some structure duplication
61 static int ogg_save(AVFormatContext *s)
62 {
63     struct ogg *ogg = s->priv_data;
64     struct ogg_state *ost =
65         av_malloc(sizeof(*ost) + (ogg->nstreams - 1) * sizeof(*ogg->streams));
66     int i;
67     if (!ost)
68         return AVERROR(ENOMEM);
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 + AV_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, err;
92
93     if (!ost)
94         return 0;
95
96     ogg->state = ost->next;
97
98     if (!discard) {
99
100         for (i = 0; i < ogg->nstreams; i++)
101             av_free(ogg->streams[i].buf);
102
103         avio_seek(bc, ost->pos, SEEK_SET);
104         ogg->curidx   = ost->curidx;
105         ogg->nstreams = ost->nstreams;
106         if ((err = av_reallocp_array(&ogg->streams, ogg->nstreams,
107                                      sizeof(*ogg->streams))) < 0) {
108             ogg->nstreams = 0;
109             return err;
110         } else
111             memcpy(ogg->streams, ost->streams,
112                    ost->nstreams * sizeof(*ogg->streams));
113     }
114
115     av_free(ost);
116
117     return 0;
118 }
119
120 static int ogg_reset(struct ogg *ogg)
121 {
122     int i;
123
124     for (i = 0; i < ogg->nstreams; i++) {
125         struct ogg_stream *os = ogg->streams + i;
126         os->bufpos     = 0;
127         os->pstart     = 0;
128         os->psize      = 0;
129         os->granule    = -1;
130         os->lastpts    = AV_NOPTS_VALUE;
131         os->lastdts    = AV_NOPTS_VALUE;
132         os->sync_pos   = -1;
133         os->page_pos   = 0;
134         os->nsegs      = 0;
135         os->segp       = 0;
136         os->incomplete = 0;
137     }
138
139     ogg->curidx = -1;
140
141     return 0;
142 }
143
144 static const struct ogg_codec *ogg_find_codec(uint8_t *buf, int size)
145 {
146     int i;
147
148     for (i = 0; ogg_codecs[i]; i++)
149         if (size >= ogg_codecs[i]->magicsize &&
150             !memcmp(buf, ogg_codecs[i]->magic, ogg_codecs[i]->magicsize))
151             return ogg_codecs[i];
152
153     return NULL;
154 }
155
156 static int ogg_new_stream(AVFormatContext *s, uint32_t serial, int new_avstream)
157 {
158     struct ogg *ogg = s->priv_data;
159     int idx         = ogg->nstreams++;
160     AVStream *st;
161     struct ogg_stream *os;
162
163     os = av_realloc(ogg->streams, ogg->nstreams * sizeof(*ogg->streams));
164
165     if (!os)
166         return AVERROR(ENOMEM);
167
168     ogg->streams = os;
169
170     memset(ogg->streams + idx, 0, sizeof(*ogg->streams));
171
172     os                = ogg->streams + idx;
173     os->serial        = serial;
174     os->bufsize       = DECODER_BUFFER_SIZE;
175     os->buf           = av_malloc(os->bufsize + AV_INPUT_BUFFER_PADDING_SIZE);
176     os->header        = -1;
177     os->start_granule = OGG_NOGRANULE_VALUE;
178
179     if (new_avstream) {
180         st = avformat_new_stream(s, NULL);
181         if (!st)
182             return AVERROR(ENOMEM);
183
184         st->id = idx;
185         avpriv_set_pts_info(st, 64, 1, 1000000);
186     }
187
188     return idx;
189 }
190
191 static int ogg_new_buf(struct ogg *ogg, int idx)
192 {
193     struct ogg_stream *os = ogg->streams + idx;
194     uint8_t *nb = av_malloc(os->bufsize + AV_INPUT_BUFFER_PADDING_SIZE);
195     int size = os->bufpos - os->pstart;
196
197     if (!nb)
198         return AVERROR(ENOMEM);
199
200     if (os->buf) {
201         memcpy(nb, os->buf + os->pstart, size);
202         av_free(os->buf);
203     }
204
205     os->buf    = nb;
206     os->bufpos = size;
207     os->pstart = 0;
208
209     return 0;
210 }
211
212 static int ogg_read_page(AVFormatContext *s, int *str)
213 {
214     AVIOContext *bc = s->pb;
215     struct ogg *ogg = s->priv_data;
216     struct ogg_stream *os;
217     int ret, i = 0;
218     int flags, nsegs;
219     uint64_t gp;
220     uint32_t serial;
221     int size, idx;
222     uint8_t sync[4];
223     int sp = 0;
224
225     ret = avio_read(bc, sync, 4);
226     if (ret < 4)
227         return ret < 0 ? ret : AVERROR_EOF;
228
229     do {
230         int c;
231
232         if (sync[sp & 3] == 'O' &&
233             sync[(sp + 1) & 3] == 'g' &&
234             sync[(sp + 2) & 3] == 'g' && sync[(sp + 3) & 3] == 'S')
235             break;
236
237         c = avio_r8(bc);
238
239         if (bc->eof_reached)
240             return AVERROR_EOF;
241
242         sync[sp++ & 3] = c;
243     } while (i++ < MAX_PAGE_SIZE);
244
245     if (i >= MAX_PAGE_SIZE) {
246         av_log(s, AV_LOG_INFO, "cannot find sync word\n");
247         return AVERROR_INVALIDDATA;
248     }
249
250     if (avio_r8(bc) != 0)      /* version */
251         return AVERROR_INVALIDDATA;
252
253     flags  = avio_r8(bc);
254     gp     = avio_rl64(bc);
255     serial = avio_rl32(bc);
256     avio_skip(bc, 8); /* seq, crc */
257     nsegs  = avio_r8(bc);
258
259     idx = ogg_find_stream(ogg, serial);
260     if (idx < 0) {
261         if (ogg->headers) {
262             int n;
263
264             for (n = 0; n < ogg->nstreams; n++) {
265                 av_freep(&ogg->streams[n].buf);
266                 if (!ogg->state ||
267                     ogg->state->streams[n].private != ogg->streams[n].private)
268                     av_freep(&ogg->streams[n].private);
269             }
270
271             ogg->curidx   = -1;
272             ogg->nstreams = 0;
273
274             idx = ogg_new_stream(s, serial, 0);
275         } else {
276             idx = ogg_new_stream(s, serial, 1);
277         }
278         if (idx < 0)
279             return idx;
280     }
281
282     os = ogg->streams + idx;
283     os->page_pos = avio_tell(bc) - 27;
284
285     if (os->psize > 0) {
286         ret = ogg_new_buf(ogg, idx);
287         if (ret < 0)
288             return ret;
289     }
290
291     ret = avio_read(bc, os->segments, nsegs);
292     if (ret < nsegs)
293         return ret < 0 ? ret : AVERROR_EOF;
294
295     os->nsegs = nsegs;
296     os->segp  = 0;
297
298     size = 0;
299     for (i = 0; i < nsegs; i++)
300         size += os->segments[i];
301
302     if (flags & OGG_FLAG_CONT || os->incomplete) {
303         if (!os->psize) {
304             while (os->segp < os->nsegs) {
305                 int seg = os->segments[os->segp++];
306                 os->pstart += seg;
307                 if (seg < 255)
308                     break;
309             }
310             os->sync_pos = os->page_pos;
311         }
312     } else {
313         os->psize    = 0;
314         os->sync_pos = os->page_pos;
315     }
316
317     if (os->bufsize - os->bufpos < size) {
318         uint8_t *nb = av_malloc((os->bufsize *= 2) + AV_INPUT_BUFFER_PADDING_SIZE);
319         if (!nb)
320             return AVERROR(ENOMEM);
321         memcpy(nb, os->buf, os->bufpos);
322         av_free(os->buf);
323         os->buf = nb;
324     }
325
326     ret = avio_read(bc, os->buf + os->bufpos, size);
327     if (ret < size)
328         return ret < 0 ? ret : AVERROR_EOF;
329
330     os->bufpos += size;
331     os->granule = gp;
332     os->flags   = flags;
333
334     memset(os->buf + os->bufpos, 0, AV_INPUT_BUFFER_PADDING_SIZE);
335     if (str)
336         *str = idx;
337
338     return 0;
339 }
340
341 static int ogg_packet(AVFormatContext *s, int *str, int *dstart, int *dsize,
342                       int64_t *fpos)
343 {
344     struct ogg *ogg = s->priv_data;
345     int idx, i, ret;
346     struct ogg_stream *os;
347     int complete = 0;
348     int segp     = 0, psize = 0;
349
350     av_log(s, AV_LOG_TRACE, "ogg_packet: curidx=%i\n", ogg->curidx);
351
352     do {
353         idx = ogg->curidx;
354
355         while (idx < 0) {
356             ret = ogg_read_page(s, &idx);
357             if (ret < 0)
358                 return ret;
359         }
360
361         os = ogg->streams + idx;
362
363         av_log(s, AV_LOG_TRACE, "ogg_packet: idx=%d pstart=%d psize=%d segp=%d nsegs=%d\n",
364                 idx, os->pstart, os->psize, os->segp, os->nsegs);
365
366         if (!os->codec) {
367             if (os->header < 0) {
368                 os->codec = ogg_find_codec(os->buf, os->bufpos);
369                 if (!os->codec) {
370                     av_log(s, AV_LOG_WARNING, "Codec not found\n");
371                     os->header = 0;
372                     return 0;
373                 }
374             } else {
375                 return 0;
376             }
377         }
378
379         segp  = os->segp;
380         psize = os->psize;
381
382         while (os->segp < os->nsegs) {
383             int ss = os->segments[os->segp++];
384             os->psize += ss;
385             if (ss < 255) {
386                 complete = 1;
387                 break;
388             }
389         }
390
391         if (!complete && os->segp == os->nsegs) {
392             ogg->curidx    = -1;
393             // Do not set incomplete for empty packets.
394             // Together with the code in ogg_read_page
395             // that discards all continuation of empty packets
396             // we would get an infinite loop.
397             os->incomplete = !!os->psize;
398         }
399     } while (!complete);
400
401     av_log(s, AV_LOG_TRACE, "ogg_packet: idx %i, frame size %i, start %i\n",
402             idx, os->psize, os->pstart);
403
404     if (os->granule == -1)
405         av_log(s, AV_LOG_WARNING,
406                "Page at %"PRId64" is missing granule\n",
407                os->page_pos);
408
409     ogg->curidx    = idx;
410     os->incomplete = 0;
411
412     if (os->header) {
413         os->header = os->codec->header(s, idx);
414         if (!os->header) {
415             os->segp  = segp;
416             os->psize = psize;
417
418             // We have reached the first non-header packet in this stream.
419             // Unfortunately more header packets may still follow for others,
420             // but if we continue with header parsing we may lose data packets.
421             ogg->headers = 1;
422
423             // Update the header state for all streams and
424             // compute the data_offset.
425             if (!s->internal->data_offset)
426                 s->internal->data_offset = os->sync_pos;
427
428             for (i = 0; i < ogg->nstreams; i++) {
429                 struct ogg_stream *cur_os = ogg->streams + i;
430
431                 // if we have a partial non-header packet, its start is
432                 // obviously at or after the data start
433                 if (cur_os->incomplete)
434                     s->internal->data_offset = FFMIN(s->internal->data_offset, cur_os->sync_pos);
435             }
436         } else {
437             os->nb_header++;
438             os->pstart += os->psize;
439             os->psize   = 0;
440         }
441     } else {
442         os->pflags    = 0;
443         os->pduration = 0;
444         if (os->codec && os->codec->packet)
445             os->codec->packet(s, idx);
446         if (str)
447             *str = idx;
448         if (dstart)
449             *dstart = os->pstart;
450         if (dsize)
451             *dsize = os->psize;
452         if (fpos)
453             *fpos = os->sync_pos;
454         os->pstart  += os->psize;
455         os->psize    = 0;
456         os->sync_pos = os->page_pos;
457     }
458
459     // determine whether there are more complete packets in this page
460     // if not, the page's granule will apply to this packet
461     os->page_end = 1;
462     for (i = os->segp; i < os->nsegs; i++)
463         if (os->segments[i] < 255) {
464             os->page_end = 0;
465             break;
466         }
467
468     if (os->segp == os->nsegs)
469         ogg->curidx = -1;
470
471     return 0;
472 }
473
474 static int ogg_get_headers(AVFormatContext *s)
475 {
476     struct ogg *ogg = s->priv_data;
477     int ret, i;
478
479     do {
480         ret = ogg_packet(s, NULL, NULL, NULL, NULL);
481         if (ret < 0)
482             return ret;
483     } while (!ogg->headers);
484
485     for (i = 0; i < ogg->nstreams; i++) {
486         struct ogg_stream *os = ogg->streams + i;
487
488         if (os->codec && os->codec->nb_header &&
489             os->nb_header < os->codec->nb_header) {
490             av_log(s, AV_LOG_ERROR,
491                    "Headers mismatch for stream %d: "
492                    "expected %d received %d.\n",
493                    i, os->codec->nb_header, os->nb_header);
494             if (s->error_recognition & AV_EF_EXPLODE)
495                 return AVERROR_INVALIDDATA;
496         }
497         if (os->start_granule != OGG_NOGRANULE_VALUE)
498             os->lastpts = s->streams[i]->start_time =
499                 ogg_gptopts(s, i, os->start_granule, NULL);
500     }
501     av_log(s, AV_LOG_TRACE, "found headers\n");
502
503     return 0;
504 }
505
506 static int ogg_get_length(AVFormatContext *s)
507 {
508     struct ogg *ogg = s->priv_data;
509     int i, ret;
510     int64_t size, end;
511
512     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
513         return 0;
514
515 // already set
516     if (s->duration != AV_NOPTS_VALUE)
517         return 0;
518
519     size = avio_size(s->pb);
520     if (size < 0)
521         return 0;
522     end = size > MAX_PAGE_SIZE ? size - MAX_PAGE_SIZE : 0;
523
524     ret = ogg_save(s);
525     if (ret < 0)
526         return ret;
527     avio_seek(s->pb, end, SEEK_SET);
528
529     while (!ogg_read_page(s, &i)) {
530         if (ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
531             ogg->streams[i].codec) {
532             s->streams[i]->duration =
533                 ogg_gptopts(s, i, ogg->streams[i].granule, NULL);
534             if (s->streams[i]->start_time != AV_NOPTS_VALUE)
535                 s->streams[i]->duration -= s->streams[i]->start_time;
536         }
537     }
538
539     ogg_restore(s, 0);
540
541     return 0;
542 }
543
544 static int ogg_read_close(AVFormatContext *s)
545 {
546     struct ogg *ogg = s->priv_data;
547     int i;
548
549     for (i = 0; i < ogg->nstreams; i++) {
550         av_free(ogg->streams[i].buf);
551         if (ogg->streams[i].codec &&
552             ogg->streams[i].codec->cleanup) {
553             ogg->streams[i].codec->cleanup(s, i);
554         }
555         av_free(ogg->streams[i].private);
556     }
557     av_free(ogg->streams);
558     return 0;
559 }
560
561 static int ogg_read_header(AVFormatContext *s)
562 {
563     struct ogg *ogg = s->priv_data;
564     int ret, i;
565     ogg->curidx = -1;
566     //linear headers seek from start
567     ret = ogg_get_headers(s);
568     if (ret < 0) {
569         ogg_read_close(s);
570         return ret;
571     }
572
573     for (i = 0; i < ogg->nstreams; i++)
574         if (ogg->streams[i].header < 0)
575             ogg->streams[i].codec = NULL;
576
577     //linear granulepos seek from end
578     ret = ogg_get_length(s);
579     if (ret < 0) {
580         ogg_read_close(s);
581         return ret;
582     }
583
584     //fill the extradata in the per codec callbacks
585     return 0;
586 }
587
588 static int64_t ogg_calc_pts(AVFormatContext *s, int idx, int64_t *dts)
589 {
590     struct ogg *ogg       = s->priv_data;
591     struct ogg_stream *os = ogg->streams + idx;
592     int64_t pts           = AV_NOPTS_VALUE;
593
594     if (dts)
595         *dts = AV_NOPTS_VALUE;
596
597     if (os->lastpts != AV_NOPTS_VALUE) {
598         pts         = os->lastpts;
599         os->lastpts = AV_NOPTS_VALUE;
600     }
601     if (os->lastdts != AV_NOPTS_VALUE) {
602         if (dts)
603             *dts = os->lastdts;
604         os->lastdts = AV_NOPTS_VALUE;
605     }
606     if (os->page_end) {
607         if (os->granule != -1LL) {
608             if (os->codec && os->codec->granule_is_start)
609                 pts = ogg_gptopts(s, idx, os->granule, dts);
610             else
611                 os->lastpts = ogg_gptopts(s, idx, os->granule, &os->lastdts);
612             os->granule = -1LL;
613         }
614     }
615     return pts;
616 }
617
618 static int ogg_read_packet(AVFormatContext *s, AVPacket *pkt)
619 {
620     struct ogg *ogg;
621     struct ogg_stream *os;
622     int idx = -1, ret;
623     int pstart, psize;
624     int64_t fpos, pts, dts;
625
626     //Get an ogg packet
627 retry:
628     do {
629         ret = ogg_packet(s, &idx, &pstart, &psize, &fpos);
630         if (ret < 0)
631             return ret;
632     } while (idx < 0 || !s->streams[idx]);
633
634     ogg = s->priv_data;
635     os  = ogg->streams + idx;
636
637     // pflags might not be set until after this
638     pts = ogg_calc_pts(s, idx, &dts);
639
640     if (os->keyframe_seek && !(os->pflags & AV_PKT_FLAG_KEY))
641         goto retry;
642     os->keyframe_seek = 0;
643
644     //Alloc a pkt
645     ret = av_new_packet(pkt, psize);
646     if (ret < 0)
647         return ret;
648     pkt->stream_index = idx;
649     memcpy(pkt->data, os->buf + pstart, psize);
650
651     pkt->pts      = pts;
652     pkt->dts      = dts;
653     pkt->flags    = os->pflags;
654     pkt->duration = os->pduration;
655     pkt->pos      = fpos;
656
657     return psize;
658 }
659
660 static int64_t ogg_read_timestamp(AVFormatContext *s, int stream_index,
661                                   int64_t *pos_arg, int64_t pos_limit)
662 {
663     struct ogg *ogg = s->priv_data;
664     AVIOContext *bc = s->pb;
665     int64_t pts     = AV_NOPTS_VALUE;
666     int i           = -1;
667     avio_seek(bc, *pos_arg, SEEK_SET);
668     ogg_reset(ogg);
669
670     while (avio_tell(bc) < pos_limit &&
671            !ogg_packet(s, &i, NULL, NULL, pos_arg)) {
672         if (i == stream_index) {
673             struct ogg_stream *os = ogg->streams + stream_index;
674             pts = ogg_calc_pts(s, i, NULL);
675             if (os->keyframe_seek && !(os->pflags & AV_PKT_FLAG_KEY))
676                 pts = AV_NOPTS_VALUE;
677         }
678         if (pts != AV_NOPTS_VALUE)
679             break;
680     }
681     ogg_reset(ogg);
682     return pts;
683 }
684
685 static int ogg_read_seek(AVFormatContext *s, int stream_index,
686                          int64_t timestamp, int flags)
687 {
688     struct ogg *ogg       = s->priv_data;
689     struct ogg_stream *os = ogg->streams + stream_index;
690     int ret;
691
692     // Try seeking to a keyframe first. If this fails (very possible),
693     // av_seek_frame will fall back to ignoring keyframes
694     if (s->streams[stream_index]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO
695         && !(flags & AVSEEK_FLAG_ANY))
696         os->keyframe_seek = 1;
697
698     ret = ff_seek_frame_binary(s, stream_index, timestamp, flags);
699     os  = ogg->streams + stream_index;
700     if (ret < 0)
701         os->keyframe_seek = 0;
702     return ret;
703 }
704
705 static int ogg_probe(AVProbeData *p)
706 {
707     if (!memcmp("OggS", p->buf, 5) && p->buf[5] <= 0x7)
708         return AVPROBE_SCORE_MAX;
709     return 0;
710 }
711
712 AVInputFormat ff_ogg_demuxer = {
713     .name           = "ogg",
714     .long_name      = NULL_IF_CONFIG_SMALL("Ogg"),
715     .priv_data_size = sizeof(struct ogg),
716     .read_probe     = ogg_probe,
717     .read_header    = ogg_read_header,
718     .read_packet    = ogg_read_packet,
719     .read_close     = ogg_read_close,
720     .read_seek      = ogg_read_seek,
721     .read_timestamp = ogg_read_timestamp,
722     .extensions     = "ogg",
723     .flags          = AVFMT_GENERIC_INDEX | AVFMT_NOBINSEARCH,
724 };