Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * WMA compatible decoder
  3.  * Copyright (c) 2002 The FFmpeg Project
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. /**
  23.  * @file
  24.  * WMA compatible decoder.
  25.  * This decoder handles Microsoft Windows Media Audio data, versions 1 & 2.
  26.  * WMA v1 is identified by audio format 0x160 in Microsoft media files
  27.  * (ASF/AVI/WAV). WMA v2 is identified by audio format 0x161.
  28.  *
  29.  * To use this decoder, a calling application must supply the extra data
  30.  * bytes provided with the WMA data. These are the extra, codec-specific
  31.  * bytes at the end of a WAVEFORMATEX data structure. Transmit these bytes
  32.  * to the decoder using the extradata[_size] fields in AVCodecContext. There
  33.  * should be 4 extra bytes for v1 data and 6 extra bytes for v2 data.
  34.  */
  35.  
  36. #include "libavutil/attributes.h"
  37.  
  38. #include "avcodec.h"
  39. #include "internal.h"
  40. #include "wma.h"
  41.  
  42. #define EXPVLCBITS 8
  43. #define EXPMAX     ((19 + EXPVLCBITS - 1) / EXPVLCBITS)
  44.  
  45. #define HGAINVLCBITS 9
  46. #define HGAINMAX     ((13 + HGAINVLCBITS - 1) / HGAINVLCBITS)
  47.  
  48. static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len);
  49.  
  50. #ifdef TRACE
  51. static void dump_floats(WMACodecContext *s, const char *name,
  52.                         int prec, const float *tab, int n)
  53. {
  54.     int i;
  55.  
  56.     ff_tlog(s->avctx, "%s[%d]:\n", name, n);
  57.     for (i = 0; i < n; i++) {
  58.         if ((i & 7) == 0)
  59.             ff_tlog(s->avctx, "%4d: ", i);
  60.         ff_tlog(s->avctx, " %8.*f", prec, tab[i]);
  61.         if ((i & 7) == 7)
  62.             ff_tlog(s->avctx, "\n");
  63.     }
  64.     if ((i & 7) != 0)
  65.         ff_tlog(s->avctx, "\n");
  66. }
  67. #endif /* TRACE */
  68.  
  69. static av_cold int wma_decode_init(AVCodecContext *avctx)
  70. {
  71.     WMACodecContext *s = avctx->priv_data;
  72.     int i, flags2;
  73.     uint8_t *extradata;
  74.  
  75.     if (!avctx->block_align) {
  76.         av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
  77.         return AVERROR(EINVAL);
  78.     }
  79.  
  80.     s->avctx = avctx;
  81.  
  82.     /* extract flag infos */
  83.     flags2    = 0;
  84.     extradata = avctx->extradata;
  85.     if (avctx->codec->id == AV_CODEC_ID_WMAV1 && avctx->extradata_size >= 4)
  86.         flags2 = AV_RL16(extradata + 2);
  87.     else if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 6)
  88.         flags2 = AV_RL16(extradata + 4);
  89.  
  90.     s->use_exp_vlc            = flags2 & 0x0001;
  91.     s->use_bit_reservoir      = flags2 & 0x0002;
  92.     s->use_variable_block_len = flags2 & 0x0004;
  93.  
  94.     if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 8){
  95.         if (AV_RL16(extradata+4)==0xd && s->use_variable_block_len){
  96.             av_log(avctx, AV_LOG_WARNING, "Disabling use_variable_block_len, if this fails contact the ffmpeg developers and send us the file\n");
  97.             s->use_variable_block_len= 0; // this fixes issue1503
  98.         }
  99.     }
  100.  
  101.     for (i=0; i<MAX_CHANNELS; i++)
  102.         s->max_exponent[i] = 1.0;
  103.  
  104.     if (ff_wma_init(avctx, flags2) < 0)
  105.         return -1;
  106.  
  107.     /* init MDCT */
  108.     for (i = 0; i < s->nb_block_sizes; i++)
  109.         ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1, 1.0 / 32768.0);
  110.  
  111.     if (s->use_noise_coding) {
  112.         init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(ff_wma_hgain_huffbits),
  113.                  ff_wma_hgain_huffbits, 1, 1,
  114.                  ff_wma_hgain_huffcodes, 2, 2, 0);
  115.     }
  116.  
  117.     if (s->use_exp_vlc)
  118.         init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_aac_scalefactor_bits), // FIXME move out of context
  119.                  ff_aac_scalefactor_bits, 1, 1,
  120.                  ff_aac_scalefactor_code, 4, 4, 0);
  121.     else
  122.         wma_lsp_to_curve_init(s, s->frame_len);
  123.  
  124.     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
  125.  
  126.     return 0;
  127. }
  128.  
  129. /**
  130.  * compute x^-0.25 with an exponent and mantissa table. We use linear
  131.  * interpolation to reduce the mantissa table size at a small speed
  132.  * expense (linear interpolation approximately doubles the number of
  133.  * bits of precision).
  134.  */
  135. static inline float pow_m1_4(WMACodecContext *s, float x)
  136. {
  137.     union {
  138.         float f;
  139.         unsigned int v;
  140.     } u, t;
  141.     unsigned int e, m;
  142.     float a, b;
  143.  
  144.     u.f = x;
  145.     e   =  u.v >>  23;
  146.     m   = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1);
  147.     /* build interpolation scale: 1 <= t < 2. */
  148.     t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23);
  149.     a   = s->lsp_pow_m_table1[m];
  150.     b   = s->lsp_pow_m_table2[m];
  151.     return s->lsp_pow_e_table[e] * (a + b * t.f);
  152. }
  153.  
  154. static av_cold void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
  155. {
  156.     float wdel, a, b;
  157.     int i, e, m;
  158.  
  159.     wdel = M_PI / frame_len;
  160.     for (i = 0; i < frame_len; i++)
  161.         s->lsp_cos_table[i] = 2.0f * cos(wdel * i);
  162.  
  163.     /* tables for x^-0.25 computation */
  164.     for (i = 0; i < 256; i++) {
  165.         e                     = i - 126;
  166.         s->lsp_pow_e_table[i] = pow(2.0, e * -0.25);
  167.     }
  168.  
  169.     /* NOTE: these two tables are needed to avoid two operations in
  170.      * pow_m1_4 */
  171.     b = 1.0;
  172.     for (i = (1 << LSP_POW_BITS) - 1; i >= 0; i--) {
  173.         m                      = (1 << LSP_POW_BITS) + i;
  174.         a                      = (float) m * (0.5 / (1 << LSP_POW_BITS));
  175.         a                      = pow(a, -0.25);
  176.         s->lsp_pow_m_table1[i] = 2 * a - b;
  177.         s->lsp_pow_m_table2[i] = b - a;
  178.         b                      = a;
  179.     }
  180. }
  181.  
  182. /**
  183.  * NOTE: We use the same code as Vorbis here
  184.  * @todo optimize it further with SSE/3Dnow
  185.  */
  186. static void wma_lsp_to_curve(WMACodecContext *s, float *out, float *val_max_ptr,
  187.                              int n, float *lsp)
  188. {
  189.     int i, j;
  190.     float p, q, w, v, val_max;
  191.  
  192.     val_max = 0;
  193.     for (i = 0; i < n; i++) {
  194.         p = 0.5f;
  195.         q = 0.5f;
  196.         w = s->lsp_cos_table[i];
  197.         for (j = 1; j < NB_LSP_COEFS; j += 2) {
  198.             q *= w - lsp[j - 1];
  199.             p *= w - lsp[j];
  200.         }
  201.         p *= p * (2.0f - w);
  202.         q *= q * (2.0f + w);
  203.         v  = p + q;
  204.         v  = pow_m1_4(s, v);
  205.         if (v > val_max)
  206.             val_max = v;
  207.         out[i] = v;
  208.     }
  209.     *val_max_ptr = val_max;
  210. }
  211.  
  212. /**
  213.  * decode exponents coded with LSP coefficients (same idea as Vorbis)
  214.  */
  215. static void decode_exp_lsp(WMACodecContext *s, int ch)
  216. {
  217.     float lsp_coefs[NB_LSP_COEFS];
  218.     int val, i;
  219.  
  220.     for (i = 0; i < NB_LSP_COEFS; i++) {
  221.         if (i == 0 || i >= 8)
  222.             val = get_bits(&s->gb, 3);
  223.         else
  224.             val = get_bits(&s->gb, 4);
  225.         lsp_coefs[i] = ff_wma_lsp_codebook[i][val];
  226.     }
  227.  
  228.     wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch],
  229.                      s->block_len, lsp_coefs);
  230. }
  231.  
  232. /** pow(10, i / 16.0) for i in -60..95 */
  233. static const float pow_tab[] = {
  234.     1.7782794100389e-04, 2.0535250264571e-04,
  235.     2.3713737056617e-04, 2.7384196342644e-04,
  236.     3.1622776601684e-04, 3.6517412725484e-04,
  237.     4.2169650342858e-04, 4.8696752516586e-04,
  238.     5.6234132519035e-04, 6.4938163157621e-04,
  239.     7.4989420933246e-04, 8.6596432336006e-04,
  240.     1.0000000000000e-03, 1.1547819846895e-03,
  241.     1.3335214321633e-03, 1.5399265260595e-03,
  242.     1.7782794100389e-03, 2.0535250264571e-03,
  243.     2.3713737056617e-03, 2.7384196342644e-03,
  244.     3.1622776601684e-03, 3.6517412725484e-03,
  245.     4.2169650342858e-03, 4.8696752516586e-03,
  246.     5.6234132519035e-03, 6.4938163157621e-03,
  247.     7.4989420933246e-03, 8.6596432336006e-03,
  248.     1.0000000000000e-02, 1.1547819846895e-02,
  249.     1.3335214321633e-02, 1.5399265260595e-02,
  250.     1.7782794100389e-02, 2.0535250264571e-02,
  251.     2.3713737056617e-02, 2.7384196342644e-02,
  252.     3.1622776601684e-02, 3.6517412725484e-02,
  253.     4.2169650342858e-02, 4.8696752516586e-02,
  254.     5.6234132519035e-02, 6.4938163157621e-02,
  255.     7.4989420933246e-02, 8.6596432336007e-02,
  256.     1.0000000000000e-01, 1.1547819846895e-01,
  257.     1.3335214321633e-01, 1.5399265260595e-01,
  258.     1.7782794100389e-01, 2.0535250264571e-01,
  259.     2.3713737056617e-01, 2.7384196342644e-01,
  260.     3.1622776601684e-01, 3.6517412725484e-01,
  261.     4.2169650342858e-01, 4.8696752516586e-01,
  262.     5.6234132519035e-01, 6.4938163157621e-01,
  263.     7.4989420933246e-01, 8.6596432336007e-01,
  264.     1.0000000000000e+00, 1.1547819846895e+00,
  265.     1.3335214321633e+00, 1.5399265260595e+00,
  266.     1.7782794100389e+00, 2.0535250264571e+00,
  267.     2.3713737056617e+00, 2.7384196342644e+00,
  268.     3.1622776601684e+00, 3.6517412725484e+00,
  269.     4.2169650342858e+00, 4.8696752516586e+00,
  270.     5.6234132519035e+00, 6.4938163157621e+00,
  271.     7.4989420933246e+00, 8.6596432336007e+00,
  272.     1.0000000000000e+01, 1.1547819846895e+01,
  273.     1.3335214321633e+01, 1.5399265260595e+01,
  274.     1.7782794100389e+01, 2.0535250264571e+01,
  275.     2.3713737056617e+01, 2.7384196342644e+01,
  276.     3.1622776601684e+01, 3.6517412725484e+01,
  277.     4.2169650342858e+01, 4.8696752516586e+01,
  278.     5.6234132519035e+01, 6.4938163157621e+01,
  279.     7.4989420933246e+01, 8.6596432336007e+01,
  280.     1.0000000000000e+02, 1.1547819846895e+02,
  281.     1.3335214321633e+02, 1.5399265260595e+02,
  282.     1.7782794100389e+02, 2.0535250264571e+02,
  283.     2.3713737056617e+02, 2.7384196342644e+02,
  284.     3.1622776601684e+02, 3.6517412725484e+02,
  285.     4.2169650342858e+02, 4.8696752516586e+02,
  286.     5.6234132519035e+02, 6.4938163157621e+02,
  287.     7.4989420933246e+02, 8.6596432336007e+02,
  288.     1.0000000000000e+03, 1.1547819846895e+03,
  289.     1.3335214321633e+03, 1.5399265260595e+03,
  290.     1.7782794100389e+03, 2.0535250264571e+03,
  291.     2.3713737056617e+03, 2.7384196342644e+03,
  292.     3.1622776601684e+03, 3.6517412725484e+03,
  293.     4.2169650342858e+03, 4.8696752516586e+03,
  294.     5.6234132519035e+03, 6.4938163157621e+03,
  295.     7.4989420933246e+03, 8.6596432336007e+03,
  296.     1.0000000000000e+04, 1.1547819846895e+04,
  297.     1.3335214321633e+04, 1.5399265260595e+04,
  298.     1.7782794100389e+04, 2.0535250264571e+04,
  299.     2.3713737056617e+04, 2.7384196342644e+04,
  300.     3.1622776601684e+04, 3.6517412725484e+04,
  301.     4.2169650342858e+04, 4.8696752516586e+04,
  302.     5.6234132519035e+04, 6.4938163157621e+04,
  303.     7.4989420933246e+04, 8.6596432336007e+04,
  304.     1.0000000000000e+05, 1.1547819846895e+05,
  305.     1.3335214321633e+05, 1.5399265260595e+05,
  306.     1.7782794100389e+05, 2.0535250264571e+05,
  307.     2.3713737056617e+05, 2.7384196342644e+05,
  308.     3.1622776601684e+05, 3.6517412725484e+05,
  309.     4.2169650342858e+05, 4.8696752516586e+05,
  310.     5.6234132519035e+05, 6.4938163157621e+05,
  311.     7.4989420933246e+05, 8.6596432336007e+05,
  312. };
  313.  
  314. /**
  315.  * decode exponents coded with VLC codes
  316.  */
  317. static int decode_exp_vlc(WMACodecContext *s, int ch)
  318. {
  319.     int last_exp, n, code;
  320.     const uint16_t *ptr;
  321.     float v, max_scale;
  322.     uint32_t *q, *q_end, iv;
  323.     const float *ptab = pow_tab + 60;
  324.     const uint32_t *iptab = (const uint32_t *) ptab;
  325.  
  326.     ptr       = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
  327.     q         = (uint32_t *) s->exponents[ch];
  328.     q_end     = q + s->block_len;
  329.     max_scale = 0;
  330.     if (s->version == 1) {
  331.         last_exp  = get_bits(&s->gb, 5) + 10;
  332.         v         = ptab[last_exp];
  333.         iv        = iptab[last_exp];
  334.         max_scale = v;
  335.         n         = *ptr++;
  336.         switch (n & 3) do {
  337.         case 0: *q++ = iv;
  338.         case 3: *q++ = iv;
  339.         case 2: *q++ = iv;
  340.         case 1: *q++ = iv;
  341.         } while ((n -= 4) > 0);
  342.     } else
  343.         last_exp = 36;
  344.  
  345.     while (q < q_end) {
  346.         code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
  347.         if (code < 0) {
  348.             av_log(s->avctx, AV_LOG_ERROR, "Exponent vlc invalid\n");
  349.             return -1;
  350.         }
  351.         /* NOTE: this offset is the same as MPEG4 AAC ! */
  352.         last_exp += code - 60;
  353.         if ((unsigned) last_exp + 60 >= FF_ARRAY_ELEMS(pow_tab)) {
  354.             av_log(s->avctx, AV_LOG_ERROR, "Exponent out of range: %d\n",
  355.                    last_exp);
  356.             return -1;
  357.         }
  358.         v  = ptab[last_exp];
  359.         iv = iptab[last_exp];
  360.         if (v > max_scale)
  361.             max_scale = v;
  362.         n = *ptr++;
  363.         switch (n & 3) do {
  364.         case 0: *q++ = iv;
  365.         case 3: *q++ = iv;
  366.         case 2: *q++ = iv;
  367.         case 1: *q++ = iv;
  368.         } while ((n -= 4) > 0);
  369.     }
  370.     s->max_exponent[ch] = max_scale;
  371.     return 0;
  372. }
  373.  
  374. /**
  375.  * Apply MDCT window and add into output.
  376.  *
  377.  * We ensure that when the windows overlap their squared sum
  378.  * is always 1 (MDCT reconstruction rule).
  379.  */
  380. static void wma_window(WMACodecContext *s, float *out)
  381. {
  382.     float *in = s->output;
  383.     int block_len, bsize, n;
  384.  
  385.     /* left part */
  386.     if (s->block_len_bits <= s->prev_block_len_bits) {
  387.         block_len = s->block_len;
  388.         bsize     = s->frame_len_bits - s->block_len_bits;
  389.  
  390.         s->fdsp->vector_fmul_add(out, in, s->windows[bsize],
  391.                                 out, block_len);
  392.     } else {
  393.         block_len = 1 << s->prev_block_len_bits;
  394.         n         = (s->block_len - block_len) / 2;
  395.         bsize     = s->frame_len_bits - s->prev_block_len_bits;
  396.  
  397.         s->fdsp->vector_fmul_add(out + n, in + n, s->windows[bsize],
  398.                                 out + n, block_len);
  399.  
  400.         memcpy(out + n + block_len, in + n + block_len, n * sizeof(float));
  401.     }
  402.  
  403.     out += s->block_len;
  404.     in  += s->block_len;
  405.  
  406.     /* right part */
  407.     if (s->block_len_bits <= s->next_block_len_bits) {
  408.         block_len = s->block_len;
  409.         bsize     = s->frame_len_bits - s->block_len_bits;
  410.  
  411.         s->fdsp->vector_fmul_reverse(out, in, s->windows[bsize], block_len);
  412.     } else {
  413.         block_len = 1 << s->next_block_len_bits;
  414.         n         = (s->block_len - block_len) / 2;
  415.         bsize     = s->frame_len_bits - s->next_block_len_bits;
  416.  
  417.         memcpy(out, in, n * sizeof(float));
  418.  
  419.         s->fdsp->vector_fmul_reverse(out + n, in + n, s->windows[bsize],
  420.                                     block_len);
  421.  
  422.         memset(out + n + block_len, 0, n * sizeof(float));
  423.     }
  424. }
  425.  
  426. /**
  427.  * @return 0 if OK. 1 if last block of frame. return -1 if
  428.  * unrecorrable error.
  429.  */
  430. static int wma_decode_block(WMACodecContext *s)
  431. {
  432.     int n, v, a, ch, bsize;
  433.     int coef_nb_bits, total_gain;
  434.     int nb_coefs[MAX_CHANNELS];
  435.     float mdct_norm;
  436.     FFTContext *mdct;
  437.  
  438. #ifdef TRACE
  439.     ff_tlog(s->avctx, "***decode_block: %d:%d\n",
  440.             s->frame_count - 1, s->block_num);
  441. #endif /* TRACE */
  442.  
  443.     /* compute current block length */
  444.     if (s->use_variable_block_len) {
  445.         n = av_log2(s->nb_block_sizes - 1) + 1;
  446.  
  447.         if (s->reset_block_lengths) {
  448.             s->reset_block_lengths = 0;
  449.             v                      = get_bits(&s->gb, n);
  450.             if (v >= s->nb_block_sizes) {
  451.                 av_log(s->avctx, AV_LOG_ERROR,
  452.                        "prev_block_len_bits %d out of range\n",
  453.                        s->frame_len_bits - v);
  454.                 return -1;
  455.             }
  456.             s->prev_block_len_bits = s->frame_len_bits - v;
  457.             v                      = get_bits(&s->gb, n);
  458.             if (v >= s->nb_block_sizes) {
  459.                 av_log(s->avctx, AV_LOG_ERROR,
  460.                        "block_len_bits %d out of range\n",
  461.                        s->frame_len_bits - v);
  462.                 return -1;
  463.             }
  464.             s->block_len_bits = s->frame_len_bits - v;
  465.         } else {
  466.             /* update block lengths */
  467.             s->prev_block_len_bits = s->block_len_bits;
  468.             s->block_len_bits      = s->next_block_len_bits;
  469.         }
  470.         v = get_bits(&s->gb, n);
  471.         if (v >= s->nb_block_sizes) {
  472.             av_log(s->avctx, AV_LOG_ERROR,
  473.                    "next_block_len_bits %d out of range\n",
  474.                    s->frame_len_bits - v);
  475.             return -1;
  476.         }
  477.         s->next_block_len_bits = s->frame_len_bits - v;
  478.     } else {
  479.         /* fixed block len */
  480.         s->next_block_len_bits = s->frame_len_bits;
  481.         s->prev_block_len_bits = s->frame_len_bits;
  482.         s->block_len_bits      = s->frame_len_bits;
  483.     }
  484.  
  485.     if (s->frame_len_bits - s->block_len_bits >= s->nb_block_sizes){
  486.         av_log(s->avctx, AV_LOG_ERROR, "block_len_bits not initialized to a valid value\n");
  487.         return -1;
  488.     }
  489.  
  490.     /* now check if the block length is coherent with the frame length */
  491.     s->block_len = 1 << s->block_len_bits;
  492.     if ((s->block_pos + s->block_len) > s->frame_len) {
  493.         av_log(s->avctx, AV_LOG_ERROR, "frame_len overflow\n");
  494.         return -1;
  495.     }
  496.  
  497.     if (s->avctx->channels == 2)
  498.         s->ms_stereo = get_bits1(&s->gb);
  499.     v = 0;
  500.     for (ch = 0; ch < s->avctx->channels; ch++) {
  501.         a                    = get_bits1(&s->gb);
  502.         s->channel_coded[ch] = a;
  503.         v                   |= a;
  504.     }
  505.  
  506.     bsize = s->frame_len_bits - s->block_len_bits;
  507.  
  508.     /* if no channel coded, no need to go further */
  509.     /* XXX: fix potential framing problems */
  510.     if (!v)
  511.         goto next;
  512.  
  513.     /* read total gain and extract corresponding number of bits for
  514.      * coef escape coding */
  515.     total_gain = 1;
  516.     for (;;) {
  517.         if (get_bits_left(&s->gb) < 7) {
  518.             av_log(s->avctx, AV_LOG_ERROR, "total_gain overread\n");
  519.             return AVERROR_INVALIDDATA;
  520.         }
  521.         a           = get_bits(&s->gb, 7);
  522.         total_gain += a;
  523.         if (a != 127)
  524.             break;
  525.     }
  526.  
  527.     coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
  528.  
  529.     /* compute number of coefficients */
  530.     n = s->coefs_end[bsize] - s->coefs_start;
  531.     for (ch = 0; ch < s->avctx->channels; ch++)
  532.         nb_coefs[ch] = n;
  533.  
  534.     /* complex coding */
  535.     if (s->use_noise_coding) {
  536.         for (ch = 0; ch < s->avctx->channels; ch++) {
  537.             if (s->channel_coded[ch]) {
  538.                 int i, n, a;
  539.                 n = s->exponent_high_sizes[bsize];
  540.                 for (i = 0; i < n; i++) {
  541.                     a                         = get_bits1(&s->gb);
  542.                     s->high_band_coded[ch][i] = a;
  543.                     /* if noise coding, the coefficients are not transmitted */
  544.                     if (a)
  545.                         nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
  546.                 }
  547.             }
  548.         }
  549.         for (ch = 0; ch < s->avctx->channels; ch++) {
  550.             if (s->channel_coded[ch]) {
  551.                 int i, n, val, code;
  552.  
  553.                 n   = s->exponent_high_sizes[bsize];
  554.                 val = (int) 0x80000000;
  555.                 for (i = 0; i < n; i++) {
  556.                     if (s->high_band_coded[ch][i]) {
  557.                         if (val == (int) 0x80000000) {
  558.                             val = get_bits(&s->gb, 7) - 19;
  559.                         } else {
  560.                             code = get_vlc2(&s->gb, s->hgain_vlc.table,
  561.                                             HGAINVLCBITS, HGAINMAX);
  562.                             if (code < 0) {
  563.                                 av_log(s->avctx, AV_LOG_ERROR,
  564.                                        "hgain vlc invalid\n");
  565.                                 return -1;
  566.                             }
  567.                             val += code - 18;
  568.                         }
  569.                         s->high_band_values[ch][i] = val;
  570.                     }
  571.                 }
  572.             }
  573.         }
  574.     }
  575.  
  576.     /* exponents can be reused in short blocks. */
  577.     if ((s->block_len_bits == s->frame_len_bits) || get_bits1(&s->gb)) {
  578.         for (ch = 0; ch < s->avctx->channels; ch++) {
  579.             if (s->channel_coded[ch]) {
  580.                 if (s->use_exp_vlc) {
  581.                     if (decode_exp_vlc(s, ch) < 0)
  582.                         return -1;
  583.                 } else {
  584.                     decode_exp_lsp(s, ch);
  585.                 }
  586.                 s->exponents_bsize[ch] = bsize;
  587.             }
  588.         }
  589.     }
  590.  
  591.     /* parse spectral coefficients : just RLE encoding */
  592.     for (ch = 0; ch < s->avctx->channels; ch++) {
  593.         if (s->channel_coded[ch]) {
  594.             int tindex;
  595.             WMACoef *ptr = &s->coefs1[ch][0];
  596.  
  597.             /* special VLC tables are used for ms stereo because
  598.              * there is potentially less energy there */
  599.             tindex = (ch == 1 && s->ms_stereo);
  600.             memset(ptr, 0, s->block_len * sizeof(WMACoef));
  601.             ff_wma_run_level_decode(s->avctx, &s->gb, &s->coef_vlc[tindex],
  602.                                     s->level_table[tindex], s->run_table[tindex],
  603.                                     0, ptr, 0, nb_coefs[ch],
  604.                                     s->block_len, s->frame_len_bits, coef_nb_bits);
  605.         }
  606.         if (s->version == 1 && s->avctx->channels >= 2)
  607.             align_get_bits(&s->gb);
  608.     }
  609.  
  610.     /* normalize */
  611.     {
  612.         int n4 = s->block_len / 2;
  613.         mdct_norm = 1.0 / (float) n4;
  614.         if (s->version == 1)
  615.             mdct_norm *= sqrt(n4);
  616.     }
  617.  
  618.     /* finally compute the MDCT coefficients */
  619.     for (ch = 0; ch < s->avctx->channels; ch++) {
  620.         if (s->channel_coded[ch]) {
  621.             WMACoef *coefs1;
  622.             float *coefs, *exponents, mult, mult1, noise;
  623.             int i, j, n, n1, last_high_band, esize;
  624.             float exp_power[HIGH_BAND_MAX_SIZE];
  625.  
  626.             coefs1    = s->coefs1[ch];
  627.             exponents = s->exponents[ch];
  628.             esize     = s->exponents_bsize[ch];
  629.             mult      = pow(10, total_gain * 0.05) / s->max_exponent[ch];
  630.             mult     *= mdct_norm;
  631.             coefs     = s->coefs[ch];
  632.             if (s->use_noise_coding) {
  633.                 mult1 = mult;
  634.                 /* very low freqs : noise */
  635.                 for (i = 0; i < s->coefs_start; i++) {
  636.                     *coefs++ = s->noise_table[s->noise_index] *
  637.                                exponents[i << bsize >> esize] * mult1;
  638.                     s->noise_index = (s->noise_index + 1) &
  639.                                      (NOISE_TAB_SIZE - 1);
  640.                 }
  641.  
  642.                 n1 = s->exponent_high_sizes[bsize];
  643.  
  644.                 /* compute power of high bands */
  645.                 exponents = s->exponents[ch] +
  646.                             (s->high_band_start[bsize] << bsize >> esize);
  647.                 last_high_band = 0; /* avoid warning */
  648.                 for (j = 0; j < n1; j++) {
  649.                     n = s->exponent_high_bands[s->frame_len_bits -
  650.                                                s->block_len_bits][j];
  651.                     if (s->high_band_coded[ch][j]) {
  652.                         float e2, v;
  653.                         e2 = 0;
  654.                         for (i = 0; i < n; i++) {
  655.                             v   = exponents[i << bsize >> esize];
  656.                             e2 += v * v;
  657.                         }
  658.                         exp_power[j]   = e2 / n;
  659.                         last_high_band = j;
  660.                         ff_tlog(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);
  661.                     }
  662.                     exponents += n << bsize >> esize;
  663.                 }
  664.  
  665.                 /* main freqs and high freqs */
  666.                 exponents = s->exponents[ch] + (s->coefs_start << bsize >> esize);
  667.                 for (j = -1; j < n1; j++) {
  668.                     if (j < 0)
  669.                         n = s->high_band_start[bsize] - s->coefs_start;
  670.                     else
  671.                         n = s->exponent_high_bands[s->frame_len_bits -
  672.                                                    s->block_len_bits][j];
  673.                     if (j >= 0 && s->high_band_coded[ch][j]) {
  674.                         /* use noise with specified power */
  675.                         mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
  676.                         /* XXX: use a table */
  677.                         mult1  = mult1 * pow(10, s->high_band_values[ch][j] * 0.05);
  678.                         mult1  = mult1 / (s->max_exponent[ch] * s->noise_mult);
  679.                         mult1 *= mdct_norm;
  680.                         for (i = 0; i < n; i++) {
  681.                             noise          = s->noise_table[s->noise_index];
  682.                             s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
  683.                             *coefs++       = noise * exponents[i << bsize >> esize] * mult1;
  684.                         }
  685.                         exponents += n << bsize >> esize;
  686.                     } else {
  687.                         /* coded values + small noise */
  688.                         for (i = 0; i < n; i++) {
  689.                             noise          = s->noise_table[s->noise_index];
  690.                             s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
  691.                             *coefs++       = ((*coefs1++) + noise) *
  692.                                              exponents[i << bsize >> esize] * mult;
  693.                         }
  694.                         exponents += n << bsize >> esize;
  695.                     }
  696.                 }
  697.  
  698.                 /* very high freqs : noise */
  699.                 n     = s->block_len - s->coefs_end[bsize];
  700.                 mult1 = mult * exponents[(-(1 << bsize)) >> esize];
  701.                 for (i = 0; i < n; i++) {
  702.                     *coefs++       = s->noise_table[s->noise_index] * mult1;
  703.                     s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
  704.                 }
  705.             } else {
  706.                 /* XXX: optimize more */
  707.                 for (i = 0; i < s->coefs_start; i++)
  708.                     *coefs++ = 0.0;
  709.                 n = nb_coefs[ch];
  710.                 for (i = 0; i < n; i++)
  711.                     *coefs++ = coefs1[i] * exponents[i << bsize >> esize] * mult;
  712.                 n = s->block_len - s->coefs_end[bsize];
  713.                 for (i = 0; i < n; i++)
  714.                     *coefs++ = 0.0;
  715.             }
  716.         }
  717.     }
  718.  
  719. #ifdef TRACE
  720.     for (ch = 0; ch < s->avctx->channels; ch++) {
  721.         if (s->channel_coded[ch]) {
  722.             dump_floats(s, "exponents", 3, s->exponents[ch], s->block_len);
  723.             dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len);
  724.         }
  725.     }
  726. #endif /* TRACE */
  727.  
  728.     if (s->ms_stereo && s->channel_coded[1]) {
  729.         /* nominal case for ms stereo: we do it before mdct */
  730.         /* no need to optimize this case because it should almost
  731.          * never happen */
  732.         if (!s->channel_coded[0]) {
  733.             ff_tlog(s->avctx, "rare ms-stereo case happened\n");
  734.             memset(s->coefs[0], 0, sizeof(float) * s->block_len);
  735.             s->channel_coded[0] = 1;
  736.         }
  737.  
  738.         s->fdsp->butterflies_float(s->coefs[0], s->coefs[1], s->block_len);
  739.     }
  740.  
  741. next:
  742.     mdct = &s->mdct_ctx[bsize];
  743.  
  744.     for (ch = 0; ch < s->avctx->channels; ch++) {
  745.         int n4, index;
  746.  
  747.         n4 = s->block_len / 2;
  748.         if (s->channel_coded[ch])
  749.             mdct->imdct_calc(mdct, s->output, s->coefs[ch]);
  750.         else if (!(s->ms_stereo && ch == 1))
  751.             memset(s->output, 0, sizeof(s->output));
  752.  
  753.         /* multiply by the window and add in the frame */
  754.         index = (s->frame_len / 2) + s->block_pos - n4;
  755.         wma_window(s, &s->frame_out[ch][index]);
  756.     }
  757.  
  758.     /* update block number */
  759.     s->block_num++;
  760.     s->block_pos += s->block_len;
  761.     if (s->block_pos >= s->frame_len)
  762.         return 1;
  763.     else
  764.         return 0;
  765. }
  766.  
  767. /* decode a frame of frame_len samples */
  768. static int wma_decode_frame(WMACodecContext *s, float **samples,
  769.                             int samples_offset)
  770. {
  771.     int ret, ch;
  772.  
  773. #ifdef TRACE
  774.     ff_tlog(s->avctx, "***decode_frame: %d size=%d\n",
  775.             s->frame_count++, s->frame_len);
  776. #endif /* TRACE */
  777.  
  778.     /* read each block */
  779.     s->block_num = 0;
  780.     s->block_pos = 0;
  781.     for (;;) {
  782.         ret = wma_decode_block(s);
  783.         if (ret < 0)
  784.             return -1;
  785.         if (ret)
  786.             break;
  787.     }
  788.  
  789.     for (ch = 0; ch < s->avctx->channels; ch++) {
  790.         /* copy current block to output */
  791.         memcpy(samples[ch] + samples_offset, s->frame_out[ch],
  792.                s->frame_len * sizeof(*s->frame_out[ch]));
  793.         /* prepare for next block */
  794.         memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
  795.                 s->frame_len * sizeof(*s->frame_out[ch]));
  796.  
  797. #ifdef TRACE
  798.         dump_floats(s, "samples", 6, samples[ch] + samples_offset,
  799.                     s->frame_len);
  800. #endif /* TRACE */
  801.     }
  802.  
  803.     return 0;
  804. }
  805.  
  806. static int wma_decode_superframe(AVCodecContext *avctx, void *data,
  807.                                  int *got_frame_ptr, AVPacket *avpkt)
  808. {
  809.     AVFrame *frame = data;
  810.     const uint8_t *buf = avpkt->data;
  811.     int buf_size       = avpkt->size;
  812.     WMACodecContext *s = avctx->priv_data;
  813.     int nb_frames, bit_offset, i, pos, len, ret;
  814.     uint8_t *q;
  815.     float **samples;
  816.     int samples_offset;
  817.  
  818.     ff_tlog(avctx, "***decode_superframe:\n");
  819.  
  820.     if (buf_size == 0) {
  821.         s->last_superframe_len = 0;
  822.         return 0;
  823.     }
  824.     if (buf_size < avctx->block_align) {
  825.         av_log(avctx, AV_LOG_ERROR,
  826.                "Input packet size too small (%d < %d)\n",
  827.                buf_size, avctx->block_align);
  828.         return AVERROR_INVALIDDATA;
  829.     }
  830.     if (avctx->block_align)
  831.         buf_size = avctx->block_align;
  832.  
  833.     init_get_bits(&s->gb, buf, buf_size * 8);
  834.  
  835.     if (s->use_bit_reservoir) {
  836.         /* read super frame header */
  837.         skip_bits(&s->gb, 4); /* super frame index */
  838.         nb_frames = get_bits(&s->gb, 4) - (s->last_superframe_len <= 0);
  839.         if (nb_frames <= 0) {
  840.             int is_error = nb_frames < 0 || get_bits_left(&s->gb) <= 8;
  841.             av_log(avctx, is_error ? AV_LOG_ERROR : AV_LOG_WARNING,
  842.                    "nb_frames is %d bits left %d\n",
  843.                    nb_frames, get_bits_left(&s->gb));
  844.             if (is_error)
  845.                 return AVERROR_INVALIDDATA;
  846.  
  847.             if ((s->last_superframe_len + buf_size - 1) >
  848.                 MAX_CODED_SUPERFRAME_SIZE)
  849.                 goto fail;
  850.  
  851.             q   = s->last_superframe + s->last_superframe_len;
  852.             len = buf_size - 1;
  853.             while (len > 0) {
  854.                 *q++ = get_bits (&s->gb, 8);
  855.                 len --;
  856.             }
  857.             memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
  858.  
  859.             s->last_superframe_len += 8*buf_size - 8;
  860. //             s->reset_block_lengths = 1; //XXX is this needed ?
  861.             *got_frame_ptr = 0;
  862.             return buf_size;
  863.         }
  864.     } else
  865.         nb_frames = 1;
  866.  
  867.     /* get output buffer */
  868.     frame->nb_samples = nb_frames * s->frame_len;
  869.     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
  870.         return ret;
  871.     samples        = (float **) frame->extended_data;
  872.     samples_offset = 0;
  873.  
  874.     if (s->use_bit_reservoir) {
  875.         bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
  876.         if (bit_offset > get_bits_left(&s->gb)) {
  877.             av_log(avctx, AV_LOG_ERROR,
  878.                    "Invalid last frame bit offset %d > buf size %d (%d)\n",
  879.                    bit_offset, get_bits_left(&s->gb), buf_size);
  880.             goto fail;
  881.         }
  882.  
  883.         if (s->last_superframe_len > 0) {
  884.             /* add bit_offset bits to last frame */
  885.             if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
  886.                 MAX_CODED_SUPERFRAME_SIZE)
  887.                 goto fail;
  888.             q   = s->last_superframe + s->last_superframe_len;
  889.             len = bit_offset;
  890.             while (len > 7) {
  891.                 *q++ = (get_bits) (&s->gb, 8);
  892.                 len -= 8;
  893.             }
  894.             if (len > 0)
  895.                 *q++ = (get_bits) (&s->gb, len) << (8 - len);
  896.             memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
  897.  
  898.             /* XXX: bit_offset bits into last frame */
  899.             init_get_bits(&s->gb, s->last_superframe,
  900.                           s->last_superframe_len * 8 + bit_offset);
  901.             /* skip unused bits */
  902.             if (s->last_bitoffset > 0)
  903.                 skip_bits(&s->gb, s->last_bitoffset);
  904.             /* this frame is stored in the last superframe and in the
  905.              * current one */
  906.             if (wma_decode_frame(s, samples, samples_offset) < 0)
  907.                 goto fail;
  908.             samples_offset += s->frame_len;
  909.             nb_frames--;
  910.         }
  911.  
  912.         /* read each frame starting from bit_offset */
  913.         pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
  914.         if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8 || pos > buf_size * 8)
  915.             return AVERROR_INVALIDDATA;
  916.         init_get_bits(&s->gb, buf + (pos >> 3), (buf_size - (pos >> 3)) * 8);
  917.         len = pos & 7;
  918.         if (len > 0)
  919.             skip_bits(&s->gb, len);
  920.  
  921.         s->reset_block_lengths = 1;
  922.         for (i = 0; i < nb_frames; i++) {
  923.             if (wma_decode_frame(s, samples, samples_offset) < 0)
  924.                 goto fail;
  925.             samples_offset += s->frame_len;
  926.         }
  927.  
  928.         /* we copy the end of the frame in the last frame buffer */
  929.         pos               = get_bits_count(&s->gb) +
  930.                             ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
  931.         s->last_bitoffset = pos & 7;
  932.         pos             >>= 3;
  933.         len               = buf_size - pos;
  934.         if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
  935.             av_log(s->avctx, AV_LOG_ERROR, "len %d invalid\n", len);
  936.             goto fail;
  937.         }
  938.         s->last_superframe_len = len;
  939.         memcpy(s->last_superframe, buf + pos, len);
  940.     } else {
  941.         /* single frame decode */
  942.         if (wma_decode_frame(s, samples, samples_offset) < 0)
  943.             goto fail;
  944.         samples_offset += s->frame_len;
  945.     }
  946.  
  947.     ff_dlog(s->avctx, "%d %d %d %d outbytes:%"PTRDIFF_SPECIFIER" eaten:%d\n",
  948.             s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len,
  949.             (int8_t *) samples - (int8_t *) data, avctx->block_align);
  950.  
  951.     *got_frame_ptr = 1;
  952.  
  953.     return buf_size;
  954.  
  955. fail:
  956.     /* when error, we reset the bit reservoir */
  957.     s->last_superframe_len = 0;
  958.     return -1;
  959. }
  960.  
  961. static av_cold void flush(AVCodecContext *avctx)
  962. {
  963.     WMACodecContext *s = avctx->priv_data;
  964.  
  965.     s->last_bitoffset      =
  966.     s->last_superframe_len = 0;
  967. }
  968.  
  969. #if CONFIG_WMAV1_DECODER
  970. AVCodec ff_wmav1_decoder = {
  971.     .name           = "wmav1",
  972.     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
  973.     .type           = AVMEDIA_TYPE_AUDIO,
  974.     .id             = AV_CODEC_ID_WMAV1,
  975.     .priv_data_size = sizeof(WMACodecContext),
  976.     .init           = wma_decode_init,
  977.     .close          = ff_wma_end,
  978.     .decode         = wma_decode_superframe,
  979.     .flush          = flush,
  980.     .capabilities   = AV_CODEC_CAP_DR1,
  981.     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
  982.                                                       AV_SAMPLE_FMT_NONE },
  983. };
  984. #endif
  985. #if CONFIG_WMAV2_DECODER
  986. AVCodec ff_wmav2_decoder = {
  987.     .name           = "wmav2",
  988.     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
  989.     .type           = AVMEDIA_TYPE_AUDIO,
  990.     .id             = AV_CODEC_ID_WMAV2,
  991.     .priv_data_size = sizeof(WMACodecContext),
  992.     .init           = wma_decode_init,
  993.     .close          = ff_wma_end,
  994.     .decode         = wma_decode_superframe,
  995.     .flush          = flush,
  996.     .capabilities   = AV_CODEC_CAP_DR1,
  997.     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
  998.                                                       AV_SAMPLE_FMT_NONE },
  999. };
  1000. #endif
  1001.