FFmpeg
Main Page
Related Pages
Modules
Namespaces
Data Structures
Files
Examples
File List
Globals
•
All
Data Structures
Namespaces
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 "
dct.h
"
36
#include "
rdft.h
"
37
#include "
fmtconvert.h
"
38
#include "
internal.h
"
39
#include "
libavutil/intfloat.h
"
40
41
extern
const
uint16_t
ff_wma_critical_freqs
[25];
42
43
static
float
quant_table
[96];
44
45
#define MAX_CHANNELS 2
46
#define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)
47
48
typedef
struct
{
49
GetBitContext
gb
;
50
int
version_b
;
///< Bink version 'b'
51
int
first
;
52
int
channels
;
53
int
frame_len
;
///< transform size (samples)
54
int
overlap_len
;
///< overlap size (samples)
55
int
block_size
;
56
int
num_bands
;
57
unsigned
int
*
bands
;
58
float
root
;
59
DECLARE_ALIGNED
(32,
FFTSample
,
coeffs
)[
BINK_BLOCK_MAX_SIZE
];
60
float
previous[
MAX_CHANNELS
][
BINK_BLOCK_MAX_SIZE
/ 16];
///< coeffs from previous audio block
61
uint8_t
*
packet_buffer
;
62
union
{
63
RDFTContext
rdft
;
64
DCTContext
dct
;
65
} trans;
66
}
BinkAudioContext
;
67
68
69
static
av_cold
int
decode_init
(
AVCodecContext
*avctx)
70
{
71
BinkAudioContext
*
s
= avctx->
priv_data
;
72
int
sample_rate
= avctx->
sample_rate
;
73
int
sample_rate_half;
74
int
i;
75
int
frame_len_bits;
76
77
/* determine frame length */
78
if
(avctx->
sample_rate
< 22050) {
79
frame_len_bits = 9;
80
}
else
if
(avctx->
sample_rate
< 44100) {
81
frame_len_bits = 10;
82
}
else
{
83
frame_len_bits = 11;
84
}
85
86
if
(avctx->
channels
< 1 || avctx->
channels
>
MAX_CHANNELS
) {
87
av_log
(avctx,
AV_LOG_ERROR
,
"invalid number of channels: %d\n"
, avctx->
channels
);
88
return
AVERROR_INVALIDDATA
;
89
}
90
avctx->
channel_layout
= avctx->
channels
== 1 ?
AV_CH_LAYOUT_MONO
:
91
AV_CH_LAYOUT_STEREO
;
92
93
s->
version_b
= avctx->
extradata_size
>= 4 && avctx->
extradata
[3] ==
'b'
;
94
95
if
(avctx->
codec
->
id
==
AV_CODEC_ID_BINKAUDIO_RDFT
) {
96
// audio is already interleaved for the RDFT format variant
97
avctx->
sample_fmt
=
AV_SAMPLE_FMT_FLT
;
98
sample_rate *= avctx->
channels
;
99
s->
channels
= 1;
100
if
(!s->
version_b
)
101
frame_len_bits +=
av_log2
(avctx->
channels
);
102
}
else
{
103
s->
channels
= avctx->
channels
;
104
avctx->
sample_fmt
=
AV_SAMPLE_FMT_FLTP
;
105
}
106
107
s->
frame_len
= 1 << frame_len_bits;
108
s->
overlap_len
= s->
frame_len
/ 16;
109
s->
block_size
= (s->
frame_len
- s->
overlap_len
) * s->
channels
;
110
sample_rate_half = (sample_rate + 1) / 2;
111
if
(avctx->
codec
->
id
==
AV_CODEC_ID_BINKAUDIO_RDFT
)
112
s->
root
= 2.0 / (sqrt(s->
frame_len
) * 32768.0);
113
else
114
s->
root
= s->
frame_len
/ (sqrt(s->
frame_len
) * 32768.0);
115
for
(i = 0; i < 96; i++) {
116
/* constant is result of 0.066399999/log10(M_E) */
117
quant_table
[i] =
expf
(i * 0.15289164787221953823f) * s->
root
;
118
}
119
120
/* calculate number of bands */
121
for
(s->
num_bands
= 1; s->
num_bands
< 25; s->
num_bands
++)
122
if
(sample_rate_half <=
ff_wma_critical_freqs
[s->
num_bands
- 1])
123
break
;
124
125
s->
bands
=
av_malloc
((s->
num_bands
+ 1) *
sizeof
(*s->
bands
));
126
if
(!s->
bands
)
127
return
AVERROR
(ENOMEM);
128
129
/* populate bands data */
130
s->
bands
[0] = 2;
131
for
(i = 1; i < s->
num_bands
; i++)
132
s->
bands
[i] = (
ff_wma_critical_freqs
[i - 1] * s->
frame_len
/ sample_rate_half) & ~1;
133
s->
bands
[s->
num_bands
] = s->
frame_len
;
134
135
s->
first
= 1;
136
137
if
(CONFIG_BINKAUDIO_RDFT_DECODER && avctx->
codec
->
id
==
AV_CODEC_ID_BINKAUDIO_RDFT
)
138
ff_rdft_init
(&s->
trans
.
rdft
, frame_len_bits,
DFT_C2R
);
139
else
if
(CONFIG_BINKAUDIO_DCT_DECODER)
140
ff_dct_init
(&s->
trans
.
dct
, frame_len_bits,
DCT_III
);
141
else
142
return
-1;
143
144
return
0;
145
}
146
147
static
float
get_float
(
GetBitContext
*gb)
148
{
149
int
power =
get_bits
(gb, 5);
150
float
f =
ldexpf
(
get_bits_long
(gb, 23), power - 23);
151
if
(
get_bits1
(gb))
152
f = -f;
153
return
f;
154
}
155
156
static
const
uint8_t
rle_length_tab
[16] = {
157
2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64
158
};
159
160
/**
161
* Decode Bink Audio block
162
* @param[out] out Output buffer (must contain s->block_size elements)
163
* @return 0 on success, negative error code on failure
164
*/
165
static
int
decode_block
(
BinkAudioContext
*
s
,
float
**
out
,
int
use_dct)
166
{
167
int
ch, i, j, k;
168
float
q,
quant
[25];
169
int
width
,
coeff
;
170
GetBitContext
*gb = &s->
gb
;
171
172
if
(use_dct)
173
skip_bits
(gb, 2);
174
175
for
(ch = 0; ch < s->
channels
; ch++) {
176
FFTSample
*
coeffs
= out[ch];
177
178
if
(s->
version_b
) {
179
if
(
get_bits_left
(gb) < 64)
180
return
AVERROR_INVALIDDATA
;
181
coeffs[0] =
av_int2float
(
get_bits_long
(gb, 32)) * s->
root
;
182
coeffs[1] =
av_int2float
(
get_bits_long
(gb, 32)) * s->
root
;
183
}
else
{
184
if
(
get_bits_left
(gb) < 58)
185
return
AVERROR_INVALIDDATA
;
186
coeffs[0] =
get_float
(gb) * s->
root
;
187
coeffs[1] =
get_float
(gb) * s->
root
;
188
}
189
190
if
(
get_bits_left
(gb) < s->
num_bands
* 8)
191
return
AVERROR_INVALIDDATA
;
192
for
(i = 0; i < s->
num_bands
; i++) {
193
int
value
=
get_bits
(gb, 8);
194
quant[i] =
quant_table
[
FFMIN
(value, 95)];
195
}
196
197
k = 0;
198
q = quant[0];
199
200
// parse coefficients
201
i = 2;
202
while
(i < s->frame_len) {
203
if
(s->
version_b
) {
204
j = i + 16;
205
}
else
{
206
int
v
=
get_bits1
(gb);
207
if
(v) {
208
v =
get_bits
(gb, 4);
209
j = i +
rle_length_tab
[
v
] * 8;
210
}
else
{
211
j = i + 8;
212
}
213
}
214
215
j =
FFMIN
(j, s->
frame_len
);
216
217
width =
get_bits
(gb, 4);
218
if
(width == 0) {
219
memset(coeffs + i, 0, (j - i) *
sizeof
(*coeffs));
220
i = j;
221
while
(s->
bands
[k] < i)
222
q = quant[k++];
223
}
else
{
224
while
(i < j) {
225
if
(s->
bands
[k] == i)
226
q = quant[k++];
227
coeff =
get_bits
(gb, width);
228
if
(coeff) {
229
int
v
;
230
v =
get_bits1
(gb);
231
if
(v)
232
coeffs[i] = -q *
coeff
;
233
else
234
coeffs[i] = q *
coeff
;
235
}
else
{
236
coeffs[i] = 0.0f;
237
}
238
i++;
239
}
240
}
241
}
242
243
if
(CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {
244
coeffs[0] /= 0.5;
245
s->
trans
.
dct
.
dct_calc
(&s->
trans
.
dct
, coeffs);
246
}
247
else
if
(CONFIG_BINKAUDIO_RDFT_DECODER)
248
s->
trans
.
rdft
.
rdft_calc
(&s->
trans
.
rdft
, coeffs);
249
}
250
251
for
(ch = 0; ch < s->
channels
; ch++) {
252
int
j;
253
int
count
= s->
overlap_len
* s->
channels
;
254
if
(!s->
first
) {
255
j = ch;
256
for
(i = 0; i < s->
overlap_len
; i++, j += s->
channels
)
257
out[ch][i] = (s->
previous
[ch][i] * (count - j) +
258
out[ch][i] * j) /
count
;
259
}
260
memcpy(s->
previous
[ch], &out[ch][s->
frame_len
- s->
overlap_len
],
261
s->
overlap_len
*
sizeof
(*s->
previous
[ch]));
262
}
263
264
s->
first
= 0;
265
266
return
0;
267
}
268
269
static
av_cold
int
decode_end
(
AVCodecContext
*avctx)
270
{
271
BinkAudioContext
*
s
= avctx->
priv_data
;
272
av_freep
(&s->
bands
);
273
av_freep
(&s->
packet_buffer
);
274
if
(CONFIG_BINKAUDIO_RDFT_DECODER && avctx->
codec
->
id
==
AV_CODEC_ID_BINKAUDIO_RDFT
)
275
ff_rdft_end
(&s->
trans
.
rdft
);
276
else
if
(CONFIG_BINKAUDIO_DCT_DECODER)
277
ff_dct_end
(&s->
trans
.
dct
);
278
279
return
0;
280
}
281
282
static
void
get_bits_align32
(
GetBitContext
*
s
)
283
{
284
int
n
= (-
get_bits_count
(s)) & 31;
285
if
(n)
skip_bits
(s, n);
286
}
287
288
static
int
decode_frame
(
AVCodecContext
*avctx,
void
*
data
,
289
int
*got_frame_ptr,
AVPacket
*avpkt)
290
{
291
BinkAudioContext
*
s
= avctx->
priv_data
;
292
AVFrame
*
frame
=
data
;
293
GetBitContext
*gb = &s->
gb
;
294
int
ret
, consumed = 0;
295
296
if
(!
get_bits_left
(gb)) {
297
uint8_t
*
buf
;
298
/* handle end-of-stream */
299
if
(!avpkt->
size
) {
300
*got_frame_ptr = 0;
301
return
0;
302
}
303
if
(avpkt->
size
< 4) {
304
av_log
(avctx,
AV_LOG_ERROR
,
"Packet is too small\n"
);
305
return
AVERROR_INVALIDDATA
;
306
}
307
buf =
av_realloc
(s->
packet_buffer
, avpkt->
size
+
FF_INPUT_BUFFER_PADDING_SIZE
);
308
if
(!buf)
309
return
AVERROR
(ENOMEM);
310
s->
packet_buffer
=
buf
;
311
memcpy(s->
packet_buffer
, avpkt->
data
, avpkt->
size
);
312
init_get_bits
(gb, s->
packet_buffer
, avpkt->
size
* 8);
313
consumed = avpkt->
size
;
314
315
/* skip reported size */
316
skip_bits_long
(gb, 32);
317
}
318
319
/* get output buffer */
320
frame->
nb_samples
= s->
frame_len
;
321
if
((ret =
ff_get_buffer
(avctx, frame, 0)) < 0)
322
return
ret
;
323
324
if
(
decode_block
(s, (
float
**)frame->
extended_data
,
325
avctx->
codec
->
id
==
AV_CODEC_ID_BINKAUDIO_DCT
)) {
326
av_log
(avctx,
AV_LOG_ERROR
,
"Incomplete packet\n"
);
327
return
AVERROR_INVALIDDATA
;
328
}
329
get_bits_align32
(gb);
330
331
frame->
nb_samples
= s->
block_size
/ avctx->
channels
;
332
*got_frame_ptr = 1;
333
334
return
consumed;
335
}
336
337
AVCodec
ff_binkaudio_rdft_decoder
= {
338
.
name
=
"binkaudio_rdft"
,
339
.type =
AVMEDIA_TYPE_AUDIO
,
340
.id =
AV_CODEC_ID_BINKAUDIO_RDFT
,
341
.priv_data_size =
sizeof
(
BinkAudioContext
),
342
.
init
=
decode_init
,
343
.
close
=
decode_end
,
344
.
decode
=
decode_frame
,
345
.capabilities =
CODEC_CAP_DELAY
|
CODEC_CAP_DR1
,
346
.long_name =
NULL_IF_CONFIG_SMALL
(
"Bink Audio (RDFT)"
)
347
};
348
349
AVCodec
ff_binkaudio_dct_decoder
= {
350
.
name
=
"binkaudio_dct"
,
351
.type =
AVMEDIA_TYPE_AUDIO
,
352
.id =
AV_CODEC_ID_BINKAUDIO_DCT
,
353
.priv_data_size =
sizeof
(
BinkAudioContext
),
354
.
init
=
decode_init
,
355
.
close
=
decode_end
,
356
.
decode
=
decode_frame
,
357
.capabilities =
CODEC_CAP_DELAY
|
CODEC_CAP_DR1
,
358
.long_name =
NULL_IF_CONFIG_SMALL
(
"Bink Audio (DCT)"
)
359
};
Generated on Wed Jul 10 2013 23:47:56 for FFmpeg by
1.8.2