libavcodec/vorbis_parser.c

   1 /*
   2  * Copyright (c) 2012 Justin Ruggles
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 "config_components.h"
  29
  30 #include "libavutil/log.h"
  31 #include "libavutil/mem.h"
  32
  33 #include "get_bits.h"
  34 #include "xiph.h"
  35 #include "vorbis_parser_internal.h"
  36
  37 static const AVClass vorbis_parser_class = {
  38     .class_name = "Vorbis parser",
  39     .item_name  = av_default_item_name,
  40     .version    = LIBAVUTIL_VERSION_INT,
  41 };
  42
  43 static int parse_id_header(AVVorbisParseContext *s,
  44                            const uint8_t *buf, int buf_size)
  45 {
  46     /* Id header should be 30 bytes */
  47     if (buf_size < 30) {
  48         av_log(s, AV_LOG_ERROR, "Id header is too short\n");
  49         return AVERROR_INVALIDDATA;
  50     }
  51
  52     /* make sure this is the Id header */
  53     if (buf[0] != 1) {
  54         av_log(s, AV_LOG_ERROR, "Wrong packet type in Id header\n");
  55         return AVERROR_INVALIDDATA;
  56     }
  57
  58     /* check for header signature */
  59     if (memcmp(&buf[1], "vorbis", 6)) {
  60         av_log(s, AV_LOG_ERROR, "Invalid packet signature in Id header\n");
  61         return AVERROR_INVALIDDATA;
  62     }
  63
  64     if (!(buf[29] & 0x1)) {
  65         av_log(s, AV_LOG_ERROR, "Invalid framing bit in Id header\n");
  66         return AVERROR_INVALIDDATA;
  67     }
  68
  69     s->blocksize[0] = 1 << (buf[28] & 0xF);
  70     s->blocksize[1] = 1 << (buf[28] >>  4);
  71
  72     return 0;
  73 }
  74
  75 static int parse_setup_header(AVVorbisParseContext *s,
  76                               const uint8_t *buf, int buf_size)
  77 {
  78     GetBitContext gb, gb0;
  79     uint8_t *rev_buf;
  80     int i, ret = 0;
  81     int got_framing_bit, mode_count, got_mode_header, last_mode_count = 0;
  82
  83     /* avoid overread */
  84     if (buf_size < 7) {
  85         av_log(s, AV_LOG_ERROR, "Setup header is too short\n");
  86         return AVERROR_INVALIDDATA;
  87     }
  88
  89     /* make sure this is the Setup header */
  90     if (buf[0] != 5) {
  91         av_log(s, AV_LOG_ERROR, "Wrong packet type in Setup header\n");
  92         return AVERROR_INVALIDDATA;
  93     }
  94
  95     /* check for header signature */
  96     if (memcmp(&buf[1], "vorbis", 6)) {
  97         av_log(s, AV_LOG_ERROR, "Invalid packet signature in Setup header\n");
  98         return AVERROR_INVALIDDATA;
  99     }
 100
 101     /* reverse bytes so we can easily read backwards with get_bits() */
 102     if (!(rev_buf = av_malloc(buf_size))) {
 103         av_log(s, AV_LOG_ERROR, "Out of memory\n");
 104         return AVERROR(ENOMEM);
 105     }
 106     for (i = 0; i < buf_size; i++)
 107         rev_buf[i] = buf[buf_size - 1 - i];
 108     init_get_bits(&gb, rev_buf, buf_size * 8);
 109
 110     got_framing_bit = 0;
 111     while (get_bits_left(&gb) > 97) {
 112         if (get_bits1(&gb)) {
 113             got_framing_bit = get_bits_count(&gb);
 114             break;
 115         }
 116     }
 117     if (!got_framing_bit) {
 118         av_log(s, AV_LOG_ERROR, "Invalid Setup header\n");
 119         ret = AVERROR_INVALIDDATA;
 120         goto bad_header;
 121     }
 122
 123     /* Now we search backwards to find possible valid mode counts. This is not
 124      * fool-proof because we could have false positive matches and read too
 125      * far, but there isn't really any way to be sure without parsing through
 126      * all the many variable-sized fields before the modes. This approach seems
 127      * to work well in testing, and it is similar to how it is handled in
 128      * liboggz. */
 129     mode_count = 0;
 130     got_mode_header = 0;
 131     while (get_bits_left(&gb) >= 97) {
 132         if (get_bits(&gb, 8) > 63 || get_bits(&gb, 16) || get_bits(&gb, 16))
 133             break;
 134         skip_bits(&gb, 1);
 135         mode_count++;
 136         if (mode_count > 64)
 137             break;
 138         gb0 = gb;
 139         if (get_bits(&gb0, 6) + 1 == mode_count) {
 140             got_mode_header = 1;
 141             last_mode_count = mode_count;
 142         }
 143     }
 144     if (!got_mode_header) {
 145         av_log(s, AV_LOG_ERROR, "Invalid Setup header\n");
 146         ret = AVERROR_INVALIDDATA;
 147         goto bad_header;
 148     }
 149     /* All samples I've seen use <= 2 modes, so ask for a sample if we find
 150      * more than that, as it is most likely a false positive. If we get any
 151      * we may need to approach this the long way and parse the whole Setup
 152      * header, but I hope very much that it never comes to that. */
 153     if (last_mode_count > 2) {
 154         avpriv_request_sample(s,
 155                               "%d modes (either a false positive or a "
 156                               "sample from an unknown encoder)",
 157                               last_mode_count);
 158     }
 159     /* We're limiting the mode count to 63 so that we know that the previous
 160      * block flag will be in the first packet byte. */
 161     if (last_mode_count > 63) {
 162         av_log(s, AV_LOG_ERROR, "Unsupported mode count: %d\n",
 163                last_mode_count);
 164         ret = AVERROR_INVALIDDATA;
 165         goto bad_header;
 166     }
 167     s->mode_count = mode_count = last_mode_count;
 168     /* Determine the number of bits required to code the mode and turn that
 169      * into a bitmask to directly access the mode from the first frame byte. */
 170     s->mode_mask = ((1 << (av_log2(mode_count - 1) + 1)) - 1) << 1;
 171     /* The previous window flag is the next bit after the mode */
 172     s->prev_mask = (s->mode_mask | 0x1) + 1;
 173
 174     init_get_bits(&gb, rev_buf, buf_size * 8);
 175     skip_bits_long(&gb, got_framing_bit);
 176     for (i = mode_count - 1; i >= 0; i--) {
 177         skip_bits_long(&gb, 40);
 178         s->mode_blocksize[i] = get_bits1(&gb);
 179     }
 180
 181 bad_header:
 182     av_free(rev_buf);
 183     return ret;
 184 }
 185
 186 static int vorbis_parse_init(AVVorbisParseContext *s,
 187                              const uint8_t *extradata, int extradata_size)
 188 {
 189     const uint8_t *header_start[3];
 190     int header_len[3];
 191     int ret;
 192
 193     s->class = &vorbis_parser_class;
 194     s->extradata_parsed = 1;
 195
 196     if ((ret = avpriv_split_xiph_headers(extradata,
 197                                          extradata_size, 30,
 198                                          header_start, header_len)) < 0) {
 199         av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
 200         return ret;
 201     }
 202
 203     if ((ret = parse_id_header(s, header_start[0], header_len[0])) < 0)
 204         return ret;
 205
 206     if ((ret = parse_setup_header(s, header_start[2], header_len[2])) < 0)
 207         return ret;
 208
 209     s->valid_extradata = 1;
 210     s->previous_blocksize = s->blocksize[s->mode_blocksize[0]];
 211
 212     return 0;
 213 }
 214
 215 int av_vorbis_parse_frame_flags(AVVorbisParseContext *s, const uint8_t *buf,
 216                                 int buf_size, int *flags)
 217 {
 218     int duration = 0;
 219
 220     if (s->valid_extradata && buf_size > 0) {
 221         int mode, current_blocksize;
 222         int previous_blocksize = s->previous_blocksize;
 223
 224         if (buf[0] & 1) {
 225             /* If the user doesn't care about special packets, it's a bad one. */
 226             if (!flags)
 227                 goto bad_packet;
 228
 229             /* Set the flag for which kind of special packet it is. */
 230             if (buf[0] == 1)
 231                 *flags |= VORBIS_FLAG_HEADER;
 232             else if (buf[0] == 3)
 233                 *flags |= VORBIS_FLAG_COMMENT;
 234             else if (buf[0] == 5)
 235                 *flags |= VORBIS_FLAG_SETUP;
 236             else
 237                 av_log(s, AV_LOG_VERBOSE, "Ignoring packet with unknown type %u\n",
 238                        buf[0]);
 239
 240             /* Special packets have no duration. */
 241             return 0;
 242
 243 bad_packet:
 244             av_log(s, AV_LOG_ERROR, "Invalid packet\n");
 245             return AVERROR_INVALIDDATA;
 246         }
 247         if (s->mode_count == 1)
 248             mode = 0;
 249         else
 250             mode = (buf[0] & s->mode_mask) >> 1;
 251         if (mode >= s->mode_count) {
 252             av_log(s, AV_LOG_ERROR, "Invalid mode in packet\n");
 253             return AVERROR_INVALIDDATA;
 254         }
 255         if(s->mode_blocksize[mode]){
 256             int flag = !!(buf[0] & s->prev_mask);
 257             previous_blocksize = s->blocksize[flag];
 258         }
 259         current_blocksize     = s->blocksize[s->mode_blocksize[mode]];
 260         duration              = (previous_blocksize + current_blocksize) >> 2;
 261         s->previous_blocksize = current_blocksize;
 262     }
 263
 264     return duration;
 265 }
 266
 267 int av_vorbis_parse_frame(AVVorbisParseContext *s, const uint8_t *buf,
 268                           int buf_size)
 269 {
 270     return av_vorbis_parse_frame_flags(s, buf, buf_size, NULL);
 271 }
 272
 273 void av_vorbis_parse_reset(AVVorbisParseContext *s)
 274 {
 275     if (s->valid_extradata)
 276         s->previous_blocksize = s->blocksize[0];
 277 }
 278
 279 void av_vorbis_parse_free(AVVorbisParseContext **s)
 280 {
 281     av_freep(s);
 282 }
 283
 284 AVVorbisParseContext *av_vorbis_parse_init(const uint8_t *extradata,
 285                                            int extradata_size)
 286 {
 287     AVVorbisParseContext *s = av_mallocz(sizeof(*s));
 288     int ret;
 289
 290     if (!s)
 291         return NULL;
 292
 293     ret = vorbis_parse_init(s, extradata, extradata_size);
 294     if (ret < 0) {
 295         av_vorbis_parse_free(&s);
 296         return NULL;
 297     }
 298
 299     return s;
 300 }
 301
 302 #if CONFIG_VORBIS_PARSER
 303
 304 typedef struct VorbisParseContext {
 305     AVVorbisParseContext *vp;
 306 } VorbisParseContext;
 307
 308 static int vorbis_parse(AVCodecParserContext *s1, AVCodecContext *avctx,
 309                         const uint8_t **poutbuf, int *poutbuf_size,
 310                         const uint8_t *buf, int buf_size)
 311 {
 312     VorbisParseContext *s = s1->priv_data;
 313     int duration;
 314
 315     if (!s->vp && avctx->extradata && avctx->extradata_size) {
 316         s->vp = av_vorbis_parse_init(avctx->extradata, avctx->extradata_size);
 317     }
 318     if (!s->vp)
 319         goto end;
 320
 321     if ((duration = av_vorbis_parse_frame(s->vp, buf, buf_size)) >= 0)
 322         s1->duration = duration;
 323
 324 end:
 325     /* always return the full packet. this parser isn't doing any splitting or
 326        combining, only packet analysis */
 327     *poutbuf      = buf;
 328     *poutbuf_size = buf_size;
 329     return buf_size;
 330 }
 331
 332 static void vorbis_parser_close(AVCodecParserContext *ctx)
 333 {
 334     VorbisParseContext *s = ctx->priv_data;
 335     av_vorbis_parse_free(&s->vp);
 336 }
 337
 338 const AVCodecParser ff_vorbis_parser = {
 339     .codec_ids      = { AV_CODEC_ID_VORBIS },
 340     .priv_data_size = sizeof(VorbisParseContext),
 341     .parser_parse   = vorbis_parse,
 342     .parser_close   = vorbis_parser_close,
 343 };
 344 #endif /* CONFIG_VORBIS_PARSER */