ffmpeg / libavcodec / wma.c @ dfd2a005
History  View  Annotate  Download (16.5 KB)
1 
/*


2 
* WMA compatible codec

3 
* Copyright (c) 20022007 The FFmpeg Project

4 
*

5 
* This file is part of FFmpeg.

6 
*

7 
* FFmpeg is free software; you can redistribute it and/or

8 
* modify it under the terms of the GNU Lesser General Public

9 
* License as published by the Free Software Foundation; either

10 
* version 2.1 of the License, or (at your option) any later version.

11 
*

12 
* FFmpeg is distributed in the hope that it will be useful,

13 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

14 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 
* Lesser General Public License for more details.

16 
*

17 
* You should have received a copy of the GNU Lesser General Public

18 
* License along with FFmpeg; if not, write to the Free Software

19 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

20 
*/

21  
22 
#include "avcodec.h" 
23 
#include "wma.h" 
24 
#include "wmadata.h" 
25  
26 
#undef NDEBUG

27 
#include <assert.h> 
28  
29 
/* XXX: use same run/length optimization as mpeg decoders */

30 
//FIXME maybe split decode / encode or pass flag

31 
static void init_coef_vlc(VLC *vlc, uint16_t **prun_table, 
32 
float **plevel_table, uint16_t **pint_table,

33 
const CoefVLCTable *vlc_table)

34 
{ 
35 
int n = vlc_table>n;

36 
const uint8_t *table_bits = vlc_table>huffbits;

37 
const uint32_t *table_codes = vlc_table>huffcodes;

38 
const uint16_t *levels_table = vlc_table>levels;

39 
uint16_t *run_table, *level_table, *int_table; 
40 
float *flevel_table;

41 
int i, l, j, k, level;

42  
43 
init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0); 
44  
45 
run_table = av_malloc(n * sizeof(uint16_t));

46 
level_table = av_malloc(n * sizeof(uint16_t));

47 
flevel_table= av_malloc(n * sizeof(*flevel_table));

48 
int_table = av_malloc(n * sizeof(uint16_t));

49 
i = 2;

50 
level = 1;

51 
k = 0;

52 
while (i < n) {

53 
int_table[k] = i; 
54 
l = levels_table[k++]; 
55 
for (j = 0; j < l; j++) { 
56 
run_table[i] = j; 
57 
level_table[i] = level; 
58 
flevel_table[i]= level; 
59 
i++; 
60 
} 
61 
level++; 
62 
} 
63 
*prun_table = run_table; 
64 
*plevel_table = flevel_table; 
65 
*pint_table = int_table; 
66 
av_free(level_table); 
67 
} 
68  
69 
/**

70 
*@brief Get the samples per frame for this stream.

71 
*@param sample_rate output sample_rate

72 
*@param version wma version

73 
*@param decode_flags codec compression features

74 
*@return log2 of the number of output samples per frame

75 
*/

