ffmpeg / libavcodec / wmadec.c @ 5d6e4c16
History  View  Annotate  Download (31.4 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

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_aac_scalefactor_bits), //FIXME move out of context 
120 
ff_aac_scalefactor_bits, 1, 1, 
121 
ff_aac_scalefactor_code, 4, 4, 0); 
122 
} else {

123 
wma_lsp_to_curve_init(s, s>frame_len); 
124 
} 
125  
126 
avctx>sample_fmt = AV_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..95 */

244 
static const float pow_tab[] = { 
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 
1.7782794100389e+04, 2.0535250264571e+04, 
310 
2.3713737056617e+04, 2.7384196342644e+04, 
311 
3.1622776601684e+04, 3.6517412725484e+04, 
312 
4.2169650342858e+04, 4.8696752516586e+04, 
313 
5.6234132519035e+04, 6.4938163157621e+04, 
314 
7.4989420933246e+04, 8.6596432336007e+04, 
315 
1.0000000000000e+05, 1.1547819846895e+05, 
316 
1.3335214321633e+05, 1.5399265260595e+05, 
317 
1.7782794100389e+05, 2.0535250264571e+05, 
318 
2.3713737056617e+05, 2.7384196342644e+05, 
319 
3.1622776601684e+05, 3.6517412725484e+05, 
320 
4.2169650342858e+05, 4.8696752516586e+05, 
321 
5.6234132519035e+05, 6.4938163157621e+05, 
322 
7.4989420933246e+05, 8.6596432336007e+05, 
323 
}; 
324  
325 
/**

326 
* decode exponents coded with VLC codes

327 
*/

328 
static int decode_exp_vlc(WMACodecContext *s, int ch) 
329 
{ 
330 
int last_exp, n, code;

331 
const uint16_t *ptr;

332 
float v, max_scale;

333 
uint32_t *q, *q_end, iv; 
334 
const float *ptab = pow_tab + 60; 
335 
const uint32_t *iptab = (const uint32_t*)ptab; 
336  
337 
ptr = s>exponent_bands[s>frame_len_bits  s>block_len_bits]; 
338 
q = (uint32_t *)s>exponents[ch]; 
339 
q_end = q + s>block_len; 
340 
max_scale = 0;

341 
if (s>version == 1) { 
342 
last_exp = get_bits(&s>gb, 5) + 10; 
343 
v = ptab[last_exp]; 
344 
iv = iptab[last_exp]; 
345 
max_scale = v; 
346 
n = *ptr++; 
347 
switch (n & 3) do { 
348 
case 0: *q++ = iv; 
349 
case 3: *q++ = iv; 
350 
case 2: *q++ = iv; 
351 
case 1: *q++ = iv; 
352 
} while ((n = 4) > 0); 
353 
}else

354 
last_exp = 36;

355  
356 
while (q < q_end) {

357 
code = get_vlc2(&s>gb, s>exp_vlc.table, EXPVLCBITS, EXPMAX); 
358 
if (code < 0){ 
359 
av_log(s>avctx, AV_LOG_ERROR, "Exponent vlc invalid\n");

360 
return 1; 
361 
} 
362 
/* NOTE: this offset is the same as MPEG4 AAC ! */

363 
last_exp += code  60;

364 
if ((unsigned)last_exp + 60 > FF_ARRAY_ELEMS(pow_tab)) { 
365 
av_log(s>avctx, AV_LOG_ERROR, "Exponent out of range: %d\n",

366 
last_exp); 
367 
return 1; 
368 
} 
369 
v = ptab[last_exp]; 
370 
iv = iptab[last_exp]; 
371 
if (v > max_scale)

372 
max_scale = v; 
373 
n = *ptr++; 
374 
switch (n & 3) do { 
375 
case 0: *q++ = iv; 
376 
case 3: *q++ = iv; 
377 
case 2: *q++ = iv; 
378 
case 1: *q++ = iv; 
379 
} while ((n = 4) > 0); 
380 
} 
381 
s>max_exponent[ch] = max_scale; 
382 
return 0; 
383 
} 
384  
385  
386 
/**

387 
* Apply MDCT window and add into output.

388 
*

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

390 
* is always 1 (MDCT reconstruction rule).

391 
*/

