git.sesse.net Git - ffmpeg/blob - libavcodec/wmadec.c

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