76 
int av_cold ff_wma_get_frame_len_bits(int sample_rate, int version, 
77 
unsigned int decode_flags) 
78 
{ 
79  
80 
int frame_len_bits;

81  
82 
if (sample_rate <= 16000) { 
83 
frame_len_bits = 9;

84 
} else if (sample_rate <= 22050  
85 
(sample_rate <= 32000 && version == 1)) { 
86 
frame_len_bits = 10;

87 
} else if (sample_rate <= 48000) { 
88 
frame_len_bits = 11;

89 
} else if (sample_rate <= 96000) { 
90 
frame_len_bits = 12;

91 
} else {

92 
frame_len_bits = 13;

93 
} 
94  
95 
if (version == 3) { 
96 
int tmp = decode_flags & 0x6; 
97 
if (tmp == 0x2) { 
98 
++frame_len_bits; 
99 
} else if (tmp == 0x4) { 
100 
frame_len_bits; 
101 
} else if (tmp == 0x6) { 
102 
frame_len_bits = 2;

103 
} 
104 
} 
105  
106 
return frame_len_bits;

107 
} 
108  
109 
int ff_wma_init(AVCodecContext *avctx, int flags2) 
110 
{ 
111 
WMACodecContext *s = avctx>priv_data; 
112 
int i;

113 
float bps1, high_freq;

114 
volatile float bps; 
115 
int sample_rate1;

116 
int coef_vlc_table;

117  
118 
if ( avctx>sample_rate <= 0  avctx>sample_rate > 50000 
119 
 avctx>channels <= 0  avctx>channels > 8 
120 
 avctx>bit_rate <= 0)

121 
return 1; 
122  
123 
s>sample_rate = avctx>sample_rate; 
124 
s>nb_channels = avctx>channels; 
125 
s>bit_rate = avctx>bit_rate; 
126 
s>block_align = avctx>block_align; 
127  
128 
dsputil_init(&s>dsp, avctx); 
129  
130 
if (avctx>codec>id == CODEC_ID_WMAV1) {

131 
s>version = 1;

132 
} else {

133 
s>version = 2;

134 
} 
135  
136 
/* compute MDCT block size */

137 
s>frame_len_bits = ff_wma_get_frame_len_bits(s>sample_rate, s>version, 0);

138  
139 
s>frame_len = 1 << s>frame_len_bits;

140 
if (s>use_variable_block_len) {

141 
int nb_max, nb;

142 
nb = ((flags2 >> 3) & 3) + 1; 
143 
if ((s>bit_rate / s>nb_channels) >= 32000) 
144 
nb += 2;

145 
nb_max = s>frame_len_bits  BLOCK_MIN_BITS; 
146 
if (nb > nb_max)

147 
nb = nb_max; 
148 
s>nb_block_sizes = nb + 1;

149 
} else {

150 
s>nb_block_sizes = 1;

151 
} 
152  
153 
/* init rate dependent parameters */

154 
s>use_noise_coding = 1;

155 
high_freq = s>sample_rate * 0.5; 
156  
157 
/* if version 2, then the rates are normalized */

158 
sample_rate1 = s>sample_rate; 
159 
if (s>version == 2) { 
160 
if (sample_rate1 >= 44100) { 
161 
sample_rate1 = 44100;

162 
} else if (sample_rate1 >= 22050) { 
163 
sample_rate1 = 22050;

164 
} else if (sample_rate1 >= 16000) { 
165 
sample_rate1 = 16000;

166 
} else if (sample_rate1 >= 11025) { 
167 
sample_rate1 = 11025;

168 
} else if (sample_rate1 >= 8000) { 
169 
sample_rate1 = 8000;

170 
} 
171 
} 
172  
173 
bps = (float)s>bit_rate / (float)(s>nb_channels * s>sample_rate); 
174 
s>byte_offset_bits = av_log2((int)(bps * s>frame_len / 8.0 + 0.5)) + 2; 
175  
176 
/* compute high frequency value and choose if noise coding should

177 
be activated */

178 
bps1 = bps; 
179 
if (s>nb_channels == 2) 
180 
bps1 = bps * 1.6; 
181 
if (sample_rate1 == 44100) { 
182 
if (bps1 >= 0.61) { 
183 
s>use_noise_coding = 0;

184 
} else {

185 
high_freq = high_freq * 0.4; 
186 
} 
187 
} else if (sample_rate1 == 22050) { 
188 
if (bps1 >= 1.16) { 
189 
s>use_noise_coding = 0;

190 
} else if (bps1 >= 0.72) { 
191 
high_freq = high_freq * 0.7; 
192 
} else {

193 
high_freq = high_freq * 0.6; 
194 
} 
195 
} else if (sample_rate1 == 16000) { 
196 
if (bps > 0.5) { 
197 
high_freq = high_freq * 0.5; 
198 
} else {

199 
high_freq = high_freq * 0.3; 
200 
} 
201 
} else if (sample_rate1 == 11025) { 
202 
high_freq = high_freq * 0.7; 
203 
} else if (sample_rate1 == 8000) { 
204 
if (bps <= 0.625) { 
205 
high_freq = high_freq * 0.5; 
206 
} else if (bps > 0.75) { 
207 
s>use_noise_coding = 0;

208 
} else {

209 
high_freq = high_freq * 0.65; 
210 
} 
211 
} else {

212 
if (bps >= 0.8) { 
213 
high_freq = high_freq * 0.75; 
214 
} else if (bps >= 0.6) { 
215 
high_freq = high_freq * 0.6; 
216 
} else {

217 
high_freq = high_freq * 0.5; 
218 
} 
219 
} 
220 
av_dlog(s>avctx, "flags2=0x%x\n", flags2);

221 
av_dlog(s>avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",

222 
s>version, s>nb_channels, s>sample_rate, s>bit_rate, 
223 
s>block_align); 
224 
av_dlog(s>avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",

225 
bps, bps1, high_freq, s>byte_offset_bits); 
226 
av_dlog(s>avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",

227 
s>use_noise_coding, s>use_exp_vlc, s>nb_block_sizes); 
228  
229 
/* compute the scale factor band sizes for each MDCT block size */

230 
{ 
231 
int a, b, pos, lpos, k, block_len, i, j, n;

232 
const uint8_t *table;

233  
234 
if (s>version == 1) { 
235 
s>coefs_start = 3;

236 
} else {

237 
s>coefs_start = 0;

238 
} 
239 
for (k = 0; k < s>nb_block_sizes; k++) { 
240 
block_len = s>frame_len >> k; 
241  
242 
if (s>version == 1) { 
243 
lpos = 0;

244 
for (i = 0; i < 25; i++) { 
245 
a = ff_wma_critical_freqs[i]; 
246 
b = s>sample_rate; 
247 
pos = ((block_len * 2 * a) + (b >> 1)) / b; 
248 
if (pos > block_len)

249 
pos = block_len; 
250 
s>exponent_bands[0][i] = pos  lpos;

251 
if (pos >= block_len) {

252 
i++; 
253 
break;

254 
} 
255 
lpos = pos; 
256 
} 
257 
s>exponent_sizes[0] = i;

258 
} else {

259 
/* hardcoded tables */

260 
table = NULL;

261 
a = s>frame_len_bits  BLOCK_MIN_BITS  k; 
262 
if (a < 3) { 
263 
if (s>sample_rate >= 44100) { 
264 
table = exponent_band_44100[a]; 
265 
} else if (s>sample_rate >= 32000) { 
266 
table = exponent_band_32000[a]; 
267 
} else if (s>sample_rate >= 22050) { 
268 
table = exponent_band_22050[a]; 
269 
} 
270 
} 
271 
if (table) {

272 
n = *table++; 
273 
for (i = 0; i < n; i++) 
274 
s>exponent_bands[k][i] = table[i]; 
275 
s>exponent_sizes[k] = n; 
276 
} else {

277 
j = 0;

278 
lpos = 0;

279 
for (i = 0; i < 25; i++) { 
280 
a = ff_wma_critical_freqs[i]; 
281 
b = s>sample_rate; 
282 
pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); 
283 
pos <<= 2;

284 
if (pos > block_len)

285 
pos = block_len; 
286 
if (pos > lpos)

287 
s>exponent_bands[k][j++] = pos  lpos; 
288 
if (pos >= block_len)

289 
break;

290 
lpos = pos; 
291 
} 
292 
s>exponent_sizes[k] = j; 
293 
} 
294 
} 
295  
296 
/* max number of coefs */

297 
s>coefs_end[k] = (s>frame_len  ((s>frame_len * 9) / 100)) >> k; 
298 
/* high freq computation */

299 
s>high_band_start[k] = (int)((block_len * 2 * high_freq) / 
300 
s>sample_rate + 0.5); 
301 
n = s>exponent_sizes[k]; 
302 
j = 0;

303 
pos = 0;

304 
for (i = 0; i < n; i++) { 
305 
int start, end;

306 
start = pos; 
307 
pos += s>exponent_bands[k][i]; 
308 
end = pos; 
309 
if (start < s>high_band_start[k])

310 
start = s>high_band_start[k]; 
311 
if (end > s>coefs_end[k])

312 
end = s>coefs_end[k]; 
313 
if (end > start)

314 
s>exponent_high_bands[k][j++] = end  start; 
315 
} 
316 
s>exponent_high_sizes[k] = j; 
317 
#if 0

318 
tprintf(s>avctx, "%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ",

319 
s>frame_len >> k,

320 
s>coefs_end[k],

321 
s>high_band_start[k],

322 
s>exponent_high_sizes[k]);

323 
for (j = 0; j < s>exponent_high_sizes[k]; j++)

324 
tprintf(s>avctx, " %d", s>exponent_high_bands[k][j]);

325 
tprintf(s>avctx, "\n");

326 
#endif

327 
} 
328 
} 
329  
330 
#ifdef TRACE

