Subversion Repositories Kolibri OS

Rev

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