ffmpeg / libavcodec / wmadec.c @ 0e71841b
History  View  Annotate  Download (29.2 KB)
1 
/*


2 
* WMA compatible decoder

3 
* Copyright (c) 2002 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 
/**

23 
* @file libavcodec/wmadec.c

24 
* WMA compatible decoder.

25 
* This decoder handles Microsoft Windows Media Audio data, versions 1 & 2.

26 
* WMA v1 is identified by audio format 0x160 in Microsoft media files

27 
* (ASF/AVI/WAV). WMA v2 is identified by audio format 0x161.

28 
*

29 
* To use this decoder, a calling application must supply the extra data

30 
* bytes provided with the WMA data. These are the extra, codecspecific

31 
* bytes at the end of a WAVEFORMATEX data structure. Transmit these bytes

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.

34 
*/

35  
36 
#include "avcodec.h" 
37 
#include "wma.h" 
38  
39 
#undef NDEBUG

40 
#include <assert.h> 
41  
42 
#define EXPVLCBITS 8 
43 
#define EXPMAX ((19+EXPVLCBITS1)/EXPVLCBITS) 
44  
45 
#define HGAINVLCBITS 9 
46 
#define HGAINMAX ((13+HGAINVLCBITS1)/HGAINVLCBITS) 
47  
48 
static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len); 
49  
50 
#ifdef TRACE

51 
static void dump_shorts(WMACodecContext *s, const char *name, const short *tab, int n) 
52 
{ 
53 
int i;

54  
55 
tprintf(s>avctx, "%s[%d]:\n", name, n);

56 
for(i=0;i<n;i++) { 
57 
if ((i & 7) == 0) 
58 
tprintf(s>avctx, "%4d: ", i);

59 
tprintf(s>avctx, " %5d.0", tab[i]);

60 
if ((i & 7) == 7) 
61 
tprintf(s>avctx, "\n");

62 
} 
63 
} 
64  
65 
static void dump_floats(WMACodecContext *s, const char *name, int prec, const float *tab, int n) 
66 
{ 
67 
int i;

68  
69 
tprintf(s>avctx, "%s[%d]:\n", name, n);

70 
for(i=0;i<n;i++) { 
71 
if ((i & 7) == 0) 
72 
tprintf(s>avctx, "%4d: ", i);

73 
tprintf(s>avctx, " %8.*f", prec, tab[i]);

74 
if ((i & 7) == 7) 
75 
tprintf(s>avctx, "\n");

76 
} 
77 
if ((i & 7) != 0) 
78 
tprintf(s>avctx, "\n");

79 
} 
80 
#endif

81  
82 
static int wma_decode_init(AVCodecContext * avctx) 
83 
{ 
84 
WMACodecContext *s = avctx>priv_data; 
85 
int i, flags2;

86 
uint8_t *extradata; 
87  
88 
s>avctx = avctx; 
89  
90 
/* extract flag infos */

91 
flags2 = 0;

92 
extradata = avctx>extradata; 
93 
if (avctx>codec>id == CODEC_ID_WMAV1 && avctx>extradata_size >= 4) { 
94 
flags2 = AV_RL16(extradata+2);

95 
} else if (avctx>codec>id == CODEC_ID_WMAV2 && avctx>extradata_size >= 6) { 
96 
flags2 = AV_RL16(extradata+4);

97 
} 
98 
// for(i=0; i<avctx>extradata_size; i++)

99 
// av_log(NULL, AV_LOG_ERROR, "%02X ", extradata[i]);

100  
101 
s>use_exp_vlc = flags2 & 0x0001;

102 
s>use_bit_reservoir = flags2 & 0x0002;

103 
s>use_variable_block_len = flags2 & 0x0004;

104  
105 
if(ff_wma_init(avctx, flags2)<0) 
106 
return 1; 
107  
108 
/* init MDCT */

109 
for(i = 0; i < s>nb_block_sizes; i++) 
110 
ff_mdct_init(&s>mdct_ctx[i], s>frame_len_bits  i + 1, 1, 1.0); 
111  
112 
if (s>use_noise_coding) {

113 
init_vlc(&s>hgain_vlc, HGAINVLCBITS, sizeof(ff_wma_hgain_huffbits),

114 
ff_wma_hgain_huffbits, 1, 1, 
115 
ff_wma_hgain_huffcodes, 2, 2, 0); 
116 
} 
117  
118 
if (s>use_exp_vlc) {

119 
init_vlc(&s>exp_vlc, EXPVLCBITS, sizeof(ff_wma_scale_huffbits), //FIXME move out of context 
120 
ff_wma_scale_huffbits, 1, 1, 
121 
ff_wma_scale_huffcodes, 4, 4, 0); 
122 
} else {

123 
wma_lsp_to_curve_init(s, s>frame_len); 
124 
} 
125  
126 
avctx>sample_fmt = SAMPLE_FMT_S16; 
127 
return 0; 
128 
} 
129  
130 
/**

131 
* compute x^0.25 with an exponent and mantissa table. We use linear

132 
* interpolation to reduce the mantissa table size at a small speed

133 
* expense (linear interpolation approximately doubles the number of

134 
* bits of precision).

135 
*/

