ffmpeg / libavcodec / wmadec.c @ d30ba3bb
History  View  Annotate  Download (42.1 KB)
1 
/*


2 
* WMA compatible decoder

3 
* Copyright (c) 2002 The FFmpeg Project.

4 
*

5 
* This library is free software; you can redistribute it and/or

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

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

8 
* version 2 of the License, or (at your option) any later version.

9 
*

10 
* This library is distributed in the hope that it will be useful,

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

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

13 
* Lesser General Public License for more details.

14 
*

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

16 
* License along with this library; if not, write to the Free Software

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

18 
*/

19  
20 
/**

21 
* @file wmadec.c

22 
* WMA compatible decoder.

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

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

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

26 
*

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

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

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

30 
* to the decoder using the extradata[_size] fields in AVCodecContext. There

31 
* should be 4 extra bytes for v1 data and 6 extra bytes for v2 data.

32 
*/

33  
34 
#include "avcodec.h" 
35 
#include "bitstream.h" 
36 
#include "dsputil.h" 
37  
38 
/* size of blocks */

39 
#define BLOCK_MIN_BITS 7 
40 
#define BLOCK_MAX_BITS 11 
41 
#define BLOCK_MAX_SIZE (1 << BLOCK_MAX_BITS) 
42  
43 
#define BLOCK_NB_SIZES (BLOCK_MAX_BITS  BLOCK_MIN_BITS + 1) 
44  
45 
/* XXX: find exact max size */

46 
#define HIGH_BAND_MAX_SIZE 16 
47  
48 
#define NB_LSP_COEFS 10 
49  
50 
/* XXX: is it a suitable value ? */

51 
#define MAX_CODED_SUPERFRAME_SIZE 16384 
52  
53 
#define MAX_CHANNELS 2 
54  
55 
#define NOISE_TAB_SIZE 8192 
56  
57 
#define LSP_POW_BITS 7 
58  
59 
#define VLCBITS 9 
60 
#define VLCMAX ((22+VLCBITS1)/VLCBITS) 
61  
62 
#define EXPVLCBITS 8 
63 
#define EXPMAX ((19+EXPVLCBITS1)/EXPVLCBITS) 
64  
65 
#define HGAINVLCBITS 9 
66 
#define HGAINMAX ((13+HGAINVLCBITS1)/HGAINVLCBITS) 
67  
68 
typedef struct WMADecodeContext { 
69 
GetBitContext gb; 
70 
int sample_rate;

71 
int nb_channels;

72 
int bit_rate;

73 
int version; /* 1 = 0x160 (WMAV1), 2 = 0x161 (WMAV2) */ 
74 
int block_align;

75 
int use_bit_reservoir;

76 
int use_variable_block_len;

77 
int use_exp_vlc; /* exponent coding: 0 = lsp, 1 = vlc + delta */ 
78 
int use_noise_coding; /* true if perceptual noise is added */ 
79 
int byte_offset_bits;

80 
VLC exp_vlc; 
81 
int exponent_sizes[BLOCK_NB_SIZES];

82 
uint16_t exponent_bands[BLOCK_NB_SIZES][25];

83 
int high_band_start[BLOCK_NB_SIZES]; /* index of first coef in high band */ 
84 
int coefs_start; /* first coded coef */ 
85 
int coefs_end[BLOCK_NB_SIZES]; /* max number of coded coefficients */ 
86 
int exponent_high_sizes[BLOCK_NB_SIZES];

87 
int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE];

88 
VLC hgain_vlc; 
89  
90 
/* coded values in high bands */

91 
int high_band_coded[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];

92 
int high_band_values[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];

93  
94 
/* there are two possible tables for spectral coefficients */

95 
VLC coef_vlc[2];

96 
uint16_t *run_table[2];

97 
uint16_t *level_table[2];

98 
/* frame info */

99 
int frame_len; /* frame length in samples */ 
100 
int frame_len_bits; /* frame_len = 1 << frame_len_bits */ 
101 
int nb_block_sizes; /* number of block sizes */ 
102 
/* block info */

103 
int reset_block_lengths;

104 
int block_len_bits; /* log2 of current block length */ 
105 
int next_block_len_bits; /* log2 of next block length */ 
106 
int prev_block_len_bits; /* log2 of prev block length */ 
107 
int block_len; /* block length in samples */ 
108 
int block_num; /* block number in current frame */ 
109 
int block_pos; /* current position in frame */ 
110 
uint8_t ms_stereo; /* true if mid/side stereo mode */

111 
uint8_t channel_coded[MAX_CHANNELS]; /* true if channel is coded */

112 
DECLARE_ALIGNED_16(float, exponents[MAX_CHANNELS][BLOCK_MAX_SIZE]);

113 
float max_exponent[MAX_CHANNELS];

114 
int16_t coefs1[MAX_CHANNELS][BLOCK_MAX_SIZE]; 
115 
DECLARE_ALIGNED_16(float, coefs[MAX_CHANNELS][BLOCK_MAX_SIZE]);

116 
MDCTContext mdct_ctx[BLOCK_NB_SIZES]; 
117 
float *windows[BLOCK_NB_SIZES];

118 
DECLARE_ALIGNED_16(FFTSample, mdct_tmp[BLOCK_MAX_SIZE]); /* temporary storage for imdct */

119 
/* output buffer for one frame and the last for IMDCT windowing */

120 
DECLARE_ALIGNED_16(float, frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2]); 
121 
/* last frame info */

122 
uint8_t last_superframe[MAX_CODED_SUPERFRAME_SIZE + 4]; /* padding added */ 
123 
int last_bitoffset;

124 
int last_superframe_len;

125 
float noise_table[NOISE_TAB_SIZE];

126 
int noise_index;

127 
float noise_mult; /* XXX: suppress that and integrate it in the noise array */ 
128 
/* lsp_to_curve tables */

129 
float lsp_cos_table[BLOCK_MAX_SIZE];

130 
float lsp_pow_e_table[256]; 
131 
float lsp_pow_m_table1[(1 << LSP_POW_BITS)]; 
132 
float lsp_pow_m_table2[(1 << LSP_POW_BITS)]; 
133  
134 
#ifdef TRACE

135 
int frame_count;

136 
#endif

