Libav
oggdec.c
Go to the documentation of this file.
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[] = {
50  &ff_vp8_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;
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;
176  os->header = -1;
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;
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) {
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)
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)
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 
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);
495  return AVERROR_INVALIDDATA;
496  }
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 
507 {
508  struct ogg *ogg = s->priv_data;
509  int i, ret;
510  int64_t size, end;
511 
512  if (!s->pb->seekable)
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 
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 
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 
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 
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",
724 };
int headers
Definition: oggdec.h:99
int header
Definition: oggdec.h:78
int granule_is_start
1 if granule is the start time of the associated packet.
Definition: oggdec.h:53
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
#define AVFMT_NOBINSEARCH
Format does not allow to fall back on binary search via read_timestamp.
Definition: avformat.h:426
Bytestream IO Context.
Definition: avio.h:104
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:297
int size
int nstreams
Definition: oggdec.h:98
Copyright (C) 2005 Michael Ahlberg, Måns Rullgård.
Definition: oggdec.h:31
static const struct ogg_codec * ogg_find_codec(uint8_t *buf, int size)
Definition: oggdec.c:144
unsigned int bufsize
Definition: oggdec.h:63
unsigned int pflags
Definition: oggdec.h:67
const struct ogg_codec ff_celt_codec
Definition: oggparsecelt.c:90
#define DECODER_BUFFER_SIZE
Definition: oggdec.c:39
int nb_header
set to the number of parsed headers
Definition: oggdec.h:84
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:130
int(* packet)(AVFormatContext *, int)
Definition: oggdec.h:42
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1366
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:2986
static int ogg_new_buf(struct ogg *ogg, int idx)
Definition: oggdec.c:191
#define OGG_NOGRANULE_VALUE
Definition: oggdec.h:108
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:1659
const struct ogg_codec * codec
Definition: oggdec.h:77
int64_t data_offset
offset of the first packet
Definition: internal.h:62
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:242
static int sync(AVFormatContext *s, uint8_t *header)
Read input until we find the next ident.
Definition: lxfdec.c:86
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1243
int flags
Definition: oggdec.h:76
#define OGG_FLAG_CONT
Definition: oggdec.h:104
static int ogg_get_length(AVFormatContext *s)
Definition: oggdec.c:506
static int ogg_probe(AVProbeData *p)
Definition: oggdec.c:705
static const struct ogg_codec *const ogg_codecs[]
Definition: oggdec.c:41
int64_t lastpts
Definition: oggdec.h:72
static int ogg_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: oggdec.c:618
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:202
const struct ogg_codec ff_ogm_old_codec
Definition: oggparseogm.c:189
Format I/O context.
Definition: avformat.h:940
unsigned int psize
Definition: oggdec.h:66
static int ogg_restore(AVFormatContext *s, int discard)
Definition: oggdec.c:86
int64_t sync_pos
file offset of the first page needed to reconstruct the current packet
Definition: oggdec.h:74
uint64_t pos
Definition: oggdec.h:89
uint8_t
const struct ogg_codec ff_ogm_video_codec
Definition: oggparseogm.c:162
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:150
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1364
int id
Format-specific stream ID.
Definition: avformat.h:712
int(* header)(AVFormatContext *, int)
Attempt to process a packet as a header.
Definition: oggdec.h:41
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:2648
int64_t page_pos
file offset of the current page
Definition: oggdec.h:75
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1008
struct ogg_state * state
Definition: oggdec.h:101
uint8_t * data
Definition: avcodec.h:1346
static int flags
Definition: log.c:50
int nstreams
Definition: oggdec.h:92
#define AVERROR_EOF
End of file.
Definition: error.h:51
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:295
static int ogg_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: oggdec.c:685
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:545
const struct ogg_codec ff_skeleton_codec
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1378
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:84
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:168
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:190
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:665
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:148
static int ogg_read_close(AVFormatContext *s)
Definition: oggdec.c:544
#define MAX_PAGE_SIZE
Definition: oggdec.c:38
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3479
const struct ogg_codec ff_opus_codec
Definition: oggparseopus.c:136
uint8_t segments[255]
Definition: oggdec.h:80
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1352
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:536
int incomplete
whether we&#39;re expecting a continuation in the next page
Definition: oggdec.h:81
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:400
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:153
uint32_t serial
Definition: oggdec.h:69
#define FFMIN(a, b)
Definition: common.h:66
uint64_t granule
Definition: oggdec.h:70
static int ogg_get_headers(AVFormatContext *s)
Definition: oggdec.c:474
unsigned int pstart
Definition: oggdec.h:65
static int64_t ogg_calc_pts(AVFormatContext *s, int idx, int64_t *dts)
Definition: oggdec.c:588
uint64_t start_granule
Definition: oggdec.h:71
static av_always_inline int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: avio.h:286
struct ogg_stream * streams
Definition: oggdec.h:97
int segp
Definition: oggdec.h:79
const struct ogg_codec ff_vorbis_codec
const struct ogg_codec ff_vp8_codec
Definition: oggparsevp8.c:135
static int ogg_new_stream(AVFormatContext *s, uint32_t serial, int new_avstream)
Definition: oggdec.c:156
int page_end
current packet is the last one completed in the page
Definition: oggdec.h:82
AVInputFormat ff_ogg_demuxer
Definition: oggdec.c:712
#define AV_EF_EXPLODE
Definition: avcodec.h:2681
const struct ogg_codec ff_ogm_audio_codec
Definition: oggparseogm.c:171
if(ac->has_optimized_func)
Stream structure.
Definition: avformat.h:705
const struct ogg_codec ff_theora_codec
NULL
Definition: eval.c:55
static int ogg_find_stream(struct ogg *ogg, int serial)
Definition: oggdec.h:133
#define AV_LOG_INFO
Standard information.
Definition: log.h:135
unsigned int pduration
Definition: oggdec.h:68
int nsegs
Definition: oggdec.h:79
AVIOContext * pb
I/O context.
Definition: avformat.h:982
const struct ogg_codec ff_flac_codec
Definition: oggparseflac.c:91
const struct ogg_codec ff_old_dirac_codec
static int ogg_read_page(AVFormatContext *s, int *str)
Definition: oggdec.c:212
void * private
Definition: oggdec.h:85
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:421
struct ogg_state * next
Definition: oggdec.h:91
static int ogg_read_header(AVFormatContext *s)
Definition: oggdec.c:561
int nb_header
Number of expected headers.
Definition: oggdec.h:57
static int ogg_reset(struct ogg *ogg)
Definition: oggdec.c:120
int64_t lastdts
Definition: oggdec.h:73
This structure contains the data a format has to probe a file.
Definition: avformat.h:398
const struct ogg_codec ff_old_flac_codec
Definition: oggparseflac.c:98
void(* cleanup)(AVFormatContext *s, int idx)
Definition: oggdec.h:58
static int64_t pts
Global timestamp for the audio frames.
int curidx
Definition: oggdec.h:90
const int8_t * magic
Definition: oggdec.h:32
const struct ogg_codec ff_dirac_codec
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:757
uint8_t * buf
Definition: oggdec.h:62
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:407
const struct ogg_codec ff_speex_codec
Main libavformat public API header.
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:117
int64_t start_time
Decoding: pts of the first frame of the stream, in stream time base.
Definition: avformat.h:750
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1170
const struct ogg_codec ff_ogm_text_codec
Definition: oggparseogm.c:180
int keyframe_seek
Definition: oggdec.h:83
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:638
static int ogg_packet(AVFormatContext *s, int *str, int *dstart, int *dsize, int64_t *fpos)
Definition: oggdec.c:341
int eof_reached
true if eof reached
Definition: avio.h:132
Definition: oggdec.h:96
static int ogg_save(AVFormatContext *s)
Definition: oggdec.c:61
void * priv_data
Format private data.
Definition: avformat.h:968
uint8_t magicsize
Definition: oggdec.h:33
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1345
static int64_t ogg_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos_arg, int64_t pos_limit)
Definition: oggdec.c:660
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1035
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:529
int curidx
Definition: oggdec.h:100
AVCodecParameters * codecpar
Definition: avformat.h:831
int stream_index
Definition: avcodec.h:1348
struct ogg_stream streams[1]
Definition: oggdec.h:93
This structure stores compressed data.
Definition: avcodec.h:1323
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:673
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:211
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1339
unsigned int bufpos
Definition: oggdec.h:64
static uint64_t ogg_gptopts(AVFormatContext *s, int i, uint64_t gp, int64_t *dts)
Definition: oggdec.h:145
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:235
int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
Perform a binary search using av_index_search_timestamp() and AVInputFormat.read_timestamp().
Definition: utils.c:1261