136 
static inline float pow_m1_4(WMACodecContext *s, float x) 
137 
{ 
138 
union {

139 
float f;

140 
unsigned int v; 
141 
} u, t; 
142 
unsigned int e, m; 
143 
float a, b;

144  
145 
u.f = x; 
146 
e = u.v >> 23;

147 
m = (u.v >> (23  LSP_POW_BITS)) & ((1 << LSP_POW_BITS)  1); 
148 
/* build interpolation scale: 1 <= t < 2. */

149 
t.v = ((u.v << LSP_POW_BITS) & ((1 << 23)  1))  (127 << 23); 
150 
a = s>lsp_pow_m_table1[m]; 
151 
b = s>lsp_pow_m_table2[m]; 
152 
return s>lsp_pow_e_table[e] * (a + b * t.f);

153 
} 
154  
155 
static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len) 
156 
{ 
157 
float wdel, a, b;

158 
int i, e, m;

159  
160 
wdel = M_PI / frame_len; 
161 
for(i=0;i<frame_len;i++) 
162 
s>lsp_cos_table[i] = 2.0f * cos(wdel * i); 
163  
164 
/* tables for x^0.25 computation */

165 
for(i=0;i<256;i++) { 
166 
e = i  126;

167 
s>lsp_pow_e_table[i] = pow(2.0, e * 0.25); 
168 
} 
169  
170 
/* NOTE: these two tables are needed to avoid two operations in

171 
pow_m1_4 */

172 
b = 1.0; 
173 
for(i=(1 << LSP_POW_BITS)  1;i>=0;i) { 
174 
m = (1 << LSP_POW_BITS) + i;

175 
a = (float)m * (0.5 / (1 << LSP_POW_BITS)); 
176 
a = pow(a, 0.25); 
177 
s>lsp_pow_m_table1[i] = 2 * a  b;

178 
s>lsp_pow_m_table2[i] = b  a; 
179 
b = a; 
180 
} 
181 
#if 0

182 
for(i=1;i<20;i++) {

183 
float v, r1, r2;

184 
v = 5.0 / i;

185 
r1 = pow_m1_4(s, v);

186 
r2 = pow(v,0.25);

187 
printf("%f^0.25=%f e=%f\n", v, r1, r2  r1);

188 
}

189 
#endif

190 
} 
191  
192 
/**

193 
* NOTE: We use the same code as Vorbis here

194 
* @todo optimize it further with SSE/3Dnow

195 
*/

196 
static void wma_lsp_to_curve(WMACodecContext *s, 
197 
float *out, float *val_max_ptr, 
198 
int n, float *lsp) 
199 
{ 
200 
int i, j;

201 
float p, q, w, v, val_max;

202  
203 
val_max = 0;

204 
for(i=0;i<n;i++) { 
205 
p = 0.5f; 
206 
q = 0.5f; 
207 
w = s>lsp_cos_table[i]; 
208 
for(j=1;j<NB_LSP_COEFS;j+=2){ 
209 
q *= w  lsp[j  1];

210 
p *= w  lsp[j]; 
211 
} 
212 
p *= p * (2.0f  w); 
213 
q *= q * (2.0f + w); 
214 
v = p + q; 
215 
v = pow_m1_4(s, v); 
216 
if (v > val_max)

217 
val_max = v; 
218 
out[i] = v; 
219 
} 
220 
*val_max_ptr = val_max; 
221 
} 
222  
223 
/**

224 
* decode exponents coded with LSP coefficients (same idea as Vorbis)

225 
*/

226 
static void decode_exp_lsp(WMACodecContext *s, int ch) 
227 
{ 
228 
float lsp_coefs[NB_LSP_COEFS];

229 
int val, i;

230  
231 
for(i = 0; i < NB_LSP_COEFS; i++) { 
232 
if (i == 0  i >= 8) 
233 
val = get_bits(&s>gb, 3);

234 
else

235 
val = get_bits(&s>gb, 4);

236 
lsp_coefs[i] = ff_wma_lsp_codebook[i][val]; 
237 
} 
238  
239 
wma_lsp_to_curve(s, s>exponents[ch], &s>max_exponent[ch], 
240 
s>block_len, lsp_coefs); 
241 
} 
242  
243 
/** pow(10, i / 16.0) for i in 60..67 */