392 
static void wma_window(WMACodecContext *s, float *out) 
393 
{ 
394 
float *in = s>output;

395 
int block_len, bsize, n;

396  
397 
/* left part */

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

399 
block_len = s>block_len; 
400 
bsize = s>frame_len_bits  s>block_len_bits; 
401  
402 
s>dsp.vector_fmul_add(out, in, s>windows[bsize], 
403 
out, block_len); 
404  
405 
} else {

406 
block_len = 1 << s>prev_block_len_bits;

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

408 
bsize = s>frame_len_bits  s>prev_block_len_bits; 
409  
410 
s>dsp.vector_fmul_add(out+n, in+n, s>windows[bsize], 
411 
out+n, block_len); 
412  
413 
memcpy(out+n+block_len, in+n+block_len, n*sizeof(float)); 
414 
} 
415  
416 
out += s>block_len; 
417 
in += s>block_len; 
418  
419 
/* right part */

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

421 
block_len = s>block_len; 
422 
bsize = s>frame_len_bits  s>block_len_bits; 
423  
424 
s>dsp.vector_fmul_reverse(out, in, s>windows[bsize], block_len); 
425  
426 
} else {

427 
block_len = 1 << s>next_block_len_bits;

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

429 
bsize = s>frame_len_bits  s>next_block_len_bits; 
430  
431 
memcpy(out, in, n*sizeof(float)); 
432  
433 
s>dsp.vector_fmul_reverse(out+n, in+n, s>windows[bsize], block_len); 
434  
435 
memset(out+n+block_len, 0, n*sizeof(float)); 
436 
} 
437 
} 
438  
439  
440 
/**

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

442 
* unrecorrable error.

443 
*/

