Mercurial > libavcodec.hg
comparison wmadec.c @ 4490:0efc832d9102 libavcodec
wma encoder
author | michael |
---|---|
date | Tue, 06 Feb 2007 20:19:04 +0000 |
parents | b43bd0c56eaa |
children | a6ca201dd590 |
comparison
equal
deleted
inserted
replaced
4489:27e74573b074 | 4490:0efc832d9102 |
---|---|
32 * to the decoder using the extradata[_size] fields in AVCodecContext. There | 32 * to the decoder using the extradata[_size] fields in AVCodecContext. There |
33 * should be 4 extra bytes for v1 data and 6 extra bytes for v2 data. | 33 * should be 4 extra bytes for v1 data and 6 extra bytes for v2 data. |
34 */ | 34 */ |
35 | 35 |
36 #include "avcodec.h" | 36 #include "avcodec.h" |
37 #include "bitstream.h" | 37 #include "wma.h" |
38 #include "dsputil.h" | 38 |
39 | 39 #undef NDEBUG |
40 /* size of blocks */ | 40 #include <assert.h> |
41 #define BLOCK_MIN_BITS 7 | |
42 #define BLOCK_MAX_BITS 11 | |
43 #define BLOCK_MAX_SIZE (1 << BLOCK_MAX_BITS) | |
44 | |
45 #define BLOCK_NB_SIZES (BLOCK_MAX_BITS - BLOCK_MIN_BITS + 1) | |
46 | |
47 /* XXX: find exact max size */ | |
48 #define HIGH_BAND_MAX_SIZE 16 | |
49 | |
50 #define NB_LSP_COEFS 10 | |
51 | |
52 /* XXX: is it a suitable value ? */ | |
53 #define MAX_CODED_SUPERFRAME_SIZE 16384 | |
54 | |
55 #define MAX_CHANNELS 2 | |
56 | |
57 #define NOISE_TAB_SIZE 8192 | |
58 | |
59 #define LSP_POW_BITS 7 | |
60 | |
61 #define VLCBITS 9 | |
62 #define VLCMAX ((22+VLCBITS-1)/VLCBITS) | |
63 | 41 |
64 #define EXPVLCBITS 8 | 42 #define EXPVLCBITS 8 |
65 #define EXPMAX ((19+EXPVLCBITS-1)/EXPVLCBITS) | 43 #define EXPMAX ((19+EXPVLCBITS-1)/EXPVLCBITS) |
66 | 44 |
67 #define HGAINVLCBITS 9 | 45 #define HGAINVLCBITS 9 |
68 #define HGAINMAX ((13+HGAINVLCBITS-1)/HGAINVLCBITS) | 46 #define HGAINMAX ((13+HGAINVLCBITS-1)/HGAINVLCBITS) |
69 | 47 |
70 typedef struct WMADecodeContext { | |
71 GetBitContext gb; | |
72 int sample_rate; | |
73 int nb_channels; | |
74 int bit_rate; | |
75 int version; /* 1 = 0x160 (WMAV1), 2 = 0x161 (WMAV2) */ | |
76 int block_align; | |
77 int use_bit_reservoir; | |
78 int use_variable_block_len; | |
79 int use_exp_vlc; /* exponent coding: 0 = lsp, 1 = vlc + delta */ | |
80 int use_noise_coding; /* true if perceptual noise is added */ | |
81 int byte_offset_bits; | |
82 VLC exp_vlc; | |
83 int exponent_sizes[BLOCK_NB_SIZES]; | |
84 uint16_t exponent_bands[BLOCK_NB_SIZES][25]; | |
85 int high_band_start[BLOCK_NB_SIZES]; /* index of first coef in high band */ | |
86 int coefs_start; /* first coded coef */ | |
87 int coefs_end[BLOCK_NB_SIZES]; /* max number of coded coefficients */ | |
88 int exponent_high_sizes[BLOCK_NB_SIZES]; | |
89 int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE]; | |
90 VLC hgain_vlc; | |
91 | |
92 /* coded values in high bands */ | |
93 int high_band_coded[MAX_CHANNELS][HIGH_BAND_MAX_SIZE]; | |
94 int high_band_values[MAX_CHANNELS][HIGH_BAND_MAX_SIZE]; | |
95 | |
96 /* there are two possible tables for spectral coefficients */ | |
97 VLC coef_vlc[2]; | |
98 uint16_t *run_table[2]; | |
99 uint16_t *level_table[2]; | |
100 /* frame info */ | |
101 int frame_len; /* frame length in samples */ | |
102 int frame_len_bits; /* frame_len = 1 << frame_len_bits */ | |
103 int nb_block_sizes; /* number of block sizes */ | |
104 /* block info */ | |
105 int reset_block_lengths; | |
106 int block_len_bits; /* log2 of current block length */ | |
107 int next_block_len_bits; /* log2 of next block length */ | |
108 int prev_block_len_bits; /* log2 of prev block length */ | |
109 int block_len; /* block length in samples */ | |
110 int block_num; /* block number in current frame */ | |
111 int block_pos; /* current position in frame */ | |
112 uint8_t ms_stereo; /* true if mid/side stereo mode */ | |
113 uint8_t channel_coded[MAX_CHANNELS]; /* true if channel is coded */ | |
114 DECLARE_ALIGNED_16(float, exponents[MAX_CHANNELS][BLOCK_MAX_SIZE]); | |
115 float max_exponent[MAX_CHANNELS]; | |
116 int16_t coefs1[MAX_CHANNELS][BLOCK_MAX_SIZE]; | |
117 DECLARE_ALIGNED_16(float, coefs[MAX_CHANNELS][BLOCK_MAX_SIZE]); | |
118 DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]); | |
119 DECLARE_ALIGNED_16(float, window[BLOCK_MAX_SIZE * 2]); | |
120 MDCTContext mdct_ctx[BLOCK_NB_SIZES]; | |
121 float *windows[BLOCK_NB_SIZES]; | |
122 DECLARE_ALIGNED_16(FFTSample, mdct_tmp[BLOCK_MAX_SIZE]); /* temporary storage for imdct */ | |
123 /* output buffer for one frame and the last for IMDCT windowing */ | |
124 DECLARE_ALIGNED_16(float, frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2]); | |
125 /* last frame info */ | |
126 uint8_t last_superframe[MAX_CODED_SUPERFRAME_SIZE + 4]; /* padding added */ | |
127 int last_bitoffset; | |
128 int last_superframe_len; | |
129 float noise_table[NOISE_TAB_SIZE]; | |
130 int noise_index; | |
131 float noise_mult; /* XXX: suppress that and integrate it in the noise array */ | |
132 /* lsp_to_curve tables */ | |
133 float lsp_cos_table[BLOCK_MAX_SIZE]; | |
134 float lsp_pow_e_table[256]; | |
135 float lsp_pow_m_table1[(1 << LSP_POW_BITS)]; | |
136 float lsp_pow_m_table2[(1 << LSP_POW_BITS)]; | |
137 DSPContext dsp; | |
138 | |
139 #ifdef TRACE | |
140 int frame_count; | |
141 #endif | |
142 } WMADecodeContext; | |
143 | |
144 typedef struct CoefVLCTable { | |
145 int n; /* total number of codes */ | |
146 const uint32_t *huffcodes; /* VLC bit values */ | |
147 const uint8_t *huffbits; /* VLC bit size */ | |
148 const uint16_t *levels; /* table to build run/level tables */ | |
149 } CoefVLCTable; | |
150 | |
151 static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len); | 48 static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len); |
152 | |
153 #include "wmadata.h" | |
154 | 49 |
155 #ifdef TRACE | 50 #ifdef TRACE |
156 static void dump_shorts(const char *name, const short *tab, int n) | 51 static void dump_shorts(const char *name, const short *tab, int n) |
157 { | 52 { |
158 int i; | 53 int i; |
182 if ((i & 7) != 0) | 77 if ((i & 7) != 0) |
183 tprintf("\n"); | 78 tprintf("\n"); |
184 } | 79 } |
185 #endif | 80 #endif |
186 | 81 |
187 /* XXX: use same run/length optimization as mpeg decoders */ | |
188 static void init_coef_vlc(VLC *vlc, | |
189 uint16_t **prun_table, uint16_t **plevel_table, | |
190 const CoefVLCTable *vlc_table) | |
191 { | |
192 int n = vlc_table->n; | |
193 const uint8_t *table_bits = vlc_table->huffbits; | |
194 const uint32_t *table_codes = vlc_table->huffcodes; | |
195 const uint16_t *levels_table = vlc_table->levels; | |
196 uint16_t *run_table, *level_table; | |
197 const uint16_t *p; | |
198 int i, l, j, level; | |
199 | |
200 init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0); | |
201 | |
202 run_table = av_malloc(n * sizeof(uint16_t)); | |
203 level_table = av_malloc(n * sizeof(uint16_t)); | |
204 p = levels_table; | |
205 i = 2; | |
206 level = 1; | |
207 while (i < n) { | |
208 l = *p++; | |
209 for(j=0;j<l;j++) { | |
210 run_table[i] = j; | |
211 level_table[i] = level; | |
212 i++; | |
213 } | |
214 level++; | |
215 } | |
216 *prun_table = run_table; | |
217 *plevel_table = level_table; | |
218 } | |
219 | |
220 static int wma_decode_init(AVCodecContext * avctx) | 82 static int wma_decode_init(AVCodecContext * avctx) |
221 { | 83 { |
222 WMADecodeContext *s = avctx->priv_data; | 84 WMADecodeContext *s = avctx->priv_data; |
223 int i, flags1, flags2; | 85 int i, flags1, flags2; |
224 float *window; | |
225 uint8_t *extradata; | 86 uint8_t *extradata; |
226 float bps1, high_freq; | |
227 volatile float bps; | |
228 int sample_rate1; | |
229 int coef_vlc_table; | |
230 | |
231 s->sample_rate = avctx->sample_rate; | |
232 s->nb_channels = avctx->channels; | |
233 s->bit_rate = avctx->bit_rate; | |
234 s->block_align = avctx->block_align; | |
235 | |
236 dsputil_init(&s->dsp, avctx); | |
237 | |
238 if (avctx->codec->id == CODEC_ID_WMAV1) { | |
239 s->version = 1; | |
240 } else { | |
241 s->version = 2; | |
242 } | |
243 | 87 |
244 /* extract flag infos */ | 88 /* extract flag infos */ |
245 flags1 = 0; | 89 flags1 = 0; |
246 flags2 = 0; | 90 flags2 = 0; |
247 extradata = avctx->extradata; | 91 extradata = avctx->extradata; |
248 if (s->version == 1 && avctx->extradata_size >= 4) { | 92 if (avctx->codec->id == CODEC_ID_WMAV1 && avctx->extradata_size >= 4) { |
249 flags1 = extradata[0] | (extradata[1] << 8); | 93 flags1 = extradata[0] | (extradata[1] << 8); |
250 flags2 = extradata[2] | (extradata[3] << 8); | 94 flags2 = extradata[2] | (extradata[3] << 8); |
251 } else if (s->version == 2 && avctx->extradata_size >= 6) { | 95 } else if (avctx->codec->id == CODEC_ID_WMAV2 && avctx->extradata_size >= 6) { |
252 flags1 = extradata[0] | (extradata[1] << 8) | | 96 flags1 = extradata[0] | (extradata[1] << 8) | |
253 (extradata[2] << 16) | (extradata[3] << 24); | 97 (extradata[2] << 16) | (extradata[3] << 24); |
254 flags2 = extradata[4] | (extradata[5] << 8); | 98 flags2 = extradata[4] | (extradata[5] << 8); |
255 } | 99 } |
100 for(i=0; i<avctx->extradata_size; i++) | |
101 av_log(NULL, AV_LOG_ERROR, "%02X ", extradata[i]); | |
102 | |
256 s->use_exp_vlc = flags2 & 0x0001; | 103 s->use_exp_vlc = flags2 & 0x0001; |
257 s->use_bit_reservoir = flags2 & 0x0002; | 104 s->use_bit_reservoir = flags2 & 0x0002; |
258 s->use_variable_block_len = flags2 & 0x0004; | 105 s->use_variable_block_len = flags2 & 0x0004; |
259 | 106 |
260 /* compute MDCT block size */ | 107 ff_wma_init(avctx, flags2); |
261 if (s->sample_rate <= 16000) { | |
262 s->frame_len_bits = 9; | |
263 } else if (s->sample_rate <= 22050 || | |
264 (s->sample_rate <= 32000 && s->version == 1)) { | |
265 s->frame_len_bits = 10; | |
266 } else { | |
267 s->frame_len_bits = 11; | |
268 } | |
269 s->frame_len = 1 << s->frame_len_bits; | |
270 if (s->use_variable_block_len) { | |
271 int nb_max, nb; | |
272 nb = ((flags2 >> 3) & 3) + 1; | |
273 if ((s->bit_rate / s->nb_channels) >= 32000) | |
274 nb += 2; | |
275 nb_max = s->frame_len_bits - BLOCK_MIN_BITS; | |
276 if (nb > nb_max) | |
277 nb = nb_max; | |
278 s->nb_block_sizes = nb + 1; | |
279 } else { | |
280 s->nb_block_sizes = 1; | |
281 } | |
282 | |
283 /* init rate dependant parameters */ | |
284 s->use_noise_coding = 1; | |
285 high_freq = s->sample_rate * 0.5; | |
286 | |
287 /* if version 2, then the rates are normalized */ | |
288 sample_rate1 = s->sample_rate; | |
289 if (s->version == 2) { | |
290 if (sample_rate1 >= 44100) | |
291 sample_rate1 = 44100; | |
292 else if (sample_rate1 >= 22050) | |
293 sample_rate1 = 22050; | |
294 else if (sample_rate1 >= 16000) | |
295 sample_rate1 = 16000; | |
296 else if (sample_rate1 >= 11025) | |
297 sample_rate1 = 11025; | |
298 else if (sample_rate1 >= 8000) | |
299 sample_rate1 = 8000; | |
300 } | |
301 | |
302 bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate); | |
303 s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2; | |
304 | |
305 /* compute high frequency value and choose if noise coding should | |
306 be activated */ | |
307 bps1 = bps; | |
308 if (s->nb_channels == 2) | |
309 bps1 = bps * 1.6; | |
310 if (sample_rate1 == 44100) { | |
311 if (bps1 >= 0.61) | |
312 s->use_noise_coding = 0; | |
313 else | |
314 high_freq = high_freq * 0.4; | |
315 } else if (sample_rate1 == 22050) { | |
316 if (bps1 >= 1.16) | |
317 s->use_noise_coding = 0; | |
318 else if (bps1 >= 0.72) | |
319 high_freq = high_freq * 0.7; | |
320 else | |
321 high_freq = high_freq * 0.6; | |
322 } else if (sample_rate1 == 16000) { | |
323 if (bps > 0.5) | |
324 high_freq = high_freq * 0.5; | |
325 else | |
326 high_freq = high_freq * 0.3; | |
327 } else if (sample_rate1 == 11025) { | |
328 high_freq = high_freq * 0.7; | |
329 } else if (sample_rate1 == 8000) { | |
330 if (bps <= 0.625) { | |
331 high_freq = high_freq * 0.5; | |
332 } else if (bps > 0.75) { | |
333 s->use_noise_coding = 0; | |
334 } else { | |
335 high_freq = high_freq * 0.65; | |
336 } | |
337 } else { | |
338 if (bps >= 0.8) { | |
339 high_freq = high_freq * 0.75; | |
340 } else if (bps >= 0.6) { | |
341 high_freq = high_freq * 0.6; | |
342 } else { | |
343 high_freq = high_freq * 0.5; | |
344 } | |
345 } | |
346 dprintf("flags1=0x%x flags2=0x%x\n", flags1, flags2); | |
347 dprintf("version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n", | |
348 s->version, s->nb_channels, s->sample_rate, s->bit_rate, | |
349 s->block_align); | |
350 dprintf("bps=%f bps1=%f high_freq=%f bitoffset=%d\n", | |
351 bps, bps1, high_freq, s->byte_offset_bits); | |
352 dprintf("use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n", | |
353 s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes); | |
354 | |
355 /* compute the scale factor band sizes for each MDCT block size */ | |
356 { | |
357 int a, b, pos, lpos, k, block_len, i, j, n; | |
358 const uint8_t *table; | |
359 | |
360 if (s->version == 1) { | |
361 s->coefs_start = 3; | |
362 } else { | |
363 s->coefs_start = 0; | |
364 } | |
365 for(k = 0; k < s->nb_block_sizes; k++) { | |
366 block_len = s->frame_len >> k; | |
367 | |
368 if (s->version == 1) { | |
369 lpos = 0; | |
370 for(i=0;i<25;i++) { | |
371 a = wma_critical_freqs[i]; | |
372 b = s->sample_rate; | |
373 pos = ((block_len * 2 * a) + (b >> 1)) / b; | |
374 if (pos > block_len) | |
375 pos = block_len; | |
376 s->exponent_bands[0][i] = pos - lpos; | |
377 if (pos >= block_len) { | |
378 i++; | |
379 break; | |
380 } | |
381 lpos = pos; | |
382 } | |
383 s->exponent_sizes[0] = i; | |
384 } else { | |
385 /* hardcoded tables */ | |
386 table = NULL; | |
387 a = s->frame_len_bits - BLOCK_MIN_BITS - k; | |
388 if (a < 3) { | |
389 if (s->sample_rate >= 44100) | |
390 table = exponent_band_44100[a]; | |
391 else if (s->sample_rate >= 32000) | |
392 table = exponent_band_32000[a]; | |
393 else if (s->sample_rate >= 22050) | |
394 table = exponent_band_22050[a]; | |
395 } | |
396 if (table) { | |
397 n = *table++; | |
398 for(i=0;i<n;i++) | |
399 s->exponent_bands[k][i] = table[i]; | |
400 s->exponent_sizes[k] = n; | |
401 } else { | |
402 j = 0; | |
403 lpos = 0; | |
404 for(i=0;i<25;i++) { | |
405 a = wma_critical_freqs[i]; | |
406 b = s->sample_rate; | |
407 pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); | |
408 pos <<= 2; | |
409 if (pos > block_len) | |
410 pos = block_len; | |
411 if (pos > lpos) | |
412 s->exponent_bands[k][j++] = pos - lpos; | |
413 if (pos >= block_len) | |
414 break; | |
415 lpos = pos; | |
416 } | |
417 s->exponent_sizes[k] = j; | |
418 } | |
419 } | |
420 | |
421 /* max number of coefs */ | |
422 s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k; | |
423 /* high freq computation */ | |
424 s->high_band_start[k] = (int)((block_len * 2 * high_freq) / | |
425 s->sample_rate + 0.5); | |
426 n = s->exponent_sizes[k]; | |
427 j = 0; | |
428 pos = 0; | |
429 for(i=0;i<n;i++) { | |
430 int start, end; | |
431 start = pos; | |
432 pos += s->exponent_bands[k][i]; | |
433 end = pos; | |
434 if (start < s->high_band_start[k]) | |
435 start = s->high_band_start[k]; | |
436 if (end > s->coefs_end[k]) | |
437 end = s->coefs_end[k]; | |
438 if (end > start) | |
439 s->exponent_high_bands[k][j++] = end - start; | |
440 } | |
441 s->exponent_high_sizes[k] = j; | |
442 #if 0 | |
443 tprintf("%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ", | |
444 s->frame_len >> k, | |
445 s->coefs_end[k], | |
446 s->high_band_start[k], | |
447 s->exponent_high_sizes[k]); | |
448 for(j=0;j<s->exponent_high_sizes[k];j++) | |
449 tprintf(" %d", s->exponent_high_bands[k][j]); | |
450 tprintf("\n"); | |
451 #endif | |
452 } | |
453 } | |
454 | |
455 #ifdef TRACE | |
456 { | |
457 int i, j; | |
458 for(i = 0; i < s->nb_block_sizes; i++) { | |
459 tprintf("%5d: n=%2d:", | |
460 s->frame_len >> i, | |
461 s->exponent_sizes[i]); | |
462 for(j=0;j<s->exponent_sizes[i];j++) | |
463 tprintf(" %d", s->exponent_bands[i][j]); | |
464 tprintf("\n"); | |
465 } | |
466 } | |
467 #endif | |
468 | 108 |
469 /* init MDCT */ | 109 /* init MDCT */ |
470 for(i = 0; i < s->nb_block_sizes; i++) | 110 for(i = 0; i < s->nb_block_sizes; i++) |
471 ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1); | 111 ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1); |
472 | 112 |
473 /* init MDCT windows : simple sinus window */ | |
474 for(i = 0; i < s->nb_block_sizes; i++) { | |
475 int n, j; | |
476 float alpha; | |
477 n = 1 << (s->frame_len_bits - i); | |
478 window = av_malloc(sizeof(float) * n); | |
479 alpha = M_PI / (2.0 * n); | |
480 for(j=0;j<n;j++) { | |
481 window[n - j - 1] = sin((j + 0.5) * alpha); | |
482 } | |
483 s->windows[i] = window; | |
484 } | |
485 | |
486 s->reset_block_lengths = 1; | |
487 | |
488 if (s->use_noise_coding) { | 113 if (s->use_noise_coding) { |
489 | 114 init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(ff_wma_hgain_huffbits), |
490 /* init the noise generator */ | 115 ff_wma_hgain_huffbits, 1, 1, |
491 if (s->use_exp_vlc) | 116 ff_wma_hgain_huffcodes, 2, 2, 0); |
492 s->noise_mult = 0.02; | |
493 else | |
494 s->noise_mult = 0.04; | |
495 | |
496 #ifdef TRACE | |
497 for(i=0;i<NOISE_TAB_SIZE;i++) | |
498 s->noise_table[i] = 1.0 * s->noise_mult; | |
499 #else | |
500 { | |
501 unsigned int seed; | |
502 float norm; | |
503 seed = 1; | |
504 norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s->noise_mult; | |
505 for(i=0;i<NOISE_TAB_SIZE;i++) { | |
506 seed = seed * 314159 + 1; | |
507 s->noise_table[i] = (float)((int)seed) * norm; | |
508 } | |
509 } | |
510 #endif | |
511 init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(hgain_huffbits), | |
512 hgain_huffbits, 1, 1, | |
513 hgain_huffcodes, 2, 2, 0); | |
514 } | 117 } |
515 | 118 |
516 if (s->use_exp_vlc) { | 119 if (s->use_exp_vlc) { |
517 init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(scale_huffbits), | 120 init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_wma_scale_huffbits), //FIXME move out of context |
518 scale_huffbits, 1, 1, | 121 ff_wma_scale_huffbits, 1, 1, |
519 scale_huffcodes, 4, 4, 0); | 122 ff_wma_scale_huffcodes, 4, 4, 0); |
520 } else { | 123 } else { |
521 wma_lsp_to_curve_init(s, s->frame_len); | 124 wma_lsp_to_curve_init(s, s->frame_len); |
522 } | 125 } |
523 | 126 |
524 /* choose the VLC tables for the coefficients */ | |
525 coef_vlc_table = 2; | |
526 if (s->sample_rate >= 32000) { | |
527 if (bps1 < 0.72) | |
528 coef_vlc_table = 0; | |
529 else if (bps1 < 1.16) | |
530 coef_vlc_table = 1; | |
531 } | |
532 | |
533 init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0], | |
534 &coef_vlcs[coef_vlc_table * 2]); | |
535 init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1], | |
536 &coef_vlcs[coef_vlc_table * 2 + 1]); | |
537 return 0; | 127 return 0; |
538 } | 128 } |
539 | 129 |
540 /* interpolate values for a bigger or smaller block. The block must | 130 /* interpolate values for a bigger or smaller block. The block must |
541 have multiple sizes */ | 131 have multiple sizes */ |
662 for(i = 0; i < NB_LSP_COEFS; i++) { | 252 for(i = 0; i < NB_LSP_COEFS; i++) { |
663 if (i == 0 || i >= 8) | 253 if (i == 0 || i >= 8) |
664 val = get_bits(&s->gb, 3); | 254 val = get_bits(&s->gb, 3); |
665 else | 255 else |
666 val = get_bits(&s->gb, 4); | 256 val = get_bits(&s->gb, 4); |
667 lsp_coefs[i] = lsp_codebook[i][val]; | 257 lsp_coefs[i] = ff_wma_lsp_codebook[i][val]; |
668 } | 258 } |
669 | 259 |
670 wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch], | 260 wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch], |
671 s->block_len, lsp_coefs); | 261 s->block_len, lsp_coefs); |
672 } | 262 } |
690 max_scale = v; | 280 max_scale = v; |
691 n = *ptr++; | 281 n = *ptr++; |
692 do { | 282 do { |
693 *q++ = v; | 283 *q++ = v; |
694 } while (--n); | 284 } while (--n); |
695 } | 285 }else |
696 last_exp = 36; | 286 last_exp = 36; |
287 | |
697 while (q < q_end) { | 288 while (q < q_end) { |
698 code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX); | 289 code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX); |
699 if (code < 0) | 290 if (code < 0) |
700 return -1; | 291 return -1; |
701 /* NOTE: this offset is the same as MPEG4 AAC ! */ | 292 /* NOTE: this offset is the same as MPEG4 AAC ! */ |
785 total_gain += a; | 376 total_gain += a; |
786 if (a != 127) | 377 if (a != 127) |
787 break; | 378 break; |
788 } | 379 } |
789 | 380 |
790 if (total_gain < 15) | 381 coef_nb_bits= ff_wma_total_gain_to_bits(total_gain); |
791 coef_nb_bits = 13; | |
792 else if (total_gain < 32) | |
793 coef_nb_bits = 12; | |
794 else if (total_gain < 40) | |
795 coef_nb_bits = 11; | |
796 else if (total_gain < 45) | |
797 coef_nb_bits = 10; | |
798 else | |
799 coef_nb_bits = 9; | |
800 | 382 |
801 /* compute number of coefficients */ | 383 /* compute number of coefficients */ |
802 n = s->coefs_end[bsize] - s->coefs_start; | 384 n = s->coefs_end[bsize] - s->coefs_start; |
803 for(ch = 0; ch < s->nb_channels; ch++) | 385 for(ch = 0; ch < s->nb_channels; ch++) |
804 nb_coefs[ch] = n; | 386 nb_coefs[ch] = n; |
1277 /* single frame decode */ | 859 /* single frame decode */ |
1278 if (wma_decode_frame(s, samples) < 0) | 860 if (wma_decode_frame(s, samples) < 0) |
1279 goto fail; | 861 goto fail; |
1280 samples += s->nb_channels * s->frame_len; | 862 samples += s->nb_channels * s->frame_len; |
1281 } | 863 } |
864 | |
865 //av_log(NULL, AV_LOG_ERROR, "%d %d %d %d outbytes:%d eaten:%d\n", s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len, (int8_t *)samples - (int8_t *)data, s->block_align); | |
866 | |
1282 *data_size = (int8_t *)samples - (int8_t *)data; | 867 *data_size = (int8_t *)samples - (int8_t *)data; |
1283 return s->block_align; | 868 return s->block_align; |
1284 fail: | 869 fail: |
1285 /* when error, we reset the bit reservoir */ | 870 /* when error, we reset the bit reservoir */ |
1286 s->last_superframe_len = 0; | 871 s->last_superframe_len = 0; |
1287 return -1; | 872 return -1; |
1288 } | 873 } |
1289 | 874 |
1290 static int wma_decode_end(AVCodecContext *avctx) | |
1291 { | |
1292 WMADecodeContext *s = avctx->priv_data; | |
1293 int i; | |
1294 | |
1295 for(i = 0; i < s->nb_block_sizes; i++) | |
1296 ff_mdct_end(&s->mdct_ctx[i]); | |
1297 for(i = 0; i < s->nb_block_sizes; i++) | |
1298 av_free(s->windows[i]); | |
1299 | |
1300 if (s->use_exp_vlc) { | |
1301 free_vlc(&s->exp_vlc); | |
1302 } | |
1303 if (s->use_noise_coding) { | |
1304 free_vlc(&s->hgain_vlc); | |
1305 } | |
1306 for(i = 0;i < 2; i++) { | |
1307 free_vlc(&s->coef_vlc[i]); | |
1308 av_free(s->run_table[i]); | |
1309 av_free(s->level_table[i]); | |
1310 } | |
1311 | |
1312 return 0; | |
1313 } | |
1314 | |
1315 AVCodec wmav1_decoder = | 875 AVCodec wmav1_decoder = |
1316 { | 876 { |
1317 "wmav1", | 877 "wmav1", |
1318 CODEC_TYPE_AUDIO, | 878 CODEC_TYPE_AUDIO, |
1319 CODEC_ID_WMAV1, | 879 CODEC_ID_WMAV1, |
1320 sizeof(WMADecodeContext), | 880 sizeof(WMADecodeContext), |
1321 wma_decode_init, | 881 wma_decode_init, |
1322 NULL, | 882 NULL, |
1323 wma_decode_end, | 883 ff_wma_end, |
1324 wma_decode_superframe, | 884 wma_decode_superframe, |
1325 }; | 885 }; |
1326 | 886 |
1327 AVCodec wmav2_decoder = | 887 AVCodec wmav2_decoder = |
1328 { | 888 { |
1330 CODEC_TYPE_AUDIO, | 890 CODEC_TYPE_AUDIO, |
1331 CODEC_ID_WMAV2, | 891 CODEC_ID_WMAV2, |
1332 sizeof(WMADecodeContext), | 892 sizeof(WMADecodeContext), |
1333 wma_decode_init, | 893 wma_decode_init, |
1334 NULL, | 894 NULL, |
1335 wma_decode_end, | 895 ff_wma_end, |
1336 wma_decode_superframe, | 896 wma_decode_superframe, |
1337 }; | 897 }; |