244 
static const float pow_tab[128] = { 
245 
1.7782794100389e04, 2.0535250264571e04, 
246 
2.3713737056617e04, 2.7384196342644e04, 
247 
3.1622776601684e04, 3.6517412725484e04, 
248 
4.2169650342858e04, 4.8696752516586e04, 
249 
5.6234132519035e04, 6.4938163157621e04, 
250 
7.4989420933246e04, 8.6596432336006e04, 
251 
1.0000000000000e03, 1.1547819846895e03, 
252 
1.3335214321633e03, 1.5399265260595e03, 
253 
1.7782794100389e03, 2.0535250264571e03, 
254 
2.3713737056617e03, 2.7384196342644e03, 
255 
3.1622776601684e03, 3.6517412725484e03, 
256 
4.2169650342858e03, 4.8696752516586e03, 
257 
5.6234132519035e03, 6.4938163157621e03, 
258 
7.4989420933246e03, 8.6596432336006e03, 
259 
1.0000000000000e02, 1.1547819846895e02, 
260 
1.3335214321633e02, 1.5399265260595e02, 
261 
1.7782794100389e02, 2.0535250264571e02, 
262 
2.3713737056617e02, 2.7384196342644e02, 
263 
3.1622776601684e02, 3.6517412725484e02, 
264 
4.2169650342858e02, 4.8696752516586e02, 
265 
5.6234132519035e02, 6.4938163157621e02, 
266 
7.4989420933246e02, 8.6596432336007e02, 
267 
1.0000000000000e01, 1.1547819846895e01, 
268 
1.3335214321633e01, 1.5399265260595e01, 
269 
1.7782794100389e01, 2.0535250264571e01, 
270 
2.3713737056617e01, 2.7384196342644e01, 
271 
3.1622776601684e01, 3.6517412725484e01, 
272 
4.2169650342858e01, 4.8696752516586e01, 
273 
5.6234132519035e01, 6.4938163157621e01, 
274 
7.4989420933246e01, 8.6596432336007e01, 
275 
1.0000000000000e+00, 1.1547819846895e+00, 
276 
1.3335214321633e+00, 1.5399265260595e+00, 
277 
1.7782794100389e+00, 2.0535250264571e+00, 
278 
2.3713737056617e+00, 2.7384196342644e+00, 
279 
3.1622776601684e+00, 3.6517412725484e+00, 
280 
4.2169650342858e+00, 4.8696752516586e+00, 
281 
5.6234132519035e+00, 6.4938163157621e+00, 
282 
7.4989420933246e+00, 8.6596432336007e+00, 
283 
1.0000000000000e+01, 1.1547819846895e+01, 
284 
1.3335214321633e+01, 1.5399265260595e+01, 
285 
1.7782794100389e+01, 2.0535250264571e+01, 
286 
2.3713737056617e+01, 2.7384196342644e+01, 
287 
3.1622776601684e+01, 3.6517412725484e+01, 
288 
4.2169650342858e+01, 4.8696752516586e+01, 
289 
5.6234132519035e+01, 6.4938163157621e+01, 
290 
7.4989420933246e+01, 8.6596432336007e+01, 
291 
1.0000000000000e+02, 1.1547819846895e+02, 
292 
1.3335214321633e+02, 1.5399265260595e+02, 
293 
1.7782794100389e+02, 2.0535250264571e+02, 
294 
2.3713737056617e+02, 2.7384196342644e+02, 
295 
3.1622776601684e+02, 3.6517412725484e+02, 
296 
4.2169650342858e+02, 4.8696752516586e+02, 
297 
5.6234132519035e+02, 6.4938163157621e+02, 
298 
7.4989420933246e+02, 8.6596432336007e+02, 
299 
1.0000000000000e+03, 1.1547819846895e+03, 
300 
1.3335214321633e+03, 1.5399265260595e+03, 
301 
1.7782794100389e+03, 2.0535250264571e+03, 
302 
2.3713737056617e+03, 2.7384196342644e+03, 
303 
3.1622776601684e+03, 3.6517412725484e+03, 
304 
4.2169650342858e+03, 4.8696752516586e+03, 
305 
5.6234132519035e+03, 6.4938163157621e+03, 
306 
7.4989420933246e+03, 8.6596432336007e+03, 
307 
1.0000000000000e+04, 1.1547819846895e+04, 
308 
1.3335214321633e+04, 1.5399265260595e+04, 
309 
}; 
310  
311 
/**

312 
* decode exponents coded with VLC codes

313 
*/

