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