ffmpeg / libavcodec / wmadec.c @ 26f548bb
History  View  Annotate  Download (30.8 KB)
1 
/*


2 
* WMA compatible decoder

3 
* Copyright (c) 2002 The Libav Project

4 
*

5 
* This file is part of Libav.

6 
*

7 
* Libav 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 
* Libav 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 Libav; 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 
FFTContext *mdct; 
451  
452 
#ifdef TRACE

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

455  
456 
/* compute current block length */

457 
if (s>use_variable_block_len) {

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

461 
s>reset_block_lengths = 0;

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

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

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

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

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

475 
/* update block lengths */

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

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

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

486 
/* fixed block len */

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

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

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

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

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

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

512 
/* XXX: fix potential framing problems */

513 
if (!v)

514 
goto next;

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

517 
coef escape coding */

518 
total_gain = 1;

519 
for(;;) {

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

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

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

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

534 
if (s>use_noise_coding) {

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

538 
int i, n, a;

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

544 
if (a)

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

551 
int i, n, val, code;

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

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

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

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

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

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

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

579 
if (s>use_exp_vlc) {

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

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

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

593 
int tindex;

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

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

597 
there is potentially less energy there */

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

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

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

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

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

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

625 
float exp_power[HIGH_BAND_MAX_SIZE];

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

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

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

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

652 
float e2, v;

653 
e2 = 0;

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

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

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

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

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

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

690 
/* coded values + small noise */

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

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

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

709 
/* XXX: optimize more */

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

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

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

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

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

735 
never happen */

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

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

746 
mdct = &s>mdct_ctx[bsize]; 
747  
748 
for(ch = 0; ch < s>nb_channels; ch++) { 
749 
int n4, index;

750  
751 
n4 = s>block_len / 2;

752 
if(s>channel_coded[ch]){

753 
mdct>imdct_calc(mdct, s>output, s>coefs[ch]); 
754 
}else if(!(s>ms_stereo && ch==1)) 
755 
memset(s>output, 0, sizeof(s>output)); 
756  
757 
/* multiply by the window and add in the frame */

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

759 
wma_window(s, &s>frame_out[ch][index]); 
760 
} 
761  
762 
/* update block number */

763 
s>block_num++; 
764 
s>block_pos += s>block_len; 
765 
if (s>block_pos >= s>frame_len)

766 
return 1; 
767 
else

768 
return 0; 
769 
} 
770  
771 
/* decode a frame of frame_len samples */

772 
static int wma_decode_frame(WMACodecContext *s, int16_t *samples) 
773 
{ 
774 
int ret, n, ch, incr;

775 
const float *output[MAX_CHANNELS]; 
776  
777 
#ifdef TRACE

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

779 
#endif

780  
781 
/* read each block */

782 
s>block_num = 0;

783 
s>block_pos = 0;

784 
for(;;) {

785 
ret = wma_decode_block(s); 
786 
if (ret < 0) 
787 
return 1; 
788 
if (ret)

789 
break;

790 
} 
791  
792 
/* convert frame to integer */

793 
n = s>frame_len; 
794 
incr = s>nb_channels; 
795 
for (ch = 0; ch < MAX_CHANNELS; ch++) 
796 
output[ch] = s>frame_out[ch]; 
797 
s>fmt_conv.float_to_int16_interleave(samples, output, n, incr); 
798 
for (ch = 0; ch < incr; ch++) { 
799 
/* prepare for next block */

800 
memmove(&s>frame_out[ch][0], &s>frame_out[ch][n], n * sizeof(float)); 
801 
} 
802  
803 
#ifdef TRACE

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

805 
#endif

806 
return 0; 
807 
} 
808  
809 
static int wma_decode_superframe(AVCodecContext *avctx, 
810 
void *data, int *data_size, 
811 
AVPacket *avpkt) 
812 
{ 
813 
const uint8_t *buf = avpkt>data;

814 
int buf_size = avpkt>size;

815 
WMACodecContext *s = avctx>priv_data; 
816 
int nb_frames, bit_offset, i, pos, len;

817 
uint8_t *q; 
818 
int16_t *samples; 
819  
820 
tprintf(avctx, "***decode_superframe:\n");

821  
822 
if(buf_size==0){ 
823 
s>last_superframe_len = 0;

824 
return 0; 
825 
} 
826 
if (buf_size < s>block_align)

827 
return 0; 
828 
buf_size = s>block_align; 
829  
830 
samples = data; 
831  
832 
init_get_bits(&s>gb, buf, buf_size*8);

833  
834 
if (s>use_bit_reservoir) {

835 
/* read super frame header */

836 
skip_bits(&s>gb, 4); /* super frame index */ 
837 
nb_frames = get_bits(&s>gb, 4)  1; 
838  
839 
if((nb_frames+1) * s>nb_channels * s>frame_len * sizeof(int16_t) > *data_size){ 
840 
av_log(s>avctx, AV_LOG_ERROR, "Insufficient output space\n");

841 
goto fail;

842 
} 
843  
844 
bit_offset = get_bits(&s>gb, s>byte_offset_bits + 3);

845  
846 
if (s>last_superframe_len > 0) { 
847 
// printf("skip=%d\n", s>last_bitoffset);

848 
/* add bit_offset bits to last frame */

849 
if ((s>last_superframe_len + ((bit_offset + 7) >> 3)) > 
850 
MAX_CODED_SUPERFRAME_SIZE) 
851 
goto fail;

852 
q = s>last_superframe + s>last_superframe_len; 
853 
len = bit_offset; 
854 
while (len > 7) { 
855 
*q++ = (get_bits)(&s>gb, 8);

856 
len = 8;

857 
} 
858 
if (len > 0) { 
859 
*q++ = (get_bits)(&s>gb, len) << (8  len);

860 
} 
861  
862 
/* XXX: bit_offset bits into last frame */

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

864 
/* skip unused bits */

865 
if (s>last_bitoffset > 0) 
866 
skip_bits(&s>gb, s>last_bitoffset); 
867 
/* this frame is stored in the last superframe and in the

868 
current one */

869 
if (wma_decode_frame(s, samples) < 0) 
870 
goto fail;

871 
samples += s>nb_channels * s>frame_len; 
872 
} 
873  
874 
/* read each frame starting from bit_offset */

875 
pos = bit_offset + 4 + 4 + s>byte_offset_bits + 3; 
876 
init_get_bits(&s>gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE  (pos >> 3))*8); 
877 
len = pos & 7;

878 
if (len > 0) 
879 
skip_bits(&s>gb, len); 
880  
881 
s>reset_block_lengths = 1;

882 
for(i=0;i<nb_frames;i++) { 
883 
if (wma_decode_frame(s, samples) < 0) 
884 
goto fail;

885 
samples += s>nb_channels * s>frame_len; 
886 
} 
887  
888 
/* we copy the end of the frame in the last frame buffer */

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

891 
pos >>= 3;

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

895 
goto fail;

896 
} 
897 
s>last_superframe_len = len; 
898 
memcpy(s>last_superframe, buf + pos, len); 
899 
} else {

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

902 
goto fail;

903 
} 
904 
/* single frame decode */

905 
if (wma_decode_frame(s, samples) < 0) 
906 
goto fail;

907 
samples += s>nb_channels * s>frame_len; 
908 
} 
909  
910 
//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);

911  
912 
*data_size = (int8_t *)samples  (int8_t *)data; 
913 
return s>block_align;

914 
fail:

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

916 
s>last_superframe_len = 0;

917 
return 1; 
918 
} 
919  
920 
static av_cold void flush(AVCodecContext *avctx) 
921 
{ 
922 
WMACodecContext *s = avctx>priv_data; 
923  
924 
s>last_bitoffset= 
925 
s>last_superframe_len= 0;

926 
} 
927  
928 
AVCodec ff_wmav1_decoder = 
929 
{ 
930 
"wmav1",

931 
AVMEDIA_TYPE_AUDIO, 
932 
CODEC_ID_WMAV1, 
933 
sizeof(WMACodecContext),

934 
wma_decode_init, 
935 
NULL,

936 
ff_wma_end, 
937 
wma_decode_superframe, 
938 
.flush=flush, 
939 
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),

940 
}; 
941  
942 
AVCodec ff_wmav2_decoder = 
943 
{ 
944 
"wmav2",

945 
AVMEDIA_TYPE_AUDIO, 
946 
CODEC_ID_WMAV2, 
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 2"),

954 
}; 