Statistics
| Branch: | Revision:

ffmpeg / libavcodec / binkaudio.c @ 582ac86d

History | View | Annotate | Download (8.93 KB)

1
/*
2
 * Bink Audio decoder
3
 * Copyright (c) 2007-2010 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 "avcodec.h"
32
#define ALT_BITSTREAM_READER_LE
33
#include "get_bits.h"
34
#include "dsputil.h"
35
#include "fft.h"
36
#include "fmtconvert.h"
37

    
38
extern const uint16_t ff_wma_critical_freqs[25];
39

    
40
#define MAX_CHANNELS 2
41
#define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)
42

    
43
typedef struct {
44
    GetBitContext gb;
45
    DSPContext dsp;
46
    FmtConvertContext fmt_conv;
47
    int first;
48
    int channels;
49
    int frame_len;          ///< transform size (samples)
50
    int overlap_len;        ///< overlap size (samples)
51
    int block_size;
52
    int num_bands;
53
    unsigned int *bands;
54
    float root;
55
    DECLARE_ALIGNED(16, FFTSample, coeffs)[BINK_BLOCK_MAX_SIZE];
56
    DECLARE_ALIGNED(16, short, previous)[BINK_BLOCK_MAX_SIZE / 16];  ///< coeffs from previous audio block
57
    float *coeffs_ptr[MAX_CHANNELS]; ///< pointers to the coeffs arrays for float_to_int16_interleave
58
    union {
59
        RDFTContext rdft;
60
        DCTContext dct;
61
    } trans;
62
} BinkAudioContext;
63

    
64

    
65
static av_cold int decode_init(AVCodecContext *avctx)
66
{
67
    BinkAudioContext *s = avctx->priv_data;
68
    int sample_rate = avctx->sample_rate;
69
    int sample_rate_half;
70
    int i;
71
    int frame_len_bits;
72

    
73
    dsputil_init(&s->dsp, avctx);
74
    ff_fmt_convert_init(&s->fmt_conv, avctx);
75

    
76
    /* determine frame length */
77
    if (avctx->sample_rate < 22050) {
78
        frame_len_bits = 9;
79
    } else if (avctx->sample_rate < 44100) {
80
        frame_len_bits = 10;
81
    } else {
82
        frame_len_bits = 11;
83
    }
84
    s->frame_len = 1 << frame_len_bits;
85

    
86
    if (avctx->channels > MAX_CHANNELS) {
87
        av_log(avctx, AV_LOG_ERROR, "too many channels: %d\n", avctx->channels);
88
        return -1;
89
    }
90

    
91
    if (avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT) {
92
        // audio is already interleaved for the RDFT format variant
93
        sample_rate  *= avctx->channels;
94
        s->frame_len *= avctx->channels;
95
        s->channels = 1;
96
        if (avctx->channels == 2)
97
            frame_len_bits++;
98
    } else {
99
        s->channels = avctx->channels;
100
    }
101

    
102
    s->overlap_len   = s->frame_len / 16;
103
    s->block_size    = (s->frame_len - s->overlap_len) * s->channels;
104
    sample_rate_half = (sample_rate + 1) / 2;
105
    s->root          = 2.0 / sqrt(s->frame_len);
106

    
107
    /* calculate number of bands */
108
    for (s->num_bands = 1; s->num_bands < 25; s->num_bands++)
109
        if (sample_rate_half <= ff_wma_critical_freqs[s->num_bands - 1])
110
            break;
111

    
112
    s->bands = av_malloc((s->num_bands + 1) * sizeof(*s->bands));
113
    if (!s->bands)
114
        return AVERROR(ENOMEM);
115

    
116
    /* populate bands data */
117
    s->bands[0] = 2;
118
    for (i = 1; i < s->num_bands; i++)
119
        s->bands[i] = (ff_wma_critical_freqs[i - 1] * s->frame_len / sample_rate_half) & ~1;
120
    s->bands[s->num_bands] = s->frame_len;
121

    
122
    s->first = 1;
123
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
124

    
125
    for (i = 0; i < s->channels; i++)
126
        s->coeffs_ptr[i] = s->coeffs + i * s->frame_len;
127

    
128
    if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT)
129
        ff_rdft_init(&s->trans.rdft, frame_len_bits, DFT_C2R);
130
    else if (CONFIG_BINKAUDIO_DCT_DECODER)
131
        ff_dct_init(&s->trans.dct, frame_len_bits, DCT_III);
132
    else
133
        return -1;
134

    
135
    return 0;
136
}
137

    
138
static float get_float(GetBitContext *gb)
139
{
140
    int power = get_bits(gb, 5);
141
    float f = ldexpf(get_bits_long(gb, 23), power - 23);
142
    if (get_bits1(gb))
143
        f = -f;
144
    return f;
145
}
146

    
147
static const uint8_t rle_length_tab[16] = {
148
    2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64
149
};
150

    
151
/**
152
 * Decode Bink Audio block
153
 * @param[out] out Output buffer (must contain s->block_size elements)
154
 */
