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