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