331 
{ 
332 
int i, j;

333 
for (i = 0; i < s>nb_block_sizes; i++) { 
334 
tprintf(s>avctx, "%5d: n=%2d:",

335 
s>frame_len >> i, 
336 
s>exponent_sizes[i]); 
337 
for (j = 0; j < s>exponent_sizes[i]; j++) 
338 
tprintf(s>avctx, " %d", s>exponent_bands[i][j]);

339 
tprintf(s>avctx, "\n");

340 
} 
341 
} 
342 
#endif

343  
344 
/* init MDCT windows : simple sinus window */

345 
for (i = 0; i < s>nb_block_sizes; i++) { 
346 
ff_init_ff_sine_windows(s>frame_len_bits  i); 
347 
s>windows[i] = ff_sine_windows[s>frame_len_bits  i]; 
348 
} 
349  
350 
s>reset_block_lengths = 1;

351  
352 
if (s>use_noise_coding) {

353  
354 
/* init the noise generator */

355 
if (s>use_exp_vlc) {

356 
s>noise_mult = 0.02; 
357 
} else {

358 
s>noise_mult = 0.04; 
359 
} 
360  
361 
#ifdef TRACE

362 
for (i = 0; i < NOISE_TAB_SIZE; i++) 
363 
s>noise_table[i] = 1.0 * s>noise_mult; 
364 
#else

365 
{ 
366 
unsigned int seed; 
367 
float norm;

368 
seed = 1;

369 
norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s>noise_mult; 
370 
for (i = 0; i < NOISE_TAB_SIZE; i++) { 
371 
seed = seed * 314159 + 1; 
372 
s>noise_table[i] = (float)((int)seed) * norm; 
373 
} 
374 
} 
375 
#endif

376 
} 
377  
378 
/* choose the VLC tables for the coefficients */

