git.sesse.net Git - vlc/blob - modules/codec/wmafixed/wmadeci.c

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 /**
  21  * @file wmadec.c
  22  * WMA compatible decoder.
  23  */
  24
  25 #define IBSS_ATTR
  26 #define ICONST_ATTR
  27 #define ICODE_ATTR
  28
  29 #ifdef NDEBUG
  30 #include <stdio.h>
  31 #undef WMA_DEBUG /* enable when debugging wma */
  32 #endif
  33
  34 #include "asf.h"
  35 #include "wmadec.h"
  36 #include "wmafixed.h"
  37 #include "bitstream.h"
  38 #include <string.h> /* memcpy() */
  39
  40 #define VLCBITS 7       /*7 is the lowest without glitching*/
  41 #define VLCMAX ((22+VLCBITS-1)/VLCBITS)
  42
  43 #define EXPVLCBITS 7
  44 #define EXPMAX ((19+EXPVLCBITS-1)/EXPVLCBITS)
  45
  46 #define HGAINVLCBITS 9
  47 #define HGAINMAX ((13+HGAINVLCBITS-1)/HGAINVLCBITS)
  48
  49
  50 typedef struct CoefVLCTable
  51 {
  52     int n; /* total number of codes */
  53     const uint32_t *huffcodes; /* VLC bit values */
  54     const uint8_t *huffbits;   /* VLC bit size */
  55     const uint16_t *levels; /* table to build run/level tables */
  56 }
  57 CoefVLCTable;
  58
  59 static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len);
  60
  61 int32_t coefsarray[MAX_CHANNELS][BLOCK_MAX_SIZE] IBSS_ATTR;
  62
  63 /* static variables that replace malloced stuff */
  64 /* these are the MDCT reconstruction windows */
  65 int32_t stat0[2048], stat1[1024], stat2[512], stat3[256], stat4[128];
  66
  67 /* these are VLC lookup tables */
  68 uint16_t *runtabarray[2], *levtabarray[2];
  69
  70 /* these could be made smaller since only one can be 1336 */
  71 uint16_t runtab0[1336], runtab1[1336], levtab0[1336], levtab1[1336];
  72
  73 #define VLCBUF1SIZE 4598
  74 #define VLCBUF2SIZE 3574
  75 #define VLCBUF3SIZE 360
  76 #define VLCBUF4SIZE 540
  77
  78 /*putting these in IRAM actually makes PP slower*/
  79
  80 VLC_TYPE vlcbuf1[VLCBUF1SIZE][2];
  81 VLC_TYPE vlcbuf2[VLCBUF2SIZE][2];
  82 VLC_TYPE vlcbuf3[VLCBUF3SIZE][2];
  83 VLC_TYPE vlcbuf4[VLCBUF4SIZE][2];
  84
  85 #include "wmadata.h" // PJJ
  86
  87 /*
  88  * Helper functions for wma_window.
  89  *
  90  *
  91  */
  92
  93 #ifdef CPU_ARM
  94 static inline
  95 void vector_fmul_add_add(int32_t *dst, const int32_t *data,
  96                          const int32_t *window, int n)
  97 {
  98     /* Block sizes are always power of two */
  99     asm volatile (
 100         "0:"
 101         "ldmia %[d]!, {r0, r1};"
 102         "ldmia %[w]!, {r4, r5};"
 103         /* consume the first data and window value so we can use those
 104          * registers again */
 105         "smull r8, r9, r0, r4;"
 106         "ldmia %[dst], {r0, r4};"
 107         "add   r0, r0, r9, lsl #1;"  /* *dst=*dst+(r9<<1)*/
 108         "smull r8, r9, r1, r5;"
 109         "add   r1, r4, r9, lsl #1;"
 110         "stmia %[dst]!, {r0, r1};"
 111         "subs  %[n], %[n], #2;"
 112         "bne   0b;"
 113         : [d] "+r" (data), [w] "+r" (window), [dst] "+r" (dst), [n] "+r" (n)
 114         : : "r0", "r1", "r4", "r5", "r8", "r9", "memory", "cc");
 115 }
 116
 117 static inline
 118 void vector_fmul_reverse(int32_t *dst, const int32_t *src0, const int32_t *src1,
 119                          int len)
 120 {
 121     /* Block sizes are always power of two */
 122     asm volatile (
 123         "add   %[s1], %[s1], %[n], lsl #2;"
 124         "0:"
 125         "ldmia %[s0]!, {r0, r1};"
 126         "ldmdb %[s1]!, {r4, r5};"
 127         "smull r8, r9, r0, r5;"
 128         "mov   r0, r9, lsl #1;"
 129         "smull r8, r9, r1, r4;"
 130         "mov   r1, r9, lsl #1;"
 131         "stmia %[dst]!, {r0, r1};"
 132         "subs  %[n], %[n], #2;"
 133         "bne   0b;"
 134         : [s0] "+r" (src0), [s1] "+r" (src1), [dst] "+r" (dst), [n] "+r" (len)
 135         : : "r0", "r1", "r4", "r5", "r8", "r9", "memory", "cc");
 136 }
 137
 138 #elif defined(CPU_COLDFIRE)
 139
 140 static inline
 141 void vector_fmul_add_add(int32_t *dst, const int32_t *data,
 142                          const int32_t *window, int n)
 143 {
 144     /* Block sizes are always power of two. Smallest block is always way bigger
 145      * than four too.*/
 146     asm volatile (
 147         "0:"
 148         "movem.l (%[d]), %%d0-%%d3;"
 149         "movem.l (%[w]), %%d4-%%d5/%%a0-%%a1;"
 150         "mac.l %%d0, %%d4, %%acc0;"
 151         "mac.l %%d1, %%d5, %%acc1;"
 152         "mac.l %%d2, %%a0, %%acc2;"
 153         "mac.l %%d3, %%a1, %%acc3;"
 154         "lea.l (16, %[d]), %[d];"
 155         "lea.l (16, %[w]), %[w];"
 156         "movclr.l %%acc0, %%d0;"
 157         "movclr.l %%acc1, %%d1;"
 158         "movclr.l %%acc2, %%d2;"
 159         "movclr.l %%acc3, %%d3;"
 160         "add.l %%d0, (%[dst])+;"
 161         "add.l %%d1, (%[dst])+;"
 162         "add.l %%d2, (%[dst])+;"
 163         "add.l %%d3, (%[dst])+;"
 164         "subq.l #4, %[n];"
 165         "jne 0b;"
 166         : [d] "+a" (data), [w] "+a" (window), [dst] "+a" (dst), [n] "+d" (n)
 167         : : "d0", "d1", "d2", "d3", "d4", "d5", "a0", "a1", "memory", "cc");
 168 }
 169
 170 static inline
 171 void vector_fmul_reverse(int32_t *dst, const int32_t *src0, const int32_t *src1,
 172                          int len)
 173 {
 174     /* Block sizes are always power of two. Smallest block is always way bigger
 175      * than four too.*/
 176     asm volatile (
 177         "lea.l (-16, %[s1], %[n]*4), %[s1];"
 178         "0:"
 179         "movem.l (%[s0]), %%d0-%%d3;"
 180         "movem.l (%[s1]), %%d4-%%d5/%%a0-%%a1;"
 181         "mac.l %%d0, %%a1, %%acc0;"
 182         "mac.l %%d1, %%a0, %%acc1;"
 183         "mac.l %%d2, %%d5, %%acc2;"
 184         "mac.l %%d3, %%d4, %%acc3;"
 185         "lea.l (16, %[s0]), %[s0];"
 186         "lea.l (-16, %[s1]), %[s1];"
 187         "movclr.l %%acc0, %%d0;"
 188         "movclr.l %%acc1, %%d1;"
 189         "movclr.l %%acc2, %%d2;"
 190         "movclr.l %%acc3, %%d3;"
 191         "movem.l %%d0-%%d3, (%[dst]);"
 192         "lea.l (16, %[dst]), %[dst];"
 193         "subq.l #4, %[n];"
 194         "jne 0b;"
 195         : [s0] "+a" (src0), [s1] "+a" (src1), [dst] "+a" (dst), [n] "+d" (len)
 196         : : "d0", "d1", "d2", "d3", "d4", "d5", "a0", "a1", "memory", "cc");
 197 }
 198
 199 #else
 200
 201 static inline void vector_fmul_add_add(int32_t *dst, const int32_t *src0, const int32_t *src1, int len){
 202     int i;
 203     for(i=0; i<len; i++)
 204         dst[i] = fixmul32b(src0[i], src1[i]) + dst[i];
 205 }
 206
 207 static inline void vector_fmul_reverse(int32_t *dst, const int32_t *src0, const int32_t *src1, int len){
 208     int i;
 209     src1 += len-1;
 210     for(i=0; i<len; i++)
 211         dst[i] = fixmul32b(src0[i], src1[-i]);
 212 }
 213
 214 #endif
 215
 216 /**
 217   * Apply MDCT window and add into output.
 218   *
 219   * We ensure that when the windows overlap their squared sum
 220   * is always 1 (MDCT reconstruction rule).
 221   *
 222   * The Vorbis I spec has a great diagram explaining this process.
 223   * See section 1.3.2.3 of http://xiph.org/vorbis/doc/Vorbis_I_spec.html
 224   */
 225 static void wma_window(WMADecodeContext *s, int32_t *in, int32_t *out)
 226 {
 227     int block_len, bsize, n;
 228
 229      /* left part */
 230      /*previous block was larger, so we'll use the size of the current block to set the window size*/
 231     if (s->block_len_bits <= s->prev_block_len_bits) {
 232          block_len = s->block_len;
 233          bsize = s->frame_len_bits - s->block_len_bits;
 234
 235          vector_fmul_add_add(out, in, s->windows[bsize], block_len);
 236
 237     } else {
 238          /*previous block was smaller or the same size, so use it's size to set the window length*/
 239          block_len = 1 << s->prev_block_len_bits;
 240          /*find the middle of the two overlapped blocks, this will be the first overlapped sample*/
 241          n = (s->block_len - block_len) / 2;
 242          bsize = s->frame_len_bits - s->prev_block_len_bits;
 243
 244          vector_fmul_add_add(out+n, in+n, s->windows[bsize],  block_len);
 245
 246          memcpy(out+n+block_len, in+n+block_len, n*sizeof(int32_t));
 247     }
 248     /* Advance to the end of the current block and prepare to window it for the next block.
 249      * Since the window function needs to be reversed, we do it backwards starting with the
 250      * last sample and moving towards the first
 251      */
 252      out += s->block_len;
 253      in += s->block_len;
 254
 255      /* right part */
 256      if (s->block_len_bits <= s->next_block_len_bits) {
 257          block_len = s->block_len;
 258          bsize = s->frame_len_bits - s->block_len_bits;
 259
 260          vector_fmul_reverse(out, in, s->windows[bsize], block_len);
 261
 262      } else {
 263          block_len = 1 << s->next_block_len_bits;
 264          n = (s->block_len - block_len) / 2;
 265          bsize = s->frame_len_bits - s->next_block_len_bits;
 266
 267          memcpy(out, in, n*sizeof(int32_t));
 268
 269          vector_fmul_reverse(out+n, in+n, s->windows[bsize], block_len);
 270
 271          memset(out+n+block_len, 0, n*sizeof(int32_t));
 272      }
 273 }
 274
 275 /* XXX: use same run/length optimization as mpeg decoders */
 276 static void init_coef_vlc(VLC *vlc,
 277                           uint16_t **prun_table, uint16_t **plevel_table,
 278                           const CoefVLCTable *vlc_table, int tab)
 279 {
 280     int n = vlc_table->n;
 281     const uint8_t *table_bits = vlc_table->huffbits;
 282     const uint32_t *table_codes = vlc_table->huffcodes;
 283     const uint16_t *levels_table = vlc_table->levels;
 284     uint16_t *run_table, *level_table;
 285     const uint16_t *p;
 286     int i, l, j, level;
 287
 288     init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
 289
 290     run_table = runtabarray[tab];
 291     level_table= levtabarray[tab];
 292
 293     p = levels_table;
 294     i = 2;
 295     level = 1;
 296     while (i < n)
 297     {
 298         l = *p++;
 299         for(j=0;j<l;++j)
 300         {
 301             run_table[i] = j;
 302             level_table[i] = level;
 303             ++i;
 304         }
 305         ++level;
 306     }
 307     *prun_table = run_table;
 308     *plevel_table = level_table;
 309 }
 310
 311 int wma_decode_init(WMADecodeContext* s, asf_waveformatex_t *wfx)
 312 {
 313     int i, flags1, flags2;
 314     int32_t *window;
 315     uint8_t *extradata;
 316     int64_t bps1;
 317     int32_t high_freq;
 318     int64_t bps;
 319     int sample_rate1;
 320     int coef_vlc_table;
 321
 322     #ifdef CPU_COLDFIRE
 323     coldfire_set_macsr(EMAC_FRACTIONAL | EMAC_SATURATE);
 324     #endif
 325
 326     s->sample_rate = wfx->rate;
 327     s->nb_channels = wfx->channels;
 328     s->bit_rate = wfx->bitrate;
 329     s->block_align = wfx->blockalign;
 330
 331     s->coefs = &coefsarray;
 332
 333     if (wfx->codec_id == ASF_CODEC_ID_WMAV1) {
 334         s->version = 1;
 335     } else if (wfx->codec_id == ASF_CODEC_ID_WMAV2 ) {
 336         s->version = 2;
 337     } else {
 338         /*one of those other wma flavors that don't have GPLed decoders */
 339         return -1;
 340     }
 341
 342     /* extract flag infos */
 343     flags1 = 0;
 344     flags2 = 0;
 345     extradata = wfx->data;
 346     if (s->version == 1 && wfx->datalen >= 4) {
 347         flags1 = extradata[0] | (extradata[1] << 8);
 348         flags2 = extradata[2] | (extradata[3] << 8);
 349     }else if (s->version == 2 && wfx->datalen >= 6){
 350         flags1 = extradata[0] | (extradata[1] << 8) |
 351                  (extradata[2] << 16) | (extradata[3] << 24);
 352         flags2 = extradata[4] | (extradata[5] << 8);
 353     }
 354     s->use_exp_vlc = flags2 & 0x0001;
 355     s->use_bit_reservoir = flags2 & 0x0002;
 356     s->use_variable_block_len = flags2 & 0x0004;
 357
 358     /* compute MDCT block size */
 359     if (s->sample_rate <= 16000){
 360         s->frame_len_bits = 9;
 361     }else if (s->sample_rate <= 22050 ||
 362              (s->sample_rate <= 32000 && s->version == 1)){
 363         s->frame_len_bits = 10;
 364     }else{
 365         s->frame_len_bits = 11;
 366     }
 367     s->frame_len = 1 << s->frame_len_bits;
 368     if (s-> use_variable_block_len)
 369     {
 370         int nb_max, nb;
 371         nb = ((flags2 >> 3) & 3) + 1;
 372         if ((s->bit_rate / s->nb_channels) >= 32000)
 373         {
 374             nb += 2;
 375         }
 376         nb_max = s->frame_len_bits - BLOCK_MIN_BITS;  /* max is 11-7 */
 377         if (nb > nb_max)
 378             nb = nb_max;
 379         s->nb_block_sizes = nb + 1;
 380     }
 381     else
 382     {
 383         s->nb_block_sizes = 1;
 384     }
 385
 386     /* init rate dependant parameters */
 387     s->use_noise_coding = 1;
 388     high_freq = itofix64(s->sample_rate) >> 1;
 389
 390     /* if version 2, then the rates are normalized */
 391     sample_rate1 = s->sample_rate;
 392     if (s->version == 2)
 393     {
 394         if (sample_rate1 >= 44100)
 395             sample_rate1 = 44100;
 396         else if (sample_rate1 >= 22050)
 397             sample_rate1 = 22050;
 398         else if (sample_rate1 >= 16000)
 399             sample_rate1 = 16000;
 400         else if (sample_rate1 >= 11025)
 401             sample_rate1 = 11025;
 402         else if (sample_rate1 >= 8000)
 403             sample_rate1 = 8000;
 404     }
 405
 406     int64_t tmp = itofix64(s->bit_rate);
 407     int64_t tmp2 = itofix64(s->nb_channels * s->sample_rate);
 408     bps = fixdiv64(tmp, tmp2);
 409     int64_t tim = bps * s->frame_len;
 410     int64_t tmpi = fixdiv64(tim,itofix64(8));
 411     s->byte_offset_bits = av_log2(fixtoi64(tmpi+0x8000)) + 2;
 412
 413     /* compute high frequency value and choose if noise coding should
 414        be activated */
 415     bps1 = bps;
 416     if (s->nb_channels == 2)
 417         bps1 = fixmul32(bps,0x1999a);
 418     if (sample_rate1 == 44100)
 419     {
 420         if (bps1 >= 0x9c29)
 421             s->use_noise_coding = 0;
 422         else
 423             high_freq = fixmul32(high_freq,0x6666);
 424     }
 425     else if (sample_rate1 == 22050)
 426     {
 427         if (bps1 >= 0x128f6)
 428             s->use_noise_coding = 0;
 429         else if (bps1 >= 0xb852)
 430             high_freq = fixmul32(high_freq,0xb333);
 431         else
 432             high_freq = fixmul32(high_freq,0x999a);
 433     }
 434     else if (sample_rate1 == 16000)
 435     {
 436         if (bps > 0x8000)
 437             high_freq = fixmul32(high_freq,0x8000);
 438         else
 439             high_freq = fixmul32(high_freq,0x4ccd);
 440     }
 441     else if (sample_rate1 == 11025)
 442     {
 443         high_freq = fixmul32(high_freq,0xb333);
 444     }
 445     else if (sample_rate1 == 8000)
 446     {
 447         if (bps <= 0xa000)
 448         {
 449            high_freq = fixmul32(high_freq,0x8000);
 450         }
 451         else if (bps > 0xc000)
 452         {
 453             s->use_noise_coding = 0;
 454         }
 455         else
 456         {
 457             high_freq = fixmul32(high_freq,0xa666);
 458         }
 459     }
 460     else
 461     {
 462         if (bps >= 0xcccd)
 463         {
 464             high_freq = fixmul32(high_freq,0xc000);
 465         }
 466         else if (bps >= 0x999a)
 467         {
 468             high_freq = fixmul32(high_freq,0x999a);
 469         }
 470         else
 471         {
 472             high_freq = fixmul32(high_freq,0x8000);
 473         }
 474     }
 475
 476     /* compute the scale factor band sizes for each MDCT block size */
 477     {
 478         int a, b, pos, lpos, k, block_len, i, j, n;
 479         const uint8_t *table;
 480
 481         if (s->version == 1)
 482         {
 483             s->coefs_start = 3;
 484         }
 485         else
 486         {
 487             s->coefs_start = 0;
 488         }
 489         for(k = 0; k < s->nb_block_sizes; ++k)
 490         {
 491             block_len = s->frame_len >> k;
 492
 493             if (s->version == 1)
 494             {
 495                 lpos = 0;
 496                 for(i=0;i<25;++i)
 497                 {
 498                     a = wma_critical_freqs[i];
 499                     b = s->sample_rate;
 500                     pos = ((block_len * 2 * a)  + (b >> 1)) / b;
 501                     if (pos > block_len)
 502                         pos = block_len;
 503                     s->exponent_bands[0][i] = pos - lpos;
 504                     if (pos >= block_len)
 505                     {
 506                         ++i;
 507                         break;
 508                     }
 509                     lpos = pos;
 510                 }
 511                 s->exponent_sizes[0] = i;
 512             }
 513             else
 514             {
 515                 /* hardcoded tables */
 516                 table = NULL;
 517                 a = s->frame_len_bits - BLOCK_MIN_BITS - k;
 518                 if (a < 3)
 519                 {
 520                     if (s->sample_rate >= 44100)
 521                         table = exponent_band_44100[a];
 522                     else if (s->sample_rate >= 32000)
 523                         table = exponent_band_32000[a];
 524                     else if (s->sample_rate >= 22050)
 525                         table = exponent_band_22050[a];
 526                 }
 527                 if (table)
 528                 {
 529                     n = *table++;
 530                     for(i=0;i<n;++i)
 531                         s->exponent_bands[k][i] = table[i];
 532                     s->exponent_sizes[k] = n;
 533                 }
 534                 else
 535                 {
 536                     j = 0;
 537                     lpos = 0;
 538                     for(i=0;i<25;++i)
 539                     {
 540                         a = wma_critical_freqs[i];
 541                         b = s->sample_rate;
 542                         pos = ((block_len * 2 * a)  + (b << 1)) / (4 * b);
 543                         pos <<= 2;
 544                         if (pos > block_len)
 545                             pos = block_len;
 546                         if (pos > lpos)
 547                             s->exponent_bands[k][j++] = pos - lpos;
 548                         if (pos >= block_len)
 549                             break;
 550                         lpos = pos;
 551                     }
 552                     s->exponent_sizes[k] = j;
 553                 }
 554             }
 555
 556             /* max number of coefs */
 557             s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
 558             /* high freq computation */
 559
 560             int32_t tmp1 = high_freq*2;            /* high_freq is a int32_t!*/
 561             int32_t tmp2=itofix32(s->sample_rate>>1);
 562             s->high_band_start[k] = fixtoi32( fixdiv32(tmp1, tmp2) * (block_len>>1) +0x8000);
 563
 564             /*
 565             s->high_band_start[k] = (int)((block_len * 2 * high_freq) /
 566                                           s->sample_rate + 0.5);*/
 567
 568             n = s->exponent_sizes[k];
 569             j = 0;
 570             pos = 0;
 571             for(i=0;i<n;++i)
 572             {
 573                 int start, end;
 574                 start = pos;
 575                 pos += s->exponent_bands[k][i];
 576                 end = pos;
 577                 if (start < s->high_band_start[k])
 578                     start = s->high_band_start[k];
 579                 if (end > s->coefs_end[k])
 580                     end = s->coefs_end[k];
 581                 if (end > start)
 582                     s->exponent_high_bands[k][j++] = end - start;
 583             }
 584             s->exponent_high_sizes[k] = j;
 585         }
 586     }
 587
 588     mdct_init_global();
 589
 590     for(i = 0; i < s->nb_block_sizes; ++i)
 591     {
 592         ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1);
 593     }
 594
 595     /*ffmpeg uses malloc to only allocate as many window sizes as needed.
 596      * However, we're really only interested in the worst case memory usage.
 597      * In the worst case you can have 5 window sizes, 128 doubling up 2048
 598      * Smaller windows are handled differently.
 599      * Since we don't have malloc, just statically allocate this
 600      */
 601     int32_t *temp[5];
 602     temp[0] = stat0;
 603     temp[1] = stat1;
 604     temp[2] = stat2;
 605     temp[3] = stat3;
 606     temp[4] = stat4;
 607
 608     /* init MDCT windows : simple sinus window */
 609     for(i = 0; i < s->nb_block_sizes; i++)
 610     {
 611         int n, j;
 612         int32_t alpha;
 613         n = 1 << (s->frame_len_bits - i);
 614         window = temp[i];
 615
 616         alpha = (1<<15)>>(s->frame_len_bits - i+1);   /* this calculates 0.5/(2*n) */
 617         for(j=0;j<n;++j)
 618         {
 619             int32_t j2 = itofix32(j) + 0x8000;
 620             window[j] = fsincos(fixmul32(j2,alpha)<<16, 0); /* alpha between 0 and pi/2 */
 621
 622         }
 623         s->windows[i] = window;
 624
 625     }
 626
 627     s->reset_block_lengths = 1;
 628
 629     if (s->use_noise_coding)
 630     {
 631         /* init the noise generator */
 632         if (s->use_exp_vlc)
 633         {
 634             s->noise_mult = 0x51f;
 635             s->noise_table = noisetable_exp;
 636         }
 637         else
 638         {
 639             s->noise_mult = 0xa3d;
 640             /* LSP values are simply 2x the EXP values */
 641             for (i=0;i<NOISE_TAB_SIZE;++i)
 642                 noisetable_exp[i] = noisetable_exp[i]<< 1;
 643             s->noise_table = noisetable_exp;
 644         }
 645 #if 0
 646         {
 647             unsigned int seed;
 648             int32_t norm;
 649             seed = 1;
 650             norm = 0;   // PJJ: near as makes any diff to 0!
 651             for (i=0;i<NOISE_TAB_SIZE;++i)
 652             {
 653                 seed = seed * 314159 + 1;
 654                 s->noise_table[i] = itofix32((int)seed) * norm;
 655             }
 656         }
 657 #endif
 658
 659          s->hgain_vlc.table = vlcbuf4;
 660          s->hgain_vlc.table_allocated = VLCBUF4SIZE;
 661          init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(hgain_huffbits),
 662                   hgain_huffbits, 1, 1,
 663                   hgain_huffcodes, 2, 2, 0);
 664     }
 665
 666     if (s->use_exp_vlc)
 667     {
 668
 669         s->exp_vlc.table = vlcbuf3;
 670         s->exp_vlc.table_allocated = VLCBUF3SIZE;
 671
 672          init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(scale_huffbits),
 673                   scale_huffbits, 1, 1,
 674                   scale_huffcodes, 4, 4, 0);
 675     }
 676     else
 677     {
 678         wma_lsp_to_curve_init(s, s->frame_len);
 679     }
 680
 681     /* choose the VLC tables for the coefficients */
 682     coef_vlc_table = 2;
 683     if (s->sample_rate >= 32000)
 684     {
 685         if (bps1 < 0xb852)
 686             coef_vlc_table = 0;
 687         else if (bps1 < 0x128f6)
 688             coef_vlc_table = 1;
 689     }
 690
 691     runtabarray[0] = runtab0; runtabarray[1] = runtab1;
 692     levtabarray[0] = levtab0; levtabarray[1] = levtab1;
 693
 694     s->coef_vlc[0].table = vlcbuf1;
 695     s->coef_vlc[0].table_allocated = VLCBUF1SIZE;
 696     s->coef_vlc[1].table = vlcbuf2;
 697     s->coef_vlc[1].table_allocated = VLCBUF2SIZE;
 698
 699     init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0],
 700                   &coef_vlcs[coef_vlc_table * 2], 0);
 701     init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1],
 702                   &coef_vlcs[coef_vlc_table * 2 + 1], 1);
 703
 704     s->last_superframe_len = 0;
 705     s->last_bitoffset = 0;
 706
 707     return 0;
 708 }
 709
 710
 711 /* compute x^-0.25 with an exponent and mantissa table. We use linear
 712    interpolation to reduce the mantissa table size at a small speed
 713    expense (linear interpolation approximately doubles the number of
 714    bits of precision). */
 715 static inline int32_t pow_m1_4(WMADecodeContext *s, int32_t x)
 716 {
 717     union {
 718         float f;
 719         unsigned int v;
 720     } u, t;
 721     unsigned int e, m;
 722     int32_t a, b;
 723
 724     u.f = fixtof64(x);
 725     e = u.v >> 23;
 726     m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1);
 727     /* build interpolation scale: 1 <= t < 2. */
 728     t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23);
 729     a = s->lsp_pow_m_table1[m];
 730     b = s->lsp_pow_m_table2[m];
 731
 732     /* lsp_pow_e_table contains 32.32 format */
 733     /* TODO:  Since we're unlikely have value that cover the whole
 734      * IEEE754 range, we probably don't need to have all possible exponents */
 735
 736     return (lsp_pow_e_table[e] * (a + fixmul32(b, ftofix32(t.f))) >>32);
 737 }
 738
 739 static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len)
 740 {
 741     int32_t wdel, a, b, temp, temp2;
 742     int i, m;
 743
 744     wdel = fixdiv32(M_PI_F, itofix32(frame_len));
 745     temp = fixdiv32(itofix32(1),     itofix32(frame_len));
 746     for (i=0; i<frame_len; ++i)
 747     {
 748         /* TODO: can probably reuse the trig_init values here */
 749         fsincos((temp*i)<<15, &temp2);
 750         /* get 3 bits headroom + 1 bit from not doubleing the values */
 751         s->lsp_cos_table[i] = temp2>>3;
 752
 753     }
 754     /* NOTE: these two tables are needed to avoid two operations in
 755        pow_m1_4 */
 756     b = itofix32(1);
 757     int ix = 0;
 758
 759     /*double check this later*/
 760     for(i=(1 << LSP_POW_BITS) - 1;i>=0;i--)
 761     {
 762         m = (1 << LSP_POW_BITS) + i;
 763         a = pow_a_table[ix++]<<4;
 764         s->lsp_pow_m_table1[i] = 2 * a - b;
 765         s->lsp_pow_m_table2[i] = b - a;
 766         b = a;
 767     }
 768
 769 }
 770
 771 /* NOTE: We use the same code as Vorbis here */
 772 /* XXX: optimize it further with SSE/3Dnow */
 773 static void wma_lsp_to_curve(WMADecodeContext *s,
 774                              int32_t *out,
 775                              int32_t *val_max_ptr,
 776                              int n,
 777                              int32_t *lsp)
 778 {
 779     int i, j;
 780     int32_t p, q, w, v, val_max, temp, temp2;
 781
 782     val_max = 0;
 783     for(i=0;i<n;++i)
 784     {
 785         /* shift by 2 now to reduce rounding error,
 786          * we can renormalize right before pow_m1_4
 787          */
 788
 789         p = 0x8000<<5;
 790         q = 0x8000<<5;
 791         w = s->lsp_cos_table[i];
 792
 793         for (j=1;j<NB_LSP_COEFS;j+=2)
 794         {
 795             /* w is 5.27 format, lsp is in 16.16, temp2 becomes 5.27 format */
 796             temp2 = ((w - (lsp[j - 1]<<11)));
 797             temp = q;
 798
 799             /* q is 16.16 format, temp2 is 5.27, q becomes 16.16 */
 800             q = fixmul32b(q, temp2 )<<4;
 801             p = fixmul32b(p, (w - (lsp[j]<<11)))<<4;
 802         }
 803
 804         /* 2 in 5.27 format is 0x10000000 */
 805         p = fixmul32(p, fixmul32b(p, (0x10000000 - w)))<<3;
 806         q = fixmul32(q, fixmul32b(q, (0x10000000 + w)))<<3;
 807
 808         v = (p + q) >>9;  /* p/q end up as 16.16 */
 809         v = pow_m1_4(s, v);
 810         if (v > val_max)
 811             val_max = v;
 812         out[i] = v;
 813     }
 814
 815     *val_max_ptr = val_max;
 816 }
 817
 818 /* decode exponents coded with LSP coefficients (same idea as Vorbis) */
 819 static void decode_exp_lsp(WMADecodeContext *s, int ch)
 820 {
 821     int32_t lsp_coefs[NB_LSP_COEFS];
 822     int val, i;
 823
 824     for (i = 0; i < NB_LSP_COEFS; ++i)
 825     {
 826         if (i == 0 || i >= 8)
 827             val = get_bits(&s->gb, 3);
 828         else
 829             val = get_bits(&s->gb, 4);
 830         lsp_coefs[i] = lsp_codebook[i][val];
 831     }
 832
 833     wma_lsp_to_curve(s,
 834                      s->exponents[ch],
 835                      &s->max_exponent[ch],
 836                      s->block_len,
 837                      lsp_coefs);
 838 }
 839
 840 /* decode exponents coded with VLC codes */
 841 static int decode_exp_vlc(WMADecodeContext *s, int ch)
 842 {
 843     int last_exp, n, code;
 844     const uint16_t *ptr, *band_ptr;
 845     int32_t v, max_scale;
 846     int32_t *q,*q_end;
 847
 848     /*accommodate the 60 negative indices */
 849     const int32_t *pow_10_to_yover16_ptr = &pow_10_to_yover16[61];
 850
 851     band_ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
 852     ptr = band_ptr;
 853     q = s->exponents[ch];
 854     q_end = q + s->block_len;
 855     max_scale = 0;
 856
 857     if (s->version == 1) /* wmav1 only */
 858     {
 859         last_exp = get_bits(&s->gb, 5) + 10;
 860         /* XXX: use a table */
 861         v = pow_10_to_yover16_ptr[last_exp];
 862         max_scale = v;
 863         n = *ptr++;
 864         do
 865         {
 866             *q++ = v;
 867         }
 868         while (--n);
 869     }
 870     else
 871         last_exp = 36;
 872
 873     while (q < q_end)
 874     {
 875         code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
 876         if (code < 0)
 877         {
 878             return -1;
 879         }
 880         /* NOTE: this offset is the same as MPEG4 AAC ! */
 881         last_exp += code - 60;
 882         /* XXX: use a table */
 883         v = pow_10_to_yover16_ptr[last_exp];
 884         if (v > max_scale)
 885         {
 886             max_scale = v;
 887         }
 888         n = *ptr++;
 889         do
 890         {
 891             *q++ = v;
 892
 893         }
 894         while (--n);
 895     }
 896
 897     s->max_exponent[ch] = max_scale;
 898     return 0;
 899 }
 900
 901 /* return 0 if OK. return 1 if last block of frame. return -1 if
 902    unrecorrable error. */
 903 static int wma_decode_block(WMADecodeContext *s)
 904 {
 905     int n, v, a, ch, code, bsize;
 906     int coef_nb_bits, total_gain;
 907     int nb_coefs[MAX_CHANNELS];
 908     int32_t mdct_norm;
 909
 910     /* compute current block length */
 911     if (s->use_variable_block_len)
 912     {
 913         n = av_log2(s->nb_block_sizes - 1) + 1;
 914
 915         if (s->reset_block_lengths)
 916         {
 917             s->reset_block_lengths = 0;
 918             v = get_bits(&s->gb, n);
 919             if (v >= s->nb_block_sizes)
 920             {
 921                 return -2;
 922             }
 923             s->prev_block_len_bits = s->frame_len_bits - v;
 924             v = get_bits(&s->gb, n);
 925             if (v >= s->nb_block_sizes)
 926             {
 927                 return -3;
 928             }
 929             s->block_len_bits = s->frame_len_bits - v;
 930         }
 931         else
 932         {
 933             /* update block lengths */
 934             s->prev_block_len_bits = s->block_len_bits;
 935             s->block_len_bits = s->next_block_len_bits;
 936         }
 937         v = get_bits(&s->gb, n);
 938
 939         if (v >= s->nb_block_sizes)
 940             return -4;
 941
 942         s->next_block_len_bits = s->frame_len_bits - v;
 943     }
 944     else
 945     {
 946         /* fixed block len */
 947         s->next_block_len_bits = s->frame_len_bits;
 948         s->prev_block_len_bits = s->frame_len_bits;
 949         s->block_len_bits = s->frame_len_bits;
 950     }
 951     /* now check if the block length is coherent with the frame length */
 952     s->block_len = 1 << s->block_len_bits;
 953
 954     if ((s->block_pos + s->block_len) > s->frame_len)
 955     {
 956         return -5; /* oddly 32k sample from tracker fails here */
 957     }
 958
 959     if (s->nb_channels == 2)
 960     {
 961         s->ms_stereo = get_bits(&s->gb, 1);
 962     }
 963     v = 0;
 964     for (ch = 0; ch < s->nb_channels; ++ch)
 965     {
 966         a = get_bits(&s->gb, 1);
 967         s->channel_coded[ch] = a;
 968         v |= a;
 969     }
 970     /* if no channel coded, no need to go further */
 971     /* XXX: fix potential framing problems */
 972     if (!v)
 973     {
 974         goto next;
 975     }
 976
 977     bsize = s->frame_len_bits - s->block_len_bits;
 978
 979     /* read total gain and extract corresponding number of bits for
 980        coef escape coding */
 981     total_gain = 1;
 982     for(;;)
 983     {
 984         a = get_bits(&s->gb, 7);
 985         total_gain += a;
 986         if (a != 127)
 987         {
 988             break;
 989         }
 990     }
 991
 992     if (total_gain < 15)
 993         coef_nb_bits = 13;
 994     else if (total_gain < 32)
 995         coef_nb_bits = 12;
 996     else if (total_gain < 40)
 997         coef_nb_bits = 11;
 998     else if (total_gain < 45)
 999         coef_nb_bits = 10;
1000     else
1001         coef_nb_bits = 9;
1002
1003     /* compute number of coefficients */
1004     n = s->coefs_end[bsize] - s->coefs_start;
1005
1006     for(ch = 0; ch < s->nb_channels; ++ch)
1007     {
1008         nb_coefs[ch] = n;
1009     }
1010     /* complex coding */
1011     if (s->use_noise_coding)
1012     {
1013
1014         for(ch = 0; ch < s->nb_channels; ++ch)
1015         {
1016             if (s->channel_coded[ch])
1017             {
1018                 int i, n, a;
1019                 n = s->exponent_high_sizes[bsize];
1020                 for(i=0;i<n;++i)
1021                 {
1022                     a = get_bits(&s->gb, 1);
1023                     s->high_band_coded[ch][i] = a;
1024                     /* if noise coding, the coefficients are not transmitted */
1025                     if (a)
1026                         nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
1027                 }
1028             }
1029         }
1030         for(ch = 0; ch < s->nb_channels; ++ch)
1031         {
1032             if (s->channel_coded[ch])
1033             {
1034                 int i, n, val, code;
1035
1036                 n = s->exponent_high_sizes[bsize];
1037                 val = (int)0x80000000;
1038                 for(i=0;i<n;++i)
1039                 {
1040                     if (s->high_band_coded[ch][i])
1041                     {
1042                         if (val == (int)0x80000000)
1043                         {
1044                             val = get_bits(&s->gb, 7) - 19;
1045                         }
1046                         else
1047                         {
1048                             //code = get_vlc(&s->gb, &s->hgain_vlc);
1049                             code = get_vlc2(&s->gb, s->hgain_vlc.table, HGAINVLCBITS, HGAINMAX);
1050                             if (code < 0)
1051                             {
1052                                 return -6;
1053                             }
1054                             val += code - 18;
1055                         }
1056                         s->high_band_values[ch][i] = val;
1057                     }
1058                 }
1059             }
1060         }
1061     }
1062
1063     /* exponents can be reused in short blocks. */
1064     if ((s->block_len_bits == s->frame_len_bits) || get_bits(&s->gb, 1))
1065     {
1066         for(ch = 0; ch < s->nb_channels; ++ch)
1067         {
1068             if (s->channel_coded[ch])
1069             {
1070                 if (s->use_exp_vlc)
1071                 {
1072                     if (decode_exp_vlc(s, ch) < 0)
1073                     {
1074                         return -7;
1075                     }
1076                 }
1077                 else
1078                 {
1079                     decode_exp_lsp(s, ch);
1080                 }
1081                 s->exponents_bsize[ch] = bsize;
1082             }
1083         }
1084     }
1085
1086     /* parse spectral coefficients : just RLE encoding */
1087     for(ch = 0; ch < s->nb_channels; ++ch)
1088     {
1089         if (s->channel_coded[ch])
1090         {
1091             VLC *coef_vlc;
1092             int level, run, sign, tindex;
1093             int16_t *ptr, *eptr;
1094             const uint16_t *level_table, *run_table;
1095
1096             /* special VLC tables are used for ms stereo because
1097                there is potentially less energy there */
1098             tindex = (ch == 1 && s->ms_stereo);
1099             coef_vlc = &s->coef_vlc[tindex];
1100             run_table = s->run_table[tindex];
1101             level_table = s->level_table[tindex];
1102             /* XXX: optimize */
1103             ptr = &s->coefs1[ch][0];
1104             eptr = ptr + nb_coefs[ch];
1105             memset(ptr, 0, s->block_len * sizeof(int16_t));
1106
1107             for(;;)
1108             {
1109                 code = get_vlc2(&s->gb, coef_vlc->table, VLCBITS, VLCMAX);
1110                 //code = get_vlc(&s->gb, coef_vlc);
1111                 if (code < 0)
1112                 {
1113                     return -8;
1114                 }
1115                 if (code == 1)
1116                 {
1117                     /* EOB */
1118                     break;
1119                 }
1120                 else if (code == 0)
1121                 {
1122                     /* escape */
1123                     level = get_bits(&s->gb, coef_nb_bits);
1124                     /* NOTE: this is rather suboptimal. reading
1125                        block_len_bits would be better */
1126                     run = get_bits(&s->gb, s->frame_len_bits);
1127                 }
1128                 else
1129                 {
1130                     /* normal code */
1131                     run = run_table[code];
1132                     level = level_table[code];
1133                 }
1134                 sign = get_bits(&s->gb, 1);
1135                 if (!sign)
1136                     level = -level;
1137                 ptr += run;
1138                 if (ptr >= eptr)
1139                 {
1140                     break;
1141                 }
1142                 *ptr++ = level;
1143
1144
1145                 /* NOTE: EOB can be omitted */
1146                 if (ptr >= eptr)
1147                     break;
1148             }
1149         }
1150         if (s->version == 1 && s->nb_channels >= 2)
1151         {
1152             align_get_bits(&s->gb);
1153         }
1154     }
1155
1156     {
1157         int n4 = s->block_len >> 1;
1158
1159         /* theres no reason to do a divide by two in fixed precision ... */
1160         mdct_norm = 0x10000>>(s->block_len_bits-1);
1161
1162         if (s->version == 1)
1163         {
1164             mdct_norm *= fixtoi32(fixsqrt32(itofix32(n4))); /* PJJ : exercise this path */
1165         }
1166     }
1167
1168     /* finally compute the MDCT coefficients */
1169     for(ch = 0; ch < s->nb_channels; ++ch)
1170     {
1171         if (s->channel_coded[ch])
1172         {
1173             int16_t *coefs1;
1174             int32_t *exponents, *exp_ptr;
1175             int32_t *coefs, atemp;
1176             int64_t mult;
1177             int64_t mult1;
1178             int32_t noise, temp1, temp2, mult2;
1179             int i, j, n, n1, last_high_band, esize;
1180             int32_t exp_power[HIGH_BAND_MAX_SIZE];
1181
1182             coefs1 = s->coefs1[ch];
1183             exponents = s->exponents[ch];
1184             esize = s->exponents_bsize[ch];
1185             coefs = (*(s->coefs))[ch];
1186
1187             n=0;
1188
1189             /*
1190              *  Previously the IMDCT was run in 17.15 precision to avoid overflow. However rare files could
1191              *  overflow here as well, so switch to 17.15 during coefs calculation.
1192              */
1193
1194
1195             if (s->use_noise_coding)
1196             {
1197                 /*TODO:  mult should be converted to 32 bit to speed up noise coding*/
1198
1199                 mult = fixdiv64(pow_table[total_gain+20],Fixed32To64(s->max_exponent[ch]));
1200                 mult = mult* mdct_norm; //what the hell?  This is actually int64_t*2^16!
1201                 mult1 = mult;
1202
1203                 /* very low freqs : noise */
1204                 for(i = 0;i < s->coefs_start; ++i)
1205                 {
1206                     *coefs++ = fixmul32((fixmul32(s->noise_table[s->noise_index],
1207                                         (*exponents++))>>4),Fixed32From64(mult1)) >>1;
1208                     s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
1209                 }
1210
1211                 n1 = s->exponent_high_sizes[bsize];
1212
1213                 /* compute power of high bands */
1214                 exp_ptr = exponents +
1215                           s->high_band_start[bsize] -
1216                           s->coefs_start;
1217                 last_high_band = 0; /* avoid warning */
1218                 for (j=0;j<n1;++j)
1219                 {
1220                     n = s->exponent_high_bands[s->frame_len_bits -
1221                                                s->block_len_bits][j];
1222                     if (s->high_band_coded[ch][j])
1223                     {
1224                         int32_t e2, v;
1225                         e2 = 0;
1226                         for(i = 0;i < n; ++i)
1227                         {
1228                             /*v is noramlized later on so its fixed format is irrelevant*/
1229                             v = exp_ptr[i]>>4;
1230                             e2 += fixmul32(v, v)>>3;
1231                         }
1232                          exp_power[j] = e2/n; /*n is an int...*/
1233                         last_high_band = j;
1234                     }
1235                     exp_ptr += n;
1236                 }
1237
1238                 /* main freqs and high freqs */
1239                 for(j=-1;j<n1;++j)
1240                 {
1241                     if (j < 0)
1242                     {
1243                         n = s->high_band_start[bsize] -
1244                             s->coefs_start;
1245                     }
1246                     else
1247                     {
1248                         n = s->exponent_high_bands[s->frame_len_bits -
1249                                                    s->block_len_bits][j];
1250                     }
1251                     if (j >= 0 && s->high_band_coded[ch][j])
1252                     {
1253                         /* use noise with specified power */
1254                         int32_t tmp = fixdiv32(exp_power[j],exp_power[last_high_band]);
1255                         mult1 = (int64_t)fixsqrt32(tmp);
1256                         /* XXX: use a table */
1257                         /*mult1 is 48.16, pow_table is 48.16*/
1258                         mult1 = mult1 * pow_table[s->high_band_values[ch][j]+20] >> PRECISION;
1259
1260                         /*this step has a fairly high degree of error for some reason*/
1261                         mult1 = fixdiv64(mult1,fixmul32(s->max_exponent[ch],s->noise_mult));
1262
1263                         mult1 = mult1*mdct_norm>>PRECISION;
1264                         for(i = 0;i < n; ++i)
1265                         {
1266                             noise = s->noise_table[s->noise_index];
1267                             s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
1268                             *coefs++ = fixmul32((fixmul32(*exponents,noise)>>4),Fixed32From64(mult1)) >>1;
1269                             ++exponents;
1270                         }
1271                     }
1272                     else
1273                     {
1274                         /* coded values + small noise */
1275                         for(i = 0;i < n; ++i)
1276                         {
1277                             // PJJ: check code path
1278                             noise = s->noise_table[s->noise_index];
1279                             s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
1280
1281                            /*don't forget to renormalize the noise*/
1282                            temp1 = (((int32_t)*coefs1++)<<16) + (noise>>4);
1283                            temp2 = fixmul32(*exponents, mult>>17);
1284                            *coefs++ = fixmul32(temp1, temp2);
1285                            ++exponents;
1286                         }
1287                     }
1288                 }
1289
1290                 /* very high freqs : noise */
1291                 n = s->block_len - s->coefs_end[bsize];
1292                 mult2 = fixmul32(mult>>16,exponents[-1]) ;  /*the work around for 32.32 vars are getting stupid*/
1293                 for (i = 0; i < n; ++i)
1294                 {
1295                     /*renormalize the noise product and then reduce to 17.15 precison*/
1296                     *coefs++ = fixmul32(s->noise_table[s->noise_index],mult2) >>5;
1297
1298                     s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
1299                 }
1300             }
1301             else
1302             {
1303                 /*Noise coding not used, simply convert from exp to fixed representation*/
1304                 int32_t mult3 = (int32_t)(fixdiv64(pow_table[total_gain+20],Fixed32To64(s->max_exponent[ch])));
1305                 mult3 = fixmul32(mult3, mdct_norm);
1306
1307                 n = nb_coefs[ch];
1308
1309                 /* XXX: optimize more, unrolling this loop in asm might be a good idea */
1310                 for(i = 0;i < s->coefs_start; i++)
1311                     *coefs++ = 0;
1312                 for(i = 0;i < n; ++i)
1313                 {
1314                     atemp = (coefs1[i] * mult3)>>1;
1315                     *coefs++=fixmul32(atemp,exponents[i<<bsize>>esize]);
1316                 }
1317                 n = s->block_len - s->coefs_end[bsize];
1318                 memset(coefs, 0, n*sizeof(int32_t));
1319             }
1320         }
1321     }
1322
1323     if (s->ms_stereo && s->channel_coded[1])
1324     {
1325         int32_t a, b;
1326         int i;
1327         int32_t (*coefs)[MAX_CHANNELS][BLOCK_MAX_SIZE]  = (s->coefs);
1328
1329         /* nominal case for ms stereo: we do it before mdct */
1330         /* no need to optimize this case because it should almost
1331            never happen */
1332         if (!s->channel_coded[0])
1333         {
1334             memset((*(s->coefs))[0], 0, sizeof(int32_t) * s->block_len);
1335             s->channel_coded[0] = 1;
1336         }
1337
1338         for(i = 0; i < s->block_len; ++i)
1339         {
1340             a = (*coefs)[0][i];
1341             b = (*coefs)[1][i];
1342             (*coefs)[0][i] = a + b;
1343             (*coefs)[1][i] = a - b;
1344         }
1345     }
1346
1347     for(ch = 0; ch < s->nb_channels; ++ch)
1348     {
1349         if (s->channel_coded[ch])
1350         {
1351             static int32_t  output[BLOCK_MAX_SIZE * 2] IBSS_ATTR;
1352
1353             int n4, index, n;
1354
1355             n = s->block_len;
1356             n4 = s->block_len >>1;
1357
1358             ff_imdct_calc(&s->mdct_ctx[bsize],
1359                           output,
1360                           (*(s->coefs))[ch]);
1361
1362             /* add in the frame */
1363             index = (s->frame_len / 2) + s->block_pos - n4;
1364
1365             wma_window(s, output, &s->frame_out[ch][index]);
1366
1367             /* specific fast case for ms-stereo : add to second
1368                channel if it is not coded */
1369             if (s->ms_stereo && !s->channel_coded[1])
1370             {
1371                 wma_window(s, output, &s->frame_out[1][index]);
1372             }
1373         }
1374     }
1375
1376 next:
1377     /* update block number */
1378     ++s->block_num;
1379     s->block_pos += s->block_len;
1380     if (s->block_pos >= s->frame_len)
1381     {
1382         return 1;
1383     }
1384     else
1385     {
1386         return 0;
1387     }
1388 }
1389
1390 /* decode a frame of frame_len samples */
1391 static int wma_decode_frame(WMADecodeContext *s, int32_t *samples)
1392 {
1393     int ret, i, n, ch, incr;
1394     int32_t *ptr;
1395     int32_t *iptr;
1396
1397     /* read each block */
1398     s->block_num = 0;
1399     s->block_pos = 0;
1400
1401     for(;;)
1402     {
1403         ret = wma_decode_block(s);
1404         if (ret < 0)
1405         {
1406 #ifdef WMA_DEBUG
1407             printf("wma_decode_block failed with code %d\n", ret);
1408 #endif
1409             return -1;
1410         }
1411         if (ret)
1412         {
1413             break;
1414         }
1415     }
1416
1417     /* return frame with full 30-bit precision */
1418     n = s->frame_len;
1419     incr = s->nb_channels;
1420     for(ch = 0; ch < s->nb_channels; ++ch)
1421     {
1422         ptr = samples + ch;
1423         iptr = s->frame_out[ch];
1424
1425         for (i=0;i<n;++i)
1426         {
1427             *ptr = (*iptr++);
1428             ptr += incr;
1429         }
1430         /* prepare for next block */
1431         memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
1432                 s->frame_len * sizeof(int32_t));
1433
1434     }
1435
1436     return 0;
1437 }
1438
1439 /* Initialise the superframe decoding */
1440
1441 int wma_decode_superframe_init(WMADecodeContext* s,
1442                                  uint8_t *buf,  /*input*/
1443                                  int buf_size)
1444 {
1445     if (buf_size==0)
1446     {
1447         s->last_superframe_len = 0;
1448         return 0;
1449     }
1450
1451     s->current_frame = 0;
1452
1453     init_get_bits(&s->gb, buf, buf_size*8);
1454
1455     if (s->use_bit_reservoir)
1456     {
1457         /* read super frame header */
1458         get_bits(&s->gb, 4); /* super frame index */
1459         s->nb_frames = get_bits(&s->gb, 4);
1460
1461         if (s->last_superframe_len == 0)
1462             s->nb_frames --;
1463         else if (s->nb_frames == 0)
1464             s->nb_frames++;
1465
1466         s->bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
1467     } else {
1468         s->nb_frames = 1;
1469     }
1470
1471     return 1;
1472 }
1473
1474
1475 /* Decode a single frame in the current superframe - return -1 if
1476    there was a decoding error, or the number of samples decoded.
1477 */
1478
1479 int wma_decode_superframe_frame(WMADecodeContext* s,
1480                                 int32_t* samples, /*output*/
1481                                 uint8_t *buf,  /*input*/
1482                                 int buf_size)
1483 {
1484     int pos, len;
1485     uint8_t *q;
1486     int done = 0;
1487     if ((s->use_bit_reservoir) && (s->current_frame == 0))
1488     {
1489         if (s->last_superframe_len > 0)
1490         {
1491             /* add s->bit_offset bits to last frame */
1492             if ((s->last_superframe_len + ((s->bit_offset + 7) >> 3)) >
1493                     MAX_CODED_SUPERFRAME_SIZE)
1494             {
1495 #ifdef WMA_DEBUG
1496                 printf("superframe size too large error\n");
1497 #endif
1498                 goto fail;
1499             }
1500             q = s->last_superframe + s->last_superframe_len;
1501             len = s->bit_offset;
1502             while (len > 0)
1503             {
1504                 *q++ = (get_bits)(&s->gb, 8);
1505                 len -= 8;
1506             }
1507             if (len > 0)
1508             {
1509                 *q++ = (get_bits)(&s->gb, len) << (8 - len);
1510             }
1511
1512             /* XXX: s->bit_offset bits into last frame */
1513             init_get_bits(&s->gb, s->last_superframe, MAX_CODED_SUPERFRAME_SIZE*8);
1514             /* skip unused bits */
1515             if (s->last_bitoffset > 0)
1516                 skip_bits(&s->gb, s->last_bitoffset);
1517
1518             /* this frame is stored in the last superframe and in the
1519                current one */
1520             if (wma_decode_frame(s, samples) < 0)
1521             {
1522                 goto fail;
1523             }
1524             done = 1;
1525         }
1526
1527         /* read each frame starting from s->bit_offset */
1528         pos = s->bit_offset + 4 + 4 + s->byte_offset_bits + 3;
1529         init_get_bits(&s->gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE - (pos >> 3))*8);
1530         len = pos & 7;
1531         if (len > 0)
1532             skip_bits(&s->gb, len);
1533
1534         s->reset_block_lengths = 1;
1535     }
1536
1537     /* If we haven't decoded a frame yet, do it now */
1538     if (!done)
1539         {
1540             if (wma_decode_frame(s, samples) < 0)
1541             {
1542                 goto fail;
1543             }
1544         }
1545
1546     s->current_frame++;
1547
1548     if ((s->use_bit_reservoir) && (s->current_frame == s->nb_frames))
1549     {
1550         /* we copy the end of the frame in the last frame buffer */
1551         pos = get_bits_count(&s->gb) + ((s->bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
1552         s->last_bitoffset = pos & 7;
1553         pos >>= 3;
1554         len = buf_size - pos;
1555         if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0)
1556         {
1557 #ifdef WMA_DEBUG
1558             printf("superframe size too large error after decodeing\n");
1559 #endif
1560             goto fail;
1561         }
1562         s->last_superframe_len = len;
1563         memcpy(s->last_superframe, buf + pos, len);
1564     }
1565
1566     return s->frame_len;
1567
1568 fail:
1569     /* when error, we reset the bit reservoir */
1570
1571     s->last_superframe_len = 0;
1572     return -1;
1573 }
1574