libavcodec/binkaudio.c

   1 /*
   2  * Bink Audio decoder
   3  * Copyright (c) 2007-2011 Peter Ross (pross@xvid.org)
   4  * Copyright (c) 2009 Daniel Verkamp (daniel@drv.nu)
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file
  25  * Bink Audio decoder
  26  *
  27  * Technical details here:
  28  *  http://wiki.multimedia.cx/index.php?title=Bink_Audio
  29  */
  30
  31 #include "config_components.h"
  32
  33 #include "libavutil/channel_layout.h"
  34 #include "libavutil/intfloat.h"
  35 #include "libavutil/mem_internal.h"
  36 #include "libavutil/tx.h"
  37
  38 #define BITSTREAM_READER_LE
  39 #include "avcodec.h"
  40 #include "decode.h"
  41 #include "get_bits.h"
  42 #include "codec_internal.h"
  43 #include "internal.h"
  44 #include "wma_freqs.h"
  45
  46 #define MAX_DCT_CHANNELS 6
  47 #define MAX_CHANNELS 2
  48 #define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)
  49
  50 typedef struct BinkAudioContext {
  51     GetBitContext gb;
  52     int version_b;          ///< Bink version 'b'
  53     int first;
  54     int channels;
  55     int ch_offset;
  56     int frame_len;          ///< transform size (samples)
  57     int overlap_len;        ///< overlap size (samples)
  58     int block_size;
  59     int num_bands;
  60     float root;
  61     unsigned int bands[26];
  62     float previous[MAX_DCT_CHANNELS][BINK_BLOCK_MAX_SIZE / 16];  ///< coeffs from previous audio block
  63     float quant_table[96];
  64     AVPacket *pkt;
  65     AVTXContext *tx;
  66     av_tx_fn tx_fn;
  67 } BinkAudioContext;
  68
  69
  70 static av_cold int decode_init(AVCodecContext *avctx)
  71 {
  72     BinkAudioContext *s = avctx->priv_data;
  73     int sample_rate = avctx->sample_rate;
  74     int sample_rate_half;
  75     int i, ret;
  76     int frame_len_bits;
  77     int max_channels = avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT ? MAX_CHANNELS : MAX_DCT_CHANNELS;
  78     int channels = avctx->ch_layout.nb_channels;
  79
  80     /* determine frame length */
  81     if (avctx->sample_rate < 22050) {
  82         frame_len_bits = 9;
  83     } else if (avctx->sample_rate < 44100) {
  84         frame_len_bits = 10;
  85     } else {
  86         frame_len_bits = 11;
  87     }
  88
  89     if (channels < 1 || channels > max_channels) {
  90         av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n", channels);
  91         return AVERROR_INVALIDDATA;
  92     }
  93     av_channel_layout_uninit(&avctx->ch_layout);
  94     av_channel_layout_default(&avctx->ch_layout, channels);
  95
  96     s->version_b = avctx->extradata_size >= 4 && avctx->extradata[3] == 'b';
  97
  98     if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT) {
  99         // audio is already interleaved for the RDFT format variant
 100         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
 101         if (sample_rate > INT_MAX / channels)
 102             return AVERROR_INVALIDDATA;
 103         sample_rate  *= channels;
 104         s->channels = 1;
 105         if (!s->version_b)
 106             frame_len_bits += av_log2(channels);
 107     } else {
 108         s->channels = channels;
 109         avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
 110     }
 111
 112     s->frame_len     = 1 << frame_len_bits;
 113     s->overlap_len   = s->frame_len / 16;
 114     s->block_size    = (s->frame_len - s->overlap_len) * FFMIN(MAX_CHANNELS, s->channels);
 115     sample_rate_half = (sample_rate + 1LL) / 2;
 116     if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
 117         s->root = 2.0 / (sqrt(s->frame_len) * 32768.0);
 118     else
 119         s->root = s->frame_len / (sqrt(s->frame_len) * 32768.0);
 120     for (i = 0; i < 96; i++) {
 121         /* constant is result of 0.066399999/log10(M_E) */
 122         s->quant_table[i] = expf(i * 0.15289164787221953823f) * s->root;
 123     }
 124
 125     /* calculate number of bands */
 126     for (s->num_bands = 1; s->num_bands < 25; s->num_bands++)
 127         if (sample_rate_half <= ff_wma_critical_freqs[s->num_bands - 1])
 128             break;
 129
 130     /* populate bands data */
 131     s->bands[0] = 2;
 132     for (i = 1; i < s->num_bands; i++)
 133         s->bands[i] = (ff_wma_critical_freqs[i - 1] * s->frame_len / sample_rate_half) & ~1;
 134     s->bands[s->num_bands] = s->frame_len;
 135
 136     s->first = 1;
 137
 138     if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT) {
 139         float scale = 0.5;
 140         ret = av_tx_init(&s->tx, &s->tx_fn, AV_TX_FLOAT_RDFT, 1, 1 << frame_len_bits, &scale, 0);
 141     } else if (CONFIG_BINKAUDIO_DCT_DECODER) {
 142         float scale = 1.0 / (1 << frame_len_bits);
 143         ret = av_tx_init(&s->tx, &s->tx_fn, AV_TX_FLOAT_DCT, 1, 1 << (frame_len_bits - 1), &scale, 0);
 144     } else {
 145         av_assert0(0);
 146     }
 147     if (ret < 0)
 148         return ret;
 149
 150     s->pkt = avctx->internal->in_pkt;
 151
 152     return 0;
 153 }
 154
 155 static float get_float(GetBitContext *gb)
 156 {
 157     int power = get_bits(gb, 5);
 158     float f = ldexpf(get_bits(gb, 23), power - 23);
 159     if (get_bits1(gb))
 160         f = -f;
 161     return f;
 162 }
 163
 164 static const uint8_t rle_length_tab[16] = {
 165     2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64
 166 };
 167
 168 /**
 169  * Decode Bink Audio block
 170  * @param[out] out Output buffer (must contain s->block_size elements)
 171  * @return 0 on success, negative error code on failure
 172  */
 173 static int decode_block(BinkAudioContext *s, float **out, int use_dct,
 174                         int channels, int ch_offset)
 175 {
 176     int ch, i, j, k;
 177     float q, quant[25];
 178     int width, coeff;
 179     GetBitContext *gb = &s->gb;
 180     LOCAL_ALIGNED_32(float, coeffs, [4098]);
 181
 182     if (use_dct)
 183         skip_bits(gb, 2);
 184
 185     for (ch = 0; ch < channels; ch++) {
 186         if (s->version_b) {
 187             if (get_bits_left(gb) < 64)
 188                 return AVERROR_INVALIDDATA;
 189             coeffs[0] = av_int2float(get_bits_long(gb, 32)) * s->root;
 190             coeffs[1] = av_int2float(get_bits_long(gb, 32)) * s->root;
 191         } else {
 192             if (get_bits_left(gb) < 58)
 193                 return AVERROR_INVALIDDATA;
 194             coeffs[0] = get_float(gb) * s->root;
 195             coeffs[1] = get_float(gb) * s->root;
 196         }
 197
 198         if (get_bits_left(gb) < s->num_bands * 8)
 199             return AVERROR_INVALIDDATA;
 200         for (i = 0; i < s->num_bands; i++) {
 201             int value = get_bits(gb, 8);
 202             quant[i]  = s->quant_table[FFMIN(value, 95)];
 203         }
 204
 205         k = 0;
 206         q = quant[0];
 207
 208         // parse coefficients
 209         i = 2;
 210         while (i < s->frame_len) {
 211             if (s->version_b) {
 212                 j = i + 16;
 213             } else {
 214                 int v = get_bits1(gb);
 215                 if (v) {
 216                     v = get_bits(gb, 4);
 217                     j = i + rle_length_tab[v] * 8;
 218                 } else {
 219                     j = i + 8;
 220                 }
 221             }
 222
 223             j = FFMIN(j, s->frame_len);
 224
 225             width = get_bits(gb, 4);
 226             if (width == 0) {
 227                 memset(coeffs + i, 0, (j - i) * sizeof(*coeffs));
 228                 i = j;
 229                 while (s->bands[k] < i)
 230                     q = quant[k++];
 231             } else {
 232                 while (i < j) {
 233                     if (s->bands[k] == i)
 234                         q = quant[k++];
 235                     coeff = get_bits(gb, width);
 236                     if (coeff) {
 237                         int v;
 238                         v = get_bits1(gb);
 239                         if (v)
 240                             coeffs[i] = -q * coeff;
 241                         else
 242                             coeffs[i] =  q * coeff;
 243                     } else {
 244                         coeffs[i] = 0.0f;
 245                     }
 246                     i++;
 247                 }
 248             }
 249         }
 250
 251         if (CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {
 252             coeffs[0] /= 0.5;
 253             s->tx_fn(s->tx, out[ch + ch_offset], coeffs, sizeof(float));
 254         } else if (CONFIG_BINKAUDIO_RDFT_DECODER) {
 255             for (int i = 2; i < s->frame_len; i += 2)
 256                 coeffs[i + 1] *= -1;
 257
 258             coeffs[s->frame_len + 0] = coeffs[1];
 259             coeffs[s->frame_len + 1] = coeffs[1] = 0;
 260             s->tx_fn(s->tx, out[ch + ch_offset], coeffs, sizeof(AVComplexFloat));
 261         }
 262     }
 263
 264     for (ch = 0; ch < channels; ch++) {
 265         int j;
 266         int count = s->overlap_len * channels;
 267         if (!s->first) {
 268             j = ch;
 269             for (i = 0; i < s->overlap_len; i++, j += channels)
 270                 out[ch + ch_offset][i] = (s->previous[ch + ch_offset][i] * (count - j) +
 271                                                   out[ch + ch_offset][i] *          j) / count;
 272         }
 273         memcpy(s->previous[ch + ch_offset], &out[ch + ch_offset][s->frame_len - s->overlap_len],
 274                s->overlap_len * sizeof(*s->previous[ch + ch_offset]));
 275     }
 276
 277     s->first = 0;
 278
 279     return 0;
 280 }
 281
 282 static av_cold int decode_end(AVCodecContext *avctx)
 283 {
 284     BinkAudioContext * s = avctx->priv_data;
 285     av_tx_uninit(&s->tx);
 286     return 0;
 287 }
 288
 289 static void get_bits_align32(GetBitContext *s)
 290 {
 291     int n = (-get_bits_count(s)) & 31;
 292     if (n) skip_bits(s, n);
 293 }
 294
 295 static int binkaudio_receive_frame(AVCodecContext *avctx, AVFrame *frame)
 296 {
 297     BinkAudioContext *s = avctx->priv_data;
 298     GetBitContext *gb = &s->gb;
 299     int new_pkt, ret;
 300
 301 again:
 302     new_pkt = !s->pkt->data;
 303     if (!s->pkt->data) {
 304         ret = ff_decode_get_packet(avctx, s->pkt);
 305         if (ret < 0) {
 306             s->ch_offset = 0;
 307             return ret;
 308         }
 309
 310         if (s->pkt->size < 4) {
 311             av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
 312             ret = AVERROR_INVALIDDATA;
 313             goto fail;
 314         }
 315
 316         ret = init_get_bits8(gb, s->pkt->data, s->pkt->size);
 317         if (ret < 0)
 318             goto fail;
 319
 320         /* skip reported size */
 321         skip_bits_long(gb, 32);
 322     }
 323
 324     /* get output buffer */
 325     if (s->ch_offset == 0) {
 326         frame->nb_samples = s->frame_len;
 327         if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 328             goto fail;
 329         if (!new_pkt)
 330             frame->pts = AV_NOPTS_VALUE;
 331     }
 332
 333     if (decode_block(s, (float **)frame->extended_data,
 334                      avctx->codec->id == AV_CODEC_ID_BINKAUDIO_DCT,
 335                      FFMIN(MAX_CHANNELS, s->channels - s->ch_offset), s->ch_offset)) {
 336         av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");
 337         ret = AVERROR_INVALIDDATA;
 338         goto fail;
 339     }
 340     s->ch_offset += MAX_CHANNELS;
 341     get_bits_align32(gb);
 342     if (!get_bits_left(gb)) {
 343         memset(gb, 0, sizeof(*gb));
 344         av_packet_unref(s->pkt);
 345     }
 346     if (s->ch_offset >= s->channels) {
 347         s->ch_offset = 0;
 348     } else {
 349         goto again;
 350     }
 351
 352     frame->nb_samples = s->block_size / FFMIN(avctx->ch_layout.nb_channels, MAX_CHANNELS);
 353
 354     return 0;
 355 fail:
 356     s->ch_offset = 0;
 357     av_packet_unref(s->pkt);
 358     return ret;
 359 }
 360
 361 static void decode_flush(AVCodecContext *avctx)
 362 {
 363     BinkAudioContext *const s = avctx->priv_data;
 364
 365     /* s->pkt coincides with avctx->internal->in_pkt
 366      * and is unreferenced generically when flushing. */
 367     s->first = 1;
 368     s->ch_offset = 0;
 369 }
 370
 371 const FFCodec ff_binkaudio_rdft_decoder = {
 372     .p.name         = "binkaudio_rdft",
 373     CODEC_LONG_NAME("Bink Audio (RDFT)"),
 374     .p.type         = AVMEDIA_TYPE_AUDIO,
 375     .p.id           = AV_CODEC_ID_BINKAUDIO_RDFT,
 376     .priv_data_size = sizeof(BinkAudioContext),
 377     .init           = decode_init,
 378     .flush          = decode_flush,
 379     .close          = decode_end,
 380     FF_CODEC_RECEIVE_FRAME_CB(binkaudio_receive_frame),
 381     .p.capabilities = AV_CODEC_CAP_DR1,
 382     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 383 };
 384
 385 const FFCodec ff_binkaudio_dct_decoder = {
 386     .p.name         = "binkaudio_dct",
 387     CODEC_LONG_NAME("Bink Audio (DCT)"),
 388     .p.type         = AVMEDIA_TYPE_AUDIO,
 389     .p.id           = AV_CODEC_ID_BINKAUDIO_DCT,
 390     .priv_data_size = sizeof(BinkAudioContext),
 391     .init           = decode_init,
 392     .flush          = decode_flush,
 393     .close          = decode_end,
 394     FF_CODEC_RECEIVE_FRAME_CB(binkaudio_receive_frame),
 395     .p.capabilities = AV_CODEC_CAP_DR1,
 396     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 397 };