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/dict.h"
30 
31 #include "libavcodec/bytestream.h"
33 
34 #include "avformat.h"
35 #include "demux.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 (pkt_type > 5) {
315  av_log(s, AV_LOG_VERBOSE, "Ignoring packet with unknown type %d\n", pkt_type);
316  return 1;
317  }
318 
319  if (os->psize < 1)
320  return AVERROR_INVALIDDATA;
321 
322  if (priv->packet[pkt_type >> 1])
323  return AVERROR_INVALIDDATA;
324  if (pkt_type > 1 && !priv->packet[0] || pkt_type > 3 && !priv->packet[1])
325  return priv->vp ? 0 : AVERROR_INVALIDDATA;
326 
327  priv->len[pkt_type >> 1] = os->psize;
328  priv->packet[pkt_type >> 1] = av_memdup(os->buf + os->pstart, os->psize);
329  if (!priv->packet[pkt_type >> 1])
330  return AVERROR(ENOMEM);
331  if (os->buf[os->pstart] == 1) {
332  const uint8_t *p = os->buf + os->pstart + 7; /* skip "\001vorbis" tag */
333  unsigned blocksize, bs0, bs1;
334  int srate;
335  int channels;
336 
337  if (os->psize != 30)
338  return AVERROR_INVALIDDATA;
339 
340  if (bytestream_get_le32(&p) != 0) /* vorbis_version */
341  return AVERROR_INVALIDDATA;
342 
343  channels = bytestream_get_byte(&p);
344  if (st->codecpar->ch_layout.nb_channels &&
346  av_log(s, AV_LOG_ERROR, "Channel change is not supported\n");
347  return AVERROR_PATCHWELCOME;
348  }
350  srate = bytestream_get_le32(&p);
351  p += 4; // skip maximum bitrate
352  st->codecpar->bit_rate = bytestream_get_le32(&p); // nominal bitrate
353  p += 4; // skip minimum bitrate
354 
355  blocksize = bytestream_get_byte(&p);
356  bs0 = blocksize & 15;
357  bs1 = blocksize >> 4;
358 
359  if (bs0 > bs1)
360  return AVERROR_INVALIDDATA;
361  if (bs0 < 6 || bs1 > 13)
362  return AVERROR_INVALIDDATA;
363 
364  if (bytestream_get_byte(&p) != 1) /* framing_flag */
365  return AVERROR_INVALIDDATA;
366 
369 
370  if (srate > 0) {
371  st->codecpar->sample_rate = srate;
372  avpriv_set_pts_info(st, 64, 1, srate);
373  }
374  } else if (os->buf[os->pstart] == 3) {
375  if (vorbis_update_metadata(s, idx) >= 0 && priv->len[1] > 10) {
376  unsigned new_len;
377 
378  int ret = ff_replaygain_export(st, st->metadata);
379  if (ret < 0)
380  return ret;
381 
382  // drop all metadata we parsed and which is not required by libvorbis
383  new_len = 7 + 4 + AV_RL32(priv->packet[1] + 7) + 4 + 1;
384  if (new_len >= 16 && new_len < os->psize) {
385  AV_WL32(priv->packet[1] + new_len - 5, 0);
386  priv->packet[1][new_len - 1] = 1;
387  priv->len[1] = new_len;
388  }
389  }
390  } else {
391  int ret;
392 
393  if (priv->vp)
394  return AVERROR_INVALIDDATA;
395 
396  ret = fixup_vorbis_headers(s, priv, &st->codecpar->extradata);
397  if (ret < 0) {
398  st->codecpar->extradata_size = 0;
399  return ret;
400  }
401  st->codecpar->extradata_size = ret;
402 
404  if (!priv->vp) {
405  av_freep(&st->codecpar->extradata);
406  st->codecpar->extradata_size = 0;
407  return AVERROR_UNKNOWN;
408  }
409  }
410 
411  return 1;
412 }
413 
414 static int vorbis_packet(AVFormatContext *s, int idx)
415 {
416  struct ogg *ogg = s->priv_data;
417  struct ogg_stream *os = ogg->streams + idx;
418  struct oggvorbis_private *priv = os->private;
419  int duration, flags = 0;
420 
421  if (!priv->vp)
422  return AVERROR_INVALIDDATA;
423 
424  /* first packet handling
425  * here we parse the duration of each packet in the first page and compare
426  * the total duration to the page granule to find the encoder delay and
427  * set the first timestamp */
428  if ((!os->lastpts || os->lastpts == AV_NOPTS_VALUE) && !(os->flags & OGG_FLAG_EOS) && (int64_t)os->granule>=0) {
429  int seg, d;
430  uint8_t *last_pkt = os->buf + os->pstart;
431  uint8_t *next_pkt = last_pkt;
432 
433  av_vorbis_parse_reset(priv->vp);
434  duration = 0;
435  seg = os->segp;
436  d = av_vorbis_parse_frame_flags(priv->vp, last_pkt, 1, &flags);
437  if (d < 0) {
439  return 0;
440  } else if (flags & VORBIS_FLAG_COMMENT) {
442  flags = 0;
443  }
444  duration += d;
445  last_pkt = next_pkt = next_pkt + os->psize;
446  for (; seg < os->nsegs; seg++) {
447  if (os->segments[seg] < 255) {
448  int d = av_vorbis_parse_frame_flags(priv->vp, last_pkt, 1, &flags);
449  if (d < 0) {
450  duration = os->granule;
451  break;
452  } else if (flags & VORBIS_FLAG_COMMENT) {
454  flags = 0;
455  }
456  duration += d;
457  last_pkt = next_pkt + os->segments[seg];
458  }
459  next_pkt += os->segments[seg];
460  }
461  os->lastpts =
462  os->lastdts = os->granule - duration;
463 
464  if (!os->granule && duration) //hack to deal with broken files (Ticket3710)
465  os->lastpts = os->lastdts = AV_NOPTS_VALUE;
466 
467  if (s->streams[idx]->start_time == AV_NOPTS_VALUE) {
468  s->streams[idx]->start_time = FFMAX(os->lastpts, 0);
469  if (s->streams[idx]->duration != AV_NOPTS_VALUE)
470  s->streams[idx]->duration -= s->streams[idx]->start_time;
471  }
472  priv->final_pts = AV_NOPTS_VALUE;
473  av_vorbis_parse_reset(priv->vp);
474  }
475 
476  /* parse packet duration */
477  if (os->psize > 0) {
478  duration = av_vorbis_parse_frame_flags(priv->vp, os->buf + os->pstart, 1, &flags);
479  if (duration < 0) {
481  return 0;
482  } else if (flags & VORBIS_FLAG_COMMENT) {
484  flags = 0;
485  }
486  os->pduration = duration;
487  }
488 
489  /* final packet handling
490  * here we save the pts of the first packet in the final page, sum up all
491  * packet durations in the final page except for the last one, and compare
492  * to the page granule to find the duration of the final packet */
493  if (os->flags & OGG_FLAG_EOS) {
494  if (os->lastpts != AV_NOPTS_VALUE) {
495  priv->final_pts = os->lastpts;
496  priv->final_duration = 0;
497  }
498  if (os->segp == os->nsegs) {
499  int64_t skip = priv->final_pts + priv->final_duration + os->pduration - os->granule;
500  if (skip > 0)
501  os->end_trimming = skip;
502  os->pduration = os->granule - priv->final_pts - priv->final_duration;
503  }
504  priv->final_duration += os->pduration;
505  }
506 
507  return 0;
508 }
509 
510 const struct ogg_codec ff_vorbis_codec = {
511  .magic = "\001vorbis",
512  .magicsize = 7,
513  .header = vorbis_header,
514  .packet = vorbis_packet,
515  .cleanup = vorbis_cleanup,
516  .nb_header = 3,
517 };
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: demux_utils.c:42
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:69
ogg_stream::segp
int segp
Definition: oggdec.h:78
av_vorbis_parse_free
void av_vorbis_parse_free(AVVorbisParseContext **s)
Free the parser and everything associated with it.
Definition: vorbis_parser.c:279
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1326
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:71
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
AVVorbisParseContext
Definition: vorbis_parser_internal.h:34
AVFormatContext::nb_chapters
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1580
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:94
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:215
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
ff_metadata_conv
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
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:69
AV_DICT_APPEND
#define AV_DICT_APPEND
If the entry already exists, append to it.
Definition: dict.h:82
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVDictionary
Definition: dict.c:34
ogg_stream::buf
uint8_t * buf
Definition: oggdec.h:61
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ogg_stream::nsegs
int nsegs
Definition: oggdec.h:78
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:323
ogg
Definition: oggdec.h:101
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:30
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:302
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: avformat.c:843
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:72
AVChapter
Definition: avformat.h:1322
val
static double val(void *priv, double ch)
Definition: aeval.c:78
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:64
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:578
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:62
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVFormatContext::chapters
AVChapter ** chapters
Definition: avformat.h:1581
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:510
channels
channels
Definition: aptx.h:31
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:88
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:174
AVFormatContext
Format I/O context.
Definition: avformat.h:1363
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
oggvorbis_private
Definition: oggparsevorbis.c:211
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:140
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ogg_stream::flags
int flags
Definition: oggdec.h:75
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:921
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:81
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:206
base64.h
ogg::streams
struct ogg_stream * streams
Definition: oggdec.h:102
AVSTREAM_EVENT_FLAG_METADATA_UPDATED
#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:991
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:171
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:33
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
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:217
ogg_stream::private
void * private
Definition: oggdec.h:90
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:186
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:984
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:312
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:225
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:66
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
ogg_stream
Definition: oggdec.h:60
AVChapter::id
int64_t id
unique ID to identify the chapter
Definition: avformat.h:1323
vorbis_header
static int vorbis_header(AVFormatContext *s, int idx)
Definition: oggparsevorbis.c:295
vorbis_packet
static int vorbis_packet(AVFormatContext *s, int idx)
Definition: oggparsevorbis.c:414
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:254
demux.h
len
int len
Definition: vorbis_enc_data.h:426
oggvorbis_private::vp
AVVorbisParseContext * vp
Definition: oggparsevorbis.c:214
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:841
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:284
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
ogg_stream::new_metadata_size
size_t new_metadata_size
Definition: oggdec.h:89
ogg_stream::segments
uint8_t segments[255]
Definition: oggdec.h:79
OGG_FLAG_EOS
#define OGG_FLAG_EOS
Definition: oggdec.h:112
av_vorbis_parse_reset
void av_vorbis_parse_reset(AVVorbisParseContext *s)
Definition: vorbis_parser.c:273
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:88
ogg_stream::psize
unsigned int psize
Definition: oggdec.h:65
ogg_codec
Copyright (C) 2005 Michael Ahlberg, Måns Rullgård.
Definition: oggdec.h:30
d
d
Definition: ffmpeg_filter.c:424
bytestream.h
replaygain.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:84
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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:448
ogg_codec::magic
const int8_t * magic
Definition: oggdec.h:31
ogg_stream::end_trimming
int end_trimming
set the number of packets to drop from the end
Definition: oggdec.h:87
avstring.h
ogg_stream::pduration
unsigned int pduration
Definition: oggdec.h:67
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
fixup_vorbis_headers
static int fixup_vorbis_headers(AVFormatContext *as, struct oggvorbis_private *priv, uint8_t **buf)
Definition: oggparsevorbis.c:219