FFmpeg
oggparsevorbis.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2005 Michael Ahlberg, Måns Rullgård
3  *
4  * Permission is hereby granted, free of charge, to any person
5  * obtaining a copy of this software and associated documentation
6  * files (the "Software"), to deal in the Software without
7  * restriction, including without limitation the rights to use, copy,
8  * modify, merge, publish, distribute, sublicense, and/or sell copies
9  * of the Software, and to permit persons to whom the Software is
10  * furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be
13  * included in all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22  * DEALINGS IN THE SOFTWARE.
23  */
24 
25 #include <stdlib.h>
26 
27 #include "libavutil/avstring.h"
28 #include "libavutil/base64.h"
29 #include "libavutil/bswap.h"
30 #include "libavutil/dict.h"
31 
32 #include "libavcodec/bytestream.h"
34 
35 #include "avformat.h"
36 #include "flac_picture.h"
37 #include "internal.h"
38 #include "oggdec.h"
39 #include "vorbiscomment.h"
40 #include "replaygain.h"
41 
42 static int ogm_chapter(AVFormatContext *as, const uint8_t *key, const uint8_t *val)
43 {
44  int i, cnum, h, m, s, ms, keylen = strlen(key);
45  AVChapter *chapter = NULL;
46 
47  if (keylen < 9 || av_strncasecmp(key, "CHAPTER", 7) || sscanf(key+7, "%03d", &cnum) != 1)
48  return 0;
49 
50  if (keylen <= 10) {
51  if (sscanf(val, "%02d:%02d:%02d.%03d", &h, &m, &s, &ms) < 4)
52  return 0;
53 
54  avpriv_new_chapter(as, cnum, (AVRational) { 1, 1000 },
55  ms + 1000 * (s + 60 * (m + 60 * h)),
57  } else if (!av_strcasecmp(key + keylen - 4, "NAME")) {
58  for (i = 0; i < as->nb_chapters; i++)
59  if (as->chapters[i]->id == cnum) {
60  chapter = as->chapters[i];
61  break;
62  }
63  if (!chapter)
64  return 0;
65 
66  av_dict_set(&chapter->metadata, "title", val, 0);
67  } else
68  return 0;
69 
70  return 1;
71 }
72 
74  const uint8_t *buf, int size)
75 {
76  int updates = ff_vorbis_comment(as, &st->metadata, buf, size, 1);
77 
78  if (updates > 0) {
80  }
81 
82  return updates;
83 }
84 
85 /**
86  * This function temporarily modifies the (const qualified) input buffer
87  * and reverts its changes before return. The input buffer needs to have
88  * at least one byte of padding.
89  */
91  const uint8_t *buf, uint32_t size,
92  int *updates, int parse_picture)
93 {
94  char *t = (char*)buf, *v = memchr(t, '=', size);
95  int tl, vl;
96  char backup;
97 
98  if (!v)
99  return 0;
100 
101  tl = v - t;
102  vl = size - tl - 1;
103  v++;
104 
105  if (!tl || !vl)
106  return 0;
107 
108  t[tl] = 0;
109 
110  backup = v[vl];
111  v[vl] = 0;
112 
113  /* The format in which the pictures are stored is the FLAC format.
114  * Xiph says: "The binary FLAC picture structure is base64 encoded
115  * and placed within a VorbisComment with the tag name
116  * 'METADATA_BLOCK_PICTURE'. This is the preferred and
117  * recommended way of embedding cover art within VorbisComments."
118  */
119  if (!av_strcasecmp(t, "METADATA_BLOCK_PICTURE") && parse_picture) {
120  int ret, len = AV_BASE64_DECODE_SIZE(vl);
121  uint8_t *pict = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE);
122 
123  if (!pict) {
124  av_log(as, AV_LOG_WARNING, "out-of-memory error. Skipping cover art block.\n");
125  goto end;
126  }
127  ret = av_base64_decode(pict, v, len);
128  if (ret > 0)
129  ret = ff_flac_parse_picture(as, &pict, ret, 0);
130  av_freep(&pict);
131  if (ret < 0) {
132  av_log(as, AV_LOG_WARNING, "Failed to parse cover art block.\n");
133  goto end;
134  }
135  } else if (!ogm_chapter(as, t, v)) {
136  (*updates)++;
137  if (av_dict_get(*m, t, NULL, 0))
138  av_dict_set(m, t, ";", AV_DICT_APPEND);
139  av_dict_set(m, t, v, AV_DICT_APPEND);
140  }
141 end:
142  t[tl] = '=';
143  v[vl] = backup;
144 
145  return 0;
146 }
147 
149  const uint8_t *buf, int size,
150  int parse_picture)
151 {
152  const uint8_t *p = buf;
153  const uint8_t *end = buf + size;
154  int updates = 0;
155  unsigned n;
156  int s, ret;
157 
158  /* must have vendor_length and user_comment_list_length */
159  if (size < 8)
160  return AVERROR_INVALIDDATA;
161 
162  s = bytestream_get_le32(&p);
163 
164  if (end - p - 4 < s || s < 0)
165  return AVERROR_INVALIDDATA;
166 
167  p += s;
168 
169  n = bytestream_get_le32(&p);
170 
171  while (end - p >= 4 && n > 0) {
172  s = bytestream_get_le32(&p);
173 
174  if (end - p < s || s < 0)
175  break;
176 
177  ret = vorbis_parse_single_comment(as, m, p, s, &updates, parse_picture);
178  if (ret < 0)
179  return ret;
180  p += s;
181  n--;
182  }
183 
184  if (p != end)
185  av_log(as, AV_LOG_INFO,
186  "%"PTRDIFF_SPECIFIER" bytes of comment header remain\n", end - p);
187  if (n > 0)
188  av_log(as, AV_LOG_INFO,
189  "truncated comment header, %i comments not found\n", n);
190 
192 
193  return updates;
194 }
195 
196 /*
197  * Parse the vorbis header
198  *
199  * Vorbis Identification header from Vorbis_I_spec.html#vorbis-spec-codec
200  * [vorbis_version] = read 32 bits as unsigned integer | Not used
201  * [audio_channels] = read 8 bit integer as unsigned | Used
202  * [audio_sample_rate] = read 32 bits as unsigned integer | Used
203  * [bitrate_maximum] = read 32 bits as signed integer | Not used yet
204  * [bitrate_nominal] = read 32 bits as signed integer | Not used yet
205  * [bitrate_minimum] = read 32 bits as signed integer | Used as bitrate
206  * [blocksize_0] = read 4 bits as unsigned integer | Not Used
207  * [blocksize_1] = read 4 bits as unsigned integer | Not Used
208  * [framing_flag] = read one bit | Not Used
209  */
210 
212  unsigned int len[3];
213  unsigned char *packet[3];
215  int64_t final_pts;
217 };
218 
220  struct oggvorbis_private *priv,
221  uint8_t **buf)
222 {
223  int i, offset, len, err;
224  int buf_len;
225  unsigned char *ptr;
226 
227  len = priv->len[0] + priv->len[1] + priv->len[2];
228  buf_len = len + len / 255 + 64;
229 
230  if (*buf)
231  return AVERROR_INVALIDDATA;
232 
233  ptr = *buf = av_realloc(NULL, buf_len);
234  if (!ptr)
235  return AVERROR(ENOMEM);
236  memset(*buf, '\0', buf_len);
237 
238  ptr[0] = 2;
239  offset = 1;
240  offset += av_xiphlacing(&ptr[offset], priv->len[0]);
241  offset += av_xiphlacing(&ptr[offset], priv->len[1]);
242  for (i = 0; i < 3; i++) {
243  memcpy(&ptr[offset], priv->packet[i], priv->len[i]);
244  offset += priv->len[i];
245  av_freep(&priv->packet[i]);
246  }
247  if ((err = av_reallocp(buf, offset + AV_INPUT_BUFFER_PADDING_SIZE)) < 0)
248  return err;
249  return offset;
250 }
251 
252 static void vorbis_cleanup(AVFormatContext *s, int idx)
253 {
254  struct ogg *ogg = s->priv_data;
255  struct ogg_stream *os = ogg->streams + idx;
256  struct oggvorbis_private *priv = os->private;
257  int i;
258  if (os->private) {
259  av_vorbis_parse_free(&priv->vp);
260  for (i = 0; i < 3; i++)
261  av_freep(&priv->packet[i]);
262  }
263 }
264 
266 {
267  struct ogg *ogg = s->priv_data;
268  struct ogg_stream *os = ogg->streams + idx;
269  AVStream *st = s->streams[idx];
270  int ret;
271 
272  if (os->psize <= 8)
273  return 0;
274 
275  /* New metadata packet; release old data. */
276  av_dict_free(&st->metadata);
277  ret = ff_vorbis_stream_comment(s, st, os->buf + os->pstart + 7,
278  os->psize - 8);
279  if (ret < 0)
280  return ret;
281 
282  /* Update the metadata if possible. */
283  av_freep(&os->new_metadata);
284  if (st->metadata) {
286  /* Send an empty dictionary to indicate that metadata has been cleared. */
287  } else {
288  os->new_metadata = av_mallocz(1);
289  os->new_metadata_size = 0;
290  }
291 
292  return ret;
293 }
294 
295 static int vorbis_header(AVFormatContext *s, int idx)
296 {
297  struct ogg *ogg = s->priv_data;
298  AVStream *st = s->streams[idx];
299  struct ogg_stream *os = ogg->streams + idx;
300  struct oggvorbis_private *priv;
301  int pkt_type = os->buf[os->pstart];
302 
303  if (!os->private) {
304  os->private = av_mallocz(sizeof(struct oggvorbis_private));
305  if (!os->private)
306  return AVERROR(ENOMEM);
307  }
308 
309  priv = os->private;
310 
311  if (!(pkt_type & 1))
312  return priv->vp ? 0 : AVERROR_INVALIDDATA;
313 
314  if (os->psize < 1 || pkt_type > 5)
315  return AVERROR_INVALIDDATA;
316 
317  if (priv->packet[pkt_type >> 1])
318  return AVERROR_INVALIDDATA;
319  if (pkt_type > 1 && !priv->packet[0] || pkt_type > 3 && !priv->packet[1])
320  return priv->vp ? 0 : AVERROR_INVALIDDATA;
321 
322  priv->len[pkt_type >> 1] = os->psize;
323  priv->packet[pkt_type >> 1] = av_mallocz(os->psize);
324  if (!priv->packet[pkt_type >> 1])
325  return AVERROR(ENOMEM);
326  memcpy(priv->packet[pkt_type >> 1], os->buf + os->pstart, os->psize);
327  if (os->buf[os->pstart] == 1) {
328  const uint8_t *p = os->buf + os->pstart + 7; /* skip "\001vorbis" tag */
329  unsigned blocksize, bs0, bs1;
330  int srate;
331  int channels;
332 
333  if (os->psize != 30)
334  return AVERROR_INVALIDDATA;
335 
336  if (bytestream_get_le32(&p) != 0) /* vorbis_version */
337  return AVERROR_INVALIDDATA;
338 
339  channels = bytestream_get_byte(&p);
340  if (st->codecpar->channels && channels != st->codecpar->channels) {
341  av_log(s, AV_LOG_ERROR, "Channel change is not supported\n");
342  return AVERROR_PATCHWELCOME;
343  }
344  st->codecpar->channels = channels;
345  srate = bytestream_get_le32(&p);
346  p += 4; // skip maximum bitrate
347  st->codecpar->bit_rate = bytestream_get_le32(&p); // nominal bitrate
348  p += 4; // skip minimum bitrate
349 
350  blocksize = bytestream_get_byte(&p);
351  bs0 = blocksize & 15;
352  bs1 = blocksize >> 4;
353 
354  if (bs0 > bs1)
355  return AVERROR_INVALIDDATA;
356  if (bs0 < 6 || bs1 > 13)
357  return AVERROR_INVALIDDATA;
358 
359  if (bytestream_get_byte(&p) != 1) /* framing_flag */
360  return AVERROR_INVALIDDATA;
361 
364 
365  if (srate > 0) {
366  st->codecpar->sample_rate = srate;
367  avpriv_set_pts_info(st, 64, 1, srate);
368  }
369  } else if (os->buf[os->pstart] == 3) {
370  if (vorbis_update_metadata(s, idx) >= 0 && priv->len[1] > 10) {
371  unsigned new_len;
372 
373  int ret = ff_replaygain_export(st, st->metadata);
374  if (ret < 0)
375  return ret;
376 
377  // drop all metadata we parsed and which is not required by libvorbis
378  new_len = 7 + 4 + AV_RL32(priv->packet[1] + 7) + 4 + 1;
379  if (new_len >= 16 && new_len < os->psize) {
380  AV_WL32(priv->packet[1] + new_len - 5, 0);
381  priv->packet[1][new_len - 1] = 1;
382  priv->len[1] = new_len;
383  }
384  }
385  } else {
386  int ret;
387 
388  if (priv->vp)
389  return AVERROR_INVALIDDATA;
390 
391  ret = fixup_vorbis_headers(s, priv, &st->codecpar->extradata);
392  if (ret < 0) {
393  st->codecpar->extradata_size = 0;
394  return ret;
395  }
396  st->codecpar->extradata_size = ret;
397 
399  if (!priv->vp) {
400  av_freep(&st->codecpar->extradata);
401  st->codecpar->extradata_size = 0;
402  return AVERROR_UNKNOWN;
403  }
404  }
405 
406  return 1;
407 }
408 
409 static int vorbis_packet(AVFormatContext *s, int idx)
410 {
411  struct ogg *ogg = s->priv_data;
412  struct ogg_stream *os = ogg->streams + idx;
413  struct oggvorbis_private *priv = os->private;
414  int duration, flags = 0;
415 
416  if (!priv->vp)
417  return AVERROR_INVALIDDATA;
418 
419  /* first packet handling
420  * here we parse the duration of each packet in the first page and compare
421  * the total duration to the page granule to find the encoder delay and
422  * set the first timestamp */
423  if ((!os->lastpts || os->lastpts == AV_NOPTS_VALUE) && !(os->flags & OGG_FLAG_EOS) && (int64_t)os->granule>=0) {
424  int seg, d;
425  uint8_t *last_pkt = os->buf + os->pstart;
426  uint8_t *next_pkt = last_pkt;
427 
428  av_vorbis_parse_reset(priv->vp);
429  duration = 0;
430  seg = os->segp;
431  d = av_vorbis_parse_frame_flags(priv->vp, last_pkt, 1, &flags);
432  if (d < 0) {
434  return 0;
435  } else if (flags & VORBIS_FLAG_COMMENT) {
437  flags = 0;
438  }
439  duration += d;
440  last_pkt = next_pkt = next_pkt + os->psize;
441  for (; seg < os->nsegs; seg++) {
442  if (os->segments[seg] < 255) {
443  int d = av_vorbis_parse_frame_flags(priv->vp, last_pkt, 1, &flags);
444  if (d < 0) {
445  duration = os->granule;
446  break;
447  } else if (flags & VORBIS_FLAG_COMMENT) {
449  flags = 0;
450  }
451  duration += d;
452  last_pkt = next_pkt + os->segments[seg];
453  }
454  next_pkt += os->segments[seg];
455  }
456  os->lastpts =
457  os->lastdts = os->granule - duration;
458 
459  if (!os->granule && duration) //hack to deal with broken files (Ticket3710)
460  os->lastpts = os->lastdts = AV_NOPTS_VALUE;
461 
462  if (s->streams[idx]->start_time == AV_NOPTS_VALUE) {
463  s->streams[idx]->start_time = FFMAX(os->lastpts, 0);
464  if (s->streams[idx]->duration != AV_NOPTS_VALUE)
465  s->streams[idx]->duration -= s->streams[idx]->start_time;
466  }
467  priv->final_pts = AV_NOPTS_VALUE;
468  av_vorbis_parse_reset(priv->vp);
469  }
470 
471  /* parse packet duration */
472  if (os->psize > 0) {
473  duration = av_vorbis_parse_frame_flags(priv->vp, os->buf + os->pstart, 1, &flags);
474  if (duration < 0) {
476  return 0;
477  } else if (flags & VORBIS_FLAG_COMMENT) {
479  flags = 0;
480  }
481  os->pduration = duration;
482  }
483 
484  /* final packet handling
485  * here we save the pts of the first packet in the final page, sum up all
486  * packet durations in the final page except for the last one, and compare
487  * to the page granule to find the duration of the final packet */
488  if (os->flags & OGG_FLAG_EOS) {
489  if (os->lastpts != AV_NOPTS_VALUE) {
490  priv->final_pts = os->lastpts;
491  priv->final_duration = 0;
492  }
493  if (os->segp == os->nsegs) {
494  int64_t skip = priv->final_pts + priv->final_duration + os->pduration - os->granule;
495  if (skip > 0)
496  os->end_trimming = skip;
497  os->pduration = os->granule - priv->final_pts - priv->final_duration;
498  }
499  priv->final_duration += os->pduration;
500  }
501 
502  return 0;
503 }
504 
505 const struct ogg_codec ff_vorbis_codec = {
506  .magic = "\001vorbis",
507  .magicsize = 7,
508  .header = vorbis_header,
509  .packet = vorbis_packet,
510  .cleanup = vorbis_cleanup,
511  .nb_header = 3,
512 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
ogg_stream::segp
int segp
Definition: oggdec.h:79
av_vorbis_parse_free
void av_vorbis_parse_free(AVVorbisParseContext **s)
Free the parser and everything associated with it.
Definition: vorbis_parser.c:276
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1060
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ogg_stream::lastpts
int64_t lastpts
Definition: oggdec.h:72
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AVVorbisParseContext
Definition: vorbis_parser_internal.h:34
AVFormatContext::nb_chapters
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1315
ff_replaygain_export
int ff_replaygain_export(AVStream *st, AVDictionary *metadata)
Parse replaygain tags and export them as per-stream side data.
Definition: replaygain.c:90
av_vorbis_parse_frame_flags
int av_vorbis_parse_frame_flags(AVVorbisParseContext *s, const uint8_t *buf, int buf_size, int *flags)
Get the duration for a Vorbis packet.
Definition: vorbis_parser.c:213
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
ff_vorbis_stream_comment
int ff_vorbis_stream_comment(AVFormatContext *as, AVStream *st, const uint8_t *buf, int size)
Parse Vorbis comments and add metadata to an AVStream.
Definition: oggparsevorbis.c:73
vorbiscomment.h
ogg_stream::granule
uint64_t granule
Definition: oggdec.h:70
AV_DICT_APPEND
#define AV_DICT_APPEND
If the entry already exists, append to it.
Definition: dict.h:75
AVDictionary
Definition: dict.c:30
ogg_stream::buf
uint8_t * buf
Definition: oggdec.h:62
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ogg_stream::nsegs
int nsegs
Definition: oggdec.h:79
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
ogg
Definition: oggdec.h:102
ogm_chapter
static int ogm_chapter(AVFormatContext *as, const uint8_t *key, const uint8_t *val)
Definition: oggparsevorbis.c:42
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
AV_BASE64_DECODE_SIZE
#define AV_BASE64_DECODE_SIZE(x)
Calculate the output size in bytes needed to decode a base64 string with length x to a data buffer.
Definition: base64.h:48
ogg_stream::lastdts
int64_t lastdts
Definition: oggdec.h:73
AVChapter
Definition: avformat.h:1056
val
static double val(void *priv, double ch)
Definition: aeval.c:76
ff_vorbis_comment
int ff_vorbis_comment(AVFormatContext *as, AVDictionary **m, const uint8_t *buf, int size, int parse_picture)
Parse Vorbis comments.
Definition: oggparsevorbis.c:148
vorbis_parse_single_comment
static int vorbis_parse_single_comment(AVFormatContext *as, AVDictionary **m, const uint8_t *buf, uint32_t size, int *updates, int parse_picture)
This function temporarily modifies the (const qualified) input buffer and reverts its changes before ...
Definition: oggparsevorbis.c:90
ogg_stream::pstart
unsigned int pstart
Definition: oggdec.h:65
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:426
duration
int64_t duration
Definition: movenc.c:64
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1316
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
VORBIS_FLAG_COMMENT
#define VORBIS_FLAG_COMMENT
Definition: vorbis_parser.h:45
ff_vorbis_codec
const struct ogg_codec ff_vorbis_codec
Definition: oggparsevorbis.c:505
channels
channels
Definition: aptx.h:33
flac_picture.h
oggvorbis_private::final_duration
int final_duration
Definition: oggparsevorbis.c:216
oggvorbis_private::packet
unsigned char * packet[3]
Definition: oggparsevorbis.c:213
ogg_stream::new_metadata
uint8_t * new_metadata
Definition: oggdec.h:89
oggvorbis_private::len
unsigned int len[3]
Definition: oggparsevorbis.c:212
ff_vorbiscomment_metadata_conv
const AVMetadataConv ff_vorbiscomment_metadata_conv[]
VorbisComment metadata conversion mapping.
Definition: vorbiscomment.c:33
key
const char * key
Definition: hwcontext_opencl.c:168
AVFormatContext
Format I/O context.
Definition: avformat.h:1097
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:992
oggvorbis_private
Definition: oggparsevorbis.c:211
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:192
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:152
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ogg_stream::flags
int flags
Definition: oggdec.h:76
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:903
vorbis_parser.h
av_base64_decode
int av_base64_decode(uint8_t *out, const char *in_str, int out_size)
Decode a base64-encoded string.
Definition: base64.c:79
base64.h
ogg::streams
struct ogg_stream * streams
Definition: oggdec.h:103
AVSTREAM_EVENT_FLAG_METADATA_UPDATED
#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:965
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
ff_flac_parse_picture
int ff_flac_parse_picture(AVFormatContext *s, uint8_t **bufp, int buf_size, int truncate_workaround)
Parse a FLAC METADATA_BLOCK_PICTURE.
Definition: flac_picture.c:32
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
vorbis_cleanup
static void vorbis_cleanup(AVFormatContext *s, int idx)
Definition: oggparsevorbis.c:252
av_strncasecmp
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:225
ogg_stream::private
void * private
Definition: oggdec.h:91
size
int size
Definition: twinvq_data.h:10344
av_reallocp
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:185
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVStream::event_flags
int event_flags
Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.
Definition: avformat.h:958
av_xiphlacing
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:838
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_packet_pack_dictionary
uint8_t * av_packet_pack_dictionary(AVDictionary *dict, size_t *size)
Pack a dictionary for use in side_data.
Definition: avpacket.c:302
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
oggvorbis_private::final_pts
int64_t final_pts
Definition: oggparsevorbis.c:215
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
vorbis_update_metadata
static int vorbis_update_metadata(AVFormatContext *s, int idx)
Definition: oggparsevorbis.c:265
ogg_stream::pflags
unsigned int pflags
Definition: oggdec.h:67
i
int i
Definition: input.c:406
ogg_stream
Definition: oggdec.h:61
AVChapter::id
int64_t id
unique ID to identify the chapter
Definition: avformat.h:1057
vorbis_header
static int vorbis_header(AVFormatContext *s, int idx)
Definition: oggparsevorbis.c:295
ff_metadata_conv
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
vorbis_packet
static int vorbis_packet(AVFormatContext *s, int idx)
Definition: oggparsevorbis.c:409
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
len
int len
Definition: vorbis_enc_data.h:426
avpriv_new_chapter
AVChapter * avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:835
oggvorbis_private::vp
AVVorbisParseContext * vp
Definition: oggparsevorbis.c:214
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:845
bswap.h
av_vorbis_parse_init
AVVorbisParseContext * av_vorbis_parse_init(const uint8_t *extradata, int extradata_size)
Allocate and initialize the Vorbis parser using headers in the extradata.
Definition: vorbis_parser.c:281
avformat.h
dict.h
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
oggdec.h
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, 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:1146
ogg_stream::new_metadata_size
size_t new_metadata_size
Definition: oggdec.h:90
ogg_stream::segments
uint8_t segments[255]
Definition: oggdec.h:80
OGG_FLAG_EOS
#define OGG_FLAG_EOS
Definition: oggdec.h:113
av_vorbis_parse_reset
void av_vorbis_parse_reset(AVVorbisParseContext *s)
Definition: vorbis_parser.c:270
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
ogg_stream::psize
unsigned int psize
Definition: oggdec.h:66
ogg_codec
Copyright (C) 2005 Michael Ahlberg, Måns Rullgård.
Definition: oggdec.h:31
d
d
Definition: ffmpeg_filter.c:156
bytestream.h
replaygain.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:427
ogg_codec::magic
const int8_t * magic
Definition: oggdec.h:32
ogg_stream::end_trimming
int end_trimming
set the number of packets to drop from the end
Definition: oggdec.h:88
avstring.h
ogg_stream::pduration
unsigned int pduration
Definition: oggdec.h:68
fixup_vorbis_headers
static int fixup_vorbis_headers(AVFormatContext *as, struct oggvorbis_private *priv, uint8_t **buf)
Definition: oggparsevorbis.c:219