444 
static int wma_decode_block(WMACodecContext *s) 
445 
{ 
446 
int n, v, a, ch, bsize;

447 
int coef_nb_bits, total_gain;

448 
int nb_coefs[MAX_CHANNELS];

449 
float mdct_norm;

450  
451 
#ifdef TRACE

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

454  
455 
/* compute current block length */

456 
if (s>use_variable_block_len) {

457 
n = av_log2(s>nb_block_sizes  1) + 1; 
458  
459 
if (s>reset_block_lengths) {

460 
s>reset_block_lengths = 0;

461 
v = get_bits(&s>gb, n); 
462 
if (v >= s>nb_block_sizes){

463 
av_log(s>avctx, AV_LOG_ERROR, "prev_block_len_bits %d out of range\n", s>frame_len_bits  v);

464 
return 1; 
465 
} 
466 
s>prev_block_len_bits = s>frame_len_bits  v; 
467 
v = get_bits(&s>gb, n); 
468 
if (v >= s>nb_block_sizes){

469 
av_log(s>avctx, AV_LOG_ERROR, "block_len_bits %d out of range\n", s>frame_len_bits  v);

470 
return 1; 
471 
} 
472 
s>block_len_bits = s>frame_len_bits  v; 
473 
} else {

474 
/* update block lengths */

475 
s>prev_block_len_bits = s>block_len_bits; 
476 
s>block_len_bits = s>next_block_len_bits; 
477 
} 
478 
v = get_bits(&s>gb, n); 
479 
if (v >= s>nb_block_sizes){

480 
av_log(s>avctx, AV_LOG_ERROR, "next_block_len_bits %d out of range\n", s>frame_len_bits  v);

481 
return 1; 
482 
} 
483 
s>next_block_len_bits = s>frame_len_bits  v; 
484 
} else {

485 
/* fixed block len */

486 
s>next_block_len_bits = s>frame_len_bits; 
487 
s>prev_block_len_bits = s>frame_len_bits; 
488 
s>block_len_bits = s>frame_len_bits; 
489 
} 
490  
491 
/* now check if the block length is coherent with the frame length */

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

493 
if ((s>block_pos + s>block_len) > s>frame_len){

494 
av_log(s>avctx, AV_LOG_ERROR, "frame_len overflow\n");

495 
return 1; 
496 
} 
497  
498 
if (s>nb_channels == 2) { 
499 
s>ms_stereo = get_bits1(&s>gb); 
500 
} 
501 
v = 0;

502 
for(ch = 0; ch < s>nb_channels; ch++) { 
503 
a = get_bits1(&s>gb); 
504 
s>channel_coded[ch] = a; 
505 
v = a; 
506 
} 
507  
508 
bsize = s>frame_len_bits  s>block_len_bits; 
509  
510 
/* if no channel coded, no need to go further */

511 
/* XXX: fix potential framing problems */

512 
if (!v)

513 
goto next;

514  
515 
/* read total gain and extract corresponding number of bits for

516 
coef escape coding */

517 
total_gain = 1;

518 
for(;;) {

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

520 
total_gain += a; 
521 
if (a != 127) 
522 
break;

523 
} 
524  
525 
coef_nb_bits= ff_wma_total_gain_to_bits(total_gain); 
526  
527 
/* compute number of coefficients */

528 
n = s>coefs_end[bsize]  s>coefs_start; 
529 
for(ch = 0; ch < s>nb_channels; ch++) 
530 
nb_coefs[ch] = n; 
531  
532 
/* complex coding */

533 
if (s>use_noise_coding) {

534  
535 
for(ch = 0; ch < s>nb_channels; ch++) { 
536 
if (s>channel_coded[ch]) {

537 
int i, n, a;

538 
n = s>exponent_high_sizes[bsize]; 
539 
for(i=0;i<n;i++) { 
540 
a = get_bits1(&s>gb); 
541 
s>high_band_coded[ch][i] = a; 
542 
/* if noise coding, the coefficients are not transmitted */

543 
if (a)

544 
nb_coefs[ch] = s>exponent_high_bands[bsize][i]; 
545 
} 
546 
} 
547 
} 
548 
for(ch = 0; ch < s>nb_channels; ch++) { 
549 
if (s>channel_coded[ch]) {

550 
int i, n, val, code;

551  
552 
n = s>exponent_high_sizes[bsize]; 
553 
val = (int)0x80000000; 
554 
for(i=0;i<n;i++) { 
555 
if (s>high_band_coded[ch][i]) {

556 
if (val == (int)0x80000000) { 
557 
val = get_bits(&s>gb, 7)  19; 
558 
} else {

559 
code = get_vlc2(&s>gb, s>hgain_vlc.table, HGAINVLCBITS, HGAINMAX); 
560 
if (code < 0){ 
561 
av_log(s>avctx, AV_LOG_ERROR, "hgain vlc invalid\n");

562 
return 1; 
563 
} 
564 
val += code  18;

565 
} 
566 
s>high_band_values[ch][i] = val; 
567 
} 
568 
} 
569 
} 
570 
} 
571 
} 
572  
573 
/* exponents can be reused in short blocks. */

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

575 
get_bits1(&s>gb)) { 
576 
for(ch = 0; ch < s>nb_channels; ch++) { 
577 
if (s>channel_coded[ch]) {

578 
if (s>use_exp_vlc) {

579 
if (decode_exp_vlc(s, ch) < 0) 
580 
return 1; 
581 
} else {

582 
decode_exp_lsp(s, ch); 
583 
} 
584 
s>exponents_bsize[ch] = bsize; 
585 
} 
586 
} 
587 
} 
588  
589 
/* parse spectral coefficients : just RLE encoding */

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

592 
int tindex;

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

594  
595 
/* special VLC tables are used for ms stereo because

596 
there is potentially less energy there */

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

598 
memset(ptr, 0, s>block_len * sizeof(WMACoef)); 
599 
ff_wma_run_level_decode(s>avctx, &s>gb, &s>coef_vlc[tindex], 
600 
s>level_table[tindex], s>run_table[tindex], 
601 
0, ptr, 0, nb_coefs[ch], 
602 
s>block_len, s>frame_len_bits, coef_nb_bits); 
603 
} 
604 
if (s>version == 1 && s>nb_channels >= 2) { 
605 
align_get_bits(&s>gb); 
606 
} 
607 
} 
608  
609 
/* normalize */

610 
{ 
611 
int n4 = s>block_len / 2; 
612 
mdct_norm = 1.0 / (float)n4; 
613 
if (s>version == 1) { 
614 
mdct_norm *= sqrt(n4); 
615 
} 
616 
} 
617  
618 
/* finally compute the MDCT coefficients */

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

