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