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 02110-1301 USA 20 */ 21 22/** 23 * @file libavcodec/wmadec.c 24 * WMA compatible decoder. 25 * This decoder handles Microsoft Windows Media Audio data, versions 1 & 2. 26 * WMA v1 is identified by audio format 0x160 in Microsoft media files 27 * (ASF/AVI/WAV). WMA v2 is identified by audio format 0x161. 28 * 29 * To use this decoder, a calling application must supply the extra data 30 * bytes provided with the WMA data. These are the extra, codec-specific 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+EXPVLCBITS-1)/EXPVLCBITS) 44 45#define HGAINVLCBITS 9 46#define HGAINMAX ((13+HGAINVLCBITS-1)/HGAINVLCBITS) 47 48static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len); 49 50#ifdef TRACE 51static 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 65static 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 82static int wma_decode_init(AVCodecContext * avctx) 83{ 84 WMACodecContext *s = avctx->priv_data; 85 int i, flags1, flags2; 86 uint8_t *extradata; 87 88 s->avctx = avctx; 89 90 /* extract flag infos */ 91 flags1 = 0; 92 flags2 = 0; 93 extradata = avctx->extradata; 94 if (avctx->codec->id == CODEC_ID_WMAV1 && avctx->extradata_size >= 4) { 95 flags1 = AV_RL16(extradata); 96 flags2 = AV_RL16(extradata+2); 97 } else if (avctx->codec->id == CODEC_ID_WMAV2 && avctx->extradata_size >= 6) { 98 flags1 = AV_RL32(extradata); 99 flags2 = AV_RL16(extradata+4); 100 } 101// for(i=0; i<avctx->extradata_size; i++) 102// av_log(NULL, AV_LOG_ERROR, "%02X ", extradata[i]); 103 104 s->use_exp_vlc = flags2 & 0x0001; 105 s->use_bit_reservoir = flags2 & 0x0002; 106 s->use_variable_block_len = flags2 & 0x0004; 107 108 if(ff_wma_init(avctx, flags2)<0) 109 return -1; 110 111 /* init MDCT */ 112 for(i = 0; i < s->nb_block_sizes; i++) 113 ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1); 114 115 if (s->use_noise_coding) { 116 init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(ff_wma_hgain_huffbits), 117 ff_wma_hgain_huffbits, 1, 1, 118 ff_wma_hgain_huffcodes, 2, 2, 0); 119 } 120 121 if (s->use_exp_vlc) { 122 init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_wma_scale_huffbits), //FIXME move out of context 123 ff_wma_scale_huffbits, 1, 1, 124 ff_wma_scale_huffcodes, 4, 4, 0); 125 } else { 126 wma_lsp_to_curve_init(s, s->frame_len); 127 } 128 129 avctx->sample_fmt = SAMPLE_FMT_S16; 130 return 0; 131} 132 133/** 134 * compute x^-0.25 with an exponent and mantissa table. We use linear 135 * interpolation to reduce the mantissa table size at a small speed 136 * expense (linear interpolation approximately doubles the number of 137 * bits of precision). 138 */ 139static inline float pow_m1_4(WMACodecContext *s, float x) 140{ 141 union { 142 float f; 143 unsigned int v; 144 } u, t; 145 unsigned int e, m; 146 float a, b; 147 148 u.f = x; 149 e = u.v >> 23; 150 m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1); 151 /* build interpolation scale: 1 <= t < 2. */ 152 t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23); 153 a = s->lsp_pow_m_table1[m]; 154 b = s->lsp_pow_m_table2[m]; 155 return s->lsp_pow_e_table[e] * (a + b * t.f); 156} 157 158static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len) 159{ 160 float wdel, a, b; 161 int i, e, m; 162 163 wdel = M_PI / frame_len; 164 for(i=0;i<frame_len;i++) 165 s->lsp_cos_table[i] = 2.0f * cos(wdel * i); 166 167 /* tables for x^-0.25 computation */ 168 for(i=0;i<256;i++) { 169 e = i - 126; 170 s->lsp_pow_e_table[i] = pow(2.0, e * -0.25); 171 } 172 173 /* NOTE: these two tables are needed to avoid two operations in 174 pow_m1_4 */ 175 b = 1.0; 176 for(i=(1 << LSP_POW_BITS) - 1;i>=0;i--) { 177 m = (1 << LSP_POW_BITS) + i; 178 a = (float)m * (0.5 / (1 << LSP_POW_BITS)); 179 a = pow(a, -0.25); 180 s->lsp_pow_m_table1[i] = 2 * a - b; 181 s->lsp_pow_m_table2[i] = b - a; 182 b = a; 183 } 184#if 0 185 for(i=1;i<20;i++) { 186 float v, r1, r2; 187 v = 5.0 / i; 188 r1 = pow_m1_4(s, v); 189 r2 = pow(v,-0.25); 190 printf("%f^-0.25=%f e=%f\n", v, r1, r2 - r1); 191 } 192#endif 193} 194 195/** 196 * NOTE: We use the same code as Vorbis here 197 * @todo optimize it further with SSE/3Dnow 198 */ 199static void wma_lsp_to_curve(WMACodecContext *s, 200 float *out, float *val_max_ptr, 201 int n, float *lsp) 202{ 203 int i, j; 204 float p, q, w, v, val_max; 205 206 val_max = 0; 207 for(i=0;i<n;i++) { 208 p = 0.5f; 209 q = 0.5f; 210 w = s->lsp_cos_table[i]; 211 for(j=1;j<NB_LSP_COEFS;j+=2){ 212 q *= w - lsp[j - 1]; 213 p *= w - lsp[j]; 214 } 215 p *= p * (2.0f - w); 216 q *= q * (2.0f + w); 217 v = p + q; 218 v = pow_m1_4(s, v); 219 if (v > val_max) 220 val_max = v; 221 out[i] = v; 222 } 223 *val_max_ptr = val_max; 224} 225 226/** 227 * decode exponents coded with LSP coefficients (same idea as Vorbis) 228 */ 229static void decode_exp_lsp(WMACodecContext *s, int ch) 230{ 231 float lsp_coefs[NB_LSP_COEFS]; 232 int val, i; 233 234 for(i = 0; i < NB_LSP_COEFS; i++) { 235 if (i == 0 || i >= 8) 236 val = get_bits(&s->gb, 3); 237 else 238 val = get_bits(&s->gb, 4); 239 lsp_coefs[i] = ff_wma_lsp_codebook[i][val]; 240 } 241 242 wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch], 243 s->block_len, lsp_coefs); 244} 245 246/** 247 * decode exponents coded with VLC codes 248 */ 249static int decode_exp_vlc(WMACodecContext *s, int ch) 250{ 251 int last_exp, n, code; 252 const uint16_t *ptr, *band_ptr; 253 float v, *q, max_scale, *q_end; 254 255 band_ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits]; 256 ptr = band_ptr; 257 q = s->exponents[ch]; 258 q_end = q + s->block_len; 259 max_scale = 0; 260 if (s->version == 1) { 261 last_exp = get_bits(&s->gb, 5) + 10; 262 /* XXX: use a table */ 263 v = pow(10, last_exp * (1.0 / 16.0)); 264 max_scale = v; 265 n = *ptr++; 266 do { 267 *q++ = v; 268 } while (--n); 269 }else 270 last_exp = 36; 271 272 while (q < q_end) { 273 code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX); 274 if (code < 0) 275 return -1; 276 /* NOTE: this offset is the same as MPEG4 AAC ! */ 277 last_exp += code - 60; 278 /* XXX: use a table */ 279 v = pow(10, last_exp * (1.0 / 16.0)); 280 if (v > max_scale) 281 max_scale = v; 282 n = *ptr++; 283 do { 284 *q++ = v; 285 } while (--n); 286 } 287 s->max_exponent[ch] = max_scale; 288 return 0; 289} 290 291 292/** 293 * Apply MDCT window and add into output. 294 * 295 * We ensure that when the windows overlap their squared sum 296 * is always 1 (MDCT reconstruction rule). 297 */ 298static void wma_window(WMACodecContext *s, float *out) 299{ 300 float *in = s->output; 301 int block_len, bsize, n; 302 303 /* left part */ 304 if (s->block_len_bits <= s->prev_block_len_bits) { 305 block_len = s->block_len; 306 bsize = s->frame_len_bits - s->block_len_bits; 307 308 s->dsp.vector_fmul_add_add(out, in, s->windows[bsize], 309 out, 0, block_len, 1); 310 311 } else { 312 block_len = 1 << s->prev_block_len_bits; 313 n = (s->block_len - block_len) / 2; 314 bsize = s->frame_len_bits - s->prev_block_len_bits; 315 316 s->dsp.vector_fmul_add_add(out+n, in+n, s->windows[bsize], 317 out+n, 0, block_len, 1); 318 319 memcpy(out+n+block_len, in+n+block_len, n*sizeof(float)); 320 } 321 322 out += s->block_len; 323 in += s->block_len; 324 325 /* right part */ 326 if (s->block_len_bits <= s->next_block_len_bits) { 327 block_len = s->block_len; 328 bsize = s->frame_len_bits - s->block_len_bits; 329 330 s->dsp.vector_fmul_reverse(out, in, s->windows[bsize], block_len); 331 332 } else { 333 block_len = 1 << s->next_block_len_bits; 334 n = (s->block_len - block_len) / 2; 335 bsize = s->frame_len_bits - s->next_block_len_bits; 336 337 memcpy(out, in, n*sizeof(float)); 338 339 s->dsp.vector_fmul_reverse(out+n, in+n, s->windows[bsize], block_len); 340 341 memset(out+n+block_len, 0, n*sizeof(float)); 342 } 343} 344 345 346/** 347 * @return 0 if OK. 1 if last block of frame. return -1 if 348 * unrecorrable error. 349 */ 350static int wma_decode_block(WMACodecContext *s) 351{ 352 int n, v, a, ch, code, bsize; 353 int coef_nb_bits, total_gain; 354 int nb_coefs[MAX_CHANNELS]; 355 float mdct_norm; 356 357#ifdef TRACE 358 tprintf(s->avctx, "***decode_block: %d:%d\n", s->frame_count - 1, s->block_num); 359#endif 360 361 /* compute current block length */ 362 if (s->use_variable_block_len) { 363 n = av_log2(s->nb_block_sizes - 1) + 1; 364 365 if (s->reset_block_lengths) { 366 s->reset_block_lengths = 0; 367 v = get_bits(&s->gb, n); 368 if (v >= s->nb_block_sizes) 369 return -1; 370 s->prev_block_len_bits = s->frame_len_bits - v; 371 v = get_bits(&s->gb, n); 372 if (v >= s->nb_block_sizes) 373 return -1; 374 s->block_len_bits = s->frame_len_bits - v; 375 } else { 376 /* update block lengths */ 377 s->prev_block_len_bits = s->block_len_bits; 378 s->block_len_bits = s->next_block_len_bits; 379 } 380 v = get_bits(&s->gb, n); 381 if (v >= s->nb_block_sizes) 382 return -1; 383 s->next_block_len_bits = s->frame_len_bits - v; 384 } else { 385 /* fixed block len */ 386 s->next_block_len_bits = s->frame_len_bits; 387 s->prev_block_len_bits = s->frame_len_bits; 388 s->block_len_bits = s->frame_len_bits; 389 } 390 391 /* now check if the block length is coherent with the frame length */ 392 s->block_len = 1 << s->block_len_bits; 393 if ((s->block_pos + s->block_len) > s->frame_len) 394 return -1; 395 396 if (s->nb_channels == 2) { 397 s->ms_stereo = get_bits1(&s->gb); 398 } 399 v = 0; 400 for(ch = 0; ch < s->nb_channels; ch++) { 401 a = get_bits1(&s->gb); 402 s->channel_coded[ch] = a; 403 v |= a; 404 } 405 406 bsize = s->frame_len_bits - s->block_len_bits; 407 408 /* if no channel coded, no need to go further */ 409 /* XXX: fix potential framing problems */ 410 if (!v) 411 goto next; 412 413 /* read total gain and extract corresponding number of bits for 414 coef escape coding */ 415 total_gain = 1; 416 for(;;) { 417 a = get_bits(&s->gb, 7); 418 total_gain += a; 419 if (a != 127) 420 break; 421 } 422 423 coef_nb_bits= ff_wma_total_gain_to_bits(total_gain); 424 425 /* compute number of coefficients */ 426 n = s->coefs_end[bsize] - s->coefs_start; 427 for(ch = 0; ch < s->nb_channels; ch++) 428 nb_coefs[ch] = n; 429 430 /* complex coding */ 431 if (s->use_noise_coding) { 432 433 for(ch = 0; ch < s->nb_channels; ch++) { 434 if (s->channel_coded[ch]) { 435 int i, n, a; 436 n = s->exponent_high_sizes[bsize]; 437 for(i=0;i<n;i++) { 438 a = get_bits1(&s->gb); 439 s->high_band_coded[ch][i] = a; 440 /* if noise coding, the coefficients are not transmitted */ 441 if (a) 442 nb_coefs[ch] -= s->exponent_high_bands[bsize][i]; 443 } 444 } 445 } 446 for(ch = 0; ch < s->nb_channels; ch++) { 447 if (s->channel_coded[ch]) { 448 int i, n, val, code; 449 450 n = s->exponent_high_sizes[bsize]; 451 val = (int)0x80000000; 452 for(i=0;i<n;i++) { 453 if (s->high_band_coded[ch][i]) { 454 if (val == (int)0x80000000) { 455 val = get_bits(&s->gb, 7) - 19; 456 } else { 457 code = get_vlc2(&s->gb, s->hgain_vlc.table, HGAINVLCBITS, HGAINMAX); 458 if (code < 0) 459 return -1; 460 val += code - 18; 461 } 462 s->high_band_values[ch][i] = val; 463 } 464 } 465 } 466 } 467 } 468 469 /* exponents can be reused in short blocks. */ 470 if ((s->block_len_bits == s->frame_len_bits) || 471 get_bits1(&s->gb)) { 472 for(ch = 0; ch < s->nb_channels; ch++) { 473 if (s->channel_coded[ch]) { 474 if (s->use_exp_vlc) { 475 if (decode_exp_vlc(s, ch) < 0) 476 return -1; 477 } else { 478 decode_exp_lsp(s, ch); 479 } 480 s->exponents_bsize[ch] = bsize; 481 } 482 } 483 } 484 485 /* parse spectral coefficients : just RLE encoding */ 486 for(ch = 0; ch < s->nb_channels; ch++) { 487 if (s->channel_coded[ch]) { 488 VLC *coef_vlc; 489 int level, run, sign, tindex; 490 int16_t *ptr, *eptr; 491 const uint16_t *level_table, *run_table; 492 493 /* special VLC tables are used for ms stereo because 494 there is potentially less energy there */ 495 tindex = (ch == 1 && s->ms_stereo); 496 coef_vlc = &s->coef_vlc[tindex]; 497 run_table = s->run_table[tindex]; 498 level_table = s->level_table[tindex]; 499 /* XXX: optimize */ 500 ptr = &s->coefs1[ch][0]; 501 eptr = ptr + nb_coefs[ch]; 502 memset(ptr, 0, s->block_len * sizeof(int16_t)); 503 for(;;) { 504 code = get_vlc2(&s->gb, coef_vlc->table, VLCBITS, VLCMAX); 505 if (code < 0) 506 return -1; 507 if (code == 1) { 508 /* EOB */ 509 break; 510 } else if (code == 0) { 511 /* escape */ 512 level = get_bits(&s->gb, coef_nb_bits); 513 /* NOTE: this is rather suboptimal. reading 514 block_len_bits would be better */ 515 run = get_bits(&s->gb, s->frame_len_bits); 516 } else { 517 /* normal code */ 518 run = run_table[code]; 519 level = level_table[code]; 520 } 521 sign = get_bits1(&s->gb); 522 if (!sign) 523 level = -level; 524 ptr += run; 525 if (ptr >= eptr) 526 { 527 av_log(NULL, AV_LOG_ERROR, "overflow in spectral RLE, ignoring\n"); 528 break; 529 } 530 *ptr++ = level; 531 /* NOTE: EOB can be omitted */ 532 if (ptr >= eptr) 533 break; 534 } 535 } 536 if (s->version == 1 && s->nb_channels >= 2) { 537 align_get_bits(&s->gb); 538 } 539 } 540 541 /* normalize */ 542 { 543 int n4 = s->block_len / 2; 544 mdct_norm = 1.0 / (float)n4; 545 if (s->version == 1) { 546 mdct_norm *= sqrt(n4); 547 } 548 } 549 550 /* finally compute the MDCT coefficients */ 551 for(ch = 0; ch < s->nb_channels; ch++) { 552 if (s->channel_coded[ch]) { 553 int16_t *coefs1; 554 float *coefs, *exponents, mult, mult1, noise; 555 int i, j, n, n1, last_high_band, esize; 556 float exp_power[HIGH_BAND_MAX_SIZE]; 557 558 coefs1 = s->coefs1[ch]; 559 exponents = s->exponents[ch]; 560 esize = s->exponents_bsize[ch]; 561 mult = pow(10, total_gain * 0.05) / s->max_exponent[ch]; 562 mult *= mdct_norm; 563 coefs = s->coefs[ch]; 564 if (s->use_noise_coding) { 565 mult1 = mult; 566 /* very low freqs : noise */ 567 for(i = 0;i < s->coefs_start; i++) { 568 *coefs++ = s->noise_table[s->noise_index] * 569 exponents[i<<bsize>>esize] * mult1; 570 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); 571 } 572 573 n1 = s->exponent_high_sizes[bsize]; 574 575 /* compute power of high bands */ 576 exponents = s->exponents[ch] + 577 (s->high_band_start[bsize]<<bsize); 578 last_high_band = 0; /* avoid warning */ 579 for(j=0;j<n1;j++) { 580 n = s->exponent_high_bands[s->frame_len_bits - 581 s->block_len_bits][j]; 582 if (s->high_band_coded[ch][j]) { 583 float e2, v; 584 e2 = 0; 585 for(i = 0;i < n; i++) { 586 v = exponents[i<<bsize>>esize]; 587 e2 += v * v; 588 } 589 exp_power[j] = e2 / n; 590 last_high_band = j; 591 tprintf(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n); 592 } 593 exponents += n<<bsize; 594 } 595 596 /* main freqs and high freqs */ 597 exponents = s->exponents[ch] + (s->coefs_start<<bsize); 598 for(j=-1;j<n1;j++) { 599 if (j < 0) { 600 n = s->high_band_start[bsize] - 601 s->coefs_start; 602 } else { 603 n = s->exponent_high_bands[s->frame_len_bits - 604 s->block_len_bits][j]; 605 } 606 if (j >= 0 && s->high_band_coded[ch][j]) { 607 /* use noise with specified power */ 608 mult1 = sqrt(exp_power[j] / exp_power[last_high_band]); 609 /* XXX: use a table */ 610 mult1 = mult1 * pow(10, s->high_band_values[ch][j] * 0.05); 611 mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult); 612 mult1 *= mdct_norm; 613 for(i = 0;i < n; i++) { 614 noise = s->noise_table[s->noise_index]; 615 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); 616 *coefs++ = noise * 617 exponents[i<<bsize>>esize] * mult1; 618 } 619 exponents += n<<bsize; 620 } else { 621 /* coded values + small noise */ 622 for(i = 0;i < n; i++) { 623 noise = s->noise_table[s->noise_index]; 624 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); 625 *coefs++ = ((*coefs1++) + noise) * 626 exponents[i<<bsize>>esize] * mult; 627 } 628 exponents += n<<bsize; 629 } 630 } 631 632 /* very high freqs : noise */ 633 n = s->block_len - s->coefs_end[bsize]; 634 mult1 = mult * exponents[((-1<<bsize))>>esize]; 635 for(i = 0; i < n; i++) { 636 *coefs++ = s->noise_table[s->noise_index] * mult1; 637 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); 638 } 639 } else { 640 /* XXX: optimize more */ 641 for(i = 0;i < s->coefs_start; i++) 642 *coefs++ = 0.0; 643 n = nb_coefs[ch]; 644 for(i = 0;i < n; i++) { 645 *coefs++ = coefs1[i] * exponents[i<<bsize>>esize] * mult; 646 } 647 n = s->block_len - s->coefs_end[bsize]; 648 for(i = 0;i < n; i++) 649 *coefs++ = 0.0; 650 } 651 } 652 } 653 654#ifdef TRACE 655 for(ch = 0; ch < s->nb_channels; ch++) { 656 if (s->channel_coded[ch]) { 657 dump_floats(s, "exponents", 3, s->exponents[ch], s->block_len); 658 dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len); 659 } 660 } 661#endif 662 663 if (s->ms_stereo && s->channel_coded[1]) { 664 float a, b; 665 int i; 666 667 /* nominal case for ms stereo: we do it before mdct */ 668 /* no need to optimize this case because it should almost 669 never happen */ 670 if (!s->channel_coded[0]) { 671 tprintf(s->avctx, "rare ms-stereo case happened\n"); 672 memset(s->coefs[0], 0, sizeof(float) * s->block_len); 673 s->channel_coded[0] = 1; 674 } 675 676 for(i = 0; i < s->block_len; i++) { 677 a = s->coefs[0][i]; 678 b = s->coefs[1][i]; 679 s->coefs[0][i] = a + b; 680 s->coefs[1][i] = a - b; 681 } 682 } 683 684next: 685 for(ch = 0; ch < s->nb_channels; ch++) { 686 int n4, index, n; 687 688 n = s->block_len; 689 n4 = s->block_len / 2; 690 if(s->channel_coded[ch]){ 691 ff_imdct_calc(&s->mdct_ctx[bsize], s->output, s->coefs[ch]); 692 }else if(!(s->ms_stereo && ch==1)) 693 memset(s->output, 0, sizeof(s->output)); 694 695 /* multiply by the window and add in the frame */ 696 index = (s->frame_len / 2) + s->block_pos - n4; 697 wma_window(s, &s->frame_out[ch][index]); 698 } 699 700 /* update block number */ 701 s->block_num++; 702 s->block_pos += s->block_len; 703 if (s->block_pos >= s->frame_len) 704 return 1; 705 else 706 return 0; 707} 708 709/* decode a frame of frame_len samples */ 710static int wma_decode_frame(WMACodecContext *s, int16_t *samples) 711{ 712 int ret, i, n, ch, incr; 713 int16_t *ptr; 714 float *iptr; 715 716#ifdef TRACE 717 tprintf(s->avctx, "***decode_frame: %d size=%d\n", s->frame_count++, s->frame_len); 718#endif 719 720 /* read each block */ 721 s->block_num = 0; 722 s->block_pos = 0; 723 for(;;) { 724 ret = wma_decode_block(s); 725 if (ret < 0) 726 return -1; 727 if (ret) 728 break; 729 } 730 731 /* convert frame to integer */ 732 n = s->frame_len; 733 incr = s->nb_channels; 734 for(ch = 0; ch < s->nb_channels; ch++) { 735 ptr = samples + ch; 736 iptr = s->frame_out[ch]; 737 738 for(i=0;i<n;i++) { 739 *ptr = av_clip_int16(lrintf(*iptr++)); 740 ptr += incr; 741 } 742 /* prepare for next block */ 743 memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len], 744 s->frame_len * sizeof(float)); 745 } 746 747#ifdef TRACE 748 dump_shorts(s, "samples", samples, n * s->nb_channels); 749#endif 750 return 0; 751} 752 753static int wma_decode_superframe(AVCodecContext *avctx, 754 void *data, int *data_size, 755 const uint8_t *buf, int buf_size) 756{ 757 WMACodecContext *s = avctx->priv_data; 758 int nb_frames, bit_offset, i, pos, len; 759 uint8_t *q; 760 int16_t *samples; 761 762 tprintf(avctx, "***decode_superframe:\n"); 763 764 if(buf_size==0){ 765 s->last_superframe_len = 0; 766 return 0; 767 } 768 if (buf_size < s->block_align) 769 return 0; 770 buf_size = s->block_align; 771 772 samples = data; 773 774 init_get_bits(&s->gb, buf, buf_size*8); 775 776 if (s->use_bit_reservoir) { 777 /* read super frame header */ 778 skip_bits(&s->gb, 4); /* super frame index */ 779 nb_frames = get_bits(&s->gb, 4) - 1; 780 781 if((nb_frames+1) * s->nb_channels * s->frame_len * sizeof(int16_t) > *data_size){ 782 av_log(s->avctx, AV_LOG_ERROR, "Insufficient output space\n"); 783 goto fail; 784 } 785 786 bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3); 787 788 if (s->last_superframe_len > 0) { 789 // printf("skip=%d\n", s->last_bitoffset); 790 /* add bit_offset bits to last frame */ 791 if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) > 792 MAX_CODED_SUPERFRAME_SIZE) 793 goto fail; 794 q = s->last_superframe + s->last_superframe_len; 795 len = bit_offset; 796 while (len > 7) { 797 *q++ = (get_bits)(&s->gb, 8); 798 len -= 8; 799 } 800 if (len > 0) { 801 *q++ = (get_bits)(&s->gb, len) << (8 - len); 802 } 803 804 /* XXX: bit_offset bits into last frame */ 805 init_get_bits(&s->gb, s->last_superframe, MAX_CODED_SUPERFRAME_SIZE*8); 806 /* skip unused bits */ 807 if (s->last_bitoffset > 0) 808 skip_bits(&s->gb, s->last_bitoffset); 809 /* this frame is stored in the last superframe and in the 810 current one */ 811 if (wma_decode_frame(s, samples) < 0) 812 goto fail; 813 samples += s->nb_channels * s->frame_len; 814 } 815 816 /* read each frame starting from bit_offset */ 817 pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3; 818 init_get_bits(&s->gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE - (pos >> 3))*8); 819 len = pos & 7; 820 if (len > 0) 821 skip_bits(&s->gb, len); 822 823 s->reset_block_lengths = 1; 824 for(i=0;i<nb_frames;i++) { 825 if (wma_decode_frame(s, samples) < 0) 826 goto fail; 827 samples += s->nb_channels * s->frame_len; 828 } 829 830 /* we copy the end of the frame in the last frame buffer */ 831 pos = get_bits_count(&s->gb) + ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7); 832 s->last_bitoffset = pos & 7; 833 pos >>= 3; 834 len = buf_size - pos; 835 if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) { 836 goto fail; 837 } 838 s->last_superframe_len = len; 839 memcpy(s->last_superframe, buf + pos, len); 840 } else { 841 if(s->nb_channels * s->frame_len * sizeof(int16_t) > *data_size){ 842 av_log(s->avctx, AV_LOG_ERROR, "Insufficient output space\n"); 843 goto fail; 844 } 845 /* single frame decode */ 846 if (wma_decode_frame(s, samples) < 0) 847 goto fail; 848 samples += s->nb_channels * s->frame_len; 849 } 850 851//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); 852 853 *data_size = (int8_t *)samples - (int8_t *)data; 854 return s->block_align; 855 fail: 856 /* when error, we reset the bit reservoir */ 857 s->last_superframe_len = 0; 858 return -1; 859} 860 861AVCodec wmav1_decoder = 862{ 863 "wmav1", 864 CODEC_TYPE_AUDIO, 865 CODEC_ID_WMAV1, 866 sizeof(WMACodecContext), 867 wma_decode_init, 868 NULL, 869 ff_wma_end, 870 wma_decode_superframe, 871 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"), 872}; 873 874AVCodec wmav2_decoder = 875{ 876 "wmav2", 877 CODEC_TYPE_AUDIO, 878 CODEC_ID_WMAV2, 879 sizeof(WMACodecContext), 880 wma_decode_init, 881 NULL, 882 ff_wma_end, 883 wma_decode_superframe, 884 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"), 885}; 886