137 
} WMADecodeContext; 
138  
139 
typedef struct CoefVLCTable { 
140 
int n; /* total number of codes */ 
141 
const uint32_t *huffcodes; /* VLC bit values */ 
142 
const uint8_t *huffbits; /* VLC bit size */ 
143 
const uint16_t *levels; /* table to build run/level tables */ 
144 
} CoefVLCTable; 
145  
146 
static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len); 
147  
148 
#include "wmadata.h" 
149  
150 
#ifdef TRACE

151 
static void dump_shorts(const char *name, const short *tab, int n) 
152 
{ 
153 
int i;

154  
155 
tprintf("%s[%d]:\n", name, n);

156 
for(i=0;i<n;i++) { 
157 
if ((i & 7) == 0) 
158 
tprintf("%4d: ", i);

159 
tprintf(" %5d.0", tab[i]);

160 
if ((i & 7) == 7) 
161 
tprintf("\n");

162 
} 
163 
} 
164  
165 
static void dump_floats(const char *name, int prec, const float *tab, int n) 
166 
{ 
167 
int i;

168  
169 
tprintf("%s[%d]:\n", name, n);

170 
for(i=0;i<n;i++) { 
171 
if ((i & 7) == 0) 
172 
tprintf("%4d: ", i);

173 
tprintf(" %8.*f", prec, tab[i]);

174 
if ((i & 7) == 7) 
175 
tprintf("\n");

176 
} 
177 
if ((i & 7) != 0) 
178 
tprintf("\n");

179 
} 
180 
#endif

181  
182 
/* XXX: use same run/length optimization as mpeg decoders */

183 
static void init_coef_vlc(VLC *vlc, 
184 
uint16_t **prun_table, uint16_t **plevel_table, 
185 
const CoefVLCTable *vlc_table)

186 
{ 
187 
int n = vlc_table>n;

188 
const uint8_t *table_bits = vlc_table>huffbits;

189 
const uint32_t *table_codes = vlc_table>huffcodes;

190 
const uint16_t *levels_table = vlc_table>levels;

191 
uint16_t *run_table, *level_table; 
192 
const uint16_t *p;

193 
int i, l, j, level;

194  
195 
init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0); 
196  
197 
run_table = av_malloc(n * sizeof(uint16_t));

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

199 
p = levels_table; 
200 
i = 2;

201 
level = 1;