314 
static int decode_exp_vlc(WMACodecContext *s, int ch) 
315 
{ 
316 
int last_exp, n, code;

317 
const uint16_t *ptr;

318 
float v, max_scale;

319 
uint32_t *q, *q_end, iv; 
320 
const float *ptab = pow_tab + 60; 
321 
const uint32_t *iptab = (const uint32_t*)ptab; 
322  
323 
ptr = s>exponent_bands[s>frame_len_bits  s>block_len_bits]; 
324 
q = (uint32_t *)s>exponents[ch]; 
325 
q_end = q + s>block_len; 
326 
max_scale = 0;

327 
if (s>version == 1) { 
328 
last_exp = get_bits(&s>gb, 5) + 10; 
329 
v = ptab[last_exp]; 
330 
iv = iptab[last_exp]; 
331 
max_scale = v; 
332 
n = *ptr++; 
333 
switch (n & 3) do { 
334 
case 0: *q++ = iv; 
335 
case 3: *q++ = iv; 
336 
case 2: *q++ = iv; 
337 
case 1: *q++ = iv; 
338 
} while ((n = 4) > 0); 
339 
}else

340 
last_exp = 36;

341  
342 
while (q < q_end) {

343 
code = get_vlc2(&s>gb, s>exp_vlc.table, EXPVLCBITS, EXPMAX); 
344 
if (code < 0) 
345 
return 1; 
346 
/* NOTE: this offset is the same as MPEG4 AAC ! */

347 
last_exp += code  60;

348 
if ((unsigned)last_exp + 60 > FF_ARRAY_ELEMS(pow_tab)) 
349 
return 1; 
350 
v = ptab[last_exp]; 
351 
iv = iptab[last_exp]; 
352 
if (v > max_scale)

353 
max_scale = v; 
354 
n = *ptr++; 
355 
switch (n & 3) do { 
356 
case 0: *q++ = iv; 
357 
case 3: *q++ = iv; 
358 
case 2: *q++ = iv; 
359 
case 1: *q++ = iv; 
360 
} while ((n = 4) > 0); 
361 
} 
362 
s>max_exponent[ch] = max_scale; 
363 
return 0; 
364 
} 
365  
366  
367 
/**

368 
* Apply MDCT window and add into output.

369 
*

370 
* We ensure that when the windows overlap their squared sum

371 
* is always 1 (MDCT reconstruction rule).

372 
*/

373 
static void wma_window(WMACodecContext *s, float *out) 
374 
{ 
375 
float *in = s>output;

376 
int block_len, bsize, n;

377  
378 
/* left part */

379 
if (s>block_len_bits <= s>prev_block_len_bits) {

380 
block_len = s>block_len; 
381 
bsize = s>frame_len_bits  s>block_len_bits; 
382  
383 
s>dsp.vector_fmul_add(out, in, s>windows[bsize], 
384 
out, block_len); 
385  
386 
} else {

387 
block_len = 1 << s>prev_block_len_bits;

388 
n = (s>block_len  block_len) / 2;

389 
bsize = s>frame_len_bits  s>prev_block_len_bits; 
390  
391 
s>dsp.vector_fmul_add(out+n, in+n, s>windows[bsize], 
392 
out+n, block_len); 
393  
394 
memcpy(out+n+block_len, in+n+block_len, n*sizeof(float)); 
395 
} 
396  
397 
out += s>block_len; 
398 
in += s>block_len; 
399  
400 
/* right part */

401 
if (s>block_len_bits <= s>next_block_len_bits) {

402 
block_len = s>block_len; 
403 
bsize = s>frame_len_bits  s>block_len_bits; 
404  
405 
s>dsp.vector_fmul_reverse(out, in, s>windows[bsize], block_len); 
406  
407 
} else {

408 
block_len = 1 << s>next_block_len_bits;

409 
n = (s>block_len  block_len) / 2;

410 
bsize = s>frame_len_bits  s>next_block_len_bits; 
411  
412 
memcpy(out, in, n*sizeof(float)); 
413  
414 
s>dsp.vector_fmul_reverse(out+n, in+n, s>windows[bsize], block_len); 
415  
416 
memset(out+n+block_len, 0, n*sizeof(float)); 
417 
} 
418 
} 
419  
420  
421 
/**

422 
* @return 0 if OK. 1 if last block of frame. return 1 if

423 
* unrecorrable error.

424 
*/

