FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 #include "libavutil/avstring.h"
27 #include "libavutil/bswap.h"
28 #include "libavutil/dict.h"
29 #include "libavcodec/get_bits.h"
30 #include "libavcodec/bytestream.h"
32 #include "avformat.h"
33 #include "internal.h"
34 #include "oggdec.h"
35 #include "vorbiscomment.h"
36 
37 static int ogm_chapter(AVFormatContext *as, uint8_t *key, uint8_t *val)
38 {
39  int i, cnum, h, m, s, ms, keylen = strlen(key);
40  AVChapter *chapter = NULL;
41 
42  if (keylen < 9 || sscanf(key, "CHAPTER%02d", &cnum) != 1)
43  return 0;
44 
45  if (keylen == 9) {
46  if (sscanf(val, "%02d:%02d:%02d.%03d", &h, &m, &s, &ms) < 4)
47  return 0;
48 
49  avpriv_new_chapter(as, cnum, (AVRational){1,1000},
50  ms + 1000*(s + 60*(m + 60*h)),
52  av_free(val);
53  } else if (!strcmp(key+9, "NAME")) {
54  for(i = 0; i < as->nb_chapters; i++)
55  if (as->chapters[i]->id == cnum) {
56  chapter = as->chapters[i];
57  break;
58  }
59  if (!chapter)
60  return 0;
61 
62  av_dict_set(&chapter->metadata, "title", val,
64  } else
65  return 0;
66 
67  av_free(key);
68  return 1;
69 }
70 
71 int
73 {
74  const uint8_t *p = buf;
75  const uint8_t *end = buf + size;
76  unsigned n, j;
77  int s;
78 
79  if (size < 8) /* must have vendor_length and user_comment_list_length */
80  return -1;
81 
82  s = bytestream_get_le32(&p);
83 
84  if (end - p - 4 < s || s < 0)
85  return -1;
86 
87  p += s;
88 
89  n = bytestream_get_le32(&p);
90 
91  while (end - p >= 4 && n > 0) {
92  const char *t, *v;
93  int tl, vl;
94 
95  s = bytestream_get_le32(&p);
96 
97  if (end - p < s || s < 0)
98  break;
99 
100  t = p;
101  p += s;
102  n--;
103 
104  v = memchr(t, '=', s);
105  if (!v)
106  continue;
107 
108  tl = v - t;
109  vl = s - tl - 1;
110  v++;
111 
112  if (tl && vl) {
113  char *tt, *ct;
114 
115  tt = av_malloc(tl + 1);
116  ct = av_malloc(vl + 1);
117  if (!tt || !ct) {
118  av_freep(&tt);
119  av_freep(&ct);
120  av_log(as, AV_LOG_WARNING, "out-of-memory error. skipping VorbisComment tag.\n");
121  continue;
122  }
123 
124  for (j = 0; j < tl; j++)
125  tt[j] = av_toupper(t[j]);
126  tt[tl] = 0;
127 
128  memcpy(ct, v, vl);
129  ct[vl] = 0;
130 
131  if (!ogm_chapter(as, tt, ct))
132  av_dict_set(m, tt, ct,
135  }
136  }
137 
138  if (p != end)
139  av_log(as, AV_LOG_INFO, "%ti bytes of comment header remain\n", end-p);
140  if (n > 0)
141  av_log(as, AV_LOG_INFO,
142  "truncated comment header, %i comments not found\n", n);
143 
145 
146  return 0;
147 }
148 
149 
150 /** Parse the vorbis header
151  * Vorbis Identification header from Vorbis_I_spec.html#vorbis-spec-codec
152  * [vorbis_version] = read 32 bits as unsigned integer | Not used
153  * [audio_channels] = read 8 bit integer as unsigned | Used
154  * [audio_sample_rate] = read 32 bits as unsigned integer | Used
155  * [bitrate_maximum] = read 32 bits as signed integer | Not used yet
156  * [bitrate_nominal] = read 32 bits as signed integer | Not used yet
157  * [bitrate_minimum] = read 32 bits as signed integer | Used as bitrate
158  * [blocksize_0] = read 4 bits as unsigned integer | Not Used
159  * [blocksize_1] = read 4 bits as unsigned integer | Not Used
160  * [framing_flag] = read one bit | Not Used
161  * */
162 
164  unsigned int len[3];
165  unsigned char *packet[3];
167  int64_t final_pts;
169 };
170 
171 
172 static unsigned int
174  uint8_t **buf)
175 {
176  int i,offset, len, buf_len;
177  unsigned char *ptr;
178 
179  len = priv->len[0] + priv->len[1] + priv->len[2];
180  buf_len = len + len/255 + 64;
181  ptr = *buf = av_realloc(NULL, buf_len);
182  if (!*buf)
183  return 0;
184  memset(*buf, '\0', buf_len);
185 
186  ptr[0] = 2;
187  offset = 1;
188  offset += av_xiphlacing(&ptr[offset], priv->len[0]);
189  offset += av_xiphlacing(&ptr[offset], priv->len[1]);
190  for (i = 0; i < 3; i++) {
191  memcpy(&ptr[offset], priv->packet[i], priv->len[i]);
192  offset += priv->len[i];
193  av_freep(&priv->packet[i]);
194  }
195  *buf = av_realloc(*buf, offset + FF_INPUT_BUFFER_PADDING_SIZE);
196  return offset;
197 }
198 
199 static void vorbis_cleanup(AVFormatContext *s, int idx)
200 {
201  struct ogg *ogg = s->priv_data;
202  struct ogg_stream *os = ogg->streams + idx;
203  struct oggvorbis_private *priv = os->private;
204  int i;
205  if (os->private)
206  for (i = 0; i < 3; i++)
207  av_freep(&priv->packet[i]);
208 }
209 
210 static int
212 {
213  struct ogg *ogg = s->priv_data;
214  struct ogg_stream *os = ogg->streams + idx;
215  AVStream *st = s->streams[idx];
216  struct oggvorbis_private *priv;
217  int pkt_type = os->buf[os->pstart];
218 
219  if (!(pkt_type & 1))
220  return os->private ? 0 : -1;
221 
222  if (!os->private) {
223  os->private = av_mallocz(sizeof(struct oggvorbis_private));
224  if (!os->private)
225  return -1;
226  }
227 
228  if (os->psize < 1 || pkt_type > 5)
229  return -1;
230 
231  priv = os->private;
232 
233  if (priv->packet[pkt_type>>1])
234  return -1;
235  if (pkt_type > 1 && !priv->packet[0] || pkt_type > 3 && !priv->packet[1])
236  return -1;
237 
238  priv->len[pkt_type >> 1] = os->psize;
239  priv->packet[pkt_type >> 1] = av_mallocz(os->psize);
240  if (!priv->packet[pkt_type >> 1])
241  return AVERROR(ENOMEM);
242  memcpy(priv->packet[pkt_type >> 1], os->buf + os->pstart, os->psize);
243  if (os->buf[os->pstart] == 1) {
244  const uint8_t *p = os->buf + os->pstart + 7; /* skip "\001vorbis" tag */
245  unsigned blocksize, bs0, bs1;
246  int srate;
247  int channels;
248 
249  if (os->psize != 30)
250  return -1;
251 
252  if (bytestream_get_le32(&p) != 0) /* vorbis_version */
253  return -1;
254 
255  channels= bytestream_get_byte(&p);
256  if (st->codec->channels && channels != st->codec->channels) {
257  av_log(s, AV_LOG_ERROR, "Channel change is not supported\n");
258  return AVERROR_PATCHWELCOME;
259  }
260  st->codec->channels = channels;
261  srate = bytestream_get_le32(&p);
262  p += 4; // skip maximum bitrate
263  st->codec->bit_rate = bytestream_get_le32(&p); // nominal bitrate
264  p += 4; // skip minimum bitrate
265 
266  blocksize = bytestream_get_byte(&p);
267  bs0 = blocksize & 15;
268  bs1 = blocksize >> 4;
269 
270  if (bs0 > bs1)
271  return -1;
272  if (bs0 < 6 || bs1 > 13)
273  return -1;
274 
275  if (bytestream_get_byte(&p) != 1) /* framing_flag */
276  return -1;
277 
280 
281  if (srate > 0) {
282  st->codec->sample_rate = srate;
283  avpriv_set_pts_info(st, 64, 1, srate);
284  }
285  } else if (os->buf[os->pstart] == 3) {
286  if (os->psize > 8 &&
287  ff_vorbis_comment(s, &st->metadata, os->buf + os->pstart + 7, os->psize - 8) >= 0) {
288  // drop all metadata we parsed and which is not required by libvorbis
289  unsigned new_len = 7 + 4 + AV_RL32(priv->packet[1] + 7) + 4 + 1;
290  if (new_len >= 16 && new_len < os->psize) {
291  AV_WL32(priv->packet[1] + new_len - 5, 0);
292  priv->packet[1][new_len - 1] = 1;
293  priv->len[1] = new_len;
294  }
295  }
296  } else {
297  int ret;
298  st->codec->extradata_size =
299  fixup_vorbis_headers(s, priv, &st->codec->extradata);
300  if ((ret = avpriv_vorbis_parse_extradata(st->codec, &priv->vp))) {
301  av_freep(&st->codec->extradata);
302  st->codec->extradata_size = 0;
303  return ret;
304  }
305  }
306 
307  return 1;
308 }
309 
310 static int vorbis_packet(AVFormatContext *s, int idx)
311 {
312  struct ogg *ogg = s->priv_data;
313  struct ogg_stream *os = ogg->streams + idx;
314  struct oggvorbis_private *priv = os->private;
315  int duration;
316 
317  /* first packet handling
318  here we parse the duration of each packet in the first page and compare
319  the total duration to the page granule to find the encoder delay and
320  set the first timestamp */
321  if ((!os->lastpts || os->lastpts == AV_NOPTS_VALUE) && !(os->flags & OGG_FLAG_EOS)) {
322  int seg, d;
323  uint8_t *last_pkt = os->buf + os->pstart;
324  uint8_t *next_pkt = last_pkt;
325 
327  duration = 0;
328  seg = os->segp;
329  d = avpriv_vorbis_parse_frame(&priv->vp, last_pkt, 1);
330  if (d < 0) {
332  return 0;
333  }
334  duration += d;
335  last_pkt = next_pkt = next_pkt + os->psize;
336  for (; seg < os->nsegs; seg++) {
337  if (os->segments[seg] < 255) {
338  int d = avpriv_vorbis_parse_frame(&priv->vp, last_pkt, 1);
339  if (d < 0) {
340  duration = os->granule;
341  break;
342  }
343  duration += d;
344  last_pkt = next_pkt + os->segments[seg];
345  }
346  next_pkt += os->segments[seg];
347  }
348  os->lastpts = os->lastdts = os->granule - duration;
349  if(s->streams[idx]->start_time == AV_NOPTS_VALUE) {
350  s->streams[idx]->start_time = FFMAX(os->lastpts, 0);
351  if (s->streams[idx]->duration)
352  s->streams[idx]->duration -= s->streams[idx]->start_time;
353  }
354  priv->final_pts = AV_NOPTS_VALUE;
356  }
357 
358  /* parse packet duration */
359  if (os->psize > 0) {
360  duration = avpriv_vorbis_parse_frame(&priv->vp, os->buf + os->pstart, 1);
361  if (duration < 0) {
363  return 0;
364  }
365  os->pduration = duration;
366  }
367 
368  /* final packet handling
369  here we save the pts of the first packet in the final page, sum up all
370  packet durations in the final page except for the last one, and compare
371  to the page granule to find the duration of the final packet */
372  if (os->flags & OGG_FLAG_EOS) {
373  if (os->lastpts != AV_NOPTS_VALUE) {
374  priv->final_pts = os->lastpts;
375  priv->final_duration = 0;
376  }
377  if (os->segp == os->nsegs)
378  os->pduration = os->granule - priv->final_pts - priv->final_duration;
379  priv->final_duration += os->pduration;
380  }
381 
382  return 0;
383 }
384 
385 const struct ogg_codec ff_vorbis_codec = {
386  .magic = "\001vorbis",
387  .magicsize = 7,
388  .header = vorbis_header,
389  .packet = vorbis_packet,
390  .cleanup= vorbis_cleanup,
391  .nb_header = 3,
392 };