202 
while (i < n) {

203 
l = *p++; 
204 
for(j=0;j<l;j++) { 
205 
run_table[i] = j; 
206 
level_table[i] = level; 
207 
i++; 
208 
} 
209 
level++; 
210 
} 
211 
*prun_table = run_table; 
212 
*plevel_table = level_table; 
213 
} 
214  
215 
static int wma_decode_init(AVCodecContext * avctx) 
216 
{ 
217 
WMADecodeContext *s = avctx>priv_data; 
218 
int i, flags1, flags2;

219 
float *window;

220 
uint8_t *extradata; 
221 
float bps1, high_freq;

222 
volatile float bps; 
223 
int sample_rate1;

224 
int coef_vlc_table;

225  
226 
s>sample_rate = avctx>sample_rate; 
227 
s>nb_channels = avctx>channels; 
228 
s>bit_rate = avctx>bit_rate; 
229 
s>block_align = avctx>block_align; 
230  
231 
if (avctx>codec>id == CODEC_ID_WMAV1) {

232 
s>version = 1;

233 
} else {

234 
s>version = 2;

235 
} 
236  
237 
/* extract flag infos */

238 
flags1 = 0;

239 
flags2 = 0;

240 
extradata = avctx>extradata; 
241 
if (s>version == 1 && avctx>extradata_size >= 4) { 
242 
flags1 = extradata[0]  (extradata[1] << 8); 
243 
flags2 = extradata[2]  (extradata[3] << 8); 
244 
} else if (s>version == 2 && avctx>extradata_size >= 6) { 
245 
flags1 = extradata[0]  (extradata[1] << 8)  
246 
(extradata[2] << 16)  (extradata[3] << 24); 
247 
flags2 = extradata[4]  (extradata[5] << 8); 
248 
} 
249 
s>use_exp_vlc = flags2 & 0x0001;

250 
s>use_bit_reservoir = flags2 & 0x0002;

251 
s>use_variable_block_len = flags2 & 0x0004;

252  
253 
/* compute MDCT block size */

254 
if (s>sample_rate <= 16000) { 
255 
s>frame_len_bits = 9;

256 
} else if (s>sample_rate <= 22050  
257 
(s>sample_rate <= 32000 && s>version == 1)) { 
258 
s>frame_len_bits = 10;

259 
} else {

260 
s>frame_len_bits = 11;

261 
} 
262 
s>frame_len = 1 << s>frame_len_bits;

263 
if (s>use_variable_block_len) {

264 
int nb_max, nb;

265 
nb = ((flags2 >> 3) & 3) + 1; 
266 
if ((s>bit_rate / s>nb_channels) >= 32000) 
267 
nb += 2;

268 
nb_max = s>frame_len_bits  BLOCK_MIN_BITS; 
269 
if (nb > nb_max)

270 
nb = nb_max; 
271 
s>nb_block_sizes = nb + 1;

272 
} else {

273 
s>nb_block_sizes = 1;

274 
} 
275  
276 
/* init rate dependant parameters */

277 
s>use_noise_coding = 1;

278 
high_freq = s>sample_rate * 0.5; 
279  
280 
/* if version 2, then the rates are normalized */

281 
sample_rate1 = s>sample_rate; 
282 
if (s>version == 2) { 
283 
if (sample_rate1 >= 44100) 
284 
sample_rate1 = 44100;

285 
else if (sample_rate1 >= 22050) 
286 
sample_rate1 = 22050;

287 
else if (sample_rate1 >= 16000) 
288 
sample_rate1 = 16000;

289 
else if (sample_rate1 >= 11025) 
290 
sample_rate1 = 11025;

291 
else if (sample_rate1 >= 8000) 
292 
sample_rate1 = 8000;

293 
} 
294  
295 
bps = (float)s>bit_rate / (float)(s>nb_channels * s>sample_rate); 
296 
s>byte_offset_bits = av_log2((int)(bps * s>frame_len / 8.0 + 0.5)) + 2; 
297  
298 
/* compute high frequency value and choose if noise coding should

299 
be activated */

300 
bps1 = bps; 
301 
if (s>nb_channels == 2) 
302 
bps1 = bps * 1.6; 
303 
if (sample_rate1 == 44100) { 
304 
if (bps1 >= 0.61) 
305 
s>use_noise_coding = 0;

306 
else

307 
high_freq = high_freq * 0.4; 
308 
} else if (sample_rate1 == 22050) { 
309 
if (bps1 >= 1.16) 
310 
s>use_noise_coding = 0;

311 
else if (bps1 >= 0.72) 
312 
high_freq = high_freq * 0.7; 
313 
else

314 
high_freq = high_freq * 0.6; 
315 
} else if (sample_rate1 == 16000) { 
316 
if (bps > 0.5) 
317 
high_freq = high_freq * 0.5; 
318 
else

319 
high_freq = high_freq * 0.3; 
320 
} else if (sample_rate1 == 11025) { 
321 
high_freq = high_freq * 0.7; 
322 
} else if (sample_rate1 == 8000) { 
323 
if (bps <= 0.625) { 
324 
high_freq = high_freq * 0.5; 
325 
} else if (bps > 0.75) { 
326 
s>use_noise_coding = 0;

327 
} else {

328 
high_freq = high_freq * 0.65; 
329 
} 
330 
} else {

331 
if (bps >= 0.8) { 
332 
high_freq = high_freq * 0.75; 
333 
} else if (bps >= 0.6) { 
334 
high_freq = high_freq * 0.6; 
335 
} else {

336 
high_freq = high_freq * 0.5; 
337 
} 
338 
} 
339 
dprintf("flags1=0x%x flags2=0x%x\n", flags1, flags2);

340 
dprintf("version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",

341 
s>version, s>nb_channels, s>sample_rate, s>bit_rate, 
342 
s>block_align); 
343 
dprintf("bps=%f bps1=%f high_freq=%f bitoffset=%d\n",

344 
bps, bps1, high_freq, s>byte_offset_bits); 
345 
dprintf("use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",

346 
s>use_noise_coding, s>use_exp_vlc, s>nb_block_sizes); 
347  
348 
/* compute the scale factor band sizes for each MDCT block size */

349 
{ 
350 
int a, b, pos, lpos, k, block_len, i, j, n;

351 
const uint8_t *table;

352  
353 
if (s>version == 1) { 
354 
s>coefs_start = 3;

355 
} else {

356 
s>coefs_start = 0;

357 
} 
358 
for(k = 0; k < s>nb_block_sizes; k++) { 
359 
block_len = s>frame_len >> k; 
360  
361 
if (s>version == 1) { 
362 
lpos = 0;

363 
for(i=0;i<25;i++) { 
364 
a = wma_critical_freqs[i]; 
365 
b = s>sample_rate; 
366 
pos = ((block_len * 2 * a) + (b >> 1)) / b; 
367 
if (pos > block_len)

368 
pos = block_len; 
369 
s>exponent_bands[0][i] = pos  lpos;

370 
if (pos >= block_len) {

371 
i++; 
372 
break;

373 
} 
374 
lpos = pos; 
375 
} 
376 
s>exponent_sizes[0] = i;

377 
} else {

378 
/* hardcoded tables */

379 
table = NULL;

380 
a = s>frame_len_bits  BLOCK_MIN_BITS  k; 
381 
if (a < 3) { 
382 
if (s>sample_rate >= 44100) 
383 
table = exponent_band_44100[a]; 
384 
else if (s>sample_rate >= 32000) 
385 
table = exponent_band_32000[a]; 
386 
else if (s>sample_rate >= 22050) 
387 
table = exponent_band_22050[a]; 
388 
} 
389 
if (table) {

390 
n = *table++; 
391 
for(i=0;i<n;i++) 
392 
s>exponent_bands[k][i] = table[i]; 
393 
s>exponent_sizes[k] = n; 
394 
} else {

395 
j = 0;

396 
lpos = 0;

397 
for(i=0;i<25;i++) { 
398 
a = wma_critical_freqs[i]; 
399 
b = s>sample_rate; 
400 
pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); 
401 
pos <<= 2;

402 
if (pos > block_len)

403 
pos = block_len; 
404 
if (pos > lpos)

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

407 
break;

408 
lpos = pos; 
409 
} 
410 
s>exponent_sizes[k] = j; 
411 
} 
412 
} 
413  
414 
/* max number of coefs */

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

417 
s>high_band_start[k] = (int)((block_len * 2 * high_freq) / 
418 
s>sample_rate + 0.5); 
419 
n = s>exponent_sizes[k]; 
420 
j = 0;

421 
pos = 0;

422 
for(i=0;i<n;i++) { 
423 
int start, end;

424 
start = pos; 
425 
pos += s>exponent_bands[k][i]; 
426 
end = pos; 
427 
if (start < s>high_band_start[k])

428 
start = s>high_band_start[k]; 
429 
if (end > s>coefs_end[k])

430 
end = s>coefs_end[k]; 
431 
if (end > start)

432 
s>exponent_high_bands[k][j++] = end  start; 
433 
} 
434 
s>exponent_high_sizes[k] = j; 
435 
#if 0

436 
tprintf("%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ",

437 
s>frame_len >> k,

438 
s>coefs_end[k],

439 
s>high_band_start[k],

440 
s>exponent_high_sizes[k]);

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

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

443 
tprintf("\n");

444 
#endif

445 
} 
446 
} 
447  
448 
#ifdef TRACE

449 
{ 
450 
int i, j;

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

453 
s>frame_len >> i, 
454 
s>exponent_sizes[i]); 
455 
for(j=0;j<s>exponent_sizes[i];j++) 
456 
tprintf(" %d", s>exponent_bands[i][j]);

457 
tprintf("\n");

458 
} 
459 
} 
460 
#endif

461  
462 
/* init MDCT */

463 
for(i = 0; i < s>nb_block_sizes; i++) 
464 
ff_mdct_init(&s>mdct_ctx[i], s>frame_len_bits  i + 1, 1); 
465  
466 
/* init MDCT windows : simple sinus window */

467 
for(i = 0; i < s>nb_block_sizes; i++) { 
468 
int n, j;

469 
float alpha;

470 
n = 1 << (s>frame_len_bits  i);

471 
window = av_malloc(sizeof(float) * n); 
472 
alpha = M_PI / (2.0 * n); 
473 
for(j=0;j<n;j++) { 
474 
window[n  j  1] = sin((j + 0.5) * alpha); 
475 
} 
476 
s>windows[i] = window; 
477 
} 
478  
479 
s>reset_block_lengths = 1;

