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