379 
coef_vlc_table = 2;

380 
if (s>sample_rate >= 32000) { 
381 
if (bps1 < 0.72) { 
382 
coef_vlc_table = 0;

383 
} else if (bps1 < 1.16) { 
384 
coef_vlc_table = 1;

385 
} 
386 
} 
387 
s>coef_vlcs[0]= &coef_vlcs[coef_vlc_table * 2 ]; 
388 
s>coef_vlcs[1]= &coef_vlcs[coef_vlc_table * 2 + 1]; 
389 
init_coef_vlc(&s>coef_vlc[0], &s>run_table[0], &s>level_table[0], &s>int_table[0], 
390 
s>coef_vlcs[0]);

391 
init_coef_vlc(&s>coef_vlc[1], &s>run_table[1], &s>level_table[1], &s>int_table[1], 
392 
s>coef_vlcs[1]);

393  
394 
return 0; 
395 
} 
396  
397 
int ff_wma_total_gain_to_bits(int total_gain) 
398 
{ 
399 
if (total_gain < 15) return 13; 
400 
else if (total_gain < 32) return 12; 
401 
else if (total_gain < 40) return 11; 
402 
else if (total_gain < 45) return 10; 
403 
else return 9; 
404 
} 
405  
406 
int ff_wma_end(AVCodecContext *avctx)

