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.
32 #include "libavutil/avassert.h"
33 #include "libavutil/intreadwrite.h"
34 #include "avio_internal.h"
38 #include "vorbiscomment.h"
40 #define MAX_PAGE_SIZE 65307
41 #define DECODER_BUFFER_SIZE MAX_PAGE_SIZE
43 static const struct ogg_codec * const ogg_codecs[] = {
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);
66 static void free_stream(AVFormatContext *s, int i)
68 struct ogg *ogg = s->priv_data;
69 struct ogg_stream *stream = &ogg->streams[i];
71 av_freep(&stream->buf);
73 stream->codec->cleanup) {
74 stream->codec->cleanup(s, i);
77 av_freep(&stream->private);
78 av_freep(&stream->new_metadata);
81 //FIXME We could avoid some structure duplication
82 static int ogg_save(AVFormatContext *s)
84 struct ogg *ogg = s->priv_data;
85 struct ogg_state *ost =
86 av_malloc(sizeof(*ost) + (ogg->nstreams - 1) * sizeof(*ogg->streams));
91 return AVERROR(ENOMEM);
93 ost->pos = avio_tell(s->pb);
94 ost->curidx = ogg->curidx;
95 ost->next = ogg->state;
96 ost->nstreams = ogg->nstreams;
97 memcpy(ost->streams, ogg->streams, ogg->nstreams * sizeof(*ogg->streams));
99 for (i = 0; i < ogg->nstreams; i++) {
100 struct ogg_stream *os = ogg->streams + i;
101 os->buf = av_mallocz(os->bufsize + AV_INPUT_BUFFER_PADDING_SIZE);
103 memcpy(os->buf, ost->streams[i].buf, os->bufpos);
105 ret = AVERROR(ENOMEM);
106 os->new_metadata = NULL;
107 os->new_metadata_size = 0;
118 static int ogg_restore(AVFormatContext *s)
120 struct ogg *ogg = s->priv_data;
121 AVIOContext *bc = s->pb;
122 struct ogg_state *ost = ogg->state;
128 ogg->state = ost->next;
130 for (i = 0; i < ogg->nstreams; i++) {
131 struct ogg_stream *stream = &ogg->streams[i];
132 av_freep(&stream->buf);
133 av_freep(&stream->new_metadata);
135 if (i >= ost->nstreams || !ost->streams[i].private) {
140 avio_seek(bc, ost->pos, SEEK_SET);
142 ogg->curidx = ost->curidx;
143 ogg->nstreams = ost->nstreams;
144 if ((err = av_reallocp_array(&ogg->streams, ogg->nstreams,
145 sizeof(*ogg->streams))) < 0) {
149 memcpy(ogg->streams, ost->streams,
150 ost->nstreams * sizeof(*ogg->streams));
157 static int ogg_reset(AVFormatContext *s)
159 struct ogg *ogg = s->priv_data;
161 int64_t start_pos = avio_tell(s->pb);
163 for (i = 0; i < ogg->nstreams; i++) {
164 struct ogg_stream *os = ogg->streams + i;
169 os->lastpts = AV_NOPTS_VALUE;
170 os->lastdts = AV_NOPTS_VALUE;
177 if (start_pos <= s->internal->data_offset) {
180 os->start_trimming = 0;
181 os->end_trimming = 0;
182 av_freep(&os->new_metadata);
183 os->new_metadata_size = 0;
192 static const struct ogg_codec *ogg_find_codec(uint8_t *buf, int size)
196 for (i = 0; ogg_codecs[i]; i++)
197 if (size >= ogg_codecs[i]->magicsize &&
198 !memcmp(buf, ogg_codecs[i]->magic, ogg_codecs[i]->magicsize))
199 return ogg_codecs[i];
205 * Replace the current stream with a new one. This is a typical webradio
206 * situation where a new audio stream spawn (identified with a new serial) and
207 * must replace the previous one (track switch).
209 static int ogg_replace_stream(AVFormatContext *s, uint32_t serial, char *magic, int page_size,
212 struct ogg *ogg = s->priv_data;
213 struct ogg_stream *os;
214 const struct ogg_codec *codec;
217 if (ogg->nstreams != 1) {
218 avpriv_report_missing_feature(s, "Changing stream parameters in multistream ogg");
219 return AVERROR_PATCHWELCOME;
222 /* Check for codecs */
223 codec = ogg_find_codec(magic, page_size);
224 if (!codec && !probing) {
225 av_log(s, AV_LOG_ERROR, "Cannot identify new stream\n");
226 return AVERROR_INVALIDDATA;
229 os = &ogg->streams[0];
230 if (os->codec != codec)
231 return AVERROR(EINVAL);
238 os->start_trimming = 0;
239 os->end_trimming = 0;
241 /* Chained files have extradata as a new packet */
242 if (codec == &ff_opus_codec)
248 static int ogg_new_stream(AVFormatContext *s, uint32_t serial)
250 struct ogg *ogg = s->priv_data;
251 int idx = ogg->nstreams;
253 struct ogg_stream *os;
257 av_log(s, AV_LOG_ERROR, "New streams are not supposed to be added "
258 "in between Ogg context save/restore operations.\n");
262 /* Allocate and init a new Ogg Stream */
263 if (av_size_mult(ogg->nstreams + 1, sizeof(*ogg->streams), &size) < 0 ||
264 !(os = av_realloc(ogg->streams, size)))
265 return AVERROR(ENOMEM);
267 os = ogg->streams + idx;
268 memset(os, 0, sizeof(*os));
270 os->bufsize = DECODER_BUFFER_SIZE;
271 os->buf = av_malloc(os->bufsize + AV_INPUT_BUFFER_PADDING_SIZE);
273 os->start_granule = OGG_NOGRANULE_VALUE;
275 return AVERROR(ENOMEM);
277 /* Create the associated AVStream */
278 st = avformat_new_stream(s, NULL);
281 return AVERROR(ENOMEM);
284 avpriv_set_pts_info(st, 64, 1, 1000000);
290 static int data_packets_seen(const struct ogg *ogg)
294 for (i = 0; i < ogg->nstreams; i++)
295 if (ogg->streams[i].got_data)
300 static int buf_realloc(struct ogg_stream *os, int size)
302 /* Even if invalid guarantee there's enough memory to read the page */
303 if (os->bufsize - os->bufpos < size) {
304 uint8_t *nb = av_realloc(os->buf, 2*os->bufsize + AV_INPUT_BUFFER_PADDING_SIZE);
306 return AVERROR(ENOMEM);
314 static int ogg_read_page(AVFormatContext *s, int *sid, int probing)
316 AVIOContext *bc = s->pb;
317 struct ogg *ogg = s->priv_data;
318 struct ogg_stream *os;
323 uint32_t crc, crc_tmp;
325 int64_t version, page_pos;
328 uint8_t segments[255];
329 uint8_t *readout_buf;
332 ret = avio_read(bc, sync, 4);
334 return ret < 0 ? ret : AVERROR_EOF;
339 if (sync[sp & 3] == 'O' &&
340 sync[(sp + 1) & 3] == 'g' &&
341 sync[(sp + 2) & 3] == 'g' && sync[(sp + 3) & 3] == 'S')
344 if(!i && (bc->seekable & AVIO_SEEKABLE_NORMAL) && ogg->page_pos > 0) {
346 avio_seek(bc, ogg->page_pos+4, SEEK_SET);
356 } while (i++ < MAX_PAGE_SIZE);
358 if (i >= MAX_PAGE_SIZE) {
359 av_log(s, AV_LOG_INFO, "cannot find sync word\n");
360 return AVERROR_INVALIDDATA;
363 /* 0x4fa9b05f = av_crc(AV_CRC_32_IEEE, 0x0, "OggS", 4) */
364 ffio_init_checksum(bc, ff_crc04C11DB7_update, 0x4fa9b05f);
366 /* To rewind if checksum is bad/check magic on switches - this is the max packet size */
367 ffio_ensure_seekback(bc, MAX_PAGE_SIZE);
368 start_pos = avio_tell(bc);
370 version = avio_r8(bc);
373 serial = avio_rl32(bc);
374 avio_skip(bc, 4); /* seq */
376 crc_tmp = ffio_get_checksum(bc);
378 crc_tmp = ff_crc04C11DB7_update(crc_tmp, (uint8_t[4]){0}, 4);
379 ffio_init_checksum(bc, ff_crc04C11DB7_update, crc_tmp);
382 page_pos = avio_tell(bc) - 27;
384 ret = avio_read(bc, segments, nsegs);
386 return ret < 0 ? ret : AVERROR_EOF;
388 for (i = 0; i < nsegs; i++)
391 idx = ogg_find_stream(ogg, serial);
393 os = ogg->streams + idx;
395 ret = buf_realloc(os, size);
399 readout_buf = os->buf + os->bufpos;
401 readout_buf = av_malloc(size);
404 ret = avio_read(bc, readout_buf, size);
407 av_free(readout_buf);
408 return ret < 0 ? ret : AVERROR_EOF;
411 if (crc ^ ffio_get_checksum(bc)) {
412 av_log(s, AV_LOG_ERROR, "CRC mismatch!\n");
414 av_free(readout_buf);
415 avio_seek(bc, start_pos, SEEK_SET);
420 /* Since we're almost sure its a valid packet, checking the version after
421 * the checksum lets the demuxer be more tolerant */
423 av_log(s, AV_LOG_ERROR, "Invalid Ogg vers!\n");
425 av_free(readout_buf);
426 avio_seek(bc, start_pos, SEEK_SET);
431 /* CRC is correct so we can be 99% sure there's an actual change here */
433 if (data_packets_seen(ogg))
434 idx = ogg_replace_stream(s, serial, readout_buf, size, probing);
436 idx = ogg_new_stream(s, serial);
439 av_log(s, AV_LOG_ERROR, "failed to create or replace stream\n");
440 av_free(readout_buf);
444 os = ogg->streams + idx;
446 ret = buf_realloc(os, size);
448 av_free(readout_buf);
452 memcpy(os->buf + os->bufpos, readout_buf, size);
453 av_free(readout_buf);
456 ogg->page_pos = page_pos;
457 os->page_pos = page_pos;
460 os->got_data = !(flags & OGG_FLAG_BOS);
464 memcpy(os->segments, segments, nsegs);
465 memset(os->buf + os->bufpos, 0, AV_INPUT_BUFFER_PADDING_SIZE);
467 if (flags & OGG_FLAG_CONT || os->incomplete) {
469 // If this is the very first segment we started
470 // playback in the middle of a continuation packet.
471 // Discard it since we missed the start of it.
472 while (os->segp < os->nsegs) {
473 int seg = os->segments[os->segp++];
478 os->sync_pos = os->page_pos;
482 os->sync_pos = os->page_pos;
485 /* This function is always called with sid != NULL */
492 * @brief find the next Ogg packet
493 * @param *sid is set to the stream for the packet or -1 if there is
494 * no matching stream, in that case assume all other return
495 * values to be uninitialized.
496 * @return negative value on error or EOF.
498 static int ogg_packet(AVFormatContext *s, int *sid, int *dstart, int *dsize,
501 struct ogg *ogg = s->priv_data;
503 struct ogg_stream *os;
505 int segp = 0, psize = 0;
507 av_log(s, AV_LOG_TRACE, "ogg_packet: curidx=%i\n", ogg->curidx);
515 ret = ogg_read_page(s, &idx, 0);
520 os = ogg->streams + idx;
522 av_log(s, AV_LOG_TRACE, "ogg_packet: idx=%d pstart=%d psize=%d segp=%d nsegs=%d\n",
523 idx, os->pstart, os->psize, os->segp, os->nsegs);
526 if (os->header < 0) {
527 os->codec = ogg_find_codec(os->buf, os->bufpos);
529 av_log(s, AV_LOG_WARNING, "Codec not found\n");
541 while (os->segp < os->nsegs) {
542 int ss = os->segments[os->segp++];
550 if (!complete && os->segp == os->nsegs) {
552 // Do not set incomplete for empty packets.
553 // Together with the code in ogg_read_page
554 // that discards all continuation of empty packets
555 // we would get an infinite loop.
556 os->incomplete = !!os->psize;
561 if (os->granule == -1)
562 av_log(s, AV_LOG_WARNING,
563 "Page at %"PRId64" is missing granule\n",
570 if ((ret = os->codec->header(s, idx)) < 0) {
571 av_log(s, AV_LOG_ERROR, "Header processing failed: %s\n", av_err2str(ret));
579 // We have reached the first non-header packet in this stream.
580 // Unfortunately more header packets may still follow for others,
581 // but if we continue with header parsing we may lose data packets.
584 // Update the header state for all streams and
585 // compute the data_offset.
586 if (!s->internal->data_offset)
587 s->internal->data_offset = os->sync_pos;
589 for (i = 0; i < ogg->nstreams; i++) {
590 struct ogg_stream *cur_os = ogg->streams + i;
592 // if we have a partial non-header packet, its start is
593 // obviously at or after the data start
594 if (cur_os->incomplete)
595 s->internal->data_offset = FFMIN(s->internal->data_offset, cur_os->sync_pos);
599 os->pstart += os->psize;
605 if (os->codec && os->codec->packet) {
606 if ((ret = os->codec->packet(s, idx)) < 0) {
607 av_log(s, AV_LOG_ERROR, "Packet processing failed: %s\n", av_err2str(ret));
614 *dstart = os->pstart;
618 *fpos = os->sync_pos;
619 os->pstart += os->psize;
621 if(os->pstart == os->bufpos)
622 os->bufpos = os->pstart = 0;
623 os->sync_pos = os->page_pos;
626 // determine whether there are more complete packets in this page
627 // if not, the page's granule will apply to this packet
629 for (i = os->segp; i < os->nsegs; i++)
630 if (os->segments[i] < 255) {
635 if (os->segp == os->nsegs)
641 static int ogg_get_length(AVFormatContext *s)
643 struct ogg *ogg = s->priv_data;
648 if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
652 if (s->duration != AV_NOPTS_VALUE)
655 size = avio_size(s->pb);
658 end = size > MAX_PAGE_SIZE ? size - MAX_PAGE_SIZE : 0;
663 avio_seek(s->pb, end, SEEK_SET);
666 while (!ogg_read_page(s, &i, 1)) {
667 if (i >= 0 && ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
668 ogg->streams[i].codec) {
669 s->streams[i]->duration =
670 ogg_gptopts(s, i, ogg->streams[i].granule, NULL);
671 if (s->streams[i]->start_time != AV_NOPTS_VALUE) {
672 s->streams[i]->duration -= s->streams[i]->start_time;
673 streams_left-= (ogg->streams[i].got_start==-1);
674 ogg->streams[i].got_start= 1;
675 } else if(!ogg->streams[i].got_start) {
676 ogg->streams[i].got_start= -1;
688 avio_seek (s->pb, s->internal->data_offset, SEEK_SET);
690 while (streams_left > 0 && !ogg_packet(s, &i, NULL, NULL, NULL)) {
693 pts = ogg_calc_pts(s, i, NULL);
694 if (s->streams[i]->duration == AV_NOPTS_VALUE)
696 if (pts != AV_NOPTS_VALUE && s->streams[i]->start_time == AV_NOPTS_VALUE && !ogg->streams[i].got_start) {
697 s->streams[i]->duration -= pts;
698 ogg->streams[i].got_start= 1;
700 }else if(s->streams[i]->start_time != AV_NOPTS_VALUE && !ogg->streams[i].got_start) {
701 ogg->streams[i].got_start= 1;
710 static int ogg_read_close(AVFormatContext *s)
712 struct ogg *ogg = s->priv_data;
715 for (i = 0; i < ogg->nstreams; i++) {
721 av_freep(&ogg->streams);
725 static int ogg_read_header(AVFormatContext *s)
727 struct ogg *ogg = s->priv_data;
732 //linear headers seek from start
734 ret = ogg_packet(s, NULL, NULL, NULL, NULL);
739 } while (!ogg->headers);
740 av_log(s, AV_LOG_TRACE, "found headers\n");
742 for (i = 0; i < ogg->nstreams; i++) {
743 struct ogg_stream *os = ogg->streams + i;
745 if (ogg->streams[i].header < 0) {
746 av_log(s, AV_LOG_ERROR, "Header parsing failed for stream %d\n", i);
747 ogg->streams[i].codec = NULL;
748 av_freep(&ogg->streams[i].private);
749 } else if (os->codec && os->nb_header < os->codec->nb_header) {
750 av_log(s, AV_LOG_WARNING,
751 "Headers mismatch for stream %d: "
752 "expected %d received %d.\n",
753 i, os->codec->nb_header, os->nb_header);
754 if (s->error_recognition & AV_EF_EXPLODE) {
756 return AVERROR_INVALIDDATA;
759 if (os->start_granule != OGG_NOGRANULE_VALUE)
760 os->lastpts = s->streams[i]->start_time =
761 ogg_gptopts(s, i, os->start_granule, NULL);
764 //linear granulepos seek from end
765 ret = ogg_get_length(s);
774 static int64_t ogg_calc_pts(AVFormatContext *s, int idx, int64_t *dts)
776 struct ogg *ogg = s->priv_data;
777 struct ogg_stream *os = ogg->streams + idx;
778 int64_t pts = AV_NOPTS_VALUE;
781 *dts = AV_NOPTS_VALUE;
783 if (os->lastpts != AV_NOPTS_VALUE) {
785 os->lastpts = AV_NOPTS_VALUE;
787 if (os->lastdts != AV_NOPTS_VALUE) {
790 os->lastdts = AV_NOPTS_VALUE;
793 if (os->granule != -1LL) {
794 if (os->codec && os->codec->granule_is_start)
795 pts = ogg_gptopts(s, idx, os->granule, dts);
797 os->lastpts = ogg_gptopts(s, idx, os->granule, &os->lastdts);
804 static void ogg_validate_keyframe(AVFormatContext *s, int idx, int pstart, int psize)
806 struct ogg *ogg = s->priv_data;
807 struct ogg_stream *os = ogg->streams + idx;
810 switch (s->streams[idx]->codecpar->codec_id) {
811 case AV_CODEC_ID_THEORA:
812 invalid = !!(os->pflags & AV_PKT_FLAG_KEY) != !(os->buf[pstart] & 0x40);
814 case AV_CODEC_ID_VP8:
815 invalid = !!(os->pflags & AV_PKT_FLAG_KEY) != !(os->buf[pstart] & 1);
818 os->pflags ^= AV_PKT_FLAG_KEY;
819 av_log(s, AV_LOG_WARNING, "Broken file, %skeyframe not correctly marked.\n",
820 (os->pflags & AV_PKT_FLAG_KEY) ? "" : "non-");
825 static int ogg_read_packet(AVFormatContext *s, AVPacket *pkt)
828 struct ogg_stream *os;
831 int64_t fpos, pts, dts;
833 if (s->io_repositioned) {
835 s->io_repositioned = 0;
841 ret = ogg_packet(s, &idx, &pstart, &psize, &fpos);
844 } while (idx < 0 || !s->streams[idx]);
847 os = ogg->streams + idx;
849 // pflags might not be set until after this
850 pts = ogg_calc_pts(s, idx, &dts);
851 ogg_validate_keyframe(s, idx, pstart, psize);
853 if (os->keyframe_seek && !(os->pflags & AV_PKT_FLAG_KEY))
855 os->keyframe_seek = 0;
858 ret = av_new_packet(pkt, psize);
861 pkt->stream_index = idx;
862 memcpy(pkt->data, os->buf + pstart, psize);
866 pkt->flags = os->pflags;
867 pkt->duration = os->pduration;
870 if (os->start_trimming || os->end_trimming) {
871 uint8_t *side_data = av_packet_new_side_data(pkt,
872 AV_PKT_DATA_SKIP_SAMPLES,
875 return AVERROR(ENOMEM);
876 AV_WL32(side_data + 0, os->start_trimming);
877 AV_WL32(side_data + 4, os->end_trimming);
878 os->start_trimming = 0;
879 os->end_trimming = 0;
882 if (os->new_metadata) {
883 ret = av_packet_add_side_data(pkt, AV_PKT_DATA_METADATA_UPDATE,
884 os->new_metadata, os->new_metadata_size);
888 os->new_metadata = NULL;
889 os->new_metadata_size = 0;
895 static int64_t ogg_read_timestamp(AVFormatContext *s, int stream_index,
896 int64_t *pos_arg, int64_t pos_limit)
898 struct ogg *ogg = s->priv_data;
899 AVIOContext *bc = s->pb;
900 int64_t pts = AV_NOPTS_VALUE;
904 avio_seek(bc, *pos_arg, SEEK_SET);
907 while ( avio_tell(bc) <= pos_limit
908 && !ogg_packet(s, &i, &pstart, &psize, pos_arg)) {
909 if (i == stream_index) {
910 struct ogg_stream *os = ogg->streams + stream_index;
911 // Do not trust the last timestamps of an ogm video
912 if ( (os->flags & OGG_FLAG_EOS)
913 && !(os->flags & OGG_FLAG_BOS)
914 && os->codec == &ff_ogm_video_codec)
916 pts = ogg_calc_pts(s, i, NULL);
917 ogg_validate_keyframe(s, i, pstart, psize);
918 if (os->pflags & AV_PKT_FLAG_KEY) {
920 } else if (os->keyframe_seek) {
921 // if we had a previous keyframe but no pts for it,
922 // return that keyframe with this pts value.
926 pts = AV_NOPTS_VALUE;
929 if (pts != AV_NOPTS_VALUE)
936 static int ogg_read_seek(AVFormatContext *s, int stream_index,
937 int64_t timestamp, int flags)
939 struct ogg *ogg = s->priv_data;
940 struct ogg_stream *os = ogg->streams + stream_index;
943 av_assert0(stream_index < ogg->nstreams);
944 // Ensure everything is reset even when seeking via
945 // the generated index.
948 // Try seeking to a keyframe first. If this fails (very possible),
949 // av_seek_frame will fall back to ignoring keyframes
950 if (s->streams[stream_index]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO
951 && !(flags & AVSEEK_FLAG_ANY))
952 os->keyframe_seek = 1;
954 ret = ff_seek_frame_binary(s, stream_index, timestamp, flags);
956 os = ogg->streams + stream_index;
958 os->keyframe_seek = 0;
962 static int ogg_probe(const AVProbeData *p)
964 if (!memcmp("OggS", p->buf, 5) && p->buf[5] <= 0x7)
965 return AVPROBE_SCORE_MAX;
969 AVInputFormat ff_ogg_demuxer = {
971 .long_name = NULL_IF_CONFIG_SMALL("Ogg"),
972 .priv_data_size = sizeof(struct ogg),
973 .read_probe = ogg_probe,
974 .read_header = ogg_read_header,
975 .read_packet = ogg_read_packet,
976 .read_close = ogg_read_close,
977 .read_seek = ogg_read_seek,
978 .read_timestamp = ogg_read_timestamp,
980 .flags = AVFMT_GENERIC_INDEX | AVFMT_TS_DISCONT | AVFMT_NOBINSEARCH,