155
static void decode_block(BinkAudioContext *s, short *out, int use_dct)
156
{
157
    int ch, i, j, k;
158
    float q, quant[25];
159
    int width, coeff;
160
    GetBitContext *gb = &s->gb;
161

    
162
    if (use_dct)
163
        skip_bits(gb, 2);
164

    
165
    for (ch = 0; ch < s->channels; ch++) {
166
        FFTSample *coeffs = s->coeffs_ptr[ch];
167
        q = 0.0f;
168
        coeffs[0] = get_float(gb) * s->root;
169
        coeffs[1] = get_float(gb) * s->root;
170

    
171
        for (i = 0; i < s->num_bands; i++) {
172
            /* constant is result of 0.066399999/log10(M_E) */
173
            int value = get_bits(gb, 8);
174
            quant[i] = expf(FFMIN(value, 95) * 0.15289164787221953823f) * s->root;
175
        }
176

    
177
        // find band (k)
178
        for (k = 0; s->bands[k] < 1; k++) {
179
            q = quant[k];
180
        }
181

    
182
        // parse coefficients
183
        i = 2;
184
        while (i < s->frame_len) {
185
            if (get_bits1(gb)) {
186
                j = i + rle_length_tab[get_bits(gb, 4)] * 8;
187
            } else {
188
                j = i + 8;
189
            }
190

    
191
            j = FFMIN(j, s->frame_len);
192

    
193
            width = get_bits(gb, 4);
194
            if (width == 0) {
195
                memset(coeffs + i, 0, (j - i) * sizeof(*coeffs));
196
                i = j;
197
                while (s->bands[k] < i)
198
                    q = quant[k++];
199
            } else {
200
                while (i < j) {
201
                    if (s->bands[k] == i)
202
                        q = quant[k++];
203
                    coeff = get_bits(gb, width);
204
                    if (coeff) {
205
                        if (get_bits1(gb))
206
                            coeffs[i] = -q * coeff;
207
                        else
208
                            coeffs[i] =  q * coeff;
209
                    } else {
210
                        coeffs[i] = 0.0f;
211
                    }
212
                    i++;
213
                }
214
            }
215
        }
216

    
217
        if (CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {
218
            coeffs[0] /= 0.5;
219
            ff_dct_calc (&s->trans.dct,  coeffs);
220
            s->dsp.vector_fmul_scalar(coeffs, coeffs, s->frame_len / 2, s->frame_len);
221
        }
222
        else if (CONFIG_BINKAUDIO_RDFT_DECODER)
223
            ff_rdft_calc(&s->trans.rdft, coeffs);
224
    }
225

    
226
    s->fmt_conv.float_to_int16_interleave(out, (const float **)s->coeffs_ptr,
227
                                          s->frame_len, s->channels);
228

    
229
    if (!s->first) {
230
        int count = s->overlap_len * s->channels;
231
        int shift = av_log2(count);
232
        for (i = 0; i < count; i++) {
233
            out[i] = (s->previous[i] * (count - i) + out[i] * i) >> shift;
234
        }
235
    }
236

    
237
    memcpy(s->previous, out + s->block_size,
238
           s->overlap_len * s->channels * sizeof(*out));
239

    
240
    s->first = 0;
241
}
242

    
243
static av_cold int decode_end(AVCodecContext *avctx)
244
{
245
    BinkAudioContext * s = avctx->priv_data;
246
    av_freep(&s->bands);
247
    if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT)
248
        ff_rdft_end(&s->trans.rdft);
249
    else if (CONFIG_BINKAUDIO_DCT_DECODER)
250
        ff_dct_end(&s->trans.dct);
251
    return 0;
252
}
253

    
254
static void get_bits_align32(GetBitContext *s)
255
{
256
    int n = (-get_bits_count(s)) & 31;
257
    if (n) skip_bits(s, n);
258
}
259

    
260
static int decode_frame(AVCodecContext *avctx,
261
                        void *data, int *data_size,
262
                        AVPacket *avpkt)
263
{
264
    BinkAudioContext *s = avctx->priv_data;
265
    const uint8_t *buf  = avpkt->data;
266
    int buf_size        = avpkt->size;
267
    short *samples      = data;
268
    short *samples_end  = (short*)((uint8_t*)data + *data_size);
269
    int reported_size;
270
    GetBitContext *gb = &s->gb;
271

    
272
    init_get_bits(gb, buf, buf_size * 8);
273

    
274
    reported_size = get_bits_long(gb, 32);
275
    while (get_bits_count(gb) / 8 < buf_size &&
276
           samples + s->block_size <= samples_end) {
277
        decode_block(s, samples, avctx->codec->id == CODEC_ID_BINKAUDIO_DCT);
278
        samples += s->block_size;
279
        get_bits_align32(gb);
280
    }
281

    
282
    *data_size = FFMIN(reported_size, (uint8_t*)samples - (uint8_t*)data);
283
    return buf_size;
284
}
285

    
286
AVCodec ff_binkaudio_rdft_decoder = {
287
    "binkaudio_rdft",
288
    AVMEDIA_TYPE_AUDIO,
289
    CODEC_ID_BINKAUDIO_RDFT,
290
    sizeof(BinkAudioContext),
291
    decode_init,
292
    NULL,
293
    decode_end,
294
    decode_frame,
295
    .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")
296
};
297

    
298
AVCodec ff_binkaudio_dct_decoder = {
299
    "binkaudio_dct",
300
    AVMEDIA_TYPE_AUDIO,
301
    CODEC_ID_BINKAUDIO_DCT,
302
    sizeof(BinkAudioContext),
303
    decode_init,
304
    NULL,
305
    decode_end,
306
    decode_frame,
307
    .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)")
308
};