407 
{ 
408 
WMACodecContext *s = avctx>priv_data; 
409 
int i;

410  
411 
for (i = 0; i < s>nb_block_sizes; i++) 
412 
ff_mdct_end(&s>mdct_ctx[i]); 
413  
414 
if (s>use_exp_vlc) {

415 
free_vlc(&s>exp_vlc); 
416 
} 
417 
if (s>use_noise_coding) {

418 
free_vlc(&s>hgain_vlc); 
419 
} 
420 
for (i = 0; i < 2; i++) { 
421 
free_vlc(&s>coef_vlc[i]); 
422 
av_free(s>run_table[i]); 
423 
av_free(s>level_table[i]); 
424 
av_free(s>int_table[i]); 
425 
} 
426  
427 
return 0; 
428 
} 
429  
430 
/**

431 
* Decode an uncompressed coefficient.

432 
* @param gb GetBitContext

433 
* @return the decoded coefficient

434 
*/

435 
unsigned int ff_wma_get_large_val(GetBitContext* gb) 
436 
{ 
437 
/** consumes up to 34 bits */

438 
int n_bits = 8; 
439 
/** decode length */

440 
if (get_bits1(gb)) {

441 
n_bits += 8;

442 
if (get_bits1(gb)) {

443 
n_bits += 8;

444 
if (get_bits1(gb)) {

445 
n_bits += 7;

446 
} 
447 
} 
448 
} 
449 
return get_bits_long(gb, n_bits);

450 
} 
451  
452 
/**

453 
* Decode run level compressed coefficients.

454 
* @param avctx codec context

455 
* @param gb bitstream reader context

456 
* @param vlc vlc table for get_vlc2

457 
* @param level_table level codes

458 
* @param run_table run codes

459 
* @param version 0 for wma1,2 1 for wmapro

460 
* @param ptr output buffer

461 
* @param offset offset in the output buffer

462 
* @param num_coefs number of input coefficents

463 
* @param block_len input buffer length (2^n)

464 
* @param frame_len_bits number of bits for escaped run codes

465 
* @param coef_nb_bits number of bits for escaped level codes

466 
* @return 0 on success, 1 otherwise

467 
*/

468 
int ff_wma_run_level_decode(AVCodecContext* avctx, GetBitContext* gb,

469 
VLC *vlc, 
470 
const float *level_table, const uint16_t *run_table, 
471 
int version, WMACoef *ptr, int offset, 
472 
int num_coefs, int block_len, int frame_len_bits, 
473 
int coef_nb_bits)

474 
{ 
475 
int code, level, sign;

476 
const uint32_t *ilvl = (const uint32_t*)level_table; 
477 
uint32_t *iptr = (uint32_t*)ptr; 
478 
const unsigned int coef_mask = block_len  1; 
479 
for (; offset < num_coefs; offset++) {

480 
code = get_vlc2(gb, vlc>table, VLCBITS, VLCMAX); 
481 
if (code > 1) { 
482 
/** normal code */

483 
offset += run_table[code]; 
484 
sign = get_bits1(gb)  1;

485 
iptr[offset & coef_mask] = ilvl[code] ^ sign<<31;

486 
} else if (code == 1) { 
487 
/** EOB */

488 
break;

489 
} else {

490 
/** escape */

491 
if (!version) {

492 
level = get_bits(gb, coef_nb_bits); 
493 
/** NOTE: this is rather suboptimal. reading

494 
block_len_bits would be better */

495 
offset += get_bits(gb, frame_len_bits); 
496 
} else {

497 
level = ff_wma_get_large_val(gb); 
498 
/** escape decode */

499 
if (get_bits1(gb)) {

500 
if (get_bits1(gb)) {

501 
if (get_bits1(gb)) {

502 
av_log(avctx,AV_LOG_ERROR, 
503 
"broken escape sequence\n");

504 
return 1; 
505 
} else

506 
offset += get_bits(gb, frame_len_bits) + 4;

507 
} else

508 
offset += get_bits(gb, 2) + 1; 
509 
} 
510 
} 
511 
sign = get_bits1(gb)  1;

512 
ptr[offset & coef_mask] = (level^sign)  sign; 
513 
} 
514 
} 
515 
/** NOTE: EOB can be omitted */

516 
if (offset > num_coefs) {

517 
av_log(avctx, AV_LOG_ERROR, "overflow in spectral RLE, ignoring\n");

518 
return 1; 
519 
} 
520  
521 
return 0; 
522 
} 
523 