480  
481 
if (s>use_noise_coding) {

482  
483 
/* init the noise generator */

484 
if (s>use_exp_vlc)

485 
s>noise_mult = 0.02; 
486 
else

487 
s>noise_mult = 0.04; 
488  
489 
#ifdef TRACE

490 
for(i=0;i<NOISE_TAB_SIZE;i++) 
491 
s>noise_table[i] = 1.0 * s>noise_mult; 
492 
#else

493 
{ 
494 
unsigned int seed; 
495 
float norm;

496 
seed = 1;

497 
norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s>noise_mult; 
498 
for(i=0;i<NOISE_TAB_SIZE;i++) { 
499 
seed = seed * 314159 + 1; 
500 
s>noise_table[i] = (float)((int)seed) * norm; 
501 
} 
502 
} 
503 
#endif

504 
init_vlc(&s>hgain_vlc, HGAINVLCBITS, sizeof(hgain_huffbits),

505 
hgain_huffbits, 1, 1, 
506 
hgain_huffcodes, 2, 2, 0); 
507 
} 
508  
509 
if (s>use_exp_vlc) {

510 
init_vlc(&s>exp_vlc, EXPVLCBITS, sizeof(scale_huffbits),

511 
scale_huffbits, 1, 1, 
512 
scale_huffcodes, 4, 4, 0); 
513 
} else {

514 
wma_lsp_to_curve_init(s, s>frame_len); 
515 
} 
516  
517 
/* choose the VLC tables for the coefficients */

518 
coef_vlc_table = 2;

519 
if (s>sample_rate >= 32000) { 
520 
if (bps1 < 0.72) 
521 
coef_vlc_table = 0;

522 
else if (bps1 < 1.16) 
523 
coef_vlc_table = 1;

524 
} 
525  
526 
init_coef_vlc(&s>coef_vlc[0], &s>run_table[0], &s>level_table[0], 
527 
&coef_vlcs[coef_vlc_table * 2]);

528 
init_coef_vlc(&s>coef_vlc[1], &s>run_table[1], &s>level_table[1], 
529 
&coef_vlcs[coef_vlc_table * 2 + 1]); 
530 
return 0; 
531 
} 
532  
533 
/* interpolate values for a bigger or smaller block. The block must

534 
have multiple sizes */

535 
static void interpolate_array(float *scale, int old_size, int new_size) 
536 
{ 
537 
int i, j, jincr, k;

538 
float v;

539  
540 
if (new_size > old_size) {

541 
jincr = new_size / old_size; 
542 
j = new_size; 
543 
for(i = old_size  1; i >=0; i) { 
544 
v = scale[i]; 
545 
k = jincr; 
546 
do {

547 
scale[j] = v; 
548 
} while (k);

549 
} 
550 
} else if (new_size < old_size) { 
551 
j = 0;

552 
jincr = old_size / new_size; 
553 
for(i = 0; i < new_size; i++) { 
554 
scale[i] = scale[j]; 
555 
j += jincr; 
556 
} 
557 
} 
558 
} 
559  
560 
/* compute x^0.25 with an exponent and mantissa table. We use linear

561 
interpolation to reduce the mantissa table size at a small speed

562 
expense (linear interpolation approximately doubles the number of

563 
bits of precision). */

564 
static inline float pow_m1_4(WMADecodeContext *s, float x) 
565 
{ 
566 
union {

567 
float f;

568 
unsigned int v; 
569 
} u, t; 
570 
unsigned int e, m; 
571 
float a, b;

572  
573 
u.f = x; 
574 
e = u.v >> 23;

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

577 
t.v = ((u.v << LSP_POW_BITS) & ((1 << 23)  1))  (127 << 23); 
578 
a = s>lsp_pow_m_table1[m]; 
579 
b = s>lsp_pow_m_table2[m]; 
580 
return s>lsp_pow_e_table[e] * (a + b * t.f);

581 
} 
582  
583 
static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len) 
584 
{ 
585 
float wdel, a, b;

586 
int i, e, m;

587  
588 
wdel = M_PI / frame_len; 
589 
for(i=0;i<frame_len;i++) 
590 
s>lsp_cos_table[i] = 2.0f * cos(wdel * i); 
591  
592 
/* tables for x^0.25 computation */

593 
for(i=0;i<256;i++) { 
594 
e = i  126;

595 
s>lsp_pow_e_table[i] = pow(2.0, e * 0.25); 
596 
} 
597  
598 
/* NOTE: these two tables are needed to avoid two operations in

599 
pow_m1_4 */

600 
b = 1.0; 
601 
for(i=(1 << LSP_POW_BITS)  1;i>=0;i) { 
602 
m = (1 << LSP_POW_BITS) + i;

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

606 
s>lsp_pow_m_table2[i] = b  a; 
607 
b = a; 
608 
} 
609 
#if 0

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

611 
float v, r1, r2;

612 
v = 5.0 / i;

613 
r1 = pow_m1_4(s, v);

614 
r2 = pow(v,0.25);

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

616 
}

617 
#endif

618 
} 
619  
620 
/* NOTE: We use the same code as Vorbis here */

621 
/* XXX: optimize it further with SSE/3Dnow */

622 
static void wma_lsp_to_curve(WMADecodeContext *s, 
623 
float *out, float *val_max_ptr, 
624 
int n, float *lsp) 
625 
{ 
626 
int i, j;

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

628  
629 
val_max = 0;

630 
for(i=0;i<n;i++) { 
631 
p = 0.5f; 
632 
q = 0.5f; 
633 
w = s>lsp_cos_table[i]; 
634 
for(j=1;j<NB_LSP_COEFS;j+=2){ 
635 
q *= w  lsp[j  1];

636 
p *= w  lsp[j]; 
637 
} 
638 
p *= p * (2.0f  w); 
639 
q *= q * (2.0f + w); 
640 
v = p + q; 
641 
v = pow_m1_4(s, v); 
642 
if (v > val_max)

643 
val_max = v; 
644 
out[i] = v; 
645 
} 
646 
*val_max_ptr = val_max; 
647 
} 
648  
649 
/* decode exponents coded with LSP coefficients (same idea as Vorbis) */

