git.sesse.net Git - ffmpeg/blob - libavcodec/vorbis_parser.c

   1 /*
   2  * Copyright (c) 2012 Justin Ruggles
   3  *
   4  * This file is part of Libav.
   5  *
   6  * Libav is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * Libav is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with Libav; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /**
  22  * @file
  23  * Vorbis audio parser
  24  *
  25  * Determines the duration for each packet.
  26  */
  27
  28 #include "get_bits.h"
  29 #include "parser.h"
  30 #include "xiph.h"
  31 #include "vorbis_parser.h"
  32
  33 static int parse_id_header(AVCodecContext *avctx, VorbisParseContext *s,
  34                            const uint8_t *buf, int buf_size)
  35 {
  36     /* Id header should be 30 bytes */
  37     if (buf_size < 30) {
  38         av_log(avctx, AV_LOG_ERROR, "Id header is too short\n");
  39         return AVERROR_INVALIDDATA;
  40     }
  41
  42     /* make sure this is the Id header */
  43     if (buf[0] != 1) {
  44         av_log(avctx, AV_LOG_ERROR, "Wrong packet type in Id header\n");
  45         return AVERROR_INVALIDDATA;
  46     }
  47
  48     /* check for header signature */
  49     if (memcmp(&buf[1], "vorbis", 6)) {
  50         av_log(avctx, AV_LOG_ERROR, "Invalid packet signature in Id header\n");
  51         return AVERROR_INVALIDDATA;
  52     }
  53
  54     if (!(buf[29] & 0x1)) {
  55         av_log(avctx, AV_LOG_ERROR, "Invalid framing bit in Id header\n");
  56         return AVERROR_INVALIDDATA;
  57     }
  58
  59     s->blocksize[0] = 1 << (buf[28] & 0xF);
  60     s->blocksize[1] = 1 << (buf[28] >>  4);
  61
  62     return 0;
  63 }
  64
  65 static int parse_setup_header(AVCodecContext *avctx, VorbisParseContext *s,
  66                               const uint8_t *buf, int buf_size)
  67 {
  68     GetBitContext gb, gb0;
  69     uint8_t *rev_buf;
  70     int i, ret = 0;
  71     int got_framing_bit, mode_count, got_mode_header, last_mode_count = 0;
  72
  73     /* avoid overread */
  74     if (buf_size < 7) {
  75         av_log(avctx, AV_LOG_ERROR, "Setup header is too short\n");
  76         return AVERROR_INVALIDDATA;
  77     }
  78
  79     /* make sure this is the Setup header */
  80     if (buf[0] != 5) {
  81         av_log(avctx, AV_LOG_ERROR, "Wrong packet type in Setup header\n");
  82         return AVERROR_INVALIDDATA;
  83     }
  84
  85     /* check for header signature */
  86     if (memcmp(&buf[1], "vorbis", 6)) {
  87         av_log(avctx, AV_LOG_ERROR, "Invalid packet signature in Setup header\n");
  88         return AVERROR_INVALIDDATA;
  89     }
  90
  91     /* reverse bytes so we can easily read backwards with get_bits() */
  92     if (!(rev_buf = av_malloc(buf_size))) {
  93         av_log(avctx, AV_LOG_ERROR, "Out of memory\n");
  94         return AVERROR(ENOMEM);
  95     }
  96     for (i = 0; i < buf_size; i++)
  97         rev_buf[i] = buf[buf_size - 1 - i];
  98     init_get_bits(&gb, rev_buf, buf_size * 8);
  99
 100     got_framing_bit = 0;
 101     while (get_bits_left(&gb) > 97) {
 102         if (get_bits1(&gb)) {
 103             got_framing_bit = get_bits_count(&gb);
 104             break;
 105         }
 106     }
 107     if (!got_framing_bit) {
 108         av_log(avctx, AV_LOG_ERROR, "Invalid Setup header\n");
 109         ret = AVERROR_INVALIDDATA;
 110         goto bad_header;
 111     }
 112
 113     /* Now we search backwards to find possible valid mode counts. This is not
 114      * fool-proof because we could have false positive matches and read too
 115      * far, but there isn't really any way to be sure without parsing through
 116      * all the many variable-sized fields before the modes. This approach seems
 117      * to work well in testing, and it is similar to how it is handled in
 118      * liboggz. */
 119     mode_count = 0;
 120     got_mode_header = 0;
 121     while (get_bits_left(&gb) >= 97) {
 122         if (get_bits(&gb, 8) > 63 || get_bits(&gb, 16) || get_bits(&gb, 16))
 123             break;
 124         skip_bits(&gb, 1);
 125         mode_count++;
 126         if (mode_count > 64)
 127             break;
 128         gb0 = gb;
 129         if (get_bits(&gb0, 6) + 1 == mode_count) {
 130             got_mode_header = 1;
 131             last_mode_count = mode_count;
 132         }
 133     }
 134     if (!got_mode_header) {
 135         av_log(avctx, AV_LOG_ERROR, "Invalid Setup header\n");
 136         ret = AVERROR_INVALIDDATA;
 137         goto bad_header;
 138     }
 139     /* All samples I've seen use <= 2 modes, so ask for a sample if we find
 140      * more than that, as it is most likely a false positive. If we get any
 141      * we may need to approach this the long way and parse the whole Setup
 142      * header, but I hope very much that it never comes to that. */
 143     if (last_mode_count > 2) {
 144         avpriv_request_sample(avctx,
 145                               "%d modes (either a false positive or a "
 146                               "sample from an unknown encoder)",
 147                               last_mode_count);
 148     }
 149     /* We're limiting the mode count to 63 so that we know that the previous
 150      * block flag will be in the first packet byte. */
 151     if (last_mode_count > 63) {
 152         av_log(avctx, AV_LOG_ERROR, "Unsupported mode count: %d\n",
 153                last_mode_count);
 154         ret = AVERROR_INVALIDDATA;
 155         goto bad_header;
 156     }
 157     s->mode_count = mode_count = last_mode_count;
 158     /* Determine the number of bits required to code the mode and turn that
 159      * into a bitmask to directly access the mode from the first frame byte. */
 160     s->mode_mask = ((1 << (av_log2(mode_count - 1) + 1)) - 1) << 1;
 161     /* The previous window flag is the next bit after the mode */
 162     s->prev_mask = (s->mode_mask | 0x1) + 1;
 163
 164     init_get_bits(&gb, rev_buf, buf_size * 8);
 165     skip_bits_long(&gb, got_framing_bit);
 166     for (i = mode_count - 1; i >= 0; i--) {
 167         skip_bits_long(&gb, 40);
 168         s->mode_blocksize[i] = s->blocksize[get_bits1(&gb)];
 169     }
 170
 171 bad_header:
 172     av_free(rev_buf);
 173     return ret;
 174 }
 175
 176 int avpriv_vorbis_parse_extradata(AVCodecContext *avctx, VorbisParseContext *s)
 177 {
 178     uint8_t *header_start[3];
 179     int header_len[3];
 180     int ret;
 181
 182     s->avctx = avctx;
 183     s->extradata_parsed = 1;
 184
 185     if ((ret = avpriv_split_xiph_headers(avctx->extradata,
 186                                          avctx->extradata_size, 30,
 187                                          header_start, header_len)) < 0) {
 188         av_log(avctx, AV_LOG_ERROR, "Extradata corrupt.\n");
 189         return ret;
 190     }
 191
 192     if ((ret = parse_id_header(avctx, s, header_start[0], header_len[0])) < 0)
 193         return ret;
 194
 195     if ((ret = parse_setup_header(avctx, s, header_start[2], header_len[2])) < 0)
 196         return ret;
 197
 198     s->valid_extradata = 1;
 199     s->previous_blocksize = s->mode_blocksize[0];
 200
 201     return 0;
 202 }
 203
 204 int avpriv_vorbis_parse_frame(VorbisParseContext *s, const uint8_t *buf,
 205                               int buf_size)
 206 {
 207     int duration = 0;
 208
 209     if (s->valid_extradata && buf_size > 0) {
 210         int mode, current_blocksize;
 211         int previous_blocksize = s->previous_blocksize;
 212
 213         if (buf[0] & 1) {
 214             av_log(s->avctx, AV_LOG_ERROR, "Invalid packet\n");
 215             return AVERROR_INVALIDDATA;
 216         }
 217         if (s->mode_count == 1)
 218             mode = 0;
 219         else
 220             mode = (buf[0] & s->mode_mask) >> 1;
 221         if (mode >= s->mode_count) {
 222             av_log(s->avctx, AV_LOG_ERROR, "Invalid mode in packet\n");
 223             return AVERROR_INVALIDDATA;
 224         }
 225         if (mode) {
 226             int flag = !!(buf[0] & s->prev_mask);
 227             previous_blocksize = s->blocksize[flag];
 228         }
 229         current_blocksize     = s->mode_blocksize[mode];
 230         duration              = (previous_blocksize + current_blocksize) >> 2;
 231         s->previous_blocksize = current_blocksize;
 232     }
 233
 234     return duration;
 235 }
 236
 237 void avpriv_vorbis_parse_reset(VorbisParseContext *s)
 238 {
 239     if (s->valid_extradata)
 240         s->previous_blocksize = s->mode_blocksize[0];
 241 }
 242
 243 #if CONFIG_VORBIS_PARSER
 244 static int vorbis_parse(AVCodecParserContext *s1, AVCodecContext *avctx,
 245                         const uint8_t **poutbuf, int *poutbuf_size,
 246                         const uint8_t *buf, int buf_size)
 247 {
 248     VorbisParseContext *s = s1->priv_data;
 249     int duration;
 250
 251     if (!s->extradata_parsed && avctx->extradata && avctx->extradata_size)
 252         if (avpriv_vorbis_parse_extradata(avctx, s))
 253             goto end;
 254
 255     if ((duration = avpriv_vorbis_parse_frame(s, buf, buf_size)) >= 0)
 256         s1->duration = duration;
 257
 258 end:
 259     /* always return the full packet. this parser isn't doing any splitting or
 260        combining, only packet analysis */
 261     *poutbuf      = buf;
 262     *poutbuf_size = buf_size;
 263     return buf_size;
 264 }
 265
 266 AVCodecParser ff_vorbis_parser = {
 267     .codec_ids      = { AV_CODEC_ID_VORBIS },
 268     .priv_data_size = sizeof(VorbisParseContext),
 269     .parser_parse   = vorbis_parse,
 270 };
 271 #endif /* CONFIG_VORBIS_PARSER */