NEWS update.
[paraslash.git] / wmadec_filter.c
index 802cb82..fdf3da9 100644 (file)
@@ -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
-       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
@@ -289,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;
@@ -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;
-       } 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",
@@ -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)
-                       return -1;
+                       return code;
                /* 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)
-                                       return -1;
+                                       return code;
                                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)
 {
-       int n, v, ch, code, bsize;
+       int ret, n, v, ch, code, bsize;
        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)
-                               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 */
@@ -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)
-                       return -1;
+                       return -E_WMA_BLOCK_SIZE;
                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;
 
-       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;
                        }
                }
@@ -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)
-                               return -1;
+                               return code;
                        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)
-                       return -1;
+                       return ret;
                if (ret)
                        break;
        }
@@ -1074,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;
@@ -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.
                         */
-                       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;
                }
 
@@ -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++) {
-                       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;
                }
 
@@ -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 */
-               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;
@@ -1187,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) {
@@ -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;
        }
-       /* 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)