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] = 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;
177  unsigned char *ptr;
178 
179  len = priv->len[0] + priv->len[1] + priv->len[2];
180  ptr = *buf = av_mallocz(len + len/255 + 64);
181 
182  ptr[0] = 2;
183  offset = 1;
184  offset += av_xiphlacing(&ptr[offset], priv->len[0]);
185  offset += av_xiphlacing(&ptr[offset], priv->len[1]);
186  for (i = 0; i < 3; i++) {
187  memcpy(&ptr[offset], priv->packet[i], priv->len[i]);
188  offset += priv->len[i];
189  av_freep(&priv->packet[i]);
190  }
191  *buf = av_realloc(*buf, offset + FF_INPUT_BUFFER_PADDING_SIZE);
192  return offset;
193 }
194 
195 static void vorbis_cleanup(AVFormatContext *s, int idx)
196 {
197  struct ogg *ogg = s->priv_data;
198  struct ogg_stream *os = ogg->streams + idx;
199  struct oggvorbis_private *priv = os->private;
200  int i;
201  if (os->private)
202  for (i = 0; i < 3; i++)
203  av_freep(&priv->packet[i]);
204 }
205 
206 static int
208 {
209  struct ogg *ogg = s->priv_data;
210  struct ogg_stream *os = ogg->streams + idx;
211  AVStream *st = s->streams[idx];
212  struct oggvorbis_private *priv;
213  int pkt_type = os->buf[os->pstart];
214 
215  if (!(pkt_type & 1))
216  return os->private ? 0 : -1;
217 
218  if (!os->private) {
219  os->private = av_mallocz(sizeof(struct oggvorbis_private));
220  if (!os->private)
221  return -1;
222  }
223 
224  if (os->psize < 1 || pkt_type > 5)
225  return -1;
226 
227  priv = os->private;
228 
229  if (priv->packet[pkt_type>>1])
230  return -1;
231  if (pkt_type > 1 && !priv->packet[0] || pkt_type > 3 && !priv->packet[1])
232  return -1;
233 
234  priv->len[pkt_type >> 1] = os->psize;
235  priv->packet[pkt_type >> 1] = av_mallocz(os->psize);
236  if (!priv->packet[pkt_type >> 1])
237  return AVERROR(ENOMEM);
238  memcpy(priv->packet[pkt_type >> 1], os->buf + os->pstart, os->psize);
239  if (os->buf[os->pstart] == 1) {
240  const uint8_t *p = os->buf + os->pstart + 7; /* skip "\001vorbis" tag */
241  unsigned blocksize, bs0, bs1;
242  int srate;
243  int channels;
244 
245  if (os->psize != 30)
246  return -1;
247 
248  if (bytestream_get_le32(&p) != 0) /* vorbis_version */
249  return -1;
250 
251  channels= bytestream_get_byte(&p);
252  if (st->codec->channels && channels != st->codec->channels) {
253  av_log(s, AV_LOG_ERROR, "Channel change is not supported\n");
254  return AVERROR_PATCHWELCOME;
255  }
256  st->codec->channels = channels;
257  srate = bytestream_get_le32(&p);
258  p += 4; // skip maximum bitrate
259  st->codec->bit_rate = bytestream_get_le32(&p); // nominal bitrate
260  p += 4; // skip minimum bitrate
261 
262  blocksize = bytestream_get_byte(&p);
263  bs0 = blocksize & 15;
264  bs1 = blocksize >> 4;
265 
266  if (bs0 > bs1)
267  return -1;
268  if (bs0 < 6 || bs1 > 13)
269  return -1;
270 
271  if (bytestream_get_byte(&p) != 1) /* framing_flag */
272  return -1;
273 
276 
277  if (srate > 0) {
278  st->codec->sample_rate = srate;
279  avpriv_set_pts_info(st, 64, 1, srate);
280  }
281  } else if (os->buf[os->pstart] == 3) {
282  if (os->psize > 8 &&
283  ff_vorbis_comment(s, &st->metadata, os->buf + os->pstart + 7, os->psize - 8) >= 0) {
284  // drop all metadata we parsed and which is not required by libvorbis
285  unsigned new_len = 7 + 4 + AV_RL32(priv->packet[1] + 7) + 4 + 1;
286  if (new_len >= 16 && new_len < os->psize) {
287  AV_WL32(priv->packet[1] + new_len - 5, 0);
288  priv->packet[1][new_len - 1] = 1;
289  priv->len[1] = new_len;
290  }
291  }
292  } else {
293  int ret;
294  st->codec->extradata_size =
295  fixup_vorbis_headers(s, priv, &st->codec->extradata);
296  if ((ret = avpriv_vorbis_parse_extradata(st->codec, &priv->vp))) {
297  av_freep(&st->codec->extradata);
298  st->codec->extradata_size = 0;
299  return ret;
300  }
301  }
302 
303  return 1;
304 }
305 
306 static int vorbis_packet(AVFormatContext *s, int idx)
307 {
308  struct ogg *ogg = s->priv_data;
309  struct ogg_stream *os = ogg->streams + idx;
310  struct oggvorbis_private *priv = os->private;
311  int duration;
312 
313  /* first packet handling
314  here we parse the duration of each packet in the first page and compare
315  the total duration to the page granule to find the encoder delay and
316  set the first timestamp */
317  if ((!os->lastpts || os->lastpts == AV_NOPTS_VALUE) && !(os->flags & OGG_FLAG_EOS)) {
318  int seg, d;
319  uint8_t *last_pkt = os->buf + os->pstart;
320  uint8_t *next_pkt = last_pkt;
321 
323  duration = 0;
324  seg = os->segp;
325  d = avpriv_vorbis_parse_frame(&priv->vp, last_pkt, 1);
326  if (d < 0) {
328  return 0;
329  }
330  duration += d;
331  last_pkt = next_pkt = next_pkt + os->psize;
332  for (; seg < os->nsegs; seg++) {
333  if (os->segments[seg] < 255) {
334  int d = avpriv_vorbis_parse_frame(&priv->vp, last_pkt, 1);
335  if (d < 0) {
336  duration = os->granule;
337  break;
338  }
339  duration += d;
340  last_pkt = next_pkt + os->segments[seg];
341  }
342  next_pkt += os->segments[seg];
343  }
344  os->lastpts = os->lastdts = os->granule - duration;
345  if(s->streams[idx]->start_time == AV_NOPTS_VALUE) {
346  s->streams[idx]->start_time = FFMAX(os->lastpts, 0);
347  if (s->streams[idx]->duration)
348  s->streams[idx]->duration -= s->streams[idx]->start_time;
349  }
350  priv->final_pts = AV_NOPTS_VALUE;
352  }
353 
354  /* parse packet duration */
355  if (os->psize > 0) {
356  duration = avpriv_vorbis_parse_frame(&priv->vp, os->buf + os->pstart, 1);
357  if (duration < 0) {
359  return 0;
360  }
361  os->pduration = duration;
362  }
363 
364  /* final packet handling
365  here we save the pts of the first packet in the final page, sum up all
366  packet durations in the final page except for the last one, and compare
367  to the page granule to find the duration of the final packet */
368  if (os->flags & OGG_FLAG_EOS) {
369  if (os->lastpts != AV_NOPTS_VALUE) {
370  priv->final_pts = os->lastpts;
371  priv->final_duration = 0;
372  }
373  if (os->segp == os->nsegs)
374  os->pduration = os->granule - priv->final_pts - priv->final_duration;
375  priv->final_duration += os->pduration;
376  }
377 
378  return 0;
379 }
380 
381 const struct ogg_codec ff_vorbis_codec = {
382  .magic = "\001vorbis",
383  .magicsize = 7,
384  .header = vorbis_header,
385  .packet = vorbis_packet,
386  .cleanup= vorbis_cleanup,
387  .nb_header = 3,
388 };