621 
WMACoef *coefs1; 
622 
float *coefs, *exponents, mult, mult1, noise;

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

624 
float exp_power[HIGH_BAND_MAX_SIZE];

625  
626 
coefs1 = s>coefs1[ch]; 
627 
exponents = s>exponents[ch]; 
628 
esize = s>exponents_bsize[ch]; 
629 
mult = pow(10, total_gain * 0.05) / s>max_exponent[ch]; 
630 
mult *= mdct_norm; 
631 
coefs = s>coefs[ch]; 
632 
if (s>use_noise_coding) {

633 
mult1 = mult; 
634 
/* very low freqs : noise */

635 
for(i = 0;i < s>coefs_start; i++) { 
636 
*coefs++ = s>noise_table[s>noise_index] * 
637 
exponents[i<<bsize>>esize] * mult1; 
638 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
639 
} 
640  
641 
n1 = s>exponent_high_sizes[bsize]; 
642  
643 
/* compute power of high bands */

644 
exponents = s>exponents[ch] + 
645 
(s>high_band_start[bsize]<<bsize>>esize); 
646 
last_high_band = 0; /* avoid warning */ 
647 
for(j=0;j<n1;j++) { 
648 
n = s>exponent_high_bands[s>frame_len_bits  
649 
s>block_len_bits][j]; 
650 
if (s>high_band_coded[ch][j]) {

651 
float e2, v;

652 
e2 = 0;

653 
for(i = 0;i < n; i++) { 
654 
v = exponents[i<<bsize>>esize]; 
655 
e2 += v * v; 
656 
} 
657 
exp_power[j] = e2 / n; 
658 
last_high_band = j; 
659 
tprintf(s>avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);

660 
} 
661 
exponents += n<<bsize>>esize; 
662 
} 
663  
664 
/* main freqs and high freqs */

665 
exponents = s>exponents[ch] + (s>coefs_start<<bsize>>esize); 
666 
for(j=1;j<n1;j++) { 
667 
if (j < 0) { 
668 
n = s>high_band_start[bsize]  
669 
s>coefs_start; 
670 
} else {

671 
n = s>exponent_high_bands[s>frame_len_bits  
672 
s>block_len_bits][j]; 
673 
} 
674 
if (j >= 0 && s>high_band_coded[ch][j]) { 
675 
/* use noise with specified power */

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

678 
mult1 = mult1 * pow(10, s>high_band_values[ch][j] * 0.05); 
679 
mult1 = mult1 / (s>max_exponent[ch] * s>noise_mult); 
680 
mult1 *= mdct_norm; 
681 
for(i = 0;i < n; i++) { 
682 
noise = s>noise_table[s>noise_index]; 
683 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
684 
*coefs++ = noise * 
685 
exponents[i<<bsize>>esize] * mult1; 
686 
} 
687 
exponents += n<<bsize>>esize; 
688 
} else {

689 
/* coded values + small noise */

690 
for(i = 0;i < n; i++) { 
691 
noise = s>noise_table[s>noise_index]; 
692 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
693 
*coefs++ = ((*coefs1++) + noise) * 
694 
exponents[i<<bsize>>esize] * mult; 
695 
} 
696 
exponents += n<<bsize>>esize; 
697 
} 
698 
} 
699  
700 
/* very high freqs : noise */

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

703 
for(i = 0; i < n; i++) { 
704 
*coefs++ = s>noise_table[s>noise_index] * mult1; 
705 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
706 
} 
707 
} else {

708 
/* XXX: optimize more */

709 
for(i = 0;i < s>coefs_start; i++) 
710 
*coefs++ = 0.0; 
711 
n = nb_coefs[ch]; 
712 
for(i = 0;i < n; i++) { 
713 
*coefs++ = coefs1[i] * exponents[i<<bsize>>esize] * mult; 
714 
} 
715 
n = s>block_len  s>coefs_end[bsize]; 
716 
for(i = 0;i < n; i++) 
717 
*coefs++ = 0.0; 
718 
} 
719 
} 
720 
} 
721  
722 
#ifdef TRACE

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

