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