FFmpeg
Main Page
Related Pages
Modules
Data Structures
Files
Examples
File List
Globals
All
Data Structures
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
libavcodec
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
31
#include "
libavutil/channel_layout.h
"
32
#include "
avcodec.h
"
33
#define BITSTREAM_READER_LE
34
#include "
get_bits.h
"
35
#include "
dsputil.h
"
36
#include "
dct.h
"
37
#include "
rdft.h
"
38
#include "
fmtconvert.h
"
39
#include "
internal.h
"
40
#include "
libavutil/intfloat.h
"
41
42
extern
const
uint16_t
ff_wma_critical_freqs
[25];
43
44
static
float
quant_table
[96];
45
46
#define MAX_CHANNELS 2
47
#define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)
48
49
typedef
struct
{
50
AVFrame
frame
;
51
GetBitContext
gb
;
52
int
version_b
;
///< Bink version 'b'
53
int
first
;
54
int
channels
;
55
int
frame_len
;
///< transform size (samples)
56
int
overlap_len
;
///< overlap size (samples)
57
int
block_size
;
58
int
num_bands
;
59
unsigned
int
*
bands
;
60
float
root
;
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
;
64
union
{
65
RDFTContext
rdft
;
66
DCTContext
dct
;
67
} trans;
68
}
BinkAudioContext
;
69
70
71
static
av_cold
int
decode_init
(
AVCodecContext
*avctx)
72
{
73
BinkAudioContext
*s = avctx->
priv_data
;
74
int
sample_rate
= avctx->
sample_rate
;
75
int
sample_rate_half;
76
int
i;
77
int
frame_len_bits;
78
79
/* determine frame length */
80
if
(avctx->
sample_rate
< 22050) {
81
frame_len_bits = 9;
82
}
else
if
(avctx->
sample_rate
< 44100) {
83
frame_len_bits = 10;
84
}
else
{
85
frame_len_bits = 11;
86
}
87
88
if
(avctx->
channels
< 1 || avctx->
channels
>
MAX_CHANNELS
) {
89
av_log
(avctx,
AV_LOG_ERROR
,
"invalid number of channels: %d\n"
, avctx->
channels
);
90
return
AVERROR_INVALIDDATA
;
91
}
92
avctx->
channel_layout
= avctx->
channels
== 1 ?
AV_CH_LAYOUT_MONO
:
93
AV_CH_LAYOUT_STEREO
;
94
95
s->
version_b
= avctx->
extradata_size
>= 4 && avctx->
extradata
[3] ==
'b'
;
96
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
;
101
s->
channels
= 1;
102
if
(!s->
version_b
)
103
frame_len_bits +=
av_log2
(avctx->
channels
);
104
}
else
{
105
s->
channels
= avctx->
channels
;
106
avctx->
sample_fmt
=
AV_SAMPLE_FMT_FLTP
;
107
}
108
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);
115
else
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
;
120
}
121
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])
125
break
;
126
127
s->
bands
=
av_malloc
((s->
num_bands
+ 1) *
sizeof
(*s->
bands
));
128
if
(!s->
bands
)
129
return
AVERROR
(ENOMEM);
130
131
/* populate bands data */
132
s->
bands
[0] = 2;
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
;
136
137
s->
first
= 1;
138
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
);
143
else
144
return
-1;
145
146
avcodec_get_frame_defaults
(&s->
frame
);
147
avctx->
coded_frame
= &s->
frame
;
148
149
return
0;
150
}
151
152
static
float
get_float
(
GetBitContext
*gb)
153
{
154
int
power =
get_bits
(gb, 5);
155
float
f =
ldexpf
(
get_bits_long
(gb, 23), power - 23);
156
if
(
get_bits1
(gb))
157
f = -f;
158
return
f;
159
}
160
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
163
};
164
165
/**
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
169
*/
170
static
int
decode_block
(
BinkAudioContext
*s,
float
**out,
int
use_dct)
171
{
172
int
ch, i, j, k;
173
float
q,
quant
[25];
174
int
width
,
coeff
;
175
GetBitContext
*gb = &s->
gb
;
176
177
if
(use_dct)
178
skip_bits
(gb, 2);
179
180
for
(ch = 0; ch < s->
channels
; ch++) {
181
FFTSample
*
coeffs
= out[ch];
182
183
if
(s->
version_b
) {
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
;
188
}
else
{
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
;
193
}
194
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)];
200
}
201
202
k = 0;
203
q = quant[0];
204
205
// parse coefficients
206
i = 2;
207
while
(i < s->frame_len) {
208
if
(s->
version_b
) {
209
j = i + 16;
210
}
else
{
211
int
v =
get_bits1
(gb);
212
if
(v) {
213
v =
get_bits
(gb, 4);
214
j = i +
rle_length_tab
[v] * 8;
215
}
else
{
216
j = i + 8;
217
}
218
}
219
220
j =
FFMIN
(j, s->
frame_len
);
221
222
width =
get_bits
(gb, 4);
223
if
(width == 0) {
224
memset(coeffs + i, 0, (j - i) *
sizeof
(*coeffs));
225
i = j;
226
while
(s->
bands
[k] < i)
227
q = quant[k++];
228
}
else
{
229
while
(i < j) {
230
if
(s->
bands
[k] == i)
231
q = quant[k++];
232
coeff =
get_bits
(gb, width);
233
if
(coeff) {
234
int
v;
235
v =
get_bits1
(gb);
236
if
(v)
237
coeffs[i] = -q *
coeff
;
238
else
239
coeffs[i] = q *
coeff
;
240
}
else
{
241
coeffs[i] = 0.0f;
242
}
243
i++;
244
}
245
}
246
}
247
248
if
(CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {
249
coeffs[0] /= 0.5;
250
s->
trans
.
dct
.
dct_calc
(&s->
trans
.
dct
, coeffs);
251
}
252
else
if
(CONFIG_BINKAUDIO_RDFT_DECODER)
253
s->
trans
.
rdft
.
rdft_calc
(&s->
trans
.
rdft
, coeffs);
254
}
255
256
for
(ch = 0; ch < s->
channels
; ch++) {
257
int
j;
258
int
count = s->
overlap_len
* s->
channels
;
259
if
(!s->
first
) {
260
j = ch;
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;
264
}
265
memcpy(s->
previous
[ch], &out[ch][s->
frame_len
- s->
overlap_len
],
266
s->
overlap_len
*
sizeof
(*s->
previous
[ch]));
267
}
268
269
s->
first
= 0;
270
271
return
0;
272
}
273
274
static
av_cold
int
decode_end
(
AVCodecContext
*avctx)
275
{
276
BinkAudioContext
* s = avctx->
priv_data
;
277
av_freep
(&s->
bands
);
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
);
283
284
return
0;
285
}
286
287
static
void
get_bits_align32
(
GetBitContext
*s)
288
{
289
int
n = (-
get_bits_count
(s)) & 31;
290
if
(n)
skip_bits
(s, n);
291
}
292
293
static
int
decode_frame
(
AVCodecContext
*avctx,
void
*
data
,
294
int
*got_frame_ptr,
AVPacket
*avpkt)
295
{
296
BinkAudioContext
*s = avctx->
priv_data
;
297
GetBitContext
*gb = &s->
gb
;
298
int
ret, consumed = 0;
299
300
if
(!
get_bits_left
(gb)) {
301
uint8_t
*buf;
302
/* handle end-of-stream */
303
if
(!avpkt->
size
) {
304
*got_frame_ptr = 0;
305
return
0;
306
}
307
if
(avpkt->
size
< 4) {
308
av_log
(avctx,
AV_LOG_ERROR
,
"Packet is too small\n"
);
309
return
AVERROR_INVALIDDATA
;
310
}
311
buf =
av_realloc
(s->
packet_buffer
, avpkt->
size
+
FF_INPUT_BUFFER_PADDING_SIZE
);
312
if
(!buf)
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
;
318
319
/* skip reported size */
320
skip_bits_long
(gb, 32);
321
}
322
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"
);
327
return
ret;
328
}
329
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
;
334
}
335
get_bits_align32
(gb);
336
337
s->
frame
.
nb_samples
= s->
block_size
/ avctx->
channels
;
338
*got_frame_ptr = 1;
339
*(
AVFrame
*)data = s->
frame
;
340
341
return
consumed;
342
}
343
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
),
349
.
init
=
decode_init
,
350
.
close
=
decode_end
,
351
.
decode
=
decode_frame
,
352
.capabilities =
CODEC_CAP_DELAY
|
CODEC_CAP_DR1
,
353
.long_name =
NULL_IF_CONFIG_SMALL
(
"Bink Audio (RDFT)"
)
354
};
355
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
),
361
.
init
=
decode_init
,
362
.
close
=
decode_end
,
363
.
decode
=
decode_frame
,
364
.capabilities =
CODEC_CAP_DELAY
|
CODEC_CAP_DR1
,
365
.long_name =
NULL_IF_CONFIG_SMALL
(
"Bink Audio (DCT)"
)
366
};
Generated on Sat May 25 2013 03:58:32 for FFmpeg by
1.8.2