725 
dump_floats(s, "exponents", 3, s>exponents[ch], s>block_len); 
726 
dump_floats(s, "coefs", 1, s>coefs[ch], s>block_len); 
727 
} 
728 
} 
729 
#endif

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

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

734 
never happen */

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

737 
memset(s>coefs[0], 0, sizeof(float) * s>block_len); 
738 
s>channel_coded[0] = 1; 
739 
} 
740  
741 
s>dsp.butterflies_float(s>coefs[0], s>coefs[1], s>block_len); 
742 
} 
743  
744 
next:

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

747  
748 
n4 = s>block_len / 2;

749 
if(s>channel_coded[ch]){

750 
ff_imdct_calc(&s>mdct_ctx[bsize], s>output, s>coefs[ch]); 
751 
}else if(!(s>ms_stereo && ch==1)) 
752 
memset(s>output, 0, sizeof(s>output)); 
753  
754 
/* multiply by the window and add in the frame */

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

756 
wma_window(s, &s>frame_out[ch][index]); 
757 
} 
758  
759 
/* update block number */

760 
s>block_num++; 
761 
s>block_pos += s>block_len; 
762 
if (s>block_pos >= s>frame_len)

763 
return 1; 
764 
else

765 
return 0; 
766 
} 
767  
768 
/* decode a frame of frame_len samples */

769 
static int wma_decode_frame(WMACodecContext *s, int16_t *samples) 
770 
{ 
771 
int ret, i, n, ch, incr;

772 
int16_t *ptr; 
773 
float *iptr;

774  
775 
#ifdef TRACE

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

777 
#endif

778  
779 
/* read each block */

780 
s>block_num = 0;

781 
s>block_pos = 0;

782 
for(;;) {

783 
ret = wma_decode_block(s); 
784 
if (ret < 0) 
785 
return 1; 
786 
if (ret)

787 
break;

788 
} 
789  
790 
/* convert frame to integer */

791 
n = s>frame_len; 
792 
incr = s>nb_channels; 
793 
if (s>dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {

794 
for(ch = 0; ch < s>nb_channels; ch++) { 
795 
ptr = samples + ch; 
796 
iptr = s>frame_out[ch]; 
797  
798 
for(i=0;i<n;i++) { 
799 
*ptr = av_clip_int16(lrintf(*iptr++)); 
800 
ptr += incr; 
801 
} 
802 
/* prepare for next block */

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

804 
s>frame_len * sizeof(float)); 
805 
} 
806 
} else {

807 
const float *output[MAX_CHANNELS]; 
808 
for (ch = 0; ch < MAX_CHANNELS; ch++) 
809 
output[ch] = s>frame_out[ch]; 
810 
s>dsp.float_to_int16_interleave(samples, output, n, incr); 
811 
for(ch = 0; ch < incr; ch++) { 
812 
/* prepare for next block */

813 
memmove(&s>frame_out[ch][0], &s>frame_out[ch][n], n * sizeof(float)); 
814 
} 
815 
} 
816  
817 
#ifdef TRACE

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

819 
#endif

820 
return 0; 
821 
} 
822  
823 
static int wma_decode_superframe(AVCodecContext *avctx, 
824 
void *data, int *data_size, 
825 
AVPacket *avpkt) 
826 
{ 
827 
const uint8_t *buf = avpkt>data;

828 
int buf_size = avpkt>size;

829 
WMACodecContext *s = avctx>priv_data; 
830 
int nb_frames, bit_offset, i, pos, len;

831 
uint8_t *q; 
832 
int16_t *samples; 
833  
834 
tprintf(avctx, "***decode_superframe:\n");

835  
836 
if(buf_size==0){ 
837 
s>last_superframe_len = 0;

838 
return 0; 
839 
} 
840 
if (buf_size < s>block_align)

841 
return 0; 
842 
buf_size = s>block_align; 
843  
844 
samples = data; 
845  
846 
init_get_bits(&s>gb, buf, buf_size*8);

847  
848 
if (s>use_bit_reservoir) {

849 
/* read super frame header */

850 
skip_bits(&s>gb, 4); /* super frame index */ 
851 
nb_frames = get_bits(&s>gb, 4)  1; 
852  
853 
if((nb_frames+1) * s>nb_channels * s>frame_len * sizeof(int16_t) > *data_size){ 
854 
av_log(s>avctx, AV_LOG_ERROR, "Insufficient output space\n");

855 
goto fail;

856 
} 
857  
858 
bit_offset = get_bits(&s>gb, s>byte_offset_bits + 3);

859  
860 
if (s>last_superframe_len > 0) { 
861 
// printf("skip=%d\n", s>last_bitoffset);

862 
/* add bit_offset bits to last frame */

863 
if ((s>last_superframe_len + ((bit_offset + 7) >> 3)) > 
864 
MAX_CODED_SUPERFRAME_SIZE) 
865 
goto fail;

866 
q = s>last_superframe + s>last_superframe_len; 
867 
len = bit_offset; 
868 
while (len > 7) { 
869 
*q++ = (get_bits)(&s>gb, 8);

870 
len = 8;

871 
} 
872 
if (len > 0) { 
873 
*q++ = (get_bits)(&s>gb, len) << (8  len);

874 
} 
875  
876 
/* XXX: bit_offset bits into last frame */

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

878 
/* skip unused bits */

879 
if (s>last_bitoffset > 0) 
880 
skip_bits(&s>gb, s>last_bitoffset); 
881 
/* this frame is stored in the last superframe and in the

882 
current one */

883 
if (wma_decode_frame(s, samples) < 0) 
884 
goto fail;

885 
samples += s>nb_channels * s>frame_len; 
886 
} 
887  
888 
/* read each frame starting from bit_offset */

889 
pos = bit_offset + 4 + 4 + s>byte_offset_bits + 3; 
890 
init_get_bits(&s>gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE  (pos >> 3))*8); 
891 
len = pos & 7;

892 
if (len > 0) 
893 
skip_bits(&s>gb, len); 
894  
895 
s>reset_block_lengths = 1;

896 
for(i=0;i<nb_frames;i++) { 
897 
if (wma_decode_frame(s, samples) < 0) 
898 
goto fail;

899 
samples += s>nb_channels * s>frame_len; 
900 
} 
901  
902 
/* we copy the end of the frame in the last frame buffer */

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

905 
pos >>= 3;

906 
len = buf_size  pos; 
907 
if (len > MAX_CODED_SUPERFRAME_SIZE  len < 0) { 
908 
av_log(s>avctx, AV_LOG_ERROR, "len %d invalid\n", len);

909 
goto fail;

910 
} 
911 
s>last_superframe_len = len; 
912 
memcpy(s>last_superframe, buf + pos, len); 
913 
} else {

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

916 
goto fail;

917 
} 
918 
/* single frame decode */

