2 * Ogg bitstream support
3 * Luca Barbato <lu_zero@gentoo.org>
4 * Based on tcvp implementation
9 Copyright (C) 2005 Michael Ahlberg, Måns Rullgård
11 Permission is hereby granted, free of charge, to any person
12 obtaining a copy of this software and associated documentation
13 files (the "Software"), to deal in the Software without
14 restriction, including without limitation the rights to use, copy,
15 modify, merge, publish, distribute, sublicense, and/or sell copies
16 of the Software, and to permit persons to whom the Software is
17 furnished to do so, subject to the following conditions:
19 The above copyright notice and this permission notice shall be
20 included in all copies or substantial portions of the Software.
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
27 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
28 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29 DEALINGS IN THE SOFTWARE.
36 #include "vorbiscomment.h"
38 #define MAX_PAGE_SIZE 65307
39 #define DECODER_BUFFER_SIZE MAX_PAGE_SIZE
41 static const struct ogg_codec * const ogg_codecs[] = {
57 //FIXME We could avoid some structure duplication
59 ogg_save (AVFormatContext * s)
61 struct ogg *ogg = s->priv_data;
62 struct ogg_state *ost =
63 av_malloc(sizeof (*ost) + (ogg->nstreams-1) * sizeof (*ogg->streams));
65 ost->pos = avio_tell (s->pb);
66 ost->curidx = ogg->curidx;
67 ost->next = ogg->state;
68 ost->nstreams = ogg->nstreams;
69 memcpy(ost->streams, ogg->streams, ogg->nstreams * sizeof(*ogg->streams));
71 for (i = 0; i < ogg->nstreams; i++){
72 struct ogg_stream *os = ogg->streams + i;
73 os->buf = av_malloc (os->bufsize);
74 memset (os->buf, 0, os->bufsize);
75 memcpy (os->buf, ost->streams[i].buf, os->bufpos);
84 ogg_restore (AVFormatContext * s, int discard)
86 struct ogg *ogg = s->priv_data;
87 AVIOContext *bc = s->pb;
88 struct ogg_state *ost = ogg->state;
94 ogg->state = ost->next;
97 for (i = 0; i < ogg->nstreams; i++)
98 av_free (ogg->streams[i].buf);
100 avio_seek (bc, ost->pos, SEEK_SET);
101 ogg->curidx = ost->curidx;
102 ogg->nstreams = ost->nstreams;
103 memcpy(ogg->streams, ost->streams,
104 ost->nstreams * sizeof(*ogg->streams));
113 ogg_reset (struct ogg * ogg)
117 for (i = 0; i < ogg->nstreams; i++){
118 struct ogg_stream *os = ogg->streams + i;
123 os->lastpts = AV_NOPTS_VALUE;
124 os->lastdts = AV_NOPTS_VALUE;
137 static const struct ogg_codec *
138 ogg_find_codec (uint8_t * buf, int size)
142 for (i = 0; ogg_codecs[i]; i++)
143 if (size >= ogg_codecs[i]->magicsize &&
144 !memcmp (buf, ogg_codecs[i]->magic, ogg_codecs[i]->magicsize))
145 return ogg_codecs[i];
151 ogg_new_stream (AVFormatContext * s, uint32_t serial)
154 struct ogg *ogg = s->priv_data;
155 int idx = ogg->nstreams++;
157 struct ogg_stream *os;
159 ogg->streams = av_realloc (ogg->streams,
160 ogg->nstreams * sizeof (*ogg->streams));
161 memset (ogg->streams + idx, 0, sizeof (*ogg->streams));
162 os = ogg->streams + idx;
164 os->bufsize = DECODER_BUFFER_SIZE;
165 os->buf = av_malloc(os->bufsize);
168 st = av_new_stream (s, idx);
170 return AVERROR(ENOMEM);
172 av_set_pts_info(st, 64, 1, 1000000);
178 ogg_new_buf(struct ogg *ogg, int idx)
180 struct ogg_stream *os = ogg->streams + idx;
181 uint8_t *nb = av_malloc(os->bufsize);
182 int size = os->bufpos - os->pstart;
184 memcpy(nb, os->buf + os->pstart, size);
195 ogg_read_page (AVFormatContext * s, int *str)
197 AVIOContext *bc = s->pb;
198 struct ogg *ogg = s->priv_data;
199 struct ogg_stream *os;
210 if (avio_read (bc, sync, 4) < 4)
216 if (sync[sp & 3] == 'O' &&
217 sync[(sp + 1) & 3] == 'g' &&
218 sync[(sp + 2) & 3] == 'g' && sync[(sp + 3) & 3] == 'S')
225 }while (i++ < MAX_PAGE_SIZE);
227 if (i >= MAX_PAGE_SIZE){
228 av_log (s, AV_LOG_INFO, "ogg, can't find sync word\n");
232 if (avio_r8(bc) != 0) /* version */
237 serial = avio_rl32 (bc);
238 seq = avio_rl32 (bc);
239 crc = avio_rl32 (bc);
242 idx = ogg_find_stream (ogg, serial);
247 for (n = 0; n < ogg->nstreams; n++) {
248 av_freep(&ogg->streams[n].buf);
249 av_freep(&ogg->streams[n].private);
254 idx = ogg_new_stream (s, serial);
259 os = ogg->streams + idx;
260 os->page_pos = avio_tell(bc) - 27;
263 ogg_new_buf(ogg, idx);
265 if (avio_read (bc, os->segments, nsegs) < nsegs)
272 for (i = 0; i < nsegs; i++)
273 size += os->segments[i];
275 if (flags & OGG_FLAG_CONT || os->incomplete){
277 while (os->segp < os->nsegs){
278 int seg = os->segments[os->segp++];
283 os->sync_pos = os->page_pos;
287 os->sync_pos = os->page_pos;
290 if (os->bufsize - os->bufpos < size){
291 uint8_t *nb = av_malloc (os->bufsize *= 2);
292 memcpy (nb, os->buf, os->bufpos);
297 if (avio_read (bc, os->buf + os->bufpos, size) < size)
311 ogg_packet (AVFormatContext * s, int *str, int *dstart, int *dsize, int64_t *fpos)
313 struct ogg *ogg = s->priv_data;
315 struct ogg_stream *os;
317 int segp = 0, psize = 0;
319 av_dlog(s, AV_LOG_DEBUG, "ogg_packet: curidx=%i\n", ogg->curidx);
325 if (ogg_read_page (s, &idx) < 0)
329 os = ogg->streams + idx;
331 av_dlog(s, AV_LOG_DEBUG,
332 "ogg_packet: idx=%d pstart=%d psize=%d segp=%d nsegs=%d\n",
333 idx, os->pstart, os->psize, os->segp, os->nsegs);
337 os->codec = ogg_find_codec (os->buf, os->bufpos);
350 while (os->segp < os->nsegs){
351 int ss = os->segments[os->segp++];
359 if (!complete && os->segp == os->nsegs){
365 av_dlog(s, AV_LOG_DEBUG,
366 "ogg_packet: idx %i, frame size %i, start %i\n",
367 idx, os->psize, os->pstart);
369 if (os->granule == -1)
370 av_log(s, AV_LOG_WARNING, "Page at %"PRId64" is missing granule\n", os->page_pos);
376 os->header = os->codec->header (s, idx);
381 // We have reached the first non-header packet in this stream.
382 // Unfortunately more header packets may still follow for others,
383 // so we reset this later unless we are done with the headers
387 // Update the header state for all streams and
388 // compute the data_offset.
390 s->data_offset = os->sync_pos;
391 for (i = 0; i < ogg->nstreams; i++) {
392 struct ogg_stream *cur_os = ogg->streams + i;
393 if (cur_os->header > 0)
396 // if we have a partial non-header packet, its start is
397 // obviously at or after the data start
398 if (cur_os->incomplete)
399 s->data_offset = FFMIN(s->data_offset, cur_os->sync_pos);
402 os->pstart += os->psize;
408 if (os->codec && os->codec->packet)
409 os->codec->packet (s, idx);
413 *dstart = os->pstart;
417 *fpos = os->sync_pos;
418 os->pstart += os->psize;
420 os->sync_pos = os->page_pos;
423 // determine whether there are more complete packets in this page
424 // if not, the page's granule will apply to this packet
426 for (i = os->segp; i < os->nsegs; i++)
427 if (os->segments[i] < 255) {
432 if (os->segp == os->nsegs)
439 ogg_get_headers (AVFormatContext * s)
441 struct ogg *ogg = s->priv_data;
444 if (ogg_packet (s, NULL, NULL, NULL, NULL) < 0)
446 }while (!ogg->headers);
448 av_dlog(s, AV_LOG_DEBUG, "found headers\n");
454 ogg_get_length (AVFormatContext * s)
456 struct ogg *ogg = s->priv_data;
464 if (s->duration != AV_NOPTS_VALUE)
467 size = avio_size(s->pb);
470 end = size > MAX_PAGE_SIZE? size - MAX_PAGE_SIZE: 0;
473 avio_seek (s->pb, end, SEEK_SET);
475 while (!ogg_read_page (s, &i)){
476 if (ogg->streams[i].granule != -1 && ogg->streams[i].granule != 0 &&
477 ogg->streams[i].codec) {
478 s->streams[i]->duration =
479 ogg_gptopts (s, i, ogg->streams[i].granule, NULL);
480 if (s->streams[i]->start_time != AV_NOPTS_VALUE)
481 s->streams[i]->duration -= s->streams[i]->start_time;
492 ogg_read_header (AVFormatContext * s, AVFormatParameters * ap)
494 struct ogg *ogg = s->priv_data;
497 //linear headers seek from start
498 if (ogg_get_headers (s) < 0){
502 for (i = 0; i < ogg->nstreams; i++)
503 if (ogg->streams[i].header < 0)
504 ogg->streams[i].codec = NULL;
506 //linear granulepos seek from end
509 //fill the extradata in the per codec callbacks
513 static int64_t ogg_calc_pts(AVFormatContext *s, int idx, int64_t *dts)
515 struct ogg *ogg = s->priv_data;
516 struct ogg_stream *os = ogg->streams + idx;
517 int64_t pts = AV_NOPTS_VALUE;
520 *dts = AV_NOPTS_VALUE;
522 if (os->lastpts != AV_NOPTS_VALUE) {
524 os->lastpts = AV_NOPTS_VALUE;
526 if (os->lastdts != AV_NOPTS_VALUE) {
529 os->lastdts = AV_NOPTS_VALUE;
532 if (os->granule != -1LL) {
533 if (os->codec && os->codec->granule_is_start)
534 pts = ogg_gptopts(s, idx, os->granule, dts);
536 os->lastpts = ogg_gptopts(s, idx, os->granule, &os->lastdts);
544 ogg_read_packet (AVFormatContext * s, AVPacket * pkt)
547 struct ogg_stream *os;
550 int64_t fpos, pts, dts;
555 if (ogg_packet (s, &idx, &pstart, &psize, &fpos) < 0)
557 }while (idx < 0 || !s->streams[idx]);
560 os = ogg->streams + idx;
562 // pflags might not be set until after this
563 pts = ogg_calc_pts(s, idx, &dts);
565 if (os->keyframe_seek && !(os->pflags & AV_PKT_FLAG_KEY))
567 os->keyframe_seek = 0;
570 if (av_new_packet (pkt, psize) < 0)
572 pkt->stream_index = idx;
573 memcpy (pkt->data, os->buf + pstart, psize);
577 pkt->flags = os->pflags;
578 pkt->duration = os->pduration;
586 ogg_read_close (AVFormatContext * s)
588 struct ogg *ogg = s->priv_data;
591 for (i = 0; i < ogg->nstreams; i++){
592 av_free (ogg->streams[i].buf);
593 av_free (ogg->streams[i].private);
595 av_free (ogg->streams);
601 ogg_read_timestamp (AVFormatContext * s, int stream_index, int64_t * pos_arg,
604 struct ogg *ogg = s->priv_data;
605 struct ogg_stream *os = ogg->streams + stream_index;
606 AVIOContext *bc = s->pb;
607 int64_t pts = AV_NOPTS_VALUE;
609 avio_seek(bc, *pos_arg, SEEK_SET);
612 while (avio_tell(bc) < pos_limit && !ogg_packet(s, &i, NULL, NULL, pos_arg)) {
613 if (i == stream_index) {
614 pts = ogg_calc_pts(s, i, NULL);
615 if (os->keyframe_seek && !(os->pflags & AV_PKT_FLAG_KEY))
616 pts = AV_NOPTS_VALUE;
618 if (pts != AV_NOPTS_VALUE)
625 static int ogg_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
627 struct ogg *ogg = s->priv_data;
628 struct ogg_stream *os = ogg->streams + stream_index;
631 // Try seeking to a keyframe first. If this fails (very possible),
632 // av_seek_frame will fall back to ignoring keyframes
633 if (s->streams[stream_index]->codec->codec_type == AVMEDIA_TYPE_VIDEO
634 && !(flags & AVSEEK_FLAG_ANY))
635 os->keyframe_seek = 1;
637 ret = av_seek_frame_binary(s, stream_index, timestamp, flags);
639 os->keyframe_seek = 0;
643 static int ogg_probe(AVProbeData *p)
645 if (p->buf[0] == 'O' && p->buf[1] == 'g' &&
646 p->buf[2] == 'g' && p->buf[3] == 'S' &&
647 p->buf[4] == 0x0 && p->buf[5] <= 0x7 )
648 return AVPROBE_SCORE_MAX;
653 AVInputFormat ff_ogg_demuxer = {
655 NULL_IF_CONFIG_SMALL("Ogg"),
664 .flags = AVFMT_GENERIC_INDEX,