650 
static void decode_exp_lsp(WMADecodeContext *s, int ch) 
651 
{ 
652 
float lsp_coefs[NB_LSP_COEFS];

653 
int val, i;

654  
655 
for(i = 0; i < NB_LSP_COEFS; i++) { 
656 
if (i == 0  i >= 8) 
657 
val = get_bits(&s>gb, 3);

658 
else

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

660 
lsp_coefs[i] = lsp_codebook[i][val]; 
661 
} 
662  
663 
wma_lsp_to_curve(s, s>exponents[ch], &s>max_exponent[ch], 
664 
s>block_len, lsp_coefs); 
665 
} 
666  
667 
/* decode exponents coded with VLC codes */

668 
static int decode_exp_vlc(WMADecodeContext *s, int ch) 
669 
{ 
670 
int last_exp, n, code;

671 
const uint16_t *ptr, *band_ptr;

672 
float v, *q, max_scale, *q_end;

673  
674 
band_ptr = s>exponent_bands[s>frame_len_bits  s>block_len_bits]; 
675 
ptr = band_ptr; 
676 
q = s>exponents[ch]; 
677 
q_end = q + s>block_len; 
678 
max_scale = 0;

679 
if (s>version == 1) { 
680 
last_exp = get_bits(&s>gb, 5) + 10; 
681 
/* XXX: use a table */

682 
v = pow(10, last_exp * (1.0 / 16.0)); 
683 
max_scale = v; 
684 
n = *ptr++; 
685 
do {

686 
*q++ = v; 
687 
} while (n);

688 
} 
689 
last_exp = 36;

690 
while (q < q_end) {

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

695 
last_exp += code  60;

696 
/* XXX: use a table */

697 
v = pow(10, last_exp * (1.0 / 16.0)); 
698 
if (v > max_scale)

699 
max_scale = v; 
700 
n = *ptr++; 
701 
do {

702 
*q++ = v; 
703 
} while (n);

704 
} 
705 
s>max_exponent[ch] = max_scale; 
706 
return 0; 
707 
} 
708  
709 
/* return 0 if OK. return 1 if last block of frame. return 1 if

710 
unrecorrable error. */

711 
static int wma_decode_block(WMADecodeContext *s) 
712 
{ 
713 
int n, v, a, ch, code, bsize;

714 
int coef_nb_bits, total_gain, parse_exponents;

715 
float window[BLOCK_MAX_SIZE * 2]; 
716 
// XXX: FIXME!! there's a bug somewhere which makes this mandatory under altivec

717 
#ifdef HAVE_ALTIVEC

718 
volatile int nb_coefs[MAX_CHANNELS] __attribute__((aligned(16))); 
719 
#else

720 
int nb_coefs[MAX_CHANNELS];

721 
#endif

722 
float mdct_norm;

723  
724 
#ifdef TRACE

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

727  
728 
/* compute current block length */

729 
if (s>use_variable_block_len) {

730 
n = av_log2(s>nb_block_sizes  1) + 1; 
731  
732 
if (s>reset_block_lengths) {

733 
s>reset_block_lengths = 0;

734 
v = get_bits(&s>gb, n); 
735 
if (v >= s>nb_block_sizes)

736 
return 1; 
737 
s>prev_block_len_bits = s>frame_len_bits  v; 
738 
v = get_bits(&s>gb, n); 
739 
if (v >= s>nb_block_sizes)

740 
return 1; 
741 
s>block_len_bits = s>frame_len_bits  v; 
742 
} else {

743 
/* update block lengths */

744 
s>prev_block_len_bits = s>block_len_bits; 
745 
s>block_len_bits = s>next_block_len_bits; 
746 
} 
747 
v = get_bits(&s>gb, n); 
748 
if (v >= s>nb_block_sizes)

749 
return 1; 
750 
s>next_block_len_bits = s>frame_len_bits  v; 
751 
} else {

752 
/* fixed block len */

753 
s>next_block_len_bits = s>frame_len_bits; 
754 
s>prev_block_len_bits = s>frame_len_bits; 
755 
s>block_len_bits = s>frame_len_bits; 
756 
} 
757  
758 
/* now check if the block length is coherent with the frame length */

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

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

761 
return 1; 
762  
763 
if (s>nb_channels == 2) { 
764 
s>ms_stereo = get_bits(&s>gb, 1);

765 
} 
766 
v = 0;

767 
for(ch = 0; ch < s>nb_channels; ch++) { 
768 
a = get_bits(&s>gb, 1);

769 
s>channel_coded[ch] = a; 
770 
v = a; 
771 
} 
772 
/* if no channel coded, no need to go further */

773 
/* XXX: fix potential framing problems */

774 
if (!v)

775 
goto next;

776  
777 
bsize = s>frame_len_bits  s>block_len_bits; 
778  
779 
/* read total gain and extract corresponding number of bits for

780 
coef escape coding */

781 
total_gain = 1;

782 
for(;;) {

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

784 
total_gain += a; 
785 
if (a != 127) 
786 
break;

787 
} 
788  
789 
if (total_gain < 15) 
790 
coef_nb_bits = 13;

791 
else if (total_gain < 32) 
792 
coef_nb_bits = 12;

793 
else if (total_gain < 40) 
794 
coef_nb_bits = 11;

795 
else if (total_gain < 45) 
796 
coef_nb_bits = 10;

797 
else

798 
coef_nb_bits = 9;

799  
800 
/* compute number of coefficients */

801 
n = s>coefs_end[bsize]  s>coefs_start; 
802 
for(ch = 0; ch < s>nb_channels; ch++) 
803 
nb_coefs[ch] = n; 
804  
805 
/* complex coding */

806 
if (s>use_noise_coding) {

807  
808 
for(ch = 0; ch < s>nb_channels; ch++) { 
809 
if (s>channel_coded[ch]) {

810 
int i, n, a;

811 
n = s>exponent_high_sizes[bsize]; 
812 
for(i=0;i<n;i++) { 
813 
a = get_bits(&s>gb, 1);

814 
s>high_band_coded[ch][i] = a; 
815 
/* if noise coding, the coefficients are not transmitted */

816 
if (a)

817 
nb_coefs[ch] = s>exponent_high_bands[bsize][i]; 
818 
} 
819 
} 
820 
} 
821 
for(ch = 0; ch < s>nb_channels; ch++) { 
822 
if (s>channel_coded[ch]) {

823 
int i, n, val, code;

824  
825 
n = s>exponent_high_sizes[bsize]; 
826 
val = (int)0x80000000; 
827 
for(i=0;i<n;i++) { 
828 
if (s>high_band_coded[ch][i]) {

829 
if (val == (int)0x80000000) { 
830 
val = get_bits(&s>gb, 7)  19; 
831 
} else {

832 
code = get_vlc2(&s>gb, s>hgain_vlc.table, HGAINVLCBITS, HGAINMAX); 
833 
if (code < 0) 
834 
return 1; 
835 
val += code  18;

836 
} 
837 
s>high_band_values[ch][i] = val; 
838 
} 
839 
} 
840 
} 
841 
} 
842 
} 
843  
844 
/* exposant can be interpolated in short blocks. */

845 
parse_exponents = 1;

846 
if (s>block_len_bits != s>frame_len_bits) {

847 
parse_exponents = get_bits(&s>gb, 1);

848 
} 
849  
850 
if (parse_exponents) {

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

853 
if (s>use_exp_vlc) {

854 
if (decode_exp_vlc(s, ch) < 0) 
855 
return 1; 
856 
} else {

857 
decode_exp_lsp(s, ch); 
858 
} 
859 
} 
860 
} 
861 
} else {

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

864 
interpolate_array(s>exponents[ch], 1 << s>prev_block_len_bits,

865 
s>block_len); 
866 
} 
867 
} 
868 
} 
869  
870 
/* parse spectral coefficients : just RLE encoding */

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