919 
if (wma_decode_frame(s, samples) < 0) 
920 
goto fail;

921 
samples += s>nb_channels * s>frame_len; 
922 
} 
923  
924 
//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);

925  
926 
*data_size = (int8_t *)samples  (int8_t *)data; 
927 
return s>block_align;

928 
fail:

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

930 
s>last_superframe_len = 0;

931 
return 1; 
932 
} 
933  
934 
static av_cold void flush(AVCodecContext *avctx) 
935 
{ 
936 
WMACodecContext *s = avctx>priv_data; 
937  
938 
s>last_bitoffset= 
939 
s>last_superframe_len= 0;

940 
} 
941  
942 
AVCodec wmav1_decoder = 
943 
{ 
944 
"wmav1",

945 
AVMEDIA_TYPE_AUDIO, 
946 
CODEC_ID_WMAV1, 
947 
sizeof(WMACodecContext),

948 
wma_decode_init, 
949 
NULL,

950 
ff_wma_end, 
951 
wma_decode_superframe, 
952 
.flush=flush, 
953 
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),

954 
}; 
955  
956 
AVCodec wmav2_decoder = 
957 
{ 
958 
"wmav2",

959 
AVMEDIA_TYPE_AUDIO, 
960 
CODEC_ID_WMAV2, 
961 
sizeof(WMACodecContext),

962 
wma_decode_init, 
963 
NULL,

964 
ff_wma_end, 
965 
wma_decode_superframe, 
966 
.flush=flush, 
967 
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),

968 
}; 