git.sesse.net Git - ffmpeg/blob - libavcodec/wmadec.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 /**
  21  * @file wmadec.c
  22  * WMA compatible decoder.
  23  * This decoder handles Microsoft Windows Media Audio data, versions 1 & 2.
  24  * WMA v1 is identified by audio format 0x160 in Microsoft media files
  25  * (ASF/AVI/WAV). WMA v2 is identified by audio format 0x161.
  26  *
  27  * To use this decoder, a calling application must supply the extra data
  28  * bytes provided with the WMA data. These are the extra, codec-specific
  29  * bytes at the end of a WAVEFORMATEX data structure. Transmit these bytes
  30  * to the decoder using the extradata[_size] fields in AVCodecContext. There
  31  * should be 4 extra bytes for v1 data and 6 extra bytes for v2 data.
  32  */
  33
  34 #include "avcodec.h"
  35 #include "bitstream.h"
  36 #include "dsputil.h"
  37
  38 /* size of blocks */
  39 #define BLOCK_MIN_BITS 7
  40 #define BLOCK_MAX_BITS 11
  41 #define BLOCK_MAX_SIZE (1 << BLOCK_MAX_BITS)
  42
  43 #define BLOCK_NB_SIZES (BLOCK_MAX_BITS - BLOCK_MIN_BITS + 1)
  44
  45 /* XXX: find exact max size */
  46 #define HIGH_BAND_MAX_SIZE 16
  47
  48 #define NB_LSP_COEFS 10
  49
  50 /* XXX: is it a suitable value ? */
  51 #define MAX_CODED_SUPERFRAME_SIZE 16384
  52
  53 #define MAX_CHANNELS 2
  54
  55 #define NOISE_TAB_SIZE 8192
  56
  57 #define LSP_POW_BITS 7
  58
  59 #define VLCBITS 9
  60 #define VLCMAX ((22+VLCBITS-1)/VLCBITS)
  61
  62 #define EXPVLCBITS 8
  63 #define EXPMAX ((19+EXPVLCBITS-1)/EXPVLCBITS)
  64
  65 #define HGAINVLCBITS 9
  66 #define HGAINMAX ((13+HGAINVLCBITS-1)/HGAINVLCBITS)
  67
  68 typedef struct WMADecodeContext {
  69     GetBitContext gb;
  70     int sample_rate;
  71     int nb_channels;
  72     int bit_rate;
  73     int version; /* 1 = 0x160 (WMAV1), 2 = 0x161 (WMAV2) */
  74     int block_align;
  75     int use_bit_reservoir;
  76     int use_variable_block_len;
  77     int use_exp_vlc;  /* exponent coding: 0 = lsp, 1 = vlc + delta */
  78     int use_noise_coding; /* true if perceptual noise is added */
  79     int byte_offset_bits;
  80     VLC exp_vlc;
  81     int exponent_sizes[BLOCK_NB_SIZES];
  82     uint16_t exponent_bands[BLOCK_NB_SIZES][25];
  83     int high_band_start[BLOCK_NB_SIZES]; /* index of first coef in high band */
  84     int coefs_start;               /* first coded coef */
  85     int coefs_end[BLOCK_NB_SIZES]; /* max number of coded coefficients */
  86     int exponent_high_sizes[BLOCK_NB_SIZES];
  87     int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE];
  88     VLC hgain_vlc;
  89
  90     /* coded values in high bands */
  91     int high_band_coded[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];
  92     int high_band_values[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];
  93
  94     /* there are two possible tables for spectral coefficients */
  95     VLC coef_vlc[2];
  96     uint16_t *run_table[2];
  97     uint16_t *level_table[2];
  98     /* frame info */
  99     int frame_len;       /* frame length in samples */
 100     int frame_len_bits;  /* frame_len = 1 << frame_len_bits */
 101     int nb_block_sizes;  /* number of block sizes */
 102     /* block info */
 103     int reset_block_lengths;
 104     int block_len_bits; /* log2 of current block length */
 105     int next_block_len_bits; /* log2 of next block length */
 106     int prev_block_len_bits; /* log2 of prev block length */
 107     int block_len; /* block length in samples */
 108     int block_num; /* block number in current frame */
 109     int block_pos; /* current position in frame */
 110     uint8_t ms_stereo; /* true if mid/side stereo mode */
 111     uint8_t channel_coded[MAX_CHANNELS]; /* true if channel is coded */
 112     DECLARE_ALIGNED_16(float, exponents[MAX_CHANNELS][BLOCK_MAX_SIZE]);
 113     float max_exponent[MAX_CHANNELS];
 114     int16_t coefs1[MAX_CHANNELS][BLOCK_MAX_SIZE];
 115     DECLARE_ALIGNED_16(float, coefs[MAX_CHANNELS][BLOCK_MAX_SIZE]);
 116     MDCTContext mdct_ctx[BLOCK_NB_SIZES];
 117     float *windows[BLOCK_NB_SIZES];
 118     DECLARE_ALIGNED_16(FFTSample, mdct_tmp[BLOCK_MAX_SIZE]); /* temporary storage for imdct */
 119     /* output buffer for one frame and the last for IMDCT windowing */
 120     DECLARE_ALIGNED_16(float, frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2]);
 121     /* last frame info */
 122     uint8_t last_superframe[MAX_CODED_SUPERFRAME_SIZE + 4]; /* padding added */
 123     int last_bitoffset;
 124     int last_superframe_len;
 125     float noise_table[NOISE_TAB_SIZE];
 126     int noise_index;
 127     float noise_mult; /* XXX: suppress that and integrate it in the noise array */
 128     /* lsp_to_curve tables */
 129     float lsp_cos_table[BLOCK_MAX_SIZE];
 130     float lsp_pow_e_table[256];
 131     float lsp_pow_m_table1[(1 << LSP_POW_BITS)];
 132     float lsp_pow_m_table2[(1 << LSP_POW_BITS)];
 133
 134 #ifdef TRACE
 135     int frame_count;
 136 #endif
 137 } WMADecodeContext;
 138
 139 typedef struct CoefVLCTable {
 140     int n; /* total number of codes */
 141     const uint32_t *huffcodes; /* VLC bit values */
 142     const uint8_t *huffbits;   /* VLC bit size */
 143     const uint16_t *levels; /* table to build run/level tables */
 144 } CoefVLCTable;
 145
 146 static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len);
 147
 148 #include "wmadata.h"
 149
 150 #ifdef TRACE
 151 static void dump_shorts(const char *name, const short *tab, int n)
 152 {
 153     int i;
 154
 155     tprintf("%s[%d]:\n", name, n);
 156     for(i=0;i<n;i++) {
 157         if ((i & 7) == 0)
 158             tprintf("%4d: ", i);
 159         tprintf(" %5d.0", tab[i]);
 160         if ((i & 7) == 7)
 161             tprintf("\n");
 162     }
 163 }
 164
 165 static void dump_floats(const char *name, int prec, const float *tab, int n)
 166 {
 167     int i;
 168
 169     tprintf("%s[%d]:\n", name, n);
 170     for(i=0;i<n;i++) {
 171         if ((i & 7) == 0)
 172             tprintf("%4d: ", i);
 173         tprintf(" %8.*f", prec, tab[i]);
 174         if ((i & 7) == 7)
 175             tprintf("\n");
 176     }
 177     if ((i & 7) != 0)
 178         tprintf("\n");
 179 }
 180 #endif
 181
 182 /* XXX: use same run/length optimization as mpeg decoders */
 183 static void init_coef_vlc(VLC *vlc,
 184                           uint16_t **prun_table, uint16_t **plevel_table,
 185                           const CoefVLCTable *vlc_table)
 186 {
 187     int n = vlc_table->n;
 188     const uint8_t *table_bits = vlc_table->huffbits;
 189     const uint32_t *table_codes = vlc_table->huffcodes;
 190     const uint16_t *levels_table = vlc_table->levels;
 191     uint16_t *run_table, *level_table;
 192     const uint16_t *p;
 193     int i, l, j, level;
 194
 195     init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
 196
 197     run_table = av_malloc(n * sizeof(uint16_t));
 198     level_table = av_malloc(n * sizeof(uint16_t));
 199     p = levels_table;
 200     i = 2;
 201     level = 1;
 202     while (i < n) {
 203         l = *p++;
 204         for(j=0;j<l;j++) {
 205             run_table[i] = j;
 206             level_table[i] = level;
 207             i++;
 208         }
 209         level++;
 210     }
 211     *prun_table = run_table;
 212     *plevel_table = level_table;
 213 }
 214
 215 static int wma_decode_init(AVCodecContext * avctx)
 216 {
 217     WMADecodeContext *s = avctx->priv_data;
 218     int i, flags1, flags2;
 219     float *window;
 220     uint8_t *extradata;
 221     float bps1, high_freq;
 222     volatile float bps;
 223     int sample_rate1;
 224     int coef_vlc_table;
 225
 226     s->sample_rate = avctx->sample_rate;
 227     s->nb_channels = avctx->channels;
 228     s->bit_rate = avctx->bit_rate;
 229     s->block_align = avctx->block_align;
 230
 231     if (avctx->codec->id == CODEC_ID_WMAV1) {
 232         s->version = 1;
 233     } else {
 234         s->version = 2;
 235     }
 236
 237     /* extract flag infos */
 238     flags1 = 0;
 239     flags2 = 0;
 240     extradata = avctx->extradata;
 241     if (s->version == 1 && avctx->extradata_size >= 4) {
 242         flags1 = extradata[0] | (extradata[1] << 8);
 243         flags2 = extradata[2] | (extradata[3] << 8);
 244     } else if (s->version == 2 && avctx->extradata_size >= 6) {
 245         flags1 = extradata[0] | (extradata[1] << 8) |
 246             (extradata[2] << 16) | (extradata[3] << 24);
 247         flags2 = extradata[4] | (extradata[5] << 8);
 248     }
 249     s->use_exp_vlc = flags2 & 0x0001;
 250     s->use_bit_reservoir = flags2 & 0x0002;
 251     s->use_variable_block_len = flags2 & 0x0004;
 252
 253     /* compute MDCT block size */
 254     if (s->sample_rate <= 16000) {
 255         s->frame_len_bits = 9;
 256     } else if (s->sample_rate <= 22050 ||
 257                (s->sample_rate <= 32000 && s->version == 1)) {
 258         s->frame_len_bits = 10;
 259     } else {
 260         s->frame_len_bits = 11;
 261     }
 262     s->frame_len = 1 << s->frame_len_bits;
 263     if (s->use_variable_block_len) {
 264         int nb_max, nb;
 265         nb = ((flags2 >> 3) & 3) + 1;
 266         if ((s->bit_rate / s->nb_channels) >= 32000)
 267             nb += 2;
 268         nb_max = s->frame_len_bits - BLOCK_MIN_BITS;
 269         if (nb > nb_max)
 270             nb = nb_max;
 271         s->nb_block_sizes = nb + 1;
 272     } else {
 273         s->nb_block_sizes = 1;
 274     }
 275
 276     /* init rate dependant parameters */
 277     s->use_noise_coding = 1;
 278     high_freq = s->sample_rate * 0.5;
 279
 280     /* if version 2, then the rates are normalized */
 281     sample_rate1 = s->sample_rate;
 282     if (s->version == 2) {
 283         if (sample_rate1 >= 44100)
 284             sample_rate1 = 44100;
 285         else if (sample_rate1 >= 22050)
 286             sample_rate1 = 22050;
 287         else if (sample_rate1 >= 16000)
 288             sample_rate1 = 16000;
 289         else if (sample_rate1 >= 11025)
 290             sample_rate1 = 11025;
 291         else if (sample_rate1 >= 8000)
 292             sample_rate1 = 8000;
 293     }
 294
 295     bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate);
 296     s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2;
 297
 298     /* compute high frequency value and choose if noise coding should
 299        be activated */
 300     bps1 = bps;
 301     if (s->nb_channels == 2)
 302         bps1 = bps * 1.6;
 303     if (sample_rate1 == 44100) {
 304         if (bps1 >= 0.61)
 305             s->use_noise_coding = 0;
 306         else
 307             high_freq = high_freq * 0.4;
 308     } else if (sample_rate1 == 22050) {
 309         if (bps1 >= 1.16)
 310             s->use_noise_coding = 0;
 311         else if (bps1 >= 0.72)
 312             high_freq = high_freq * 0.7;
 313         else
 314             high_freq = high_freq * 0.6;
 315     } else if (sample_rate1 == 16000) {
 316         if (bps > 0.5)
 317             high_freq = high_freq * 0.5;
 318         else
 319             high_freq = high_freq * 0.3;
 320     } else if (sample_rate1 == 11025) {
 321         high_freq = high_freq * 0.7;
 322     } else if (sample_rate1 == 8000) {
 323         if (bps <= 0.625) {
 324             high_freq = high_freq * 0.5;
 325         } else if (bps > 0.75) {
 326             s->use_noise_coding = 0;
 327         } else {
 328             high_freq = high_freq * 0.65;
 329         }
 330     } else {
 331         if (bps >= 0.8) {
 332             high_freq = high_freq * 0.75;
 333         } else if (bps >= 0.6) {
 334             high_freq = high_freq * 0.6;
 335         } else {
 336             high_freq = high_freq * 0.5;
 337         }
 338     }
 339     dprintf("flags1=0x%x flags2=0x%x\n", flags1, flags2);
 340     dprintf("version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
 341            s->version, s->nb_channels, s->sample_rate, s->bit_rate,
 342            s->block_align);
 343     dprintf("bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
 344            bps, bps1, high_freq, s->byte_offset_bits);
 345     dprintf("use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
 346            s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);
 347
 348     /* compute the scale factor band sizes for each MDCT block size */
 349     {
 350         int a, b, pos, lpos, k, block_len, i, j, n;
 351         const uint8_t *table;
 352
 353         if (s->version == 1) {
 354             s->coefs_start = 3;
 355         } else {
 356             s->coefs_start = 0;
 357         }
 358         for(k = 0; k < s->nb_block_sizes; k++) {
 359             block_len = s->frame_len >> k;
 360
 361             if (s->version == 1) {
 362                 lpos = 0;
 363                 for(i=0;i<25;i++) {
 364                     a = wma_critical_freqs[i];
 365                     b = s->sample_rate;
 366                     pos = ((block_len * 2 * a)  + (b >> 1)) / b;
 367                     if (pos > block_len)
 368                         pos = block_len;
 369                     s->exponent_bands[0][i] = pos - lpos;
 370                     if (pos >= block_len) {
 371                         i++;
 372                         break;
 373                     }
 374                     lpos = pos;
 375                 }
 376                 s->exponent_sizes[0] = i;
 377             } else {
 378                 /* hardcoded tables */
 379                 table = NULL;
 380                 a = s->frame_len_bits - BLOCK_MIN_BITS - k;
 381                 if (a < 3) {
 382                     if (s->sample_rate >= 44100)
 383                         table = exponent_band_44100[a];
 384                     else if (s->sample_rate >= 32000)
 385                         table = exponent_band_32000[a];
 386                     else if (s->sample_rate >= 22050)
 387                         table = exponent_band_22050[a];
 388                 }
 389                 if (table) {
 390                     n = *table++;
 391                     for(i=0;i<n;i++)
 392                         s->exponent_bands[k][i] = table[i];
 393                     s->exponent_sizes[k] = n;
 394                 } else {
 395                     j = 0;
 396                     lpos = 0;
 397                     for(i=0;i<25;i++) {
 398                         a = wma_critical_freqs[i];
 399                         b = s->sample_rate;
 400                         pos = ((block_len * 2 * a)  + (b << 1)) / (4 * b);
 401                         pos <<= 2;
 402                         if (pos > block_len)
 403                             pos = block_len;
 404                         if (pos > lpos)
 405                             s->exponent_bands[k][j++] = pos - lpos;
 406                         if (pos >= block_len)
 407                             break;
 408                         lpos = pos;
 409                     }
 410                     s->exponent_sizes[k] = j;
 411                 }
 412             }
 413
 414             /* max number of coefs */
 415             s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
 416             /* high freq computation */
 417             s->high_band_start[k] = (int)((block_len * 2 * high_freq) /
 418                                           s->sample_rate + 0.5);
 419             n = s->exponent_sizes[k];
 420             j = 0;
 421             pos = 0;
 422             for(i=0;i<n;i++) {
 423                 int start, end;
 424                 start = pos;
 425                 pos += s->exponent_bands[k][i];
 426                 end = pos;
 427                 if (start < s->high_band_start[k])
 428                     start = s->high_band_start[k];
 429                 if (end > s->coefs_end[k])
 430                     end = s->coefs_end[k];
 431                 if (end > start)
 432                     s->exponent_high_bands[k][j++] = end - start;
 433             }
 434             s->exponent_high_sizes[k] = j;
 435 #if 0
 436             tprintf("%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ",
 437                   s->frame_len >> k,
 438                   s->coefs_end[k],
 439                   s->high_band_start[k],
 440                   s->exponent_high_sizes[k]);
 441             for(j=0;j<s->exponent_high_sizes[k];j++)
 442                 tprintf(" %d", s->exponent_high_bands[k][j]);
 443             tprintf("\n");
 444 #endif
 445         }
 446     }
 447
 448 #ifdef TRACE
 449     {
 450         int i, j;
 451         for(i = 0; i < s->nb_block_sizes; i++) {
 452             tprintf("%5d: n=%2d:",
 453                    s->frame_len >> i,
 454                    s->exponent_sizes[i]);
 455             for(j=0;j<s->exponent_sizes[i];j++)
 456                 tprintf(" %d", s->exponent_bands[i][j]);
 457             tprintf("\n");
 458         }
 459     }
 460 #endif
 461
 462     /* init MDCT */
 463     for(i = 0; i < s->nb_block_sizes; i++)
 464         ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1);
 465
 466     /* init MDCT windows : simple sinus window */
 467     for(i = 0; i < s->nb_block_sizes; i++) {
 468         int n, j;
 469         float alpha;
 470         n = 1 << (s->frame_len_bits - i);
 471         window = av_malloc(sizeof(float) * n);
 472         alpha = M_PI / (2.0 * n);
 473         for(j=0;j<n;j++) {
 474             window[n - j - 1] = sin((j + 0.5) * alpha);
 475         }
 476         s->windows[i] = window;
 477     }
 478
 479     s->reset_block_lengths = 1;
 480
 481     if (s->use_noise_coding) {
 482
 483         /* init the noise generator */
 484         if (s->use_exp_vlc)
 485             s->noise_mult = 0.02;
 486         else
 487             s->noise_mult = 0.04;
 488
 489 #ifdef TRACE
 490         for(i=0;i<NOISE_TAB_SIZE;i++)
 491             s->noise_table[i] = 1.0 * s->noise_mult;
 492 #else
 493         {
 494             unsigned int seed;
 495             float norm;
 496             seed = 1;
 497             norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s->noise_mult;
 498             for(i=0;i<NOISE_TAB_SIZE;i++) {
 499                 seed = seed * 314159 + 1;
 500                 s->noise_table[i] = (float)((int)seed) * norm;
 501             }
 502         }
 503 #endif
 504         init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(hgain_huffbits),
 505                  hgain_huffbits, 1, 1,
 506                  hgain_huffcodes, 2, 2, 0);
 507     }
 508
 509     if (s->use_exp_vlc) {
 510         init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(scale_huffbits),
 511                  scale_huffbits, 1, 1,
 512                  scale_huffcodes, 4, 4, 0);
 513     } else {
 514         wma_lsp_to_curve_init(s, s->frame_len);
 515     }
 516
 517     /* choose the VLC tables for the coefficients */
 518     coef_vlc_table = 2;
 519     if (s->sample_rate >= 32000) {
 520         if (bps1 < 0.72)
 521             coef_vlc_table = 0;
 522         else if (bps1 < 1.16)
 523             coef_vlc_table = 1;
 524     }
 525
 526     init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0],
 527                   &coef_vlcs[coef_vlc_table * 2]);
 528     init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1],
 529                   &coef_vlcs[coef_vlc_table * 2 + 1]);
 530     return 0;
 531 }
 532
 533 /* interpolate values for a bigger or smaller block. The block must
 534    have multiple sizes */
 535 static void interpolate_array(float *scale, int old_size, int new_size)
 536 {
 537     int i, j, jincr, k;
 538     float v;
 539
 540     if (new_size > old_size) {
 541         jincr = new_size / old_size;
 542         j = new_size;
 543         for(i = old_size - 1; i >=0; i--) {
 544             v = scale[i];
 545             k = jincr;
 546             do {
 547                 scale[--j] = v;
 548             } while (--k);
 549         }
 550     } else if (new_size < old_size) {
 551         j = 0;
 552         jincr = old_size / new_size;
 553         for(i = 0; i < new_size; i++) {
 554             scale[i] = scale[j];
 555             j += jincr;
 556         }
 557     }
 558 }
 559
 560 /* compute x^-0.25 with an exponent and mantissa table. We use linear
 561    interpolation to reduce the mantissa table size at a small speed
 562    expense (linear interpolation approximately doubles the number of
 563    bits of precision). */
 564 static inline float pow_m1_4(WMADecodeContext *s, float x)
 565 {
 566     union {
 567         float f;
 568         unsigned int v;
 569     } u, t;
 570     unsigned int e, m;
 571     float a, b;
 572
 573     u.f = x;
 574     e = u.v >> 23;
 575     m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1);
 576     /* build interpolation scale: 1 <= t < 2. */
 577     t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23);
 578     a = s->lsp_pow_m_table1[m];
 579     b = s->lsp_pow_m_table2[m];
 580     return s->lsp_pow_e_table[e] * (a + b * t.f);
 581 }
 582
 583 static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len)
 584 {
 585     float wdel, a, b;
 586     int i, e, m;
 587
 588     wdel = M_PI / frame_len;
 589     for(i=0;i<frame_len;i++)
 590         s->lsp_cos_table[i] = 2.0f * cos(wdel * i);
 591
 592     /* tables for x^-0.25 computation */
 593     for(i=0;i<256;i++) {
 594         e = i - 126;
 595         s->lsp_pow_e_table[i] = pow(2.0, e * -0.25);
 596     }
 597
 598     /* NOTE: these two tables are needed to avoid two operations in
 599        pow_m1_4 */
 600     b = 1.0;
 601     for(i=(1 << LSP_POW_BITS) - 1;i>=0;i--) {
 602         m = (1 << LSP_POW_BITS) + i;
 603         a = (float)m * (0.5 / (1 << LSP_POW_BITS));
 604         a = pow(a, -0.25);
 605         s->lsp_pow_m_table1[i] = 2 * a - b;
 606         s->lsp_pow_m_table2[i] = b - a;
 607         b = a;
 608     }
 609 #if 0
 610     for(i=1;i<20;i++) {
 611         float v, r1, r2;
 612         v = 5.0 / i;
 613         r1 = pow_m1_4(s, v);
 614         r2 = pow(v,-0.25);
 615         printf("%f^-0.25=%f e=%f\n", v, r1, r2 - r1);
 616     }
 617 #endif
 618 }
 619
 620 /* NOTE: We use the same code as Vorbis here */
 621 /* XXX: optimize it further with SSE/3Dnow */
 622 static void wma_lsp_to_curve(WMADecodeContext *s,
 623                              float *out, float *val_max_ptr,
 624                              int n, float *lsp)
 625 {
 626     int i, j;
 627     float p, q, w, v, val_max;
 628
 629     val_max = 0;
 630     for(i=0;i<n;i++) {
 631         p = 0.5f;
 632         q = 0.5f;
 633         w = s->lsp_cos_table[i];
 634         for(j=1;j<NB_LSP_COEFS;j+=2){
 635             q *= w - lsp[j - 1];
 636             p *= w - lsp[j];
 637         }
 638         p *= p * (2.0f - w);
 639         q *= q * (2.0f + w);
 640         v = p + q;
 641         v = pow_m1_4(s, v);
 642         if (v > val_max)
 643             val_max = v;
 644         out[i] = v;
 645     }
 646     *val_max_ptr = val_max;
 647 }
 648
 649 /* decode exponents coded with LSP coefficients (same idea as Vorbis) */
 650 static void decode_exp_lsp(WMADecodeContext *s, int ch)
 651 {
 652     float lsp_coefs[NB_LSP_COEFS];
 653     int val, i;
 654
 655     for(i = 0; i < NB_LSP_COEFS; i++) {
 656         if (i == 0 || i >= 8)
 657             val = get_bits(&s->gb, 3);
 658         else
 659             val = get_bits(&s->gb, 4);
 660         lsp_coefs[i] = lsp_codebook[i][val];
 661     }
 662
 663     wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch],
 664                      s->block_len, lsp_coefs);
 665 }
 666
 667 /* decode exponents coded with VLC codes */
 668 static int decode_exp_vlc(WMADecodeContext *s, int ch)
 669 {
 670     int last_exp, n, code;
 671     const uint16_t *ptr, *band_ptr;
 672     float v, *q, max_scale, *q_end;
 673
 674     band_ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
 675     ptr = band_ptr;
 676     q = s->exponents[ch];
 677     q_end = q + s->block_len;
 678     max_scale = 0;
 679     if (s->version == 1) {
 680         last_exp = get_bits(&s->gb, 5) + 10;
 681         /* XXX: use a table */
 682         v = pow(10, last_exp * (1.0 / 16.0));
 683         max_scale = v;
 684         n = *ptr++;
 685         do {
 686             *q++ = v;
 687         } while (--n);
 688     }
 689     last_exp = 36;
 690     while (q < q_end) {
 691         code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
 692         if (code < 0)
 693             return -1;
 694         /* NOTE: this offset is the same as MPEG4 AAC ! */
 695         last_exp += code - 60;
 696         /* XXX: use a table */
 697         v = pow(10, last_exp * (1.0 / 16.0));
 698         if (v > max_scale)
 699             max_scale = v;
 700         n = *ptr++;
 701         do {
 702             *q++ = v;
 703         } while (--n);
 704     }
 705     s->max_exponent[ch] = max_scale;
 706     return 0;
 707 }
 708
 709 /* return 0 if OK. return 1 if last block of frame. return -1 if
 710    unrecorrable error. */
 711 static int wma_decode_block(WMADecodeContext *s)
 712 {
 713     int n, v, a, ch, code, bsize;
 714     int coef_nb_bits, total_gain, parse_exponents;
 715     float window[BLOCK_MAX_SIZE * 2];
 716 // XXX: FIXME!! there's a bug somewhere which makes this mandatory under altivec
 717 #ifdef HAVE_ALTIVEC
 718     volatile int nb_coefs[MAX_CHANNELS] __attribute__((aligned(16)));
 719 #else
 720     int nb_coefs[MAX_CHANNELS];
 721 #endif
 722     float mdct_norm;
 723
 724 #ifdef TRACE
 725     tprintf("***decode_block: %d:%d\n", s->frame_count - 1, s->block_num);
 726 #endif
 727
 728     /* compute current block length */
 729     if (s->use_variable_block_len) {
 730         n = av_log2(s->nb_block_sizes - 1) + 1;
 731
 732         if (s->reset_block_lengths) {
 733             s->reset_block_lengths = 0;
 734             v = get_bits(&s->gb, n);
 735             if (v >= s->nb_block_sizes)
 736                 return -1;
 737             s->prev_block_len_bits = s->frame_len_bits - v;
 738             v = get_bits(&s->gb, n);
 739             if (v >= s->nb_block_sizes)
 740                 return -1;
 741             s->block_len_bits = s->frame_len_bits - v;
 742         } else {
 743             /* update block lengths */
 744             s->prev_block_len_bits = s->block_len_bits;
 745             s->block_len_bits = s->next_block_len_bits;
 746         }
 747         v = get_bits(&s->gb, n);
 748         if (v >= s->nb_block_sizes)
 749             return -1;
 750         s->next_block_len_bits = s->frame_len_bits - v;
 751     } else {
 752         /* fixed block len */
 753         s->next_block_len_bits = s->frame_len_bits;
 754         s->prev_block_len_bits = s->frame_len_bits;
 755         s->block_len_bits = s->frame_len_bits;
 756     }
 757
 758     /* now check if the block length is coherent with the frame length */
 759     s->block_len = 1 << s->block_len_bits;
 760     if ((s->block_pos + s->block_len) > s->frame_len)
 761         return -1;
 762
 763     if (s->nb_channels == 2) {
 764         s->ms_stereo = get_bits(&s->gb, 1);
 765     }
 766     v = 0;
 767     for(ch = 0; ch < s->nb_channels; ch++) {
 768         a = get_bits(&s->gb, 1);
 769         s->channel_coded[ch] = a;
 770         v |= a;
 771     }
 772     /* if no channel coded, no need to go further */
 773     /* XXX: fix potential framing problems */
 774     if (!v)
 775         goto next;
 776
 777     bsize = s->frame_len_bits - s->block_len_bits;
 778
 779     /* read total gain and extract corresponding number of bits for
 780        coef escape coding */
 781     total_gain = 1;
 782     for(;;) {
 783         a = get_bits(&s->gb, 7);
 784         total_gain += a;
 785         if (a != 127)
 786             break;
 787     }
 788
 789     if (total_gain < 15)
 790         coef_nb_bits = 13;
 791     else if (total_gain < 32)
 792         coef_nb_bits = 12;
 793     else if (total_gain < 40)
 794         coef_nb_bits = 11;
 795     else if (total_gain < 45)
 796         coef_nb_bits = 10;
 797     else
 798         coef_nb_bits = 9;
 799
 800     /* compute number of coefficients */
 801     n = s->coefs_end[bsize] - s->coefs_start;
 802     for(ch = 0; ch < s->nb_channels; ch++)
 803         nb_coefs[ch] = n;
 804
 805     /* complex coding */
 806     if (s->use_noise_coding) {
 807
 808         for(ch = 0; ch < s->nb_channels; ch++) {
 809             if (s->channel_coded[ch]) {
 810                 int i, n, a;
 811                 n = s->exponent_high_sizes[bsize];
 812                 for(i=0;i<n;i++) {
 813                     a = get_bits(&s->gb, 1);
 814                     s->high_band_coded[ch][i] = a;
 815                     /* if noise coding, the coefficients are not transmitted */
 816                     if (a)
 817                         nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
 818                 }
 819             }
 820         }
 821         for(ch = 0; ch < s->nb_channels; ch++) {
 822             if (s->channel_coded[ch]) {
 823                 int i, n, val, code;
 824
 825                 n = s->exponent_high_sizes[bsize];
 826                 val = (int)0x80000000;
 827                 for(i=0;i<n;i++) {
 828                     if (s->high_band_coded[ch][i]) {
 829                         if (val == (int)0x80000000) {
 830                             val = get_bits(&s->gb, 7) - 19;
 831                         } else {
 832                             code = get_vlc2(&s->gb, s->hgain_vlc.table, HGAINVLCBITS, HGAINMAX);
 833                             if (code < 0)
 834                                 return -1;
 835                             val += code - 18;
 836                         }
 837                         s->high_band_values[ch][i] = val;
 838                     }
 839                 }
 840             }
 841         }
 842     }
 843
 844     /* exposant can be interpolated in short blocks. */
 845     parse_exponents = 1;
 846     if (s->block_len_bits != s->frame_len_bits) {
 847         parse_exponents = get_bits(&s->gb, 1);
 848     }
 849
 850     if (parse_exponents) {
 851         for(ch = 0; ch < s->nb_channels; ch++) {
 852             if (s->channel_coded[ch]) {
 853                 if (s->use_exp_vlc) {
 854                     if (decode_exp_vlc(s, ch) < 0)
 855                         return -1;
 856                 } else {
 857                     decode_exp_lsp(s, ch);
 858                 }
 859             }
 860         }
 861     } else {
 862         for(ch = 0; ch < s->nb_channels; ch++) {
 863             if (s->channel_coded[ch]) {
 864                 interpolate_array(s->exponents[ch], 1 << s->prev_block_len_bits,
 865                                   s->block_len);
 866             }
 867         }
 868     }
 869
 870     /* parse spectral coefficients : just RLE encoding */
 871     for(ch = 0; ch < s->nb_channels; ch++) {
 872         if (s->channel_coded[ch]) {
 873             VLC *coef_vlc;
 874             int level, run, sign, tindex;
 875             int16_t *ptr, *eptr;
 876             const int16_t *level_table, *run_table;
 877
 878             /* special VLC tables are used for ms stereo because
 879                there is potentially less energy there */
 880             tindex = (ch == 1 && s->ms_stereo);
 881             coef_vlc = &s->coef_vlc[tindex];
 882             run_table = s->run_table[tindex];
 883             level_table = s->level_table[tindex];
 884             /* XXX: optimize */
 885             ptr = &s->coefs1[ch][0];
 886             eptr = ptr + nb_coefs[ch];
 887             memset(ptr, 0, s->block_len * sizeof(int16_t));
 888             for(;;) {
 889                 code = get_vlc2(&s->gb, coef_vlc->table, VLCBITS, VLCMAX);
 890                 if (code < 0)
 891                     return -1;
 892                 if (code == 1) {
 893                     /* EOB */
 894                     break;
 895                 } else if (code == 0) {
 896                     /* escape */
 897                     level = get_bits(&s->gb, coef_nb_bits);
 898                     /* NOTE: this is rather suboptimal. reading
 899                        block_len_bits would be better */
 900                     run = get_bits(&s->gb, s->frame_len_bits);
 901                 } else {
 902                     /* normal code */
 903                     run = run_table[code];
 904                     level = level_table[code];
 905                 }
 906                 sign = get_bits(&s->gb, 1);
 907                 if (!sign)
 908                     level = -level;
 909                 ptr += run;
 910                 if (ptr >= eptr)
 911                     return -1;
 912                 *ptr++ = level;
 913                 /* NOTE: EOB can be omitted */
 914                 if (ptr >= eptr)
 915                     break;
 916             }
 917         }
 918         if (s->version == 1 && s->nb_channels >= 2) {
 919             align_get_bits(&s->gb);
 920         }
 921     }
 922
 923     /* normalize */
 924     {
 925         int n4 = s->block_len / 2;
 926         mdct_norm = 1.0 / (float)n4;
 927         if (s->version == 1) {
 928             mdct_norm *= sqrt(n4);
 929         }
 930     }
 931
 932     /* finally compute the MDCT coefficients */
 933     for(ch = 0; ch < s->nb_channels; ch++) {
 934         if (s->channel_coded[ch]) {
 935             int16_t *coefs1;
 936             float *coefs, *exponents, mult, mult1, noise, *exp_ptr;
 937             int i, j, n, n1, last_high_band;
 938             float exp_power[HIGH_BAND_MAX_SIZE];
 939
 940             coefs1 = s->coefs1[ch];
 941             exponents = s->exponents[ch];
 942             mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
 943             mult *= mdct_norm;
 944             coefs = s->coefs[ch];
 945             if (s->use_noise_coding) {
 946                 mult1 = mult;
 947                 /* very low freqs : noise */
 948                 for(i = 0;i < s->coefs_start; i++) {
 949                     *coefs++ = s->noise_table[s->noise_index] * (*exponents++) * mult1;
 950                     s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
 951                 }
 952
 953                 n1 = s->exponent_high_sizes[bsize];
 954
 955                 /* compute power of high bands */
 956                 exp_ptr = exponents +
 957                     s->high_band_start[bsize] -
 958                     s->coefs_start;
 959                 last_high_band = 0; /* avoid warning */
 960                 for(j=0;j<n1;j++) {
 961                     n = s->exponent_high_bands[s->frame_len_bits -
 962                                               s->block_len_bits][j];
 963                     if (s->high_band_coded[ch][j]) {
 964                         float e2, v;
 965                         e2 = 0;
 966                         for(i = 0;i < n; i++) {
 967                             v = exp_ptr[i];
 968                             e2 += v * v;
 969                         }
 970                         exp_power[j] = e2 / n;
 971                         last_high_band = j;
 972                         tprintf("%d: power=%f (%d)\n", j, exp_power[j], n);
 973                     }
 974                     exp_ptr += n;
 975                 }
 976
 977                 /* main freqs and high freqs */
 978                 for(j=-1;j<n1;j++) {
 979                     if (j < 0) {
 980                         n = s->high_band_start[bsize] -
 981                             s->coefs_start;
 982                     } else {
 983                         n = s->exponent_high_bands[s->frame_len_bits -
 984                                                   s->block_len_bits][j];
 985                     }
 986                     if (j >= 0 && s->high_band_coded[ch][j]) {
 987                         /* use noise with specified power */
 988                         mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
 989                         /* XXX: use a table */
 990                         mult1 = mult1 * pow(10, s->high_band_values[ch][j] * 0.05);
 991                         mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult);
 992                         mult1 *= mdct_norm;
 993                         for(i = 0;i < n; i++) {
 994                             noise = s->noise_table[s->noise_index];
 995                             s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
 996                             *coefs++ = (*exponents++) * noise * mult1;
 997                         }
 998                     } else {
 999                         /* coded values + small noise */
1000                         for(i = 0;i < n; i++) {
1001                             noise = s->noise_table[s->noise_index];
1002                             s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
1003                             *coefs++ = ((*coefs1++) + noise) * (*exponents++) * mult;
1004                         }
1005                     }
1006                 }
1007
1008                 /* very high freqs : noise */
1009                 n = s->block_len - s->coefs_end[bsize];
1010                 mult1 = mult * exponents[-1];
1011                 for(i = 0; i < n; i++) {
1012                     *coefs++ = s->noise_table[s->noise_index] * mult1;
1013                     s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
1014                 }
1015             } else {
1016                 /* XXX: optimize more */
1017                 for(i = 0;i < s->coefs_start; i++)
1018                     *coefs++ = 0.0;
1019                 n = nb_coefs[ch];
1020                 for(i = 0;i < n; i++) {
1021                     *coefs++ = coefs1[i] * exponents[i] * mult;
1022                 }
1023                 n = s->block_len - s->coefs_end[bsize];
1024                 for(i = 0;i < n; i++)
1025                     *coefs++ = 0.0;
1026             }
1027         }
1028     }
1029
1030 #ifdef TRACE
1031     for(ch = 0; ch < s->nb_channels; ch++) {
1032         if (s->channel_coded[ch]) {
1033             dump_floats("exponents", 3, s->exponents[ch], s->block_len);
1034             dump_floats("coefs", 1, s->coefs[ch], s->block_len);
1035         }
1036     }
1037 #endif
1038
1039     if (s->ms_stereo && s->channel_coded[1]) {
1040         float a, b;
1041         int i;
1042
1043         /* nominal case for ms stereo: we do it before mdct */
1044         /* no need to optimize this case because it should almost
1045            never happen */
1046         if (!s->channel_coded[0]) {
1047             tprintf("rare ms-stereo case happened\n");
1048             memset(s->coefs[0], 0, sizeof(float) * s->block_len);
1049             s->channel_coded[0] = 1;
1050         }
1051
1052         for(i = 0; i < s->block_len; i++) {
1053             a = s->coefs[0][i];
1054             b = s->coefs[1][i];
1055             s->coefs[0][i] = a + b;
1056             s->coefs[1][i] = a - b;
1057         }
1058     }
1059
1060     /* build the window : we ensure that when the windows overlap
1061        their squared sum is always 1 (MDCT reconstruction rule) */
1062     /* XXX: merge with output */
1063     {
1064         int i, next_block_len, block_len, prev_block_len, n;
1065         float *wptr;
1066
1067         block_len = s->block_len;
1068         prev_block_len = 1 << s->prev_block_len_bits;
1069         next_block_len = 1 << s->next_block_len_bits;
1070
1071         /* right part */
1072         wptr = window + block_len;
1073         if (block_len <= next_block_len) {
1074             for(i=0;i<block_len;i++)
1075                 *wptr++ = s->windows[bsize][i];
1076         } else {
1077             /* overlap */
1078             n = (block_len / 2) - (next_block_len / 2);
1079             for(i=0;i<n;i++)
1080                 *wptr++ = 1.0;
1081             for(i=0;i<next_block_len;i++)
1082                 *wptr++ = s->windows[s->frame_len_bits - s->next_block_len_bits][i];
1083             for(i=0;i<n;i++)
1084                 *wptr++ = 0.0;
1085         }
1086
1087         /* left part */
1088         wptr = window + block_len;
1089         if (block_len <= prev_block_len) {
1090             for(i=0;i<block_len;i++)
1091                 *--wptr = s->windows[bsize][i];
1092         } else {
1093             /* overlap */
1094             n = (block_len / 2) - (prev_block_len / 2);
1095             for(i=0;i<n;i++)
1096                 *--wptr = 1.0;
1097             for(i=0;i<prev_block_len;i++)
1098                 *--wptr = s->windows[s->frame_len_bits - s->prev_block_len_bits][i];
1099             for(i=0;i<n;i++)
1100                 *--wptr = 0.0;
1101         }
1102     }
1103
1104
1105     for(ch = 0; ch < s->nb_channels; ch++) {
1106         if (s->channel_coded[ch]) {
1107             DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]);
1108             float *ptr;
1109             int i, n4, index, n;
1110
1111             n = s->block_len;
1112             n4 = s->block_len / 2;
1113             ff_imdct_calc(&s->mdct_ctx[bsize],
1114                           output, s->coefs[ch], s->mdct_tmp);
1115
1116             /* XXX: optimize all that by build the window and
1117                multipying/adding at the same time */
1118             /* multiply by the window */
1119             for(i=0;i<n * 2;i++) {
1120                 output[i] *= window[i];
1121             }
1122
1123             /* add in the frame */
1124             index = (s->frame_len / 2) + s->block_pos - n4;
1125             ptr = &s->frame_out[ch][index];
1126             for(i=0;i<n * 2;i++) {
1127                 *ptr += output[i];
1128                 ptr++;
1129             }
1130
1131             /* specific fast case for ms-stereo : add to second
1132                channel if it is not coded */
1133             if (s->ms_stereo && !s->channel_coded[1]) {
1134                 ptr = &s->frame_out[1][index];
1135                 for(i=0;i<n * 2;i++) {
1136                     *ptr += output[i];
1137                     ptr++;
1138                 }
1139             }
1140         }
1141     }
1142  next:
1143     /* update block number */
1144     s->block_num++;
1145     s->block_pos += s->block_len;
1146     if (s->block_pos >= s->frame_len)
1147         return 1;
1148     else
1149         return 0;
1150 }
1151
1152 /* decode a frame of frame_len samples */
1153 static int wma_decode_frame(WMADecodeContext *s, int16_t *samples)
1154 {
1155     int ret, i, n, a, ch, incr;
1156     int16_t *ptr;
1157     float *iptr;
1158
1159 #ifdef TRACE
1160     tprintf("***decode_frame: %d size=%d\n", s->frame_count++, s->frame_len);
1161 #endif
1162
1163     /* read each block */
1164     s->block_num = 0;
1165     s->block_pos = 0;
1166     for(;;) {
1167         ret = wma_decode_block(s);
1168         if (ret < 0)
1169             return -1;
1170         if (ret)
1171             break;
1172     }
1173
1174     /* convert frame to integer */
1175     n = s->frame_len;
1176     incr = s->nb_channels;
1177     for(ch = 0; ch < s->nb_channels; ch++) {
1178         ptr = samples + ch;
1179         iptr = s->frame_out[ch];
1180
1181         for(i=0;i<n;i++) {
1182             a = lrintf(*iptr++);
1183             if (a > 32767)
1184                 a = 32767;
1185             else if (a < -32768)
1186                 a = -32768;
1187             *ptr = a;
1188             ptr += incr;
1189         }
1190         /* prepare for next block */
1191         memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
1192                 s->frame_len * sizeof(float));
1193         /* XXX: suppress this */
1194         memset(&s->frame_out[ch][s->frame_len], 0,
1195                s->frame_len * sizeof(float));
1196     }
1197
1198 #ifdef TRACE
1199     dump_shorts("samples", samples, n * s->nb_channels);
1200 #endif
1201     return 0;
1202 }
1203
1204 static int wma_decode_superframe(AVCodecContext *avctx,
1205                                  void *data, int *data_size,
1206                                  uint8_t *buf, int buf_size)
1207 {
1208     WMADecodeContext *s = avctx->priv_data;
1209     int nb_frames, bit_offset, i, pos, len;
1210     uint8_t *q;
1211     int16_t *samples;
1212
1213     tprintf("***decode_superframe:\n");
1214
1215     if(buf_size==0){
1216         s->last_superframe_len = 0;
1217         return 0;
1218     }
1219
1220     samples = data;
1221
1222     init_get_bits(&s->gb, buf, buf_size*8);
1223
1224     if (s->use_bit_reservoir) {
1225         /* read super frame header */
1226         get_bits(&s->gb, 4); /* super frame index */
1227         nb_frames = get_bits(&s->gb, 4) - 1;
1228
1229         bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
1230
1231         if (s->last_superframe_len > 0) {
1232             //        printf("skip=%d\n", s->last_bitoffset);
1233             /* add bit_offset bits to last frame */
1234             if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
1235                 MAX_CODED_SUPERFRAME_SIZE)
1236                 goto fail;
1237             q = s->last_superframe + s->last_superframe_len;
1238             len = bit_offset;
1239             while (len > 0) {
1240                 *q++ = (get_bits)(&s->gb, 8);
1241                 len -= 8;
1242             }
1243             if (len > 0) {
1244                 *q++ = (get_bits)(&s->gb, len) << (8 - len);
1245             }
1246
1247             /* XXX: bit_offset bits into last frame */
1248             init_get_bits(&s->gb, s->last_superframe, MAX_CODED_SUPERFRAME_SIZE*8);
1249             /* skip unused bits */
1250             if (s->last_bitoffset > 0)
1251                 skip_bits(&s->gb, s->last_bitoffset);
1252             /* this frame is stored in the last superframe and in the
1253                current one */
1254             if (wma_decode_frame(s, samples) < 0)
1255                 goto fail;
1256             samples += s->nb_channels * s->frame_len;
1257         }
1258
1259         /* read each frame starting from bit_offset */
1260         pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
1261         init_get_bits(&s->gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE - (pos >> 3))*8);
1262         len = pos & 7;
1263         if (len > 0)
1264             skip_bits(&s->gb, len);
1265
1266         s->reset_block_lengths = 1;
1267         for(i=0;i<nb_frames;i++) {
1268             if (wma_decode_frame(s, samples) < 0)
1269                 goto fail;
1270             samples += s->nb_channels * s->frame_len;
1271         }
1272
1273         /* we copy the end of the frame in the last frame buffer */
1274         pos = get_bits_count(&s->gb) + ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
1275         s->last_bitoffset = pos & 7;
1276         pos >>= 3;
1277         len = buf_size - pos;
1278         if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
1279             goto fail;
1280         }
1281         s->last_superframe_len = len;
1282         memcpy(s->last_superframe, buf + pos, len);
1283     } else {
1284         /* single frame decode */
1285         if (wma_decode_frame(s, samples) < 0)
1286             goto fail;
1287         samples += s->nb_channels * s->frame_len;
1288     }
1289     *data_size = (int8_t *)samples - (int8_t *)data;
1290     return s->block_align;
1291  fail:
1292     /* when error, we reset the bit reservoir */
1293     s->last_superframe_len = 0;
1294     return -1;
1295 }
1296
1297 static int wma_decode_end(AVCodecContext *avctx)
1298 {
1299     WMADecodeContext *s = avctx->priv_data;
1300     int i;
1301
1302     for(i = 0; i < s->nb_block_sizes; i++)
1303         ff_mdct_end(&s->mdct_ctx[i]);
1304     for(i = 0; i < s->nb_block_sizes; i++)
1305         av_free(s->windows[i]);
1306
1307     if (s->use_exp_vlc) {
1308         free_vlc(&s->exp_vlc);
1309     }
1310     if (s->use_noise_coding) {
1311         free_vlc(&s->hgain_vlc);
1312     }
1313     for(i = 0;i < 2; i++) {
1314         free_vlc(&s->coef_vlc[i]);
1315         av_free(s->run_table[i]);
1316         av_free(s->level_table[i]);
1317     }
1318
1319     return 0;
1320 }
1321
1322 AVCodec wmav1_decoder =
1323 {
1324     "wmav1",
1325     CODEC_TYPE_AUDIO,
1326     CODEC_ID_WMAV1,
1327     sizeof(WMADecodeContext),
1328     wma_decode_init,
1329     NULL,
1330     wma_decode_end,
1331     wma_decode_superframe,
1332 };
1333
1334 AVCodec wmav2_decoder =
1335 {
1336     "wmav2",
1337     CODEC_TYPE_AUDIO,
1338     CODEC_ID_WMAV2,
1339     sizeof(WMADecodeContext),
1340     wma_decode_init,
1341     NULL,
1342     wma_decode_end,
1343     wma_decode_superframe,
1344 };