2 * Ogg bitstream support
3 * Luca Barbato <lu_zero@gentoo.org>
4 * Based on tcvp implementation
8 Copyright (C) 2005 Michael Ahlberg, Måns Rullgård
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:
18 The above copyright notice and this permission notice shall be
19 included in all copies or substantial portions of the Software.
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.
35 #include "vorbiscomment.h"
37 #define MAX_PAGE_SIZE 65307
38 #define DECODER_BUFFER_SIZE MAX_PAGE_SIZE
40 static const struct ogg_codec * const ogg_codecs[] = {
57 //FIXME We could avoid some structure duplication
58 static int ogg_save(AVFormatContext *s)
60 struct ogg *ogg = s->priv_data;
61 struct ogg_state *ost =
62 av_malloc(sizeof (*ost) + (ogg->nstreams-1) * sizeof (*ogg->streams));
64 ost->pos = avio_tell (s->pb);
65 ost->curidx = ogg->curidx;
66 ost->next = ogg->state;
67 ost->nstreams = ogg->nstreams;
68 memcpy(ost->streams, ogg->streams, ogg->nstreams * sizeof(*ogg->streams));
70 for (i = 0; i < ogg->nstreams; i++){
71 struct ogg_stream *os = ogg->streams + i;
72 os->buf = av_mallocz (os->bufsize + FF_INPUT_BUFFER_PADDING_SIZE);
73 memcpy (os->buf, ost->streams[i].buf, os->bufpos);
81 static int ogg_restore(AVFormatContext *s, int discard)
83 struct ogg *ogg = s->priv_data;
84 AVIOContext *bc = s->pb;
85 struct ogg_state *ost = ogg->state;
91 ogg->state = ost->next;
94 struct ogg_stream *old_streams = ogg->streams;
96 for (i = 0; i < ogg->nstreams; i++)
97 av_free (ogg->streams[i].buf);
99 avio_seek (bc, ost->pos, SEEK_SET);
100 ogg->curidx = ost->curidx;
101 ogg->nstreams = ost->nstreams;
102 ogg->streams = av_realloc (ogg->streams,
103 ogg->nstreams * sizeof (*ogg->streams));
106 memcpy(ogg->streams, ost->streams,
107 ost->nstreams * sizeof(*ogg->streams));
109 av_free(old_streams);
119 static int ogg_reset(struct ogg *ogg)
123 for (i = 0; i < ogg->nstreams; i++){
124 struct ogg_stream *os = ogg->streams + i;
129 os->lastpts = AV_NOPTS_VALUE;
130 os->lastdts = AV_NOPTS_VALUE;
143 static const struct ogg_codec *ogg_find_codec(uint8_t *buf, int size)
147 for (i = 0; ogg_codecs[i]; i++)
148 if (size >= ogg_codecs[i]->magicsize &&
149 !memcmp (buf, ogg_codecs[i]->magic, ogg_codecs[i]->magicsize))
150 return ogg_codecs[i];
155 static int ogg_new_stream(AVFormatContext *s, uint32_t serial, int new_avstream)
158 struct ogg *ogg = s->priv_data;
159 int idx = ogg->nstreams++;
161 struct ogg_stream *os;
163 ogg->streams = av_realloc (ogg->streams,
164 ogg->nstreams * sizeof (*ogg->streams));
165 memset (ogg->streams + idx, 0, sizeof (*ogg->streams));
166 os = ogg->streams + idx;
168 os->bufsize = DECODER_BUFFER_SIZE;
169 os->buf = av_malloc(os->bufsize + FF_INPUT_BUFFER_PADDING_SIZE);
173 st = avformat_new_stream(s, NULL);
175 return AVERROR(ENOMEM);
178 avpriv_set_pts_info(st, 64, 1, 1000000);
184 static int ogg_new_buf(struct ogg *ogg, int idx)
186 struct ogg_stream *os = ogg->streams + idx;
187 uint8_t *nb = av_malloc(os->bufsize + FF_INPUT_BUFFER_PADDING_SIZE);
188 int size = os->bufpos - os->pstart;
190 memcpy(nb, os->buf + os->pstart, size);
200 static int ogg_read_page(AVFormatContext *s, int *str)
202 AVIOContext *bc = s->pb;
203 struct ogg *ogg = s->priv_data;
204 struct ogg_stream *os;
213 ret = avio_read(bc, sync, 4);
215 return ret < 0 ? ret : AVERROR_EOF;
220 if (sync[sp & 3] == 'O' &&
221 sync[(sp + 1) & 3] == 'g' &&
222 sync[(sp + 2) & 3] == 'g' && sync[(sp + 3) & 3] == 'S')
229 }while (i++ < MAX_PAGE_SIZE);
231 if (i >= MAX_PAGE_SIZE){
232 av_log (s, AV_LOG_INFO, "ogg, can't find sync word\n");
233 return AVERROR_INVALIDDATA;
236 if (avio_r8(bc) != 0) /* version */
237 return AVERROR_INVALIDDATA;
241 serial = avio_rl32 (bc);
242 avio_skip(bc, 8); /* seq, crc */
245 idx = ogg_find_stream (ogg, serial);
250 for (n = 0; n < ogg->nstreams; n++) {
251 av_freep(&ogg->streams[n].buf);
252 if (!ogg->state || ogg->state->streams[n].private != ogg->streams[n].private)
253 av_freep(&ogg->streams[n].private);
257 idx = ogg_new_stream(s, serial, 0);
259 idx = ogg_new_stream(s, serial, 1);
265 os = ogg->streams + idx;
266 os->page_pos = avio_tell(bc) - 27;
269 ogg_new_buf(ogg, idx);
271 ret = avio_read(bc, os->segments, nsegs);
273 return ret < 0 ? ret : AVERROR_EOF;
279 for (i = 0; i < nsegs; i++)
280 size += os->segments[i];
282 if (flags & OGG_FLAG_CONT || os->incomplete){
284 // If this is the very first segment we started
285 // playback in the middle of a continuation packet.
286 // Discard it since we missed the start of it.
287 while (os->segp < os->nsegs){
288 int seg = os->segments[os->segp++];
293 os->sync_pos = os->page_pos;
297 os->sync_pos = os->page_pos;
300 if (os->bufsize - os->bufpos < size){
301 uint8_t *nb = av_malloc ((os->bufsize *= 2) + FF_INPUT_BUFFER_PADDING_SIZE);
302 memcpy (nb, os->buf, os->bufpos);
307 ret = avio_read(bc, os->buf + os->bufpos, size);
309 return ret < 0 ? ret : AVERROR_EOF;
315 memset(os->buf + os->bufpos, 0, FF_INPUT_BUFFER_PADDING_SIZE);
322 static int ogg_packet(AVFormatContext *s, int *str, int *dstart, int *dsize,
325 struct ogg *ogg = s->priv_data;
327 struct ogg_stream *os;
329 int segp = 0, psize = 0;
331 av_dlog(s, "ogg_packet: curidx=%i\n", ogg->curidx);
337 ret = ogg_read_page(s, &idx);
342 os = ogg->streams + idx;
344 av_dlog(s, "ogg_packet: idx=%d pstart=%d psize=%d segp=%d nsegs=%d\n",
345 idx, os->pstart, os->psize, os->segp, os->nsegs);
349 os->codec = ogg_find_codec (os->buf, os->bufpos);
351 av_log(s, AV_LOG_WARNING, "Codec not found\n");
363 while (os->segp < os->nsegs){
364 int ss = os->segments[os->segp++];
372 if (!complete && os->segp == os->nsegs){
374 // Do not set incomplete for empty packets.
375 // Together with the code in ogg_read_page
376 // that discards all continuation of empty packets
377 // we would get an infinite loop.
378 os->incomplete = !!os->psize;
383 if (os->granule == -1)
384 av_log(s, AV_LOG_WARNING, "Page at %"PRId64" is missing granule\n", os->page_pos);
390 os->header = os->codec->header (s, idx);
395 // We have reached the first non-header packet in this stream.
396 // Unfortunately more header packets may still follow for others,
397 // but if we continue with header parsing we may lose data packets.
400 // Update the header state for all streams and
401 // compute the data_offset.
403 s->data_offset = os->sync_pos;
404 for (i = 0; i < ogg->nstreams; i++) {
405 struct ogg_stream *cur_os = ogg->streams + i;
407 // if we have a partial non-header packet, its start is
408 // obviously at or after the data start
409 if (cur_os->incomplete)
410 s->data_offset = FFMIN(s->data_offset, cur_os->sync_pos);
413 os->pstart += os->psize;
419 if (os->codec && os->codec->packet)
420 os->codec->packet (s, idx);
424 *dstart = os->pstart;
428 *fpos = os->sync_pos;
429 os->pstart += os->psize;
431 if(os->pstart == os->bufpos)
432 os->bufpos = os->pstart = 0;
433 os->sync_pos = os->page_pos;
436 // determine whether there are more complete packets in this page
437 // if not, the page's granule will apply to this packet
439 for (i = os->segp; i < os->nsegs; i++)
440 if (os->segments[i] < 255) {
445 if (os->segp == os->nsegs)
451 static int ogg_get_headers(AVFormatContext *s)
453 struct ogg *ogg = s->priv_data;
457 ret = ogg_packet(s, NULL, NULL, NULL, NULL);
460 }while (!ogg->headers);
462 av_dlog(s, "found headers\n");
467 static int ogg_get_length(AVFormatContext *s)
469 struct ogg *ogg = s->priv_data;
478 if (s->duration != AV_NOPTS_VALUE)
481 size = avio_size(s->pb);
484 end = size > MAX_PAGE_SIZE? size - MAX_PAGE_SIZE: 0;
487 avio_seek (s->pb, end, SEEK_SET);
489 while (!ogg_read_page (s, &i)){
490 if (ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
491 ogg->streams[i].codec) {
492 s->streams[i]->duration =
493 ogg_gptopts (s, i, ogg->streams[i].granule, NULL);
494 if (s->streams[i]->start_time != AV_NOPTS_VALUE){
495 s->streams[i]->duration -= s->streams[i]->start_time;
496 streams_left-= (ogg->streams[i].got_start==-1);
497 ogg->streams[i].got_start= 1;
498 }else if(!ogg->streams[i].got_start){
499 ogg->streams[i].got_start= -1;
508 avio_seek (s->pb, 0, SEEK_SET);
509 while (!ogg_read_page (s, &i)){
510 if (ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
511 ogg->streams[i].codec) {
512 if(s->streams[i]->duration && s->streams[i]->start_time == AV_NOPTS_VALUE && !ogg->streams[i].got_start){
513 int64_t start= ogg_gptopts (s, i, ogg->streams[i].granule, NULL);
514 if(av_rescale_q(start, s->streams[i]->time_base, AV_TIME_BASE_Q) > AV_TIME_BASE)
515 s->streams[i]->duration -= start;
516 ogg->streams[i].got_start= 1;
528 static int ogg_read_header(AVFormatContext *s)
530 struct ogg *ogg = s->priv_data;
533 //linear headers seek from start
534 ret = ogg_get_headers(s);
538 for (i = 0; i < ogg->nstreams; i++)
539 if (ogg->streams[i].header < 0)
540 ogg->streams[i].codec = NULL;
542 //linear granulepos seek from end
545 //fill the extradata in the per codec callbacks
549 static int64_t ogg_calc_pts(AVFormatContext *s, int idx, int64_t *dts)
551 struct ogg *ogg = s->priv_data;
552 struct ogg_stream *os = ogg->streams + idx;
553 int64_t pts = AV_NOPTS_VALUE;
556 *dts = AV_NOPTS_VALUE;
558 if (os->lastpts != AV_NOPTS_VALUE) {
560 os->lastpts = AV_NOPTS_VALUE;
562 if (os->lastdts != AV_NOPTS_VALUE) {
565 os->lastdts = AV_NOPTS_VALUE;
568 if (os->granule != -1LL) {
569 if (os->codec && os->codec->granule_is_start)
570 pts = ogg_gptopts(s, idx, os->granule, dts);
572 os->lastpts = ogg_gptopts(s, idx, os->granule, &os->lastdts);
579 static void ogg_validate_keyframe(AVFormatContext *s, int idx, int pstart, int psize)
581 struct ogg *ogg = s->priv_data;
582 struct ogg_stream *os = ogg->streams + idx;
583 if (psize && s->streams[idx]->codec->codec_id == CODEC_ID_THEORA) {
584 if (!!(os->pflags & AV_PKT_FLAG_KEY) != !(os->buf[pstart] & 0x40)) {
585 os->pflags ^= AV_PKT_FLAG_KEY;
586 av_log(s, AV_LOG_WARNING, "Broken file, %skeyframe not correctly marked.\n",
587 (os->pflags & AV_PKT_FLAG_KEY) ? "" : "non-");
592 static int ogg_read_packet(AVFormatContext *s, AVPacket *pkt)
595 struct ogg_stream *os;
598 int64_t fpos, pts, dts;
603 ret = ogg_packet(s, &idx, &pstart, &psize, &fpos);
606 }while (idx < 0 || !s->streams[idx]);
609 os = ogg->streams + idx;
611 // pflags might not be set until after this
612 pts = ogg_calc_pts(s, idx, &dts);
613 ogg_validate_keyframe(s, idx, pstart, psize);
615 if (os->keyframe_seek && !(os->pflags & AV_PKT_FLAG_KEY))
617 os->keyframe_seek = 0;
620 ret = av_new_packet(pkt, psize);
623 pkt->stream_index = idx;
624 memcpy (pkt->data, os->buf + pstart, psize);
628 pkt->flags = os->pflags;
629 pkt->duration = os->pduration;
635 static int ogg_read_close(AVFormatContext *s)
637 struct ogg *ogg = s->priv_data;
640 for (i = 0; i < ogg->nstreams; i++){
641 av_free (ogg->streams[i].buf);
642 av_free (ogg->streams[i].private);
644 av_free (ogg->streams);
648 static int64_t ogg_read_timestamp(AVFormatContext *s, int stream_index,
649 int64_t *pos_arg, int64_t pos_limit)
651 struct ogg *ogg = s->priv_data;
652 AVIOContext *bc = s->pb;
653 int64_t pts = AV_NOPTS_VALUE;
657 avio_seek(bc, *pos_arg, SEEK_SET);
660 while (avio_tell(bc) < pos_limit && !ogg_packet(s, &i, &pstart, &psize, pos_arg)) {
661 if (i == stream_index) {
662 struct ogg_stream *os = ogg->streams + stream_index;
663 pts = ogg_calc_pts(s, i, NULL);
664 ogg_validate_keyframe(s, i, pstart, psize);
665 if (os->pflags & AV_PKT_FLAG_KEY) {
667 } else if (os->keyframe_seek) {
668 // if we had a previous keyframe but no pts for it,
669 // return that keyframe with this pts value.
673 pts = AV_NOPTS_VALUE;
676 if (pts != AV_NOPTS_VALUE)
683 static int ogg_read_seek(AVFormatContext *s, int stream_index,
684 int64_t timestamp, int flags)
686 struct ogg *ogg = s->priv_data;
687 struct ogg_stream *os = ogg->streams + stream_index;
690 // Ensure everything is reset even when seeking via
691 // the generated index.
694 // Try seeking to a keyframe first. If this fails (very possible),
695 // av_seek_frame will fall back to ignoring keyframes
696 if (s->streams[stream_index]->codec->codec_type == AVMEDIA_TYPE_VIDEO
697 && !(flags & AVSEEK_FLAG_ANY))
698 os->keyframe_seek = 1;
700 ret = ff_seek_frame_binary(s, stream_index, timestamp, flags);
701 os = ogg->streams + stream_index;
703 os->keyframe_seek = 0;
707 static int ogg_probe(AVProbeData *p)
709 if (!memcmp("OggS", p->buf, 5) && p->buf[5] <= 0x7)
710 return AVPROBE_SCORE_MAX;
714 AVInputFormat ff_ogg_demuxer = {
716 .long_name = NULL_IF_CONFIG_SMALL("Ogg"),
717 .priv_data_size = sizeof(struct ogg),
718 .read_probe = ogg_probe,
719 .read_header = ogg_read_header,
720 .read_packet = ogg_read_packet,
721 .read_close = ogg_read_close,
722 .read_seek = ogg_read_seek,
723 .read_timestamp = ogg_read_timestamp,
725 .flags = AVFMT_GENERIC_INDEX,