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 "avformat.h"
  27 #include "bitstream.h"
  28 #include "bswap.h"
  29 #include "ogg2.h"
  30 #include "avstring.h"
  31
  32 extern int
  33 vorbis_comment(AVFormatContext * as, uint8_t *buf, int size)
  34 {
  35     char *p = buf;
  36     int s, n, j;
  37
  38     if (size < 4)
  39         return -1;
  40
  41     s = AV_RL32(p);
  42     p += 4;
  43     size -= 4;
  44
  45     if (size < s + 4)
  46         return -1;
  47
  48     p += s;
  49     size -= s;
  50
  51     n = AV_RL32(p);
  52     p += 4;
  53     size -= 4;
  54
  55     while (size >= 4) {
  56         char *t, *v;
  57         int tl, vl;
  58
  59         s = AV_RL32(p);
  60         p += 4;
  61         size -= 4;
  62
  63         if (size < s)
  64             break;
  65
  66         t = p;
  67         p += s;
  68         size -= s;
  69         n--;
  70
  71         v = memchr(t, '=', s);
  72         if (!v)
  73             continue;
  74
  75         tl = v - t;
  76         vl = s - tl - 1;
  77         v++;
  78
  79         if (tl && vl) {
  80             char tt[tl + 1];
  81             char ct[vl + 1];
  82
  83             for (j = 0; j < tl; j++)
  84                 tt[j] = toupper(t[j]);
  85             tt[tl] = 0;
  86
  87             memcpy(ct, v, vl);
  88             ct[vl] = 0;
  89
  90             // took from Vorbis_I_spec
  91             if (!strcmp(tt, "AUTHOR") || !strcmp(tt, "ARTIST"))
  92                 av_strlcpy(as->author, ct, sizeof(as->author));
  93             else if (!strcmp(tt, "TITLE"))
  94                 av_strlcpy(as->title, ct, sizeof(as->title));
  95             else if (!strcmp(tt, "COPYRIGHT"))
  96                 av_strlcpy(as->copyright, ct, sizeof(as->copyright));
  97             else if (!strcmp(tt, "DESCRIPTION"))
  98                 av_strlcpy(as->comment, ct, sizeof(as->comment));
  99             else if (!strcmp(tt, "GENRE"))
 100                 av_strlcpy(as->genre, ct, sizeof(as->genre));
 101             else if (!strcmp(tt, "TRACKNUMBER"))
 102                 as->track = atoi(ct);
 103             else if (!strcmp(tt, "ALBUM"))
 104                 av_strlcpy(as->album, ct, sizeof(as->album));
 105             else if (!strcmp(tt, "GENRE"))
 106                 av_strlcpy(as->genre, ct, sizeof(as->genre));
 107             else if (!strcmp(tt, "DESCRIPTION"))
 108                 av_strlcpy(as->comment, ct, sizeof(as->comment));
 109         }
 110     }
 111
 112     if (size > 0)
 113         av_log(as, AV_LOG_INFO, "%i bytes of comment header remain\n", size);
 114     if (n > 0)
 115         av_log(as, AV_LOG_INFO,
 116                "truncated comment header, %i comments not found\n", n);
 117
 118     return 0;
 119 }
 120
 121
 122 /** Parse the vorbis header
 123  * Vorbis Identification header from Vorbis_I_spec.html#vorbis-spec-codec
 124  * [vorbis_version] = read 32 bits as unsigned integer | Not used
 125  * [audio_channels] = read 8 bit integer as unsigned | Used
 126  * [audio_sample_rate] = read 32 bits as unsigned integer | Used
 127  * [bitrate_maximum] = read 32 bits as signed integer | Not used yet
 128  * [bitrate_nominal] = read 32 bits as signed integer | Not used yet
 129  * [bitrate_minimum] = read 32 bits as signed integer | Used as bitrate
 130  * [blocksize_0] = read 4 bits as unsigned integer | Not Used
 131  * [blocksize_1] = read 4 bits as unsigned integer | Not Used
 132  * [framing_flag] = read one bit | Not Used
 133  *    */
 134
 135 typedef struct {
 136     unsigned int len[3];
 137     unsigned char *packet[3];
 138 } oggvorbis_private_t;
 139
 140
 141 static unsigned int
 142 fixup_vorbis_headers(AVFormatContext * as, oggvorbis_private_t *priv,
 143                      void **buf)
 144 {
 145     int i,offset, len;
 146     unsigned char *ptr;
 147
 148     len = priv->len[0] + priv->len[1] + priv->len[2];
 149     ptr = *buf = av_mallocz(len + len/255 + 64);
 150
 151     ptr[0] = 2;
 152     offset = 1;
 153     offset += av_xiphlacing(&ptr[offset], priv->len[0]);
 154     offset += av_xiphlacing(&ptr[offset], priv->len[1]);
 155     for (i = 0; i < 3; i++) {
 156         memcpy(&ptr[offset], priv->packet[i], priv->len[i]);
 157         offset += priv->len[i];
 158     }
 159     *buf = av_realloc(*buf, offset);
 160     return offset;
 161 }
 162
 163
 164 static int
 165 vorbis_header (AVFormatContext * s, int idx)
 166 {
 167     ogg_t *ogg = s->priv_data;
 168     ogg_stream_t *os = ogg->streams + idx;
 169     AVStream *st = s->streams[idx];
 170     oggvorbis_private_t *priv;
 171
 172     if (os->seq > 2)
 173         return 0;
 174
 175     if (os->seq == 0) {
 176         os->private = av_mallocz(sizeof(oggvorbis_private_t));
 177         if (!os->private)
 178             return 0;
 179     }
 180
 181     priv = os->private;
 182     priv->len[os->seq] = os->psize;
 183     priv->packet[os->seq] = av_mallocz(os->psize);
 184     memcpy(priv->packet[os->seq], os->buf + os->pstart, os->psize);
 185     if (os->buf[os->pstart] == 1) {
 186         uint8_t *p = os->buf + os->pstart + 11; //skip up to the audio channels
 187         st->codec->channels = *p++;
 188         st->codec->sample_rate = AV_RL32(p);
 189         p += 8; //skip maximum and and nominal bitrate
 190         st->codec->bit_rate = AV_RL32(p); //Minimum bitrate
 191
 192         st->codec->codec_type = CODEC_TYPE_AUDIO;
 193         st->codec->codec_id = CODEC_ID_VORBIS;
 194
 195         st->time_base.num = 1;
 196         st->time_base.den = st->codec->sample_rate;
 197     } else if (os->buf[os->pstart] == 3) {
 198         vorbis_comment (s, os->buf + os->pstart + 7, os->psize - 8);
 199     } else {
 200         st->codec->extradata_size =
 201             fixup_vorbis_headers(s, priv, &st->codec->extradata);
 202     }
 203
 204     return os->seq < 3;
 205 }
 206
 207 ogg_codec_t vorbis_codec = {
 208     .magic = "\001vorbis",
 209     .magicsize = 7,
 210     .header = vorbis_header
 211 };