compute_mdct_coefficients(): Kill pointless cast.
[paraslash.git] / wmadec_filter.c
index d574df3..f8ea4c8 100644 (file)
@@ -131,16 +131,17 @@ struct private_wmadec_data {
 #define VLCBITS 9
 #define VLCMAX ((22 + VLCBITS - 1) / VLCBITS)
 
-DECLARE_ALIGNED(16, float, ff_sine_128[128]);
-DECLARE_ALIGNED(16, float, ff_sine_256[256]);
-DECLARE_ALIGNED(16, float, ff_sine_512[512]);
-DECLARE_ALIGNED(16, float, ff_sine_1024[1024]);
-DECLARE_ALIGNED(16, float, ff_sine_2048[2048]);
-DECLARE_ALIGNED(16, float, ff_sine_4096[4096]);
-
-static float *ff_sine_windows[6] = {
-       ff_sine_128, ff_sine_256, ff_sine_512, ff_sine_1024,
-       ff_sine_2048, ff_sine_4096
+#define SINE_WINDOW(x) float sine_ ## x[x] __aligned(16)
+
+SINE_WINDOW(128);
+SINE_WINDOW(256);
+SINE_WINDOW(512);
+SINE_WINDOW(1024);
+SINE_WINDOW(2048);
+SINE_WINDOW(4096);
+
+static float *sine_windows[6] = {
+       sine_128, sine_256, sine_512, sine_1024, sine_2048, sine_4096
 };
 
 /* Generate a sine window. */
@@ -383,8 +384,8 @@ static int wma_init(struct private_wmadec_data *pwd)
        for (i = 0; i < pwd->nb_block_sizes; i++) {
                int n;
                n = 1 << (pwd->frame_len_bits - i);
-               sine_window_init(ff_sine_windows[pwd->frame_len_bits - i - 7], n);
-               pwd->windows[i] = ff_sine_windows[pwd->frame_len_bits - i - 7];
+               sine_window_init(sine_windows[pwd->frame_len_bits - i - 7], n);
+               pwd->windows[i] = sine_windows[pwd->frame_len_bits - i - 7];
        }
 
        pwd->reset_block_lengths = 1;
@@ -481,15 +482,15 @@ static int wma_decode_init(char *initial_buf, int len, struct private_wmadec_dat
        if (pwd->use_noise_coding) {
                PARA_INFO_LOG("using noise coding\n");
                init_vlc(&pwd->hgain_vlc, HGAINVLCBITS,
-                       sizeof(ff_wma_hgain_huffbits), ff_wma_hgain_huffbits,
-                       ff_wma_hgain_huffcodes, 2);
+                       sizeof(wma_hgain_huffbits), wma_hgain_huffbits,
+                       wma_hgain_huffcodes, 2);
        }
 
        if (pwd->use_exp_vlc) {
                PARA_INFO_LOG("using exp_vlc\n");
                init_vlc(&pwd->exp_vlc, EXPVLCBITS,
-               sizeof(ff_wma_scale_huffbits), ff_wma_scale_huffbits,
-               ff_wma_scale_huffcodes, 4);
+               sizeof(wma_scale_huffbits), wma_scale_huffbits,
+               wma_scale_huffcodes, 4);
        } else {
                PARA_INFO_LOG("using curve\n");
                wma_lsp_to_curve_init(pwd, pwd->frame_len);
@@ -560,7 +561,7 @@ static void decode_exp_lsp(struct private_wmadec_data *pwd, int ch)
                        val = get_bits(&pwd->gb, 3);
                else
                        val = get_bits(&pwd->gb, 4);
-               lsp_coefs[i] = ff_wma_lsp_codebook[i][val];
+               lsp_coefs[i] = wma_lsp_codebook[i][val];
        }
 
        wma_lsp_to_curve(pwd, pwd->exponents[ch], &pwd->max_exponent[ch],
@@ -677,211 +678,62 @@ static int wma_total_gain_to_bits(int total_gain)
                return 9;
 }
 
-/**
- * @return 0 if OK. 1 if last block of frame. return -1 if
- * unrecorrable error.
- */
-static int wma_decode_block(struct private_wmadec_data *pwd)
+static int compute_high_band_values(struct private_wmadec_data *pwd,
+               int bsize, int nb_coefs[MAX_CHANNELS])
 {
-       int n, v, ch, code, bsize;
-       int coef_nb_bits, total_gain;
-       int nb_coefs[MAX_CHANNELS];
-       float mdct_norm;
-
-       /* compute current block length */
-       if (pwd->use_variable_block_len) {
-               n = wma_log2(pwd->nb_block_sizes - 1) + 1;
-
-               if (pwd->reset_block_lengths) {
-                       pwd->reset_block_lengths = 0;
-                       v = get_bits(&pwd->gb, n);
-                       if (v >= pwd->nb_block_sizes)
-                               return -1;
-                       pwd->prev_block_len_bits = pwd->frame_len_bits - v;
-                       v = get_bits(&pwd->gb, n);
-                       if (v >= pwd->nb_block_sizes)
-                               return -1;
-                       pwd->block_len_bits = pwd->frame_len_bits - v;
-               } else {
-                       /* update block lengths */
-                       pwd->prev_block_len_bits = pwd->block_len_bits;
-                       pwd->block_len_bits = pwd->next_block_len_bits;
-               }
-               v = get_bits(&pwd->gb, n);
-               if (v >= pwd->nb_block_sizes)
-                       return -1;
-               pwd->next_block_len_bits = pwd->frame_len_bits - v;
-       } else {
-               /* fixed block len */
-               pwd->next_block_len_bits = pwd->frame_len_bits;
-               pwd->prev_block_len_bits = pwd->frame_len_bits;
-               pwd->block_len_bits = pwd->frame_len_bits;
-       }
-
-       /* now check if the block length is coherent with the frame length */
-       pwd->block_len = 1 << pwd->block_len_bits;
-       if ((pwd->block_pos + pwd->block_len) > pwd->frame_len)
-               return -E_INCOHERENT_BLOCK_LEN;
+       int ch;
 
-       if (pwd->ahi.channels == 2)
-               pwd->ms_stereo = get_bit(&pwd->gb);
-       v = 0;
+       if (!pwd->use_noise_coding)
+               return 0;
        for (ch = 0; ch < pwd->ahi.channels; ch++) {
-               int a = get_bit(&pwd->gb);
-               pwd->channel_coded[ch] = a;
-               v |= a;
-       }
-
-       bsize = pwd->frame_len_bits - pwd->block_len_bits;
-
-       /* if no channel coded, no need to go further */
-       /* XXX: fix potential framing problems */
-       if (!v)
-               goto next;
-
-       /* read total gain and extract corresponding number of bits for
-          coef escape coding */
-       total_gain = 1;
-       for (;;) {
-               int a = get_bits(&pwd->gb, 7);
-               total_gain += a;
-               if (a != 127)
-                       break;
-       }
-
-       coef_nb_bits = wma_total_gain_to_bits(total_gain);
-
-       /* compute number of coefficients */
-       n = pwd->coefs_end[bsize] - pwd->coefs_start;
-       for (ch = 0; ch < pwd->ahi.channels; ch++)
-               nb_coefs[ch] = n;
-
-       /* complex coding */
-       if (pwd->use_noise_coding) {
-               for (ch = 0; ch < pwd->ahi.channels; ch++) {
-                       if (pwd->channel_coded[ch]) {
-                               int i, m, a;
-                               m = pwd->exponent_high_sizes[bsize];
-                               for (i = 0; i < m; i++) {
-                                       a = get_bit(&pwd->gb);
-                                       pwd->high_band_coded[ch][i] = a;
-                                       /* if noise coding, the coefficients are not transmitted */
-                                       if (a)
-                                               nb_coefs[ch] -=
-                                                   pwd->
-                                                   exponent_high_bands[bsize]
-                                                   [i];
-                               }
-                       }
-               }
-               for (ch = 0; ch < pwd->ahi.channels; ch++) {
-                       if (pwd->channel_coded[ch]) {
-                               int i, val;
-
-                               n = pwd->exponent_high_sizes[bsize];
-                               val = (int) 0x80000000;
-                               for (i = 0; i < n; i++) {
-                                       if (pwd->high_band_coded[ch][i]) {
-                                               if (val == (int) 0x80000000) {
-                                                       val =
-                                                           get_bits(&pwd->gb,
-                                                                    7) - 19;
-                                               } else {
-                                                       code =
-                                                           get_vlc(&pwd->gb,
-                                                                    pwd->
-                                                                    hgain_vlc.
-                                                                    table,
-                                                                    HGAINVLCBITS,
-                                                                    HGAINMAX);
-                                                       if (code < 0)
-                                                               return -1;
-                                                       val += code - 18;
-                                               }
-                                               pwd->high_band_values[ch][i] =
-                                                   val;
-                                       }
-                               }
-                       }
-               }
-       }
-
-       /* exponents can be reused in short blocks. */
-       if ((pwd->block_len_bits == pwd->frame_len_bits) || get_bit(&pwd->gb)) {
-               for (ch = 0; ch < pwd->ahi.channels; ch++) {
-                       if (pwd->channel_coded[ch]) {
-                               if (pwd->use_exp_vlc) {
-                                       if (decode_exp_vlc(pwd, ch) < 0)
-                                               return -1;
-                               } else {
-                                       decode_exp_lsp(pwd, ch);
-                               }
-                               pwd->exponents_bsize[ch] = bsize;
-                       }
+               int i, m, a;
+               if (!pwd->channel_coded[ch])
+                       continue;
+               m = pwd->exponent_high_sizes[bsize];
+               for (i = 0; i < m; i++) {
+                       a = get_bit(&pwd->gb);
+                       pwd->high_band_coded[ch][i] = a;
+                       if (!a)
+                               continue;
+                       nb_coefs[ch] -= pwd->exponent_high_bands[bsize][i];
                }
        }
-
-       /* parse spectral coefficients : just RLE encoding */
        for (ch = 0; ch < pwd->ahi.channels; ch++) {
-               struct vlc *coef_vlc;
-               int level, run, tindex;
-               int16_t *ptr, *eptr;
-               const uint16_t *level_table, *run_table;
-
+               int i, n, val;
                if (!pwd->channel_coded[ch])
                        continue;
-               /*
-                * special VLC tables are used for ms stereo because there is
-                * potentially less energy there
-                */
-               tindex = (ch == 1 && pwd->ms_stereo);
-               coef_vlc = &pwd->coef_vlc[tindex];
-               run_table = pwd->run_table[tindex];
-               level_table = pwd->level_table[tindex];
-               /* XXX: optimize */
-               ptr = &pwd->coefs1[ch][0];
-               eptr = ptr + nb_coefs[ch];
-               memset(ptr, 0, pwd->block_len * sizeof(int16_t));
-               for (;;) {
-                       code = get_vlc(&pwd->gb, coef_vlc->table,
-                               VLCBITS, VLCMAX);
-                       if (code < 0)
-                               return -1;
-                       if (code == 1) /* EOB */
-                               break;
-                       if (code == 0) { /* escape */
-                               level = get_bits(&pwd->gb, coef_nb_bits);
-                               /* reading block_len_bits would be better */
-                               run = get_bits(&pwd->gb, pwd->frame_len_bits);
-                       } else { /* normal code */
-                               run = run_table[code];
-                               level = level_table[code];
-                       }
-                       if (!get_bit(&pwd->gb))
-                               level = -level;
-                       ptr += run;
-                       if (ptr >= eptr) {
-                               PARA_ERROR_LOG("overflow in spectral RLE, ignoring\n");
-                               break;
+               n = pwd->exponent_high_sizes[bsize];
+               val = (int)0x80000000;
+               for (i = 0; i < n; i++) {
+                       if (!pwd->high_band_coded[ch][i])
+                               continue;
+                       if (val == (int)0x80000000)
+                               val = get_bits(&pwd->gb, 7) - 19;
+                       else {
+                               int code = get_vlc(&pwd->gb,
+                                       pwd->hgain_vlc.table, HGAINVLCBITS,
+                                       HGAINMAX);
+                               if (code < 0)
+                                       return -1;
+                               val += code - 18;
                        }
-                       *ptr++ = level;
-                       if (ptr >= eptr) /* EOB can be omitted */
-                               break;
+                       pwd->high_band_values[ch][i] = val;
                }
        }
+       return 1;
+}
 
-       /* normalize */
-       {
-               int n4 = pwd->block_len / 2;
-               mdct_norm = 1.0 / (float) n4;
-       }
+static void compute_mdct_coefficients(struct private_wmadec_data *pwd,
+               int bsize, int total_gain, int nb_coefs[MAX_CHANNELS])
+{
+       int ch;
+       float mdct_norm = 1.0 / (pwd->block_len / 2);
 
-       /* finally compute the MDCT coefficients */
        for (ch = 0; ch < pwd->ahi.channels; ch++) {
                if (pwd->channel_coded[ch]) {
                        int16_t *coefs1;
                        float *coefs, *exponents, mult, mult1, noise;
-                       int i, j, n1, last_high_band, esize;
+                       int i, j, n, n1, last_high_band, esize;
                        float exp_power[HIGH_BAND_MAX_SIZE];
 
                        coefs1 = pwd->coefs1[ch];
@@ -1030,6 +882,154 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                        }
                }
        }
+}
+
+/**
+ * @return 0 if OK. 1 if last block of frame. return -1 if
+ * unrecorrable error.
+ */
+static int wma_decode_block(struct private_wmadec_data *pwd)
+{
+       int n, v, ch, code, bsize;
+       int coef_nb_bits, total_gain;
+       int nb_coefs[MAX_CHANNELS];
+
+       /* compute current block length */
+       if (pwd->use_variable_block_len) {
+               n = wma_log2(pwd->nb_block_sizes - 1) + 1;
+
+               if (pwd->reset_block_lengths) {
+                       pwd->reset_block_lengths = 0;
+                       v = get_bits(&pwd->gb, n);
+                       if (v >= pwd->nb_block_sizes)
+                               return -1;
+                       pwd->prev_block_len_bits = pwd->frame_len_bits - v;
+                       v = get_bits(&pwd->gb, n);
+                       if (v >= pwd->nb_block_sizes)
+                               return -1;
+                       pwd->block_len_bits = pwd->frame_len_bits - v;
+               } else {
+                       /* update block lengths */
+                       pwd->prev_block_len_bits = pwd->block_len_bits;
+                       pwd->block_len_bits = pwd->next_block_len_bits;
+               }
+               v = get_bits(&pwd->gb, n);
+               if (v >= pwd->nb_block_sizes)
+                       return -1;
+               pwd->next_block_len_bits = pwd->frame_len_bits - v;
+       } else {
+               /* fixed block len */
+               pwd->next_block_len_bits = pwd->frame_len_bits;
+               pwd->prev_block_len_bits = pwd->frame_len_bits;
+               pwd->block_len_bits = pwd->frame_len_bits;
+       }
+
+       /* now check if the block length is coherent with the frame length */
+       pwd->block_len = 1 << pwd->block_len_bits;
+       if ((pwd->block_pos + pwd->block_len) > pwd->frame_len)
+               return -E_INCOHERENT_BLOCK_LEN;
+
+       if (pwd->ahi.channels == 2)
+               pwd->ms_stereo = get_bit(&pwd->gb);
+       v = 0;
+       for (ch = 0; ch < pwd->ahi.channels; ch++) {
+               int a = get_bit(&pwd->gb);
+               pwd->channel_coded[ch] = a;
+               v |= a;
+       }
+
+       bsize = pwd->frame_len_bits - pwd->block_len_bits;
+
+       /* if no channel coded, no need to go further */
+       /* XXX: fix potential framing problems */
+       if (!v)
+               goto next;
+
+       /* read total gain and extract corresponding number of bits for
+          coef escape coding */
+       total_gain = 1;
+       for (;;) {
+               int a = get_bits(&pwd->gb, 7);
+               total_gain += a;
+               if (a != 127)
+                       break;
+       }
+
+       coef_nb_bits = wma_total_gain_to_bits(total_gain);
+
+       /* compute number of coefficients */
+       n = pwd->coefs_end[bsize] - pwd->coefs_start;
+       for (ch = 0; ch < pwd->ahi.channels; ch++)
+               nb_coefs[ch] = n;
+
+       if (compute_high_band_values(pwd, bsize, nb_coefs) < 0)
+               return -1;
+
+       /* exponents can be reused in short blocks. */
+       if ((pwd->block_len_bits == pwd->frame_len_bits) || get_bit(&pwd->gb)) {
+               for (ch = 0; ch < pwd->ahi.channels; ch++) {
+                       if (pwd->channel_coded[ch]) {
+                               if (pwd->use_exp_vlc) {
+                                       if (decode_exp_vlc(pwd, ch) < 0)
+                                               return -1;
+                               } else {
+                                       decode_exp_lsp(pwd, ch);
+                               }
+                               pwd->exponents_bsize[ch] = bsize;
+                       }
+               }
+       }
+
+       /* parse spectral coefficients : just RLE encoding */
+       for (ch = 0; ch < pwd->ahi.channels; ch++) {
+               struct vlc *coef_vlc;
+               int level, run, tindex;
+               int16_t *ptr, *eptr;
+               const uint16_t *level_table, *run_table;
+
+               if (!pwd->channel_coded[ch])
+                       continue;
+               /*
+                * special VLC tables are used for ms stereo because there is
+                * potentially less energy there
+                */
+               tindex = (ch == 1 && pwd->ms_stereo);
+               coef_vlc = &pwd->coef_vlc[tindex];
+               run_table = pwd->run_table[tindex];
+               level_table = pwd->level_table[tindex];
+               /* XXX: optimize */
+               ptr = &pwd->coefs1[ch][0];
+               eptr = ptr + nb_coefs[ch];
+               memset(ptr, 0, pwd->block_len * sizeof(int16_t));
+               for (;;) {
+                       code = get_vlc(&pwd->gb, coef_vlc->table,
+                               VLCBITS, VLCMAX);
+                       if (code < 0)
+                               return -1;
+                       if (code == 1) /* EOB */
+                               break;
+                       if (code == 0) { /* escape */
+                               level = get_bits(&pwd->gb, coef_nb_bits);
+                               /* reading block_len_bits would be better */
+                               run = get_bits(&pwd->gb, pwd->frame_len_bits);
+                       } else { /* normal code */
+                               run = run_table[code];
+                               level = level_table[code];
+                       }
+                       if (!get_bit(&pwd->gb))
+                               level = -level;
+                       ptr += run;
+                       if (ptr >= eptr) {
+                               PARA_ERROR_LOG("overflow in spectral RLE, ignoring\n");
+                               break;
+                       }
+                       *ptr++ = level;
+                       if (ptr >= eptr) /* EOB can be omitted */
+                               break;
+               }
+       }
+
+       compute_mdct_coefficients(pwd, bsize, total_gain, nb_coefs);
 
        if (pwd->ms_stereo && pwd->channel_coded[1]) {
                float a, b;
@@ -1232,7 +1232,7 @@ static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
                samples += pwd->ahi.channels * pwd->frame_len;
        }
        PARA_DEBUG_LOG("frame_count: %d frame_len: %d, block_len: %d, "
-               "outbytes: %d, eaten: %d\n",
+               "outbytes: %zd, eaten: %d\n",
                frame_count, pwd->frame_len, pwd->block_len,
                (int8_t *) samples - (int8_t *) data, pwd->ahi.block_align);
        *data_size = (int8_t *)samples - (int8_t *)data;