425 
static int wma_decode_block(WMACodecContext *s) 
426 
{ 
427 
int n, v, a, ch, bsize;

428 
int coef_nb_bits, total_gain;

429 
int nb_coefs[MAX_CHANNELS];

430 
float mdct_norm;

431  
432 
#ifdef TRACE

433 
tprintf(s>avctx, "***decode_block: %d:%d\n", s>frame_count  1, s>block_num); 
434 
#endif

435  
436 
/* compute current block length */

437 
if (s>use_variable_block_len) {

438 
n = av_log2(s>nb_block_sizes  1) + 1; 
439  
440 
if (s>reset_block_lengths) {

441 
s>reset_block_lengths = 0;

442 
v = get_bits(&s>gb, n); 
443 
if (v >= s>nb_block_sizes)

444 
return 1; 
445 
s>prev_block_len_bits = s>frame_len_bits  v; 
446 
v = get_bits(&s>gb, n); 
447 
if (v >= s>nb_block_sizes)

448 
return 1; 
449 
s>block_len_bits = s>frame_len_bits  v; 
450 
} else {

451 
/* update block lengths */

452 
s>prev_block_len_bits = s>block_len_bits; 
453 
s>block_len_bits = s>next_block_len_bits; 
454 
} 
455 
v = get_bits(&s>gb, n); 
456 
if (v >= s>nb_block_sizes)

457 
return 1; 
458 
s>next_block_len_bits = s>frame_len_bits  v; 
459 
} else {

460 
/* fixed block len */

461 
s>next_block_len_bits = s>frame_len_bits; 
462 
s>prev_block_len_bits = s>frame_len_bits; 
463 
s>block_len_bits = s>frame_len_bits; 
464 
} 
465  
466 
/* now check if the block length is coherent with the frame length */

467 
s>block_len = 1 << s>block_len_bits;

468 
if ((s>block_pos + s>block_len) > s>frame_len)

469 
return 1; 
470  
471 
if (s>nb_channels == 2) { 
472 
s>ms_stereo = get_bits1(&s>gb); 
473 
} 
474 
v = 0;

475 
for(ch = 0; ch < s>nb_channels; ch++) { 
476 
a = get_bits1(&s>gb); 
477 
s>channel_coded[ch] = a; 
478 
v = a; 
479 
} 
480  
481 
bsize = s>frame_len_bits  s>block_len_bits; 
482  
483 
/* if no channel coded, no need to go further */

484 
/* XXX: fix potential framing problems */

485 
if (!v)

486 
goto next;

487  
488 
/* read total gain and extract corresponding number of bits for

489 
coef escape coding */

490 
total_gain = 1;

491 
for(;;) {

492 
a = get_bits(&s>gb, 7);

493 
total_gain += a; 
494 
if (a != 127) 
495 
break;

496 
} 
497  
498 
coef_nb_bits= ff_wma_total_gain_to_bits(total_gain); 
499  
500 
/* compute number of coefficients */

501 
n = s>coefs_end[bsize]  s>coefs_start; 
502 
for(ch = 0; ch < s>nb_channels; ch++) 
503 
nb_coefs[ch] = n; 
504  
505 
/* complex coding */

506 
if (s>use_noise_coding) {

507  
508 
for(ch = 0; ch < s>nb_channels; ch++) { 
509 
if (s>channel_coded[ch]) {

510 
int i, n, a;

511 
n = s>exponent_high_sizes[bsize]; 
512 
for(i=0;i<n;i++) { 
513 
a = get_bits1(&s>gb); 
514 
s>high_band_coded[ch][i] = a; 
515 
/* if noise coding, the coefficients are not transmitted */

516 
if (a)

517 
nb_coefs[ch] = s>exponent_high_bands[bsize][i]; 
518 
} 
519 
} 
520 
} 
521 
for(ch = 0; ch < s>nb_channels; ch++) { 
522 
if (s>channel_coded[ch]) {

523 
int i, n, val, code;

524  
525 
n = s>exponent_high_sizes[bsize]; 
526 
val = (int)0x80000000; 
527 
for(i=0;i<n;i++) { 
528 
if (s>high_band_coded[ch][i]) {

529 
if (val == (int)0x80000000) { 
530 
val = get_bits(&s>gb, 7)  19; 
531 
} else {

532 
code = get_vlc2(&s>gb, s>hgain_vlc.table, HGAINVLCBITS, HGAINMAX); 
533 
if (code < 0) 
534 
return 1; 
535 
val += code  18;

536 
} 
537 
s>high_band_values[ch][i] = val; 
538 
} 
539 
} 
540 
} 
541 
} 
542 
} 
543  
544 
/* exponents can be reused in short blocks. */

545 
if ((s>block_len_bits == s>frame_len_bits) 

546 
get_bits1(&s>gb)) { 
547 
for(ch = 0; ch < s>nb_channels; ch++) { 
548 
if (s>channel_coded[ch]) {

549 
if (s>use_exp_vlc) {

550 
if (decode_exp_vlc(s, ch) < 0) 
551 
return 1; 
552 
} else {

553 
decode_exp_lsp(s, ch); 
554 
} 
555 
s>exponents_bsize[ch] = bsize; 
556 
} 
557 
} 
558 
} 
559  
560 
/* parse spectral coefficients : just RLE encoding */

561 
for(ch = 0; ch < s>nb_channels; ch++) { 
562 
if (s>channel_coded[ch]) {

563 
int tindex;

564 
WMACoef* ptr = &s>coefs1[ch][0];

565  
566 
/* special VLC tables are used for ms stereo because

567 
there is potentially less energy there */

568 
tindex = (ch == 1 && s>ms_stereo);

569 
memset(ptr, 0, s>block_len * sizeof(WMACoef)); 
570 
ff_wma_run_level_decode(s>avctx, &s>gb, &s>coef_vlc[tindex], 
571 
s>level_table[tindex], s>run_table[tindex], 
572 
0, ptr, 0, nb_coefs[ch], 
573 
s>block_len, s>frame_len_bits, coef_nb_bits); 
574 
} 
575 
if (s>version == 1 && s>nb_channels >= 2) { 
576 
align_get_bits(&s>gb); 
577 
} 
578 
} 
579  
580 
/* normalize */

581 
{ 
582 
int n4 = s>block_len / 2; 
583 
mdct_norm = 1.0 / (float)n4; 
584 
if (s>version == 1) { 
585 
mdct_norm *= sqrt(n4); 
586 
} 
587 
} 
588  
589 
/* finally compute the MDCT coefficients */

590 
for(ch = 0; ch < s>nb_channels; ch++) { 
591 
if (s>channel_coded[ch]) {

592 
WMACoef *coefs1; 
593 
float *coefs, *exponents, mult, mult1, noise;

594 
int i, j, n, n1, last_high_band, esize;

595 
float exp_power[HIGH_BAND_MAX_SIZE];

596  
597 
coefs1 = s>coefs1[ch]; 
598 
exponents = s>exponents[ch]; 
599 
esize = s>exponents_bsize[ch]; 
600 
mult = pow(10, total_gain * 0.05) / s>max_exponent[ch]; 
601 
mult *= mdct_norm; 
602 
coefs = s>coefs[ch]; 
603 
if (s>use_noise_coding) {

604 
mult1 = mult; 
605 
/* very low freqs : noise */

606 
for(i = 0;i < s>coefs_start; i++) { 
607 
*coefs++ = s>noise_table[s>noise_index] * 
608 
exponents[i<<bsize>>esize] * mult1; 
609 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
610 
} 
611  
612 
n1 = s>exponent_high_sizes[bsize]; 
613  
614 
/* compute power of high bands */

615 
exponents = s>exponents[ch] + 
616 
(s>high_band_start[bsize]<<bsize); 
617 
last_high_band = 0; /* avoid warning */ 
618 
for(j=0;j<n1;j++) { 
619 
n = s>exponent_high_bands[s>frame_len_bits  
620 
s>block_len_bits][j]; 
621 
if (s>high_band_coded[ch][j]) {

622 
float e2, v;

623 
e2 = 0;

624 
for(i = 0;i < n; i++) { 
625 
v = exponents[i<<bsize>>esize]; 
626 
e2 += v * v; 
627 
} 
628 
exp_power[j] = e2 / n; 
629 
last_high_band = j; 
630 
tprintf(s>avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);

631 
} 
632 
exponents += n<<bsize; 
633 
} 
634  
635 
/* main freqs and high freqs */

636 
exponents = s>exponents[ch] + (s>coefs_start<<bsize); 
637 
for(j=1;j<n1;j++) { 
638 
if (j < 0) { 
639 
n = s>high_band_start[bsize]  
640 
s>coefs_start; 
641 
} else {

642 
n = s>exponent_high_bands[s>frame_len_bits  
643 
s>block_len_bits][j]; 
644 
} 
645 
if (j >= 0 && s>high_band_coded[ch][j]) { 
646 
/* use noise with specified power */

647 
mult1 = sqrt(exp_power[j] / exp_power[last_high_band]); 
648 
/* XXX: use a table */

649 
mult1 = mult1 * pow(10, s>high_band_values[ch][j] * 0.05); 
650 
mult1 = mult1 / (s>max_exponent[ch] * s>noise_mult); 
651 
mult1 *= mdct_norm; 
652 
for(i = 0;i < n; i++) { 
653 
noise = s>noise_table[s>noise_index]; 
654 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
655 
*coefs++ = noise * 
656 
exponents[i<<bsize>>esize] * mult1; 
657 
} 
658 
exponents += n<<bsize; 
659 
} else {

660 
/* coded values + small noise */

661 
for(i = 0;i < n; i++) { 
662 
noise = s>noise_table[s>noise_index]; 
663 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
664 
*coefs++ = ((*coefs1++) + noise) * 
665 
exponents[i<<bsize>>esize] * mult; 
666 
} 
667 
exponents += n<<bsize; 
668 
} 
669 
} 
670  
671 
/* very high freqs : noise */

672 
n = s>block_len  s>coefs_end[bsize]; 
673 
mult1 = mult * exponents[((1<<bsize))>>esize];

674 
for(i = 0; i < n; i++) { 
675 
*coefs++ = s>noise_table[s>noise_index] * mult1; 
676 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
677 
} 
678 
} else {

679 
/* XXX: optimize more */

680 
for(i = 0;i < s>coefs_start; i++) 
681 
*coefs++ = 0.0; 
682 
n = nb_coefs[ch]; 
683 
for(i = 0;i < n; i++) { 
684 
*coefs++ = coefs1[i] * exponents[i<<bsize>>esize] * mult; 
685 
} 
686 
n = s>block_len  s>coefs_end[bsize]; 
687 
for(i = 0;i < n; i++) 
688 
*coefs++ = 0.0; 
689 
} 
690 
} 
691 
} 
692  
693 
#ifdef TRACE

694 
for(ch = 0; ch < s>nb_channels; ch++) { 
695 
if (s>channel_coded[ch]) {

696 
dump_floats(s, "exponents", 3, s>exponents[ch], s>block_len); 
697 
dump_floats(s, "coefs", 1, s>coefs[ch], s>block_len); 
698 
} 
699 
} 
700 
#endif

701  
702 
if (s>ms_stereo && s>channel_coded[1]) { 
703 
/* nominal case for ms stereo: we do it before mdct */

704 
/* no need to optimize this case because it should almost

705 
never happen */

706 
if (!s>channel_coded[0]) { 
707 
tprintf(s>avctx, "rare msstereo case happened\n");

708 
memset(s>coefs[0], 0, sizeof(float) * s>block_len); 
709 
s>channel_coded[0] = 1; 
710 
} 
711  
712 
s>dsp.butterflies_float(s>coefs[0], s>coefs[1], s>block_len); 
713 
} 
714  
715 
next:

716 
for(ch = 0; ch < s>nb_channels; ch++) { 
717 
int n4, index;

718  
719 
n4 = s>block_len / 2;

720 
if(s>channel_coded[ch]){

721 
ff_imdct_calc(&s>mdct_ctx[bsize], s>output, s>coefs[ch]); 
722 
}else if(!(s>ms_stereo && ch==1)) 
723 
memset(s>output, 0, sizeof(s>output)); 
724  
725 
/* multiply by the window and add in the frame */

726 
index = (s>frame_len / 2) + s>block_pos  n4;

727 
wma_window(s, &s>frame_out[ch][index]); 
728 
} 
729  
730 
/* update block number */

731 
s>block_num++; 
732 
s>block_pos += s>block_len; 
733 
if (s>block_pos >= s>frame_len)

734 
return 1; 
735 
else

736 
return 0; 
737 
} 
738  
739 
/* decode a frame of frame_len samples */

