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/bswap.h"
  28 #include "libavcodec/get_bits.h"
  29 #include "libavcodec/bytestream.h"
  30 #include "avformat.h"
  31 #include "oggdec.h"
  32
  33 /**
  34  * VorbisComment metadata conversion mapping.
  35  * from Ogg Vorbis I format specification: comment field and header specification
  36  * http://xiph.org/vorbis/doc/v-comment.html
  37  */
  38 const AVMetadataConv ff_vorbiscomment_metadata_conv[] = {
  39     { "ARTIST"     , "author" },
  40     { "TITLE"      , "title"  },
  41     { "ALBUM"      , "album"  },
  42     { "DATE"       , "year"   },
  43     { "TRACKNUMBER", "track"  },
  44     { "GENRE"      , "genre"  },
  45     { 0 }
  46 };
  47
  48 int
  49 vorbis_comment(AVFormatContext * as, uint8_t *buf, int size)
  50 {
  51     const uint8_t *p = buf;
  52     const uint8_t *end = buf + size;
  53     unsigned s, n, j;
  54
  55     if (size < 8) /* must have vendor_length and user_comment_list_length */
  56         return -1;
  57
  58     s = bytestream_get_le32(&p);
  59
  60     if (end - p < s)
  61         return -1;
  62
  63     p += s;
  64
  65     n = bytestream_get_le32(&p);
  66
  67     while (p < end && n > 0) {
  68         const char *t, *v;
  69         int tl, vl;
  70
  71         s = bytestream_get_le32(&p);
  72
  73         if (end - p < s)
  74             break;
  75
  76         t = p;
  77         p += s;
  78         n--;
  79
  80         v = memchr(t, '=', s);
  81         if (!v)
  82             continue;
  83
  84         tl = v - t;
  85         vl = s - tl - 1;
  86         v++;
  87
  88         if (tl && vl) {
  89             char *tt, *ct;
  90
  91             tt = av_malloc(tl + 1);
  92             ct = av_malloc(vl + 1);
  93             if (!tt || !ct) {
  94                 av_freep(&tt);
  95                 av_freep(&ct);
  96                 av_log(as, AV_LOG_WARNING, "out-of-memory error. skipping VorbisComment tag.\n");
  97                 continue;
  98             }
  99
 100             for (j = 0; j < tl; j++)
 101                 tt[j] = toupper(t[j]);
 102             tt[tl] = 0;
 103
 104             memcpy(ct, v, vl);
 105             ct[vl] = 0;
 106
 107             av_metadata_set(&as->metadata, tt, ct);
 108
 109             av_freep(&tt);
 110             av_freep(&ct);
 111         }
 112     }
 113
 114     if (p != end)
 115         av_log(as, AV_LOG_INFO, "%ti bytes of comment header remain\n", p-end);
 116     if (n > 0)
 117         av_log(as, AV_LOG_INFO,
 118                "truncated comment header, %i comments not found\n", n);
 119
 120     return 0;
 121 }
 122
 123
 124 /** Parse the vorbis header
 125  * Vorbis Identification header from Vorbis_I_spec.html#vorbis-spec-codec
 126  * [vorbis_version] = read 32 bits as unsigned integer | Not used
 127  * [audio_channels] = read 8 bit integer as unsigned | Used
 128  * [audio_sample_rate] = read 32 bits as unsigned integer | Used
 129  * [bitrate_maximum] = read 32 bits as signed integer | Not used yet
 130  * [bitrate_nominal] = read 32 bits as signed integer | Not used yet
 131  * [bitrate_minimum] = read 32 bits as signed integer | Used as bitrate
 132  * [blocksize_0] = read 4 bits as unsigned integer | Not Used
 133  * [blocksize_1] = read 4 bits as unsigned integer | Not Used
 134  * [framing_flag] = read one bit | Not Used
 135  *    */
 136
 137 struct oggvorbis_private {
 138     unsigned int len[3];
 139     unsigned char *packet[3];
 140 };
 141
 142
 143 static unsigned int
 144 fixup_vorbis_headers(AVFormatContext * as, struct oggvorbis_private *priv,
 145                      uint8_t **buf)
 146 {
 147     int i,offset, len;
 148     unsigned char *ptr;
 149
 150     len = priv->len[0] + priv->len[1] + priv->len[2];
 151     ptr = *buf = av_mallocz(len + len/255 + 64);
 152
 153     ptr[0] = 2;
 154     offset = 1;
 155     offset += av_xiphlacing(&ptr[offset], priv->len[0]);
 156     offset += av_xiphlacing(&ptr[offset], priv->len[1]);
 157     for (i = 0; i < 3; i++) {
 158         memcpy(&ptr[offset], priv->packet[i], priv->len[i]);
 159         offset += priv->len[i];
 160     }
 161     *buf = av_realloc(*buf, offset + FF_INPUT_BUFFER_PADDING_SIZE);
 162     return offset;
 163 }
 164
 165
 166 static int
 167 vorbis_header (AVFormatContext * s, int idx)
 168 {
 169     struct ogg *ogg = s->priv_data;
 170     struct ogg_stream *os = ogg->streams + idx;
 171     AVStream *st = s->streams[idx];
 172     struct oggvorbis_private *priv;
 173
 174     if (os->seq > 2)
 175         return 0;
 176
 177     if (os->seq == 0) {
 178         os->private = av_mallocz(sizeof(struct oggvorbis_private));
 179         if (!os->private)
 180             return 0;
 181     }
 182
 183     if (os->psize < 1)
 184         return -1;
 185
 186     priv = os->private;
 187     priv->len[os->seq] = os->psize;
 188     priv->packet[os->seq] = av_mallocz(os->psize);
 189     memcpy(priv->packet[os->seq], os->buf + os->pstart, os->psize);
 190     if (os->buf[os->pstart] == 1) {
 191         const uint8_t *p = os->buf + os->pstart + 7; /* skip "\001vorbis" tag */
 192         unsigned blocksize, bs0, bs1;
 193
 194         if (os->psize != 30)
 195             return -1;
 196
 197         if (bytestream_get_le32(&p) != 0) /* vorbis_version */
 198             return -1;
 199
 200         st->codec->channels = bytestream_get_byte(&p);
 201         st->codec->sample_rate = bytestream_get_le32(&p);
 202         p += 4; // skip maximum bitrate
 203         st->codec->bit_rate = bytestream_get_le32(&p); // nominal bitrate
 204         p += 4; // skip minimum bitrate
 205
 206         blocksize = bytestream_get_byte(&p);
 207         bs0 = blocksize & 15;
 208         bs1 = blocksize >> 4;
 209
 210         if (bs0 > bs1)
 211             return -1;
 212         if (bs0 < 6 || bs1 > 13)
 213             return -1;
 214
 215         if (bytestream_get_byte(&p) != 1) /* framing_flag */
 216             return -1;
 217
 218         st->codec->codec_type = CODEC_TYPE_AUDIO;
 219         st->codec->codec_id = CODEC_ID_VORBIS;
 220
 221         st->time_base.num = 1;
 222         st->time_base.den = st->codec->sample_rate;
 223     } else if (os->buf[os->pstart] == 3) {
 224         if (os->psize > 8)
 225             vorbis_comment (s, os->buf + os->pstart + 7, os->psize - 8);
 226     } else {
 227         st->codec->extradata_size =
 228             fixup_vorbis_headers(s, priv, &st->codec->extradata);
 229     }
 230
 231     return os->seq < 3;
 232 }
 233
 234 const struct ogg_codec ff_vorbis_codec = {
 235     .magic = "\001vorbis",
 236     .magicsize = 7,
 237     .header = vorbis_header
 238 };