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         av_log_ask_for_sample(avctx, "%d modes found. This is either a false "
 145                               "positive or a sample from an unknown encoder.\n",
 146                               last_mode_count);
 147     }
 148     /* We're limiting the mode count to 63 so that we know that the previous
 149      * block flag will be in the first packet byte. */
 150     if (last_mode_count > 63) {
 151         av_log(avctx, AV_LOG_ERROR, "Unsupported mode count: %d\n",
 152                last_mode_count);
 153         ret = AVERROR_INVALIDDATA;
 154         goto bad_header;
 155     }
 156     s->mode_count = mode_count = last_mode_count;
 157     /* Determine the number of bits required to code the mode and turn that
 158      * into a bitmask to directly access the mode from the first frame byte. */
 159     s->mode_mask = ((1 << (av_log2(mode_count - 1) + 1)) - 1) << 1;
 160     /* The previous window flag is the next bit after the mode */
 161     s->prev_mask = (s->mode_mask | 0x1) + 1;
 162
 163     init_get_bits(&gb, rev_buf, buf_size * 8);
 164     skip_bits_long(&gb, got_framing_bit);
 165     for (i = mode_count - 1; i >= 0; i--) {
 166         skip_bits_long(&gb, 40);
 167         s->mode_blocksize[i] = s->blocksize[get_bits1(&gb)];
 168     }
 169
 170 bad_header:
 171     av_free(rev_buf);
 172     return ret;
 173 }
 174
 175 int avpriv_vorbis_parse_extradata(AVCodecContext *avctx, VorbisParseContext *s)
 176 {
 177     uint8_t *header_start[3];
 178     int header_len[3];
 179     int ret;
 180
 181     s->avctx = avctx;
 182     s->extradata_parsed = 1;
 183
 184     if ((ret = avpriv_split_xiph_headers(avctx->extradata,
 185                                          avctx->extradata_size, 30,
 186                                          header_start, header_len)) < 0) {
 187         av_log(avctx, AV_LOG_ERROR, "Extradata corrupt.\n");
 188         return ret;
 189     }
 190
 191     if ((ret = parse_id_header(avctx, s, header_start[0], header_len[0])) < 0)
 192         return ret;
 193
 194     if ((ret = parse_setup_header(avctx, s, header_start[2], header_len[2])) < 0)
 195         return ret;
 196
 197     s->valid_extradata = 1;
 198     s->previous_blocksize = s->mode_blocksize[0];
 199
 200     return 0;
 201 }
 202
 203 int avpriv_vorbis_parse_frame(VorbisParseContext *s, const uint8_t *buf,
 204                               int buf_size)
 205 {
 206     int duration = 0;
 207
 208     if (s->valid_extradata && buf_size > 0) {
 209         int mode, current_blocksize;
 210         int previous_blocksize = s->previous_blocksize;
 211
 212         if (buf[0] & 1) {
 213             av_log(s->avctx, AV_LOG_ERROR, "Invalid packet\n");
 214             return AVERROR_INVALIDDATA;
 215         }
 216         if (s->mode_count == 1)
 217             mode = 0;
 218         else
 219             mode = (buf[0] & s->mode_mask) >> 1;
 220         if (mode >= s->mode_count) {
 221             av_log(s->avctx, AV_LOG_ERROR, "Invalid mode in packet\n");
 222             return AVERROR_INVALIDDATA;
 223         }
 224         if (mode) {
 225             int flag = !!(buf[0] & s->prev_mask);
 226             previous_blocksize = s->blocksize[flag];
 227         }
 228         current_blocksize     = s->mode_blocksize[mode];
 229         duration              = (previous_blocksize + current_blocksize) >> 2;
 230         s->previous_blocksize = current_blocksize;
 231     }
 232
 233     return duration;
 234 }
 235
 236 void avpriv_vorbis_parse_reset(VorbisParseContext *s)
 237 {
 238     if (s->valid_extradata)
 239         s->previous_blocksize = s->mode_blocksize[0];
 240 }
 241
 242 #if CONFIG_VORBIS_PARSER
 243 static int vorbis_parse(AVCodecParserContext *s1, AVCodecContext *avctx,
 244                         const uint8_t **poutbuf, int *poutbuf_size,
 245                         const uint8_t *buf, int buf_size)
 246 {
 247     VorbisParseContext *s = s1->priv_data;
 248     int duration;
 249
 250     if (!s->extradata_parsed && avctx->extradata && avctx->extradata_size)
 251         if (avpriv_vorbis_parse_extradata(avctx, s))
 252             goto end;
 253
 254     if ((duration = avpriv_vorbis_parse_frame(s, buf, buf_size)) >= 0)
 255         s1->duration = duration;
 256
 257 end:
 258     /* always return the full packet. this parser isn't doing any splitting or
 259        combining, only packet analysis */
 260     *poutbuf      = buf;
 261     *poutbuf_size = buf_size;
 262     return buf_size;
 263 }
 264
 265 AVCodecParser ff_vorbis_parser = {
 266     .codec_ids      = { AV_CODEC_ID_VORBIS },
 267     .priv_data_size = sizeof(VorbisParseContext),
 268     .parser_parse   = vorbis_parse,
 269 };
 270 #endif /* CONFIG_VORBIS_PARSER */