740 
static int wma_decode_frame(WMACodecContext *s, int16_t *samples) 
741 
{ 
742 
int ret, i, n, ch, incr;

743 
int16_t *ptr; 
744 
float *iptr;

745  
746 
#ifdef TRACE

747 
tprintf(s>avctx, "***decode_frame: %d size=%d\n", s>frame_count++, s>frame_len);

748 
#endif

749  
750 
/* read each block */

751 
s>block_num = 0;

752 
s>block_pos = 0;

753 
for(;;) {

754 
ret = wma_decode_block(s); 
755 
if (ret < 0) 
756 
return 1; 
757 
if (ret)

758 
break;

759 
} 
760  
761 
/* convert frame to integer */

762 
n = s>frame_len; 
763 
incr = s>nb_channels; 
764 
for(ch = 0; ch < s>nb_channels; ch++) { 
765 
ptr = samples + ch; 
766 
iptr = s>frame_out[ch]; 
767  
768 
for(i=0;i<n;i++) { 
769 
*ptr = av_clip_int16(lrintf(*iptr++)); 
770 
ptr += incr; 
771 
} 
772 
/* prepare for next block */

773 
memmove(&s>frame_out[ch][0], &s>frame_out[ch][s>frame_len],

774 
s>frame_len * sizeof(float)); 
775 
} 
776  
777 
#ifdef TRACE

778 
dump_shorts(s, "samples", samples, n * s>nb_channels);

779 
#endif

780 
return 0; 
781 
} 
782  
783 
static int wma_decode_superframe(AVCodecContext *avctx, 
784 
void *data, int *data_size, 
785 
AVPacket *avpkt) 
786 
{ 
787 
const uint8_t *buf = avpkt>data;

788 
int buf_size = avpkt>size;

789 
WMACodecContext *s = avctx>priv_data; 
790 
int nb_frames, bit_offset, i, pos, len;

791 
uint8_t *q; 
792 
int16_t *samples; 
793  
794 
tprintf(avctx, "***decode_superframe:\n");

795  
796 
if(buf_size==0){ 
797 
s>last_superframe_len = 0;

798 
return 0; 
799 
} 
800 
if (buf_size < s>block_align)

801 
return 0; 
802 
buf_size = s>block_align; 
803  
804 
samples = data; 
805  
806 
init_get_bits(&s>gb, buf, buf_size*8);

807  
808 
if (s>use_bit_reservoir) {

809 
/* read super frame header */

810 
skip_bits(&s>gb, 4); /* super frame index */ 
811 
nb_frames = get_bits(&s>gb, 4)  1; 
812  
813 
if((nb_frames+1) * s>nb_channels * s>frame_len * sizeof(int16_t) > *data_size){ 
814 
av_log(s>avctx, AV_LOG_ERROR, "Insufficient output space\n");

815 
goto fail;

816 
} 
817  
818 
bit_offset = get_bits(&s>gb, s>byte_offset_bits + 3);

819  
820 
if (s>last_superframe_len > 0) { 
821 
// printf("skip=%d\n", s>last_bitoffset);

822 
/* add bit_offset bits to last frame */

823 
if ((s>last_superframe_len + ((bit_offset + 7) >> 3)) > 
824 
MAX_CODED_SUPERFRAME_SIZE) 
825 
goto fail;

826 
q = s>last_superframe + s>last_superframe_len; 
827 
len = bit_offset; 
828 
while (len > 7) { 
829 
*q++ = (get_bits)(&s>gb, 8);

830 
len = 8;

831 
} 
832 
if (len > 0) { 
833 
*q++ = (get_bits)(&s>gb, len) << (8  len);

834 
} 
835  
836 
/* XXX: bit_offset bits into last frame */

837 
init_get_bits(&s>gb, s>last_superframe, MAX_CODED_SUPERFRAME_SIZE*8);

838 
/* skip unused bits */

839 
if (s>last_bitoffset > 0) 
840 
skip_bits(&s>gb, s>last_bitoffset); 
841 
/* this frame is stored in the last superframe and in the

842 
current one */

843 
if (wma_decode_frame(s, samples) < 0) 
844 
goto fail;

845 
samples += s>nb_channels * s>frame_len; 
846 
} 
847  
848 
/* read each frame starting from bit_offset */

849 
pos = bit_offset + 4 + 4 + s>byte_offset_bits + 3; 
850 
init_get_bits(&s>gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE  (pos >> 3))*8); 
851 
len = pos & 7;

852 
if (len > 0) 
853 
skip_bits(&s>gb, len); 
854  
855 
s>reset_block_lengths = 1;

856 
for(i=0;i<nb_frames;i++) { 
857 
if (wma_decode_frame(s, samples) < 0) 
858 
goto fail;

859 
samples += s>nb_channels * s>frame_len; 
860 
} 
861  
862 
/* we copy the end of the frame in the last frame buffer */

863 
pos = get_bits_count(&s>gb) + ((bit_offset + 4 + 4 + s>byte_offset_bits + 3) & ~7); 
864 
s>last_bitoffset = pos & 7;

865 
pos >>= 3;

866 
len = buf_size  pos; 
867 
if (len > MAX_CODED_SUPERFRAME_SIZE  len < 0) { 
868 
goto fail;

869 
} 
870 
s>last_superframe_len = len; 
871 
memcpy(s>last_superframe, buf + pos, len); 
872 
} else {

873 
if(s>nb_channels * s>frame_len * sizeof(int16_t) > *data_size){ 
874 
av_log(s>avctx, AV_LOG_ERROR, "Insufficient output space\n");

875 
goto fail;

876 
} 
877 
/* single frame decode */

878 
if (wma_decode_frame(s, samples) < 0) 
879 
goto fail;

880 
samples += s>nb_channels * s>frame_len; 
881 
} 
882  
883 
//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);

884  
885 
*data_size = (int8_t *)samples  (int8_t *)data; 
886 
return s>block_align;

887 
fail:

888 
/* when error, we reset the bit reservoir */

889 
s>last_superframe_len = 0;

890 
return 1; 
891 
} 
892  
893 
AVCodec wmav1_decoder = 
894 
{ 
895 
"wmav1",

896 
CODEC_TYPE_AUDIO, 
897 
CODEC_ID_WMAV1, 
898 
sizeof(WMACodecContext),

899 
wma_decode_init, 
900 
NULL,

901 
ff_wma_end, 
902 
wma_decode_superframe, 
903 
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),

904 
}; 
905  
906 
AVCodec wmav2_decoder = 
907 
{ 
908 
"wmav2",

909 
CODEC_TYPE_AUDIO, 
910 
CODEC_ID_WMAV2, 
911 
sizeof(WMACodecContext),

912 
wma_decode_init, 
913 
NULL,

914 
ff_wma_end, 
915 
wma_decode_superframe, 
916 
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),

917 
}; 