NEWS update.
[paraslash.git] / wmadec_filter.c
index 7479e84..fdf3da9 100644 (file)
@@ -75,7 +75,6 @@ struct private_wmadec_data {
        uint16_t exponent_bands[BLOCK_NB_SIZES][25];
        /** The index of the first coef in high band. */
        int high_band_start[BLOCK_NB_SIZES];
-       int coefs_start;///< first coded coef
        int coefs_end[BLOCK_NB_SIZES];  ///< max number of coded coefficients
        int exponent_high_sizes[BLOCK_NB_SIZES];
        int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE];
@@ -93,7 +92,8 @@ struct private_wmadec_data {
        /* frame info */
        int frame_len;          ///< frame length in samples
        int frame_len_bits;     ///< frame_len = 1 << frame_len_bits
-       int nb_block_sizes;     ///< number of block sizes
+       /** Number of block sizes. */
+       int nb_block_sizes;
        /* block info */
        int reset_block_lengths;
        int block_len_bits;     ///< log2 of current block length
@@ -213,7 +213,6 @@ static void compute_scale_factor_band_sizes(struct private_wmadec_data *pwd,
        int a, b, pos, lpos, k, block_len, i, j, n;
        const uint8_t *table;
 
-       pwd->coefs_start = 0;
        for (k = 0; k < pwd->nb_block_sizes; k++) {
                block_len = pwd->frame_len >> k;
 
@@ -291,13 +290,12 @@ static int wma_init(struct private_wmadec_data *pwd)
                return -E_WMA_BAD_PARAMS;
 
        /* compute MDCT block size */
-       if (ahi->sample_rate <= 16000) {
+       if (ahi->sample_rate <= 16000)
                pwd->frame_len_bits = 9;
-       } else if (ahi->sample_rate <= 22050) {
+       else if (ahi->sample_rate <= 22050)
                pwd->frame_len_bits = 10;
-       } else {
+       else
                pwd->frame_len_bits = 11;
-       }
        pwd->frame_len = 1 << pwd->frame_len_bits;
        if (pwd->use_variable_block_len) {
                int nb_max, nb;
@@ -354,24 +352,22 @@ static int wma_init(struct private_wmadec_data *pwd)
                        high_freq = high_freq * 0.5;
                else
                        high_freq = high_freq * 0.3;
-       } else if (sample_rate1 == 11025) {
+       } else if (sample_rate1 == 11025)
                high_freq = high_freq * 0.7;
-       else if (sample_rate1 == 8000) {
-               if (bps <= 0.625) {
+       else if (sample_rate1 == 8000) {
+               if (bps <= 0.625)
                        high_freq = high_freq * 0.5;
-               } else if (bps > 0.75) {
+               else if (bps > 0.75)
                        pwd->use_noise_coding = 0;
-               } else {
+               else
                        high_freq = high_freq * 0.65;
-               }
        } else {
-               if (bps >= 0.8) {
+               if (bps >= 0.8)
                        high_freq = high_freq * 0.75;
-               } else if (bps >= 0.6) {
+               else if (bps >= 0.6)
                        high_freq = high_freq * 0.6;
-               } else {
+               else
                        high_freq = high_freq * 0.5;
-               }
        }
        PARA_INFO_LOG("channels=%d sample_rate=%d "
                "bitrate=%d block_align=%d\n",
@@ -590,7 +586,7 @@ static int decode_exp_vlc(struct private_wmadec_data *pwd, int ch)
        while (q < q_end) {
                code = get_vlc(&pwd->gb, pwd->exp_vlc.table, EXPVLCBITS, EXPMAX);
                if (code < 0)
-                       return -1;
+                       return code;
                /* NOTE: this offset is the same as MPEG4 AAC ! */
                last_exp += code - 60;
                /* XXX: use a table */
@@ -719,7 +715,7 @@ static int compute_high_band_values(struct private_wmadec_data *pwd,
                                        pwd->hgain_vlc.table, HGAINVLCBITS,
                                        HGAINMAX);
                                if (code < 0)
-                                       return -1;
+                                       return code;
                                val += code - 18;
                        }
                        pwd->high_band_values[ch][i] = val;
@@ -750,8 +746,6 @@ static void compute_mdct_coefficients(struct private_wmadec_data *pwd,
                coefs = pwd->coefs[ch];
                if (!pwd->use_noise_coding) {
                        /* XXX: optimize more */
-                       for (i = 0; i < pwd->coefs_start; i++)
-                               *coefs++ = 0.0;
                        n = nb_coefs[ch];
                        for (i = 0; i < n; i++)
                                *coefs++ = coefs1[i] *
@@ -762,13 +756,6 @@ static void compute_mdct_coefficients(struct private_wmadec_data *pwd,
                        continue;
                }
                mult1 = mult;
-               /* very low freqs: noise */
-               for (i = 0; i < pwd->coefs_start; i++) {
-                       *coefs++ = pwd->noise_table[pwd->noise_index] *
-                               exponents[i << bsize >> esize] * mult1;
-                       pwd->noise_index = (pwd->noise_index + 1) &
-                               (NOISE_TAB_SIZE - 1);
-               }
                n1 = pwd->exponent_high_sizes[bsize];
                /* compute power of high bands */
                exponents = pwd->exponents[ch] +
@@ -790,11 +777,10 @@ static void compute_mdct_coefficients(struct private_wmadec_data *pwd,
                        exponents += n << bsize;
                }
                /* main freqs and high freqs */
-               exponents = pwd->exponents[ch] + (pwd->coefs_start << bsize);
+               exponents = pwd->exponents[ch];
                for (j = -1; j < n1; j++) {
                        if (j < 0)
-                               n = pwd->high_band_start[bsize]
-                                       - pwd->coefs_start;
+                               n = pwd->high_band_start[bsize];
                        else
                                n = pwd->exponent_high_bands[pwd->frame_len_bits
                                        - pwd->block_len_bits][j];
@@ -840,12 +826,12 @@ static void compute_mdct_coefficients(struct private_wmadec_data *pwd,
 }
 
 /**
- * @return 0 if OK. 1 if last block of frame. return -1 if
- * unrecorrable error.
+ * Returns 0 if OK, 1 if last block of frame, negative on uncorrectable
+ * errors.
  */
 static int wma_decode_block(struct private_wmadec_data *pwd)
 {
-       int n, v, ch, code, bsize;
+       int ret, n, v, ch, code, bsize;
        int coef_nb_bits, total_gain;
        int nb_coefs[MAX_CHANNELS];
 
@@ -857,11 +843,11 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                        pwd->reset_block_lengths = 0;
                        v = get_bits(&pwd->gb, n);
                        if (v >= pwd->nb_block_sizes)
-                               return -1;
+                               return -E_WMA_BLOCK_SIZE;
                        pwd->prev_block_len_bits = pwd->frame_len_bits - v;
                        v = get_bits(&pwd->gb, n);
                        if (v >= pwd->nb_block_sizes)
-                               return -1;
+                               return -E_WMA_BLOCK_SIZE;
                        pwd->block_len_bits = pwd->frame_len_bits - v;
                } else {
                        /* update block lengths */
@@ -870,7 +856,7 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                }
                v = get_bits(&pwd->gb, n);
                if (v >= pwd->nb_block_sizes)
-                       return -1;
+                       return -E_WMA_BLOCK_SIZE;
                pwd->next_block_len_bits = pwd->frame_len_bits - v;
        } else {
                /* fixed block len */
@@ -915,23 +901,24 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
        coef_nb_bits = wma_total_gain_to_bits(total_gain);
 
        /* compute number of coefficients */
-       n = pwd->coefs_end[bsize] - pwd->coefs_start;
+       n = pwd->coefs_end[bsize];
        for (ch = 0; ch < pwd->ahi.channels; ch++)
                nb_coefs[ch] = n;
 
-       if (compute_high_band_values(pwd, bsize, nb_coefs) < 0)
-               return -1;
+       ret = compute_high_band_values(pwd, bsize, nb_coefs);
+       if (ret < 0)
+               return ret;
 
        /* 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 {
+                                       ret = decode_exp_vlc(pwd, ch);
+                                       if (ret < 0)
+                                               return ret;
+                               } else
                                        decode_exp_lsp(pwd, ch);
-                               }
                                pwd->exponents_bsize[ch] = bsize;
                        }
                }
@@ -962,7 +949,7 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                        code = get_vlc(&pwd->gb, coef_vlc->table,
                                VLCBITS, VLCMAX);
                        if (code < 0)
-                               return -1;
+                               return code;
                        if (code == 1) /* EOB */
                                break;
                        if (code == 0) { /* escape */
@@ -1058,7 +1045,7 @@ static int wma_decode_frame(struct private_wmadec_data *pwd, int16_t *samples)
        for (;;) {
                ret = wma_decode_block(pwd);
                if (ret < 0)
-                       return -1;
+                       return ret;
                if (ret)
                        break;
        }
@@ -1086,7 +1073,6 @@ static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
 {
        int ret;
        int16_t *samples;
-       static int frame_count;
 
        if (buf_size == 0) {
                pwd->last_superframe_len = 0;
@@ -1137,10 +1123,9 @@ static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
                         * This frame is stored in the last superframe and in
                         * the current one.
                         */
-                       ret = -E_WMA_DECODE;
-                       if (wma_decode_frame(pwd, samples) < 0)
+                       ret = wma_decode_frame(pwd, samples);
+                       if (ret < 0)
                                goto fail;
-                       frame_count++;
                        samples += pwd->ahi.channels * pwd->frame_len;
                }
 
@@ -1154,10 +1139,9 @@ static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
 
                pwd->reset_block_lengths = 1;
                for (i = 0; i < nb_frames; i++) {
-                       ret = -E_WMA_DECODE;
-                       if (wma_decode_frame(pwd, samples) < 0)
+                       ret = wma_decode_frame(pwd, samples);
+                       if (ret < 0)
                                goto fail;
-                       frame_count++;
                        samples += pwd->ahi.channels * pwd->frame_len;
                }
 
@@ -1178,15 +1162,13 @@ static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
                if (pwd->ahi.channels * pwd->frame_len * sizeof(int16_t) > *data_size)
                        goto fail;
                /* single frame decode */
-               ret = -E_WMA_DECODE;
-               if (wma_decode_frame(pwd, samples) < 0)
+               ret = wma_decode_frame(pwd, samples);
+               if (ret < 0)
                        goto fail;
-               frame_count++;
                samples += pwd->ahi.channels * pwd->frame_len;
        }
-       PARA_DEBUG_LOG("frame_count: %d frame_len: %d, block_len: %d, "
-               "outbytes: %zd, eaten: %d\n",
-               frame_count, pwd->frame_len, pwd->block_len,
+       PARA_DEBUG_LOG("frame_len: %d, block_len: %d, outbytes: %zd, eaten: %d\n",
+               pwd->frame_len, pwd->block_len,
                (int8_t *) samples - (int8_t *) data, pwd->ahi.block_align);
        *data_size = (int8_t *)samples - (int8_t *)data;
        return pwd->ahi.block_align;
@@ -1199,11 +1181,9 @@ fail:
 static ssize_t wmadec_convert(char *inbuffer, size_t len,
                struct filter_node *fn)
 {
-       int ret, out_size = fn->bufsize - fn->loaded;
+       int ret, converted = 0;
        struct private_wmadec_data *pwd = fn->private_data;
 
-       if (out_size < 128 * 1024)
-               return 0;
        if (len <= WMA_FRAME_SKIP)
                return 0;
        if (!pwd) {
@@ -1215,16 +1195,22 @@ static ssize_t wmadec_convert(char *inbuffer, size_t len,
                fn->fc->samplerate = pwd->ahi.sample_rate;
                return pwd->ahi.header_len;
        }
-       /* skip 31 bytes */
-       if (len <= WMA_FRAME_SKIP + pwd->ahi.block_align)
-               return 0;
-       ret = wma_decode_superframe(pwd, fn->buf + fn->loaded,
-               &out_size, (uint8_t *)inbuffer + WMA_FRAME_SKIP,
-               len - WMA_FRAME_SKIP);
-       if (ret < 0)
-               return ret;
-       fn->loaded += out_size;
-       return ret + WMA_FRAME_SKIP;
+       for (;;) {
+               int out_size;
+               if (converted + WMA_FRAME_SKIP + pwd->ahi.block_align > len)
+                       break;
+               out_size = fn->bufsize - fn->loaded;
+               if (out_size < 128 * 1024)
+                       break;
+               ret = wma_decode_superframe(pwd, fn->buf + fn->loaded,
+                       &out_size, (uint8_t *)inbuffer + converted + WMA_FRAME_SKIP,
+                       len - WMA_FRAME_SKIP);
+               if (ret < 0)
+                       return ret;
+               fn->loaded += out_size;
+               converted += ret + WMA_FRAME_SKIP;
+       }
+       return converted;
 }
 
 static void wmadec_close(struct filter_node *fn)