FFmpeg
binkaudio.c
Go to the documentation of this file.
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 
32 #include "libavutil/intfloat.h"
33 #include "libavutil/mem_internal.h"
34 
35 #define BITSTREAM_READER_LE
36 #include "avcodec.h"
37 #include "dct.h"
38 #include "decode.h"
39 #include "get_bits.h"
40 #include "internal.h"
41 #include "rdft.h"
42 #include "wma_freqs.h"
43 
44 #define MAX_CHANNELS 2
45 #define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)
46 
47 typedef struct BinkAudioContext {
49  int version_b; ///< Bink version 'b'
50  int first;
51  int channels;
52  int frame_len; ///< transform size (samples)
53  int overlap_len; ///< overlap size (samples)
55  int num_bands;
56  float root;
57  unsigned int bands[26];
58  float previous[MAX_CHANNELS][BINK_BLOCK_MAX_SIZE / 16]; ///< coeffs from previous audio block
59  float quant_table[96];
61  union {
64  } trans;
66 
67 
69 {
70  BinkAudioContext *s = avctx->priv_data;
71  int sample_rate = avctx->sample_rate;
72  int sample_rate_half;
73  int i, ret;
74  int frame_len_bits;
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 
85  if (avctx->channels < 1 || avctx->channels > MAX_CHANNELS) {
86  av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n", avctx->channels);
87  return AVERROR_INVALIDDATA;
88  }
89  avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
91 
92  s->version_b = avctx->extradata_size >= 4 && avctx->extradata[3] == 'b';
93 
94  if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT) {
95  // audio is already interleaved for the RDFT format variant
97  if (sample_rate > INT_MAX / avctx->channels)
98  return AVERROR_INVALIDDATA;
99  sample_rate *= avctx->channels;
100  s->channels = 1;
101  if (!s->version_b)
102  frame_len_bits += av_log2(avctx->channels);
103  } else {
104  s->channels = avctx->channels;
106  }
107 
108  s->frame_len = 1 << frame_len_bits;
109  s->overlap_len = s->frame_len / 16;
110  s->block_size = (s->frame_len - s->overlap_len) * s->channels;
111  sample_rate_half = (sample_rate + 1LL) / 2;
112  if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
113  s->root = 2.0 / (sqrt(s->frame_len) * 32768.0);
114  else
115  s->root = s->frame_len / (sqrt(s->frame_len) * 32768.0);
116  for (i = 0; i < 96; i++) {
117  /* constant is result of 0.066399999/log10(M_E) */
118  s->quant_table[i] = expf(i * 0.15289164787221953823f) * s->root;
119  }
120 
121  /* calculate number of bands */
122  for (s->num_bands = 1; s->num_bands < 25; s->num_bands++)
123  if (sample_rate_half <= ff_wma_critical_freqs[s->num_bands - 1])
124  break;
125 
126  /* populate bands data */
127  s->bands[0] = 2;
128  for (i = 1; i < s->num_bands; i++)
129  s->bands[i] = (ff_wma_critical_freqs[i - 1] * s->frame_len / sample_rate_half) & ~1;
130  s->bands[s->num_bands] = s->frame_len;
131 
132  s->first = 1;
133 
134  if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
135  ret = ff_rdft_init(&s->trans.rdft, frame_len_bits, DFT_C2R);
136  else if (CONFIG_BINKAUDIO_DCT_DECODER)
137  ret = ff_dct_init(&s->trans.dct, frame_len_bits, DCT_III);
138  else
139  av_assert0(0);
140  if (ret < 0)
141  return ret;
142 
143  s->pkt = avctx->internal->in_pkt;
144 
145  return 0;
146 }
147 
148 static float get_float(GetBitContext *gb)
149 {
150  int power = get_bits(gb, 5);
151  float f = ldexpf(get_bits(gb, 23), power - 23);
152  if (get_bits1(gb))
153  f = -f;
154  return f;
155 }
156 
157 static const uint8_t rle_length_tab[16] = {
158  2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64
159 };
160 
161 /**
162  * Decode Bink Audio block
163  * @param[out] out Output buffer (must contain s->block_size elements)
164  * @return 0 on success, negative error code on failure
165  */
166 static int decode_block(BinkAudioContext *s, float **out, int use_dct)
167 {
168  int ch, i, j, k;
169  float q, quant[25];
170  int width, coeff;
171  GetBitContext *gb = &s->gb;
172 
173  if (use_dct)
174  skip_bits(gb, 2);
175 
176  for (ch = 0; ch < s->channels; ch++) {
177  FFTSample *coeffs = out[ch];
178 
179  if (s->version_b) {
180  if (get_bits_left(gb) < 64)
181  return AVERROR_INVALIDDATA;
182  coeffs[0] = av_int2float(get_bits_long(gb, 32)) * s->root;
183  coeffs[1] = av_int2float(get_bits_long(gb, 32)) * s->root;
184  } else {
185  if (get_bits_left(gb) < 58)
186  return AVERROR_INVALIDDATA;
187  coeffs[0] = get_float(gb) * s->root;
188  coeffs[1] = get_float(gb) * s->root;
189  }
190 
191  if (get_bits_left(gb) < s->num_bands * 8)
192  return AVERROR_INVALIDDATA;
193  for (i = 0; i < s->num_bands; i++) {
194  int value = get_bits(gb, 8);
195  quant[i] = s->quant_table[FFMIN(value, 95)];
196  }
197 
198  k = 0;
199  q = quant[0];
200 
201  // parse coefficients
202  i = 2;
203  while (i < s->frame_len) {
204  if (s->version_b) {
205  j = i + 16;
206  } else {
207  int v = get_bits1(gb);
208  if (v) {
209  v = get_bits(gb, 4);
210  j = i + rle_length_tab[v] * 8;
211  } else {
212  j = i + 8;
213  }
214  }
215 
216  j = FFMIN(j, s->frame_len);
217 
218  width = get_bits(gb, 4);
219  if (width == 0) {
220  memset(coeffs + i, 0, (j - i) * sizeof(*coeffs));
221  i = j;
222  while (s->bands[k] < i)
223  q = quant[k++];
224  } else {
225  while (i < j) {
226  if (s->bands[k] == i)
227  q = quant[k++];
228  coeff = get_bits(gb, width);
229  if (coeff) {
230  int v;
231  v = get_bits1(gb);
232  if (v)
233  coeffs[i] = -q * coeff;
234  else
235  coeffs[i] = q * coeff;
236  } else {
237  coeffs[i] = 0.0f;
238  }
239  i++;
240  }
241  }
242  }
243 
244  if (CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {
245  coeffs[0] /= 0.5;
246  s->trans.dct.dct_calc(&s->trans.dct, coeffs);
247  }
248  else if (CONFIG_BINKAUDIO_RDFT_DECODER)
249  s->trans.rdft.rdft_calc(&s->trans.rdft, coeffs);
250  }
251 
252  for (ch = 0; ch < s->channels; ch++) {
253  int j;
254  int count = s->overlap_len * s->channels;
255  if (!s->first) {
256  j = ch;
257  for (i = 0; i < s->overlap_len; i++, j += s->channels)
258  out[ch][i] = (s->previous[ch][i] * (count - j) +
259  out[ch][i] * j) / count;
260  }
261  memcpy(s->previous[ch], &out[ch][s->frame_len - s->overlap_len],
262  s->overlap_len * sizeof(*s->previous[ch]));
263  }
264 
265  s->first = 0;
266 
267  return 0;
268 }
269 
271 {
272  BinkAudioContext * s = avctx->priv_data;
273  if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
274  ff_rdft_end(&s->trans.rdft);
275  else if (CONFIG_BINKAUDIO_DCT_DECODER)
276  ff_dct_end(&s->trans.dct);
277 
278  return 0;
279 }
280 
282 {
283  int n = (-get_bits_count(s)) & 31;
284  if (n) skip_bits(s, n);
285 }
286 
288 {
289  BinkAudioContext *s = avctx->priv_data;
290  GetBitContext *gb = &s->gb;
291  int ret;
292 
293  if (!s->pkt->data) {
294  ret = ff_decode_get_packet(avctx, s->pkt);
295  if (ret < 0)
296  return ret;
297 
298  if (s->pkt->size < 4) {
299  av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
301  goto fail;
302  }
303 
304  ret = init_get_bits8(gb, s->pkt->data, s->pkt->size);
305  if (ret < 0)
306  goto fail;
307 
308  /* skip reported size */
309  skip_bits_long(gb, 32);
310  }
311 
312  /* get output buffer */
313  frame->nb_samples = s->frame_len;
314  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
315  return ret;
316 
317  if (decode_block(s, (float **)frame->extended_data,
318  avctx->codec->id == AV_CODEC_ID_BINKAUDIO_DCT)) {
319  av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");
320  return AVERROR_INVALIDDATA;
321  }
322  get_bits_align32(gb);
323  if (!get_bits_left(gb)) {
324  memset(gb, 0, sizeof(*gb));
325  av_packet_unref(s->pkt);
326  }
327 
328  frame->nb_samples = s->block_size / avctx->channels;
329 
330  return 0;
331 fail:
332  av_packet_unref(s->pkt);
333  return ret;
334 }
335 
336 static void decode_flush(AVCodecContext *avctx)
337 {
338  BinkAudioContext *const s = avctx->priv_data;
339 
340  /* s->pkt coincides with avctx->internal->in_pkt
341  * and is unreferenced generically when flushing. */
342  s->first = 1;
343 }
344 
346  .name = "binkaudio_rdft",
347  .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)"),
348  .type = AVMEDIA_TYPE_AUDIO,
350  .priv_data_size = sizeof(BinkAudioContext),
351  .init = decode_init,
352  .flush = decode_flush,
353  .close = decode_end,
355  .capabilities = AV_CODEC_CAP_DR1,
357 };
358 
360  .name = "binkaudio_dct",
361  .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)"),
362  .type = AVMEDIA_TYPE_AUDIO,
364  .priv_data_size = sizeof(BinkAudioContext),
365  .init = decode_init,
366  .flush = decode_flush,
367  .close = decode_end,
369  .capabilities = AV_CODEC_CAP_DR1,
371 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:417
AVCodec
AVCodec.
Definition: codec.h:202
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:292
ff_decode_get_packet
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:224
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
BinkAudioContext::first
int first
Definition: binkaudio.c:50
BinkAudioContext::version_b
int version_b
Bink version 'b'.
Definition: binkaudio.c:49
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1043
mem_internal.h
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:992
wma_freqs.h
BinkAudioContext::channels
int channels
Definition: binkaudio.c:51
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
rdft.h
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:547
get_float
static float get_float(GetBitContext *gb)
Definition: binkaudio.c:148
BINK_BLOCK_MAX_SIZE
#define BINK_BLOCK_MAX_SIZE
Definition: binkaudio.c:45
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
DFT_C2R
@ DFT_C2R
Definition: avfft.h:75
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:310
internal.h
BinkAudioContext::trans
union BinkAudioContext::@23 trans
expf
#define expf(x)
Definition: libm.h:283
intfloat.h
sample_rate
sample_rate
Definition: ffmpeg_filter.c:156
BinkAudioContext::gb
GetBitContext gb
Definition: binkaudio.c:48
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
DCT_III
@ DCT_III
Definition: avfft.h:95
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:392
fail
#define fail()
Definition: checkasm.h:127
av_int2float
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
GetBitContext
Definition: get_bits.h:62
ff_rdft_end
av_cold void ff_rdft_end(RDFTContext *s)
Definition: rdft.c:114
ff_binkaudio_rdft_decoder
const AVCodec ff_binkaudio_rdft_decoder
Definition: binkaudio.c:345
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
quant
static int quant(float coef, const float Q, const float rounding)
Quantize one coefficient.
Definition: aacenc_utils.h:59
BinkAudioContext
Definition: binkaudio.c:47
BinkAudioContext::quant_table
float quant_table[96]
Definition: binkaudio.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
dct.h
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:485
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: binkaudio.c:270
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
binkaudio_receive_frame
static int binkaudio_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: binkaudio.c:287
AV_CODEC_ID_BINKAUDIO_DCT
@ AV_CODEC_ID_BINKAUDIO_DCT
Definition: codec_id.h:471
decode.h
get_bits.h
ff_wma_critical_freqs
const uint16_t ff_wma_critical_freqs[25]
Definition: wma_freqs.c:23
f
#define f(width, name)
Definition: cbs_vp9.c:255
ldexpf
#define ldexpf(x, exp)
Definition: libm.h:389
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
BinkAudioContext::overlap_len
int overlap_len
overlap size (samples)
Definition: binkaudio.c:53
BinkAudioContext::previous
float previous[MAX_CHANNELS][BINK_BLOCK_MAX_SIZE/16]
coeffs from previous audio block
Definition: binkaudio.c:58
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:418
receive_frame
static CopyRet receive_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame)
Definition: crystalhd.c:559
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
FFTSample
float FFTSample
Definition: avfft.h:35
BinkAudioContext::pkt
AVPacket * pkt
Definition: binkaudio.c:60
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1651
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
BinkAudioContext::root
float root
Definition: binkaudio.c:56
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1000
rle_length_tab
static const uint8_t rle_length_tab[16]
Definition: binkaudio.c:157
BinkAudioContext::frame_len
int frame_len
transform size (samples)
Definition: binkaudio.c:52
ff_dct_end
av_cold void ff_dct_end(DCTContext *s)
Definition: dct.c:221
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: binkaudio.c:68
AVCodec::id
enum AVCodecID id
Definition: codec.h:216
ff_rdft_init
av_cold int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans)
Set up a real FFT.
Definition: rdft.c:88
BinkAudioContext::rdft
RDFTContext rdft
Definition: binkaudio.c:62
ff_dct_init
av_cold int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType inverse)
Set up DCT.
Definition: dct.c:177
decode_block
static int decode_block(BinkAudioContext *s, float **out, int use_dct)
Decode Bink Audio block.
Definition: binkaudio.c:166
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:484
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:50
get_bits_align32
static void get_bits_align32(GetBitContext *s)
Definition: binkaudio.c:281
RDFTContext
Definition: rdft.h:28
AVCodecInternal::in_pkt
AVPacket * in_pkt
This packet is used to hold the packet given to decoders implementing the .decode API; it is unused b...
Definition: internal.h:144
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
DCTContext
Definition: dct.h:32
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
BinkAudioContext::dct
DCTContext dct
Definition: binkaudio.c:63
AVCodecContext
main external API structure.
Definition: avcodec.h:383
power
static float power(float r, float g, float b, float max)
Definition: preserve_color.h:45
channel_layout.h
ff_binkaudio_dct_decoder
const AVCodec ff_binkaudio_dct_decoder
Definition: binkaudio.c:359
BinkAudioContext::num_bands
int num_bands
Definition: binkaudio.c:55
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVPacket
This structure stores compressed data.
Definition: packet.h:350
BinkAudioContext::block_size
int block_size
Definition: binkaudio.c:54
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
decode_flush
static void decode_flush(AVCodecContext *avctx)
Definition: binkaudio.c:336
AV_CODEC_ID_BINKAUDIO_RDFT
@ AV_CODEC_ID_BINKAUDIO_RDFT
Definition: codec_id.h:470
MAX_CHANNELS
#define MAX_CHANNELS
Definition: binkaudio.c:44
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
BinkAudioContext::bands
unsigned int bands[26]
Definition: binkaudio.c:57