NEWS update.

[paraslash.git] / wmadec_filter.c

diff --git a/wmadec_filter.c b/wmadec_filter.c
index 802cb8256fa30f66698f765c4cdab004cd3abb8f..fdf3da91c44e8b7b5acd6920cbd8175c838ec30a 100644 (file)
--- a/wmadec_filter.c
+++ b/wmadec_filter.c
@@ -92,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
        /* 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
        /* block info */
        int reset_block_lengths;
        int block_len_bits;     ///< log2 of current block length


@@ -289,13 +290,12 @@ static int wma_init(struct private_wmadec_data *pwd)
                return -E_WMA_BAD_PARAMS;
 
        /* compute MDCT block size */
                return -E_WMA_BAD_PARAMS;
 
        /* compute MDCT block size */

-       if (ahi->sample_rate <= 16000) {
+       if (ahi->sample_rate <= 16000)

                pwd->frame_len_bits = 9;
                pwd->frame_len_bits = 9;

-       } else if (ahi->sample_rate <= 22050) {
+       else if (ahi->sample_rate <= 22050)

                pwd->frame_len_bits = 10;
                pwd->frame_len_bits = 10;

-       } else {
+       else

                pwd->frame_len_bits = 11;
                pwd->frame_len_bits = 11;

-       }

        pwd->frame_len = 1 << pwd->frame_len_bits;
        if (pwd->use_variable_block_len) {
                int nb_max, nb;
        pwd->frame_len = 1 << pwd->frame_len_bits;
        if (pwd->use_variable_block_len) {
                int nb_max, nb;


@@ -352,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;
                        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;
                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;
                        high_freq = high_freq * 0.5;

-               } else if (bps > 0.75) {
+               else if (bps > 0.75)

                        pwd->use_noise_coding = 0;
                        pwd->use_noise_coding = 0;

-               } else {
+               else

                        high_freq = high_freq * 0.65;
                        high_freq = high_freq * 0.65;

-               }

        } else {
        } else {

-               if (bps >= 0.8) {
+               if (bps >= 0.8)

                        high_freq = high_freq * 0.75;
                        high_freq = high_freq * 0.75;

-               } else if (bps >= 0.6) {
+               else if (bps >= 0.6)

                        high_freq = high_freq * 0.6;
                        high_freq = high_freq * 0.6;

-               } else {
+               else

                        high_freq = high_freq * 0.5;
                        high_freq = high_freq * 0.5;

-               }

        }
        PARA_INFO_LOG("channels=%d sample_rate=%d "
                "bitrate=%d block_align=%d\n",
        }
        PARA_INFO_LOG("channels=%d sample_rate=%d "
                "bitrate=%d block_align=%d\n",


@@ -588,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)
        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 */
                /* NOTE: this offset is the same as MPEG4 AAC ! */
                last_exp += code - 60;
                /* XXX: use a table */


@@ -717,7 +715,7 @@ static int compute_high_band_values(struct private_wmadec_data *pwd,
                                        pwd->hgain_vlc.table, HGAINVLCBITS,
                                        HGAINMAX);
                                if (code < 0)
                                        pwd->hgain_vlc.table, HGAINVLCBITS,
                                        HGAINMAX);
                                if (code < 0)

-                                       return -1;
+                                       return code;

                                val += code - 18;
                        }
                        pwd->high_band_values[ch][i] = val;
                                val += code - 18;
                        }
                        pwd->high_band_values[ch][i] = val;


@@ -828,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)
 {
  */
 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];
 
        int coef_nb_bits, total_gain;
        int nb_coefs[MAX_CHANNELS];
 


@@ -845,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)
                        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)
                        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 */
                        pwd->block_len_bits = pwd->frame_len_bits - v;
                } else {
                        /* update block lengths */


@@ -858,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)
                }
                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 */
                pwd->next_block_len_bits = pwd->frame_len_bits - v;
        } else {
                /* fixed block len */


@@ -907,19 +905,20 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
        for (ch = 0; ch < pwd->ahi.channels; ch++)
                nb_coefs[ch] = n;
 
        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) {
 
        /* 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);
                                        decode_exp_lsp(pwd, ch);

-                               }

                                pwd->exponents_bsize[ch] = bsize;
                        }
                }
                                pwd->exponents_bsize[ch] = bsize;
                        }
                }


@@ -950,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)
                        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 */
                        if (code == 1) /* EOB */
                                break;
                        if (code == 0) { /* escape */


@@ -1046,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)
        for (;;) {
                ret = wma_decode_block(pwd);
                if (ret < 0)

-                       return -1;
+                       return ret;

                if (ret)
                        break;
        }
                if (ret)
                        break;
        }


@@ -1074,7 +1073,6 @@ static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
 {
        int ret;
        int16_t *samples;
 {
        int ret;
        int16_t *samples;

-       static int frame_count;

 
        if (buf_size == 0) {
                pwd->last_superframe_len = 0;
 
        if (buf_size == 0) {
                pwd->last_superframe_len = 0;


@@ -1125,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.
                         */
                         * 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;
                                goto fail;

-                       frame_count++;

                        samples += pwd->ahi.channels * pwd->frame_len;
                }
 
                        samples += pwd->ahi.channels * pwd->frame_len;
                }
 


@@ -1142,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++) {
 
                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;
                                goto fail;

-                       frame_count++;

                        samples += pwd->ahi.channels * pwd->frame_len;
                }
 
                        samples += pwd->ahi.channels * pwd->frame_len;
                }
 


@@ -1166,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 */
                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;
                        goto fail;

-               frame_count++;

                samples += pwd->ahi.channels * pwd->frame_len;
        }
                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;
                (int8_t *) samples - (int8_t *) data, pwd->ahi.block_align);
        *data_size = (int8_t *)samples - (int8_t *)data;
        return pwd->ahi.block_align;


@@ -1187,11 +1181,9 @@ fail:
 static ssize_t wmadec_convert(char *inbuffer, size_t len,
                struct filter_node *fn)
 {
 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;
 
        struct private_wmadec_data *pwd = fn->private_data;
 

-       if (out_size < 128 * 1024)
-               return 0;

        if (len <= WMA_FRAME_SKIP)
                return 0;
        if (!pwd) {
        if (len <= WMA_FRAME_SKIP)
                return 0;
        if (!pwd) {


@@ -1203,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;
        }
                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)
 }
 
 static void wmadec_close(struct filter_node *fn)