873 
VLC *coef_vlc; 
874 
int level, run, sign, tindex;

875 
int16_t *ptr, *eptr; 
876 
const int16_t *level_table, *run_table;

877  
878 
/* special VLC tables are used for ms stereo because

879 
there is potentially less energy there */

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

881 
coef_vlc = &s>coef_vlc[tindex]; 
882 
run_table = s>run_table[tindex]; 
883 
level_table = s>level_table[tindex]; 
884 
/* XXX: optimize */

885 
ptr = &s>coefs1[ch][0];

886 
eptr = ptr + nb_coefs[ch]; 
887 
memset(ptr, 0, s>block_len * sizeof(int16_t)); 
888 
for(;;) {

889 
code = get_vlc2(&s>gb, coef_vlc>table, VLCBITS, VLCMAX); 
890 
if (code < 0) 
891 
return 1; 
892 
if (code == 1) { 
893 
/* EOB */

894 
break;

895 
} else if (code == 0) { 
896 
/* escape */

897 
level = get_bits(&s>gb, coef_nb_bits); 
898 
/* NOTE: this is rather suboptimal. reading

899 
block_len_bits would be better */

900 
run = get_bits(&s>gb, s>frame_len_bits); 
901 
} else {

902 
/* normal code */

903 
run = run_table[code]; 
904 
level = level_table[code]; 
905 
} 
906 
sign = get_bits(&s>gb, 1);

907 
if (!sign)

908 
level = level; 
909 
ptr += run; 
910 
if (ptr >= eptr)

911 
return 1; 
912 
*ptr++ = level; 
913 
/* NOTE: EOB can be omitted */

914 
if (ptr >= eptr)

915 
break;

916 
} 
917 
} 
918 
if (s>version == 1 && s>nb_channels >= 2) { 
919 
align_get_bits(&s>gb); 
920 
} 
921 
} 
922  
923 
/* normalize */

924 
{ 
925 
int n4 = s>block_len / 2; 
926 
mdct_norm = 1.0 / (float)n4; 
927 
if (s>version == 1) { 
928 
mdct_norm *= sqrt(n4); 
929 
} 
930 
} 
931  
932 
/* finally compute the MDCT coefficients */

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

935 
int16_t *coefs1; 
936 
float *coefs, *exponents, mult, mult1, noise, *exp_ptr;

937 
int i, j, n, n1, last_high_band;

938 
float exp_power[HIGH_BAND_MAX_SIZE];

939  
940 
coefs1 = s>coefs1[ch]; 
941 
exponents = s>exponents[ch]; 
942 
mult = pow(10, total_gain * 0.05) / s>max_exponent[ch]; 
943 
mult *= mdct_norm; 
944 
coefs = s>coefs[ch]; 
945 
if (s>use_noise_coding) {

946 
mult1 = mult; 
947 
/* very low freqs : noise */

948 
for(i = 0;i < s>coefs_start; i++) { 
949 
*coefs++ = s>noise_table[s>noise_index] * (*exponents++) * mult1; 
950 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
951 
} 
952  
953 
n1 = s>exponent_high_sizes[bsize]; 
954  
955 
/* compute power of high bands */

956 
exp_ptr = exponents + 
957 
s>high_band_start[bsize]  
958 
s>coefs_start; 
959 
last_high_band = 0; /* avoid warning */ 
960 
for(j=0;j<n1;j++) { 
961 
n = s>exponent_high_bands[s>frame_len_bits  
962 
s>block_len_bits][j]; 
963 
if (s>high_band_coded[ch][j]) {

964 
float e2, v;

965 
e2 = 0;

966 
for(i = 0;i < n; i++) { 
967 
v = exp_ptr[i]; 
968 
e2 += v * v; 
969 
} 
970 
exp_power[j] = e2 / n; 
971 
last_high_band = j; 
972 
tprintf("%d: power=%f (%d)\n", j, exp_power[j], n);

973 
} 
974 
exp_ptr += n; 
975 
} 
976  
977 
/* main freqs and high freqs */

978 
for(j=1;j<n1;j++) { 
979 
if (j < 0) { 
980 
n = s>high_band_start[bsize]  
981 
s>coefs_start; 
982 
} else {

983 
n = s>exponent_high_bands[s>frame_len_bits  
984 
s>block_len_bits][j]; 
985 
} 
986 
if (j >= 0 && s>high_band_coded[ch][j]) { 
987 
/* use noise with specified power */

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

990 
mult1 = mult1 * pow(10, s>high_band_values[ch][j] * 0.05); 
991 
mult1 = mult1 / (s>max_exponent[ch] * s>noise_mult); 
992 
mult1 *= mdct_norm; 
993 
for(i = 0;i < n; i++) { 
994 
noise = s>noise_table[s>noise_index]; 
995 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
996 
*coefs++ = (*exponents++) * noise * mult1; 
997 
} 
998 
} else {

999 
/* coded values + small noise */

1000 
for(i = 0;i < n; i++) { 
1001 
noise = s>noise_table[s>noise_index]; 
1002 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
1003 
*coefs++ = ((*coefs1++) + noise) * (*exponents++) * mult; 
1004 
} 
1005 
} 
1006 
} 
1007  
1008 
/* very high freqs : noise */

1009 
n = s>block_len  s>coefs_end[bsize]; 
1010 
mult1 = mult * exponents[1];

1011 
for(i = 0; i < n; i++) { 
1012 
*coefs++ = s>noise_table[s>noise_index] * mult1; 
1013 
s>noise_index = (s>noise_index + 1) & (NOISE_TAB_SIZE  1); 
1014 
} 
1015 
} else {

1016 
/* XXX: optimize more */

1017 
for(i = 0;i < s>coefs_start; i++) 
1018 
*coefs++ = 0.0; 
1019 
n = nb_coefs[ch]; 
1020 
for(i = 0;i < n; i++) { 
1021 
*coefs++ = coefs1[i] * exponents[i] * mult; 
1022 
} 
1023 
n = s>block_len  s>coefs_end[bsize]; 
1024 
for(i = 0;i < n; i++) 
1025 
*coefs++ = 0.0; 
1026 
} 
1027 
} 
1028 
} 
1029  
1030 
#ifdef TRACE

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

1033 
dump_floats("exponents", 3, s>exponents[ch], s>block_len); 
1034 
dump_floats("coefs", 1, s>coefs[ch], s>block_len); 
1035 
} 
1036 
} 
1037 
#endif

1038  
1039 
if (s>ms_stereo && s>channel_coded[1]) { 
1040 
float a, b;

1041 
int i;

1042  
1043 
/* nominal case for ms stereo: we do it before mdct */

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

1045 
never happen */

1046 
if (!s>channel_coded[0]) { 
1047 
tprintf("rare msstereo case happened\n");

1048 
memset(s>coefs[0], 0, sizeof(float) * s>block_len); 
1049 
s>channel_coded[0] = 1; 
1050 
} 
1051  
1052 
for(i = 0; i < s>block_len; i++) { 
1053 
a = s>coefs[0][i];

1054 
b = s>coefs[1][i];

1055 
s>coefs[0][i] = a + b;

1056 
s>coefs[1][i] = a  b;

1057 
} 
1058 
} 
1059  
1060 
/* build the window : we ensure that when the windows overlap

1061 
their squared sum is always 1 (MDCT reconstruction rule) */

1062 
/* XXX: merge with output */

1063 
{ 
1064 
int i, next_block_len, block_len, prev_block_len, n;

1065 
float *wptr;

1066  
1067 
block_len = s>block_len; 
1068 
prev_block_len = 1 << s>prev_block_len_bits;

1069 
next_block_len = 1 << s>next_block_len_bits;

1070  
1071 
/* right part */

1072 
wptr = window + block_len; 
1073 
if (block_len <= next_block_len) {

1074 
for(i=0;i<block_len;i++) 
1075 
*wptr++ = s>windows[bsize][i]; 
1076 
} else {

1077 
/* overlap */

1078 
n = (block_len / 2)  (next_block_len / 2); 
1079 
for(i=0;i<n;i++) 
1080 
*wptr++ = 1.0; 
1081 
for(i=0;i<next_block_len;i++) 
1082 
*wptr++ = s>windows[s>frame_len_bits  s>next_block_len_bits][i]; 
1083 
for(i=0;i<n;i++) 
1084 
*wptr++ = 0.0; 
1085 
} 
1086  
1087 
/* left part */

1088 
wptr = window + block_len; 
1089 
if (block_len <= prev_block_len) {

1090 
for(i=0;i<block_len;i++) 
1091 
*wptr = s>windows[bsize][i]; 
1092 
} else {

1093 
/* overlap */

1094 
n = (block_len / 2)  (prev_block_len / 2); 
1095 
for(i=0;i<n;i++) 
1096 
*wptr = 1.0; 
1097 
for(i=0;i<prev_block_len;i++) 
1098 
*wptr = s>windows[s>frame_len_bits  s>prev_block_len_bits][i]; 
1099 
for(i=0;i<n;i++) 
1100 
*wptr = 0.0; 
1101 
} 
1102 
} 
1103  
1104  
1105 
for(ch = 0; ch < s>nb_channels; ch++) { 
1106 
if (s>channel_coded[ch]) {

1107 
DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]);

1108 
float *ptr;

1109 
int i, n4, index, n;

1110  
1111 
n = s>block_len; 
1112 
n4 = s>block_len / 2;

1113 
ff_imdct_calc(&s>mdct_ctx[bsize], 
1114 
output, s>coefs[ch], s>mdct_tmp); 
1115  
1116 
/* XXX: optimize all that by build the window and

1117 
multipying/adding at the same time */

1118 
/* multiply by the window */

1119 
for(i=0;i<n * 2;i++) { 
1120 
output[i] *= window[i]; 
1121 
} 
1122  
1123 
/* add in the frame */

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

1125 
ptr = &s>frame_out[ch][index]; 
1126 
for(i=0;i<n * 2;i++) { 
1127 
*ptr += output[i]; 
1128 
ptr++; 
1129 
} 
1130  
1131 
/* specific fast case for msstereo : add to second

1132 
channel if it is not coded */

1133 
if (s>ms_stereo && !s>channel_coded[1]) { 
1134 
ptr = &s>frame_out[1][index];

1135 
for(i=0;i<n * 2;i++) { 
1136 
*ptr += output[i]; 
1137 
ptr++; 
1138 
} 
1139 
} 
1140 
} 
1141 
} 
1142 
next:

1143 
/* update block number */

1144 
s>block_num++; 
1145 
s>block_pos += s>block_len; 
1146 
if (s>block_pos >= s>frame_len)

1147 
return 1; 
1148 
else

1149 
return 0; 
1150 
} 
1151  
1152 
/* decode a frame of frame_len samples */

1153 
static int wma_decode_frame(WMADecodeContext *s, int16_t *samples) 
1154 
{ 
1155 
int ret, i, n, a, ch, incr;

1156 
int16_t *ptr; 
1157 
float *iptr;

1158  
1159 
#ifdef TRACE

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

1161 
#endif

1162  
1163 
/* read each block */

1164 
s>block_num = 0;

1165 
s>block_pos = 0;

1166 
for(;;) {

1167 
ret = wma_decode_block(s); 
1168 
if (ret < 0) 
1169 
return 1; 
1170 
if (ret)

1171 
break;

1172 
} 
1173  
1174 
/* convert frame to integer */

1175 
n = s>frame_len; 
1176 
incr = s>nb_channels; 
1177 
for(ch = 0; ch < s>nb_channels; ch++) { 
1178 
ptr = samples + ch; 
1179 
iptr = s>frame_out[ch]; 
1180  
1181 
for(i=0;i<n;i++) { 
1182 
a = lrintf(*iptr++); 
1183 
if (a > 32767) 
1184 
a = 32767;

1185 
else if (a < 32768) 
1186 
a = 32768;

1187 
*ptr = a; 
1188 
ptr += incr; 
1189 
} 
1190 
/* prepare for next block */

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

1192 
s>frame_len * sizeof(float)); 
1193 
/* XXX: suppress this */

1194 
memset(&s>frame_out[ch][s>frame_len], 0,

1195 
s>frame_len * sizeof(float)); 
1196 
} 
1197  
1198 
#ifdef TRACE

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

1200 
#endif

1201 
return 0; 
1202 
} 
1203  
1204 
static int wma_decode_superframe(AVCodecContext *avctx, 
1205 
void *data, int *data_size, 
1206 
uint8_t *buf, int buf_size)

1207 
{ 
1208 
WMADecodeContext *s = avctx>priv_data; 
1209 
int nb_frames, bit_offset, i, pos, len;

1210 
uint8_t *q; 
1211 
int16_t *samples; 
1212  
1213 
tprintf("***decode_superframe:\n");

1214  
1215 
if(buf_size==0){ 
1216 
s>last_superframe_len = 0;

1217 
return 0; 
1218 
} 
1219  
1220 
samples = data; 
1221  
1222 
init_get_bits(&s>gb, buf, buf_size*8);

1223  
1224 
if (s>use_bit_reservoir) {

1225 
/* read super frame header */

1226 
get_bits(&s>gb, 4); /* super frame index */ 
1227 
nb_frames = get_bits(&s>gb, 4)  1; 
1228  
1229 
bit_offset = get_bits(&s>gb, s>byte_offset_bits + 3);

1230  
1231 
if (s>last_superframe_len > 0) { 
1232 
// printf("skip=%d\n", s>last_bitoffset);

1233 
/* add bit_offset bits to last frame */

1234 
if ((s>last_superframe_len + ((bit_offset + 7) >> 3)) > 
1235 
MAX_CODED_SUPERFRAME_SIZE) 
1236 
goto fail;

1237 
q = s>last_superframe + s>last_superframe_len; 
1238 
len = bit_offset; 
1239 
while (len > 0) { 
1240 
*q++ = (get_bits)(&s>gb, 8);

1241 
len = 8;

1242 
} 
1243 
if (len > 0) { 
1244 
*q++ = (get_bits)(&s>gb, len) << (8  len);

1245 
} 
1246  
1247 
/* XXX: bit_offset bits into last frame */

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

1249 
/* skip unused bits */

1250 
if (s>last_bitoffset > 0) 
1251 
skip_bits(&s>gb, s>last_bitoffset); 
1252 
/* this frame is stored in the last superframe and in the

1253 
current one */

1254 
if (wma_decode_frame(s, samples) < 0) 
1255 
goto fail;

1256 
samples += s>nb_channels * s>frame_len; 
1257 
} 
1258  
1259 
/* read each frame starting from bit_offset */

1260 
pos = bit_offset + 4 + 4 + s>byte_offset_bits + 3; 
1261 
init_get_bits(&s>gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE  (pos >> 3))*8); 
1262 
len = pos & 7;

1263 
if (len > 0) 
1264 
skip_bits(&s>gb, len); 
1265  
1266 
s>reset_block_lengths = 1;

1267 
for(i=0;i<nb_frames;i++) { 
1268 
if (wma_decode_frame(s, samples) < 0) 
1269 
goto fail;

1270 
samples += s>nb_channels * s>frame_len; 
1271 
} 
1272  
1273 
/* we copy the end of the frame in the last frame buffer */

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

1276 
pos >>= 3;

1277 
len = buf_size  pos; 
1278 
if (len > MAX_CODED_SUPERFRAME_SIZE  len < 0) { 
1279 
goto fail;

1280 
} 
1281 
s>last_superframe_len = len; 
1282 
memcpy(s>last_superframe, buf + pos, len); 
1283 
} else {

1284 
/* single frame decode */

1285 
if (wma_decode_frame(s, samples) < 0) 
1286 
goto fail;

1287 
samples += s>nb_channels * s>frame_len; 
1288 
} 
1289 
*data_size = (int8_t *)samples  (int8_t *)data; 
1290 
return s>block_align;

1291 
fail:

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

1293 
s>last_superframe_len = 0;

1294 
return 1; 
1295 
} 
1296  
1297 
static int wma_decode_end(AVCodecContext *avctx) 
1298 
{ 
1299 
WMADecodeContext *s = avctx>priv_data; 
1300 
int i;

1301  
1302 
for(i = 0; i < s>nb_block_sizes; i++) 
1303 
ff_mdct_end(&s>mdct_ctx[i]); 
1304 
for(i = 0; i < s>nb_block_sizes; i++) 
1305 
av_free(s>windows[i]); 
1306  
1307 
if (s>use_exp_vlc) {

1308 
free_vlc(&s>exp_vlc); 
1309 
} 
1310 
if (s>use_noise_coding) {

1311 
free_vlc(&s>hgain_vlc); 
1312 
} 
1313 
for(i = 0;i < 2; i++) { 
1314 
free_vlc(&s>coef_vlc[i]); 
1315 
av_free(s>run_table[i]); 
1316 
av_free(s>level_table[i]); 
1317 
} 
1318  
1319 
return 0; 
1320 
} 
1321  
1322 
AVCodec wmav1_decoder = 
1323 
{ 
1324 
"wmav1",

1325 
CODEC_TYPE_AUDIO, 
1326 
CODEC_ID_WMAV1, 
1327 
sizeof(WMADecodeContext),

1328 
wma_decode_init, 
1329 
NULL,

1330 
wma_decode_end, 
1331 
wma_decode_superframe, 
1332 
}; 
1333  
1334 
AVCodec wmav2_decoder = 
1335 
{ 
1336 
"wmav2",

1337 
CODEC_TYPE_AUDIO, 
1338 
CODEC_ID_WMAV2, 
1339 
sizeof(WMADecodeContext),

1340 
wma_decode_init, 
1341 
NULL,

1342 
wma_decode_end, 
1343 
wma_decode_superframe, 
1344 
}; 