3 * Copyright (c) 2007-2011 Peter Ross (pross@xvid.org)
4 * Copyright (c) 2009 Daniel Verkamp (daniel@drv.nu)
6 * This file is part of Libav.
8 * Libav 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.
13 * Libav 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.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * Technical details here:
28 * http://wiki.multimedia.cx/index.php?title=Bink_Audio
31 #include "libavutil/channel_layout.h"
33 #define BITSTREAM_READER_LE
38 #include "fmtconvert.h"
40 #include "libavutil/intfloat.h"
42 extern const uint16_t ff_wma_critical_freqs
[25];
44 static float quant_table
[96];
46 #define MAX_CHANNELS 2
47 #define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)
52 int version_b
; ///< Bink version 'b'
55 int frame_len
; ///< transform size (samples)
56 int overlap_len
; ///< overlap size (samples)
61 DECLARE_ALIGNED(32, FFTSample
, coeffs
)[BINK_BLOCK_MAX_SIZE
];
62 float previous
[MAX_CHANNELS
][BINK_BLOCK_MAX_SIZE
/ 16]; ///< coeffs from previous audio block
63 uint8_t *packet_buffer
;
71 static av_cold
int decode_init(AVCodecContext
*avctx
)
73 BinkAudioContext
*s
= avctx
->priv_data
;
74 int sample_rate
= avctx
->sample_rate
;
79 /* determine frame length */
80 if (avctx
->sample_rate
< 22050) {
82 } else if (avctx
->sample_rate
< 44100) {
88 if (avctx
->channels
> MAX_CHANNELS
) {
89 av_log(avctx
, AV_LOG_ERROR
, "too many channels: %d\n", avctx
->channels
);
92 avctx
->channel_layout
= avctx
->channels
== 1 ? AV_CH_LAYOUT_MONO
:
95 s
->version_b
= avctx
->extradata
&& avctx
->extradata
[3] == 'b';
97 if (avctx
->codec
->id
== AV_CODEC_ID_BINKAUDIO_RDFT
) {
98 // audio is already interleaved for the RDFT format variant
99 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLT
;
100 sample_rate
*= avctx
->channels
;
103 frame_len_bits
+= av_log2(avctx
->channels
);
105 s
->channels
= avctx
->channels
;
106 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLTP
;
109 s
->frame_len
= 1 << frame_len_bits
;
110 s
->overlap_len
= s
->frame_len
/ 16;
111 s
->block_size
= (s
->frame_len
- s
->overlap_len
) * s
->channels
;
112 sample_rate_half
= (sample_rate
+ 1) / 2;
113 if (avctx
->codec
->id
== AV_CODEC_ID_BINKAUDIO_RDFT
)
114 s
->root
= 2.0 / (sqrt(s
->frame_len
) * 32768.0);
116 s
->root
= s
->frame_len
/ (sqrt(s
->frame_len
) * 32768.0);
117 for (i
= 0; i
< 96; i
++) {
118 /* constant is result of 0.066399999/log10(M_E) */
119 quant_table
[i
] = expf(i
* 0.15289164787221953823f
) * s
->root
;
122 /* calculate number of bands */
123 for (s
->num_bands
= 1; s
->num_bands
< 25; s
->num_bands
++)
124 if (sample_rate_half
<= ff_wma_critical_freqs
[s
->num_bands
- 1])
127 s
->bands
= av_malloc((s
->num_bands
+ 1) * sizeof(*s
->bands
));
129 return AVERROR(ENOMEM
);
131 /* populate bands data */
133 for (i
= 1; i
< s
->num_bands
; i
++)
134 s
->bands
[i
] = (ff_wma_critical_freqs
[i
- 1] * s
->frame_len
/ sample_rate_half
) & ~1;
135 s
->bands
[s
->num_bands
] = s
->frame_len
;
139 if (CONFIG_BINKAUDIO_RDFT_DECODER
&& avctx
->codec
->id
== AV_CODEC_ID_BINKAUDIO_RDFT
)
140 ff_rdft_init(&s
->trans
.rdft
, frame_len_bits
, DFT_C2R
);
141 else if (CONFIG_BINKAUDIO_DCT_DECODER
)
142 ff_dct_init(&s
->trans
.dct
, frame_len_bits
, DCT_III
);
146 avcodec_get_frame_defaults(&s
->frame
);
147 avctx
->coded_frame
= &s
->frame
;
152 static float get_float(GetBitContext
*gb
)
154 int power
= get_bits(gb
, 5);
155 float f
= ldexpf(get_bits_long(gb
, 23), power
- 23);
161 static const uint8_t rle_length_tab
[16] = {
162 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64
166 * Decode Bink Audio block
167 * @param[out] out Output buffer (must contain s->block_size elements)
168 * @return 0 on success, negative error code on failure
170 static int decode_block(BinkAudioContext
*s
, float **out
, int use_dct
)
175 GetBitContext
*gb
= &s
->gb
;
180 for (ch
= 0; ch
< s
->channels
; ch
++) {
181 FFTSample
*coeffs
= out
[ch
];
184 if (get_bits_left(gb
) < 64)
185 return AVERROR_INVALIDDATA
;
186 coeffs
[0] = av_int2float(get_bits_long(gb
, 32)) * s
->root
;
187 coeffs
[1] = av_int2float(get_bits_long(gb
, 32)) * s
->root
;
189 if (get_bits_left(gb
) < 58)
190 return AVERROR_INVALIDDATA
;
191 coeffs
[0] = get_float(gb
) * s
->root
;
192 coeffs
[1] = get_float(gb
) * s
->root
;
195 if (get_bits_left(gb
) < s
->num_bands
* 8)
196 return AVERROR_INVALIDDATA
;
197 for (i
= 0; i
< s
->num_bands
; i
++) {
198 int value
= get_bits(gb
, 8);
199 quant
[i
] = quant_table
[FFMIN(value
, 95)];
205 // parse coefficients
207 while (i
< s
->frame_len
) {
211 int v
= get_bits1(gb
);
214 j
= i
+ rle_length_tab
[v
] * 8;
220 j
= FFMIN(j
, s
->frame_len
);
222 width
= get_bits(gb
, 4);
224 memset(coeffs
+ i
, 0, (j
- i
) * sizeof(*coeffs
));
226 while (s
->bands
[k
] < i
)
230 if (s
->bands
[k
] == i
)
232 coeff
= get_bits(gb
, width
);
237 coeffs
[i
] = -q
* coeff
;
239 coeffs
[i
] = q
* coeff
;
248 if (CONFIG_BINKAUDIO_DCT_DECODER
&& use_dct
) {
250 s
->trans
.dct
.dct_calc(&s
->trans
.dct
, coeffs
);
252 else if (CONFIG_BINKAUDIO_RDFT_DECODER
)
253 s
->trans
.rdft
.rdft_calc(&s
->trans
.rdft
, coeffs
);
256 for (ch
= 0; ch
< s
->channels
; ch
++) {
258 int count
= s
->overlap_len
* s
->channels
;
261 for (i
= 0; i
< s
->overlap_len
; i
++, j
+= s
->channels
)
262 out
[ch
][i
] = (s
->previous
[ch
][i
] * (count
- j
) +
263 out
[ch
][i
] * j
) / count
;
265 memcpy(s
->previous
[ch
], &out
[ch
][s
->frame_len
- s
->overlap_len
],
266 s
->overlap_len
* sizeof(*s
->previous
[ch
]));
274 static av_cold
int decode_end(AVCodecContext
*avctx
)
276 BinkAudioContext
* s
= avctx
->priv_data
;
278 av_freep(&s
->packet_buffer
);
279 if (CONFIG_BINKAUDIO_RDFT_DECODER
&& avctx
->codec
->id
== AV_CODEC_ID_BINKAUDIO_RDFT
)
280 ff_rdft_end(&s
->trans
.rdft
);
281 else if (CONFIG_BINKAUDIO_DCT_DECODER
)
282 ff_dct_end(&s
->trans
.dct
);
287 static void get_bits_align32(GetBitContext
*s
)
289 int n
= (-get_bits_count(s
)) & 31;
290 if (n
) skip_bits(s
, n
);
293 static int decode_frame(AVCodecContext
*avctx
, void *data
,
294 int *got_frame_ptr
, AVPacket
*avpkt
)
296 BinkAudioContext
*s
= avctx
->priv_data
;
297 GetBitContext
*gb
= &s
->gb
;
298 int ret
, consumed
= 0;
300 if (!get_bits_left(gb
)) {
302 /* handle end-of-stream */
307 if (avpkt
->size
< 4) {
308 av_log(avctx
, AV_LOG_ERROR
, "Packet is too small\n");
309 return AVERROR_INVALIDDATA
;
311 buf
= av_realloc(s
->packet_buffer
, avpkt
->size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
313 return AVERROR(ENOMEM
);
314 s
->packet_buffer
= buf
;
315 memcpy(s
->packet_buffer
, avpkt
->data
, avpkt
->size
);
316 init_get_bits(gb
, s
->packet_buffer
, avpkt
->size
* 8);
317 consumed
= avpkt
->size
;
319 /* skip reported size */
320 skip_bits_long(gb
, 32);
323 /* get output buffer */
324 s
->frame
.nb_samples
= s
->frame_len
;
325 if ((ret
= ff_get_buffer(avctx
, &s
->frame
)) < 0) {
326 av_log(avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
330 if (decode_block(s
, (float **)s
->frame
.extended_data
,
331 avctx
->codec
->id
== AV_CODEC_ID_BINKAUDIO_DCT
)) {
332 av_log(avctx
, AV_LOG_ERROR
, "Incomplete packet\n");
333 return AVERROR_INVALIDDATA
;
335 get_bits_align32(gb
);
337 s
->frame
.nb_samples
= s
->block_size
/ avctx
->channels
;
339 *(AVFrame
*)data
= s
->frame
;
344 AVCodec ff_binkaudio_rdft_decoder
= {
345 .name
= "binkaudio_rdft",
346 .type
= AVMEDIA_TYPE_AUDIO
,
347 .id
= AV_CODEC_ID_BINKAUDIO_RDFT
,
348 .priv_data_size
= sizeof(BinkAudioContext
),
351 .decode
= decode_frame
,
352 .capabilities
= CODEC_CAP_DELAY
| CODEC_CAP_DR1
,
353 .long_name
= NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")
356 AVCodec ff_binkaudio_dct_decoder
= {
357 .name
= "binkaudio_dct",
358 .type
= AVMEDIA_TYPE_AUDIO
,
359 .id
= AV_CODEC_ID_BINKAUDIO_DCT
,
360 .priv_data_size
= sizeof(BinkAudioContext
),
363 .decode
= decode_frame
,
364 .capabilities
= CODEC_CAP_DELAY
| CODEC_CAP_DR1
,
365 .long_name
= NULL_IF_CONFIG_SMALL("Bink Audio (DCT)")