Rename get_bits1() to get_bit().

[paraslash.git] / wmadec_filter.c

diff --git a/wmadec_filter.c b/wmadec_filter.c
index 13ad99c48744090fc16a399a4b48bb54f200cc1a..e41e8c505e88e8cdbd325d1e299ed292c49e488b 100644 (file)
--- a/wmadec_filter.c
+++ b/wmadec_filter.c
@@ -183,7 +183,7 @@ static void init_coef_vlc(struct vlc *vlc, uint16_t **prun_table,
        uint16_t *run_table, *level_table, *int_table;
        int i, l, j, k, level;
 
        uint16_t *run_table, *level_table, *int_table;
        int i, l, j, k, level;
 

-       init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4);
+       init_vlc(vlc, VLCBITS, n, table_bits, table_codes, 4);

 
        run_table = para_malloc(n * sizeof(uint16_t));
        level_table = para_malloc(n * sizeof(uint16_t));
 
        run_table = para_malloc(n * sizeof(uint16_t));
        level_table = para_malloc(n * sizeof(uint16_t));


@@ -276,13 +276,15 @@ static void compute_scale_factor_band_sizes(struct private_wmadec_data *pwd,
        }
 }
 
        }
 }
 

-static int wma_init(struct private_wmadec_data *pwd, int flags2, struct asf_header_info *ahi)
+static int wma_init(struct private_wmadec_data *pwd)

 {
        int i;
        float bps1, high_freq;
        volatile float bps;
        int sample_rate1;
        int coef_vlc_table;
 {
        int i;
        float bps1, high_freq;
        volatile float bps;
        int sample_rate1;
        int coef_vlc_table;

+       struct asf_header_info *ahi = &pwd->ahi;
+       int flags2 = ahi->flags2;

 
        if (ahi->sample_rate <= 0 || ahi->sample_rate > 50000
                || ahi->channels <= 0 || ahi->channels > 8
 
        if (ahi->sample_rate <= 0 || ahi->sample_rate > 50000
                || ahi->channels <= 0 || ahi->channels > 8


@@ -474,7 +476,7 @@ static int wma_decode_init(char *initial_buf, int len, struct private_wmadec_dat
        pwd->use_bit_reservoir = pwd->ahi.flags2 & 0x0002;
        pwd->use_variable_block_len = pwd->ahi.flags2 & 0x0004;
 
        pwd->use_bit_reservoir = pwd->ahi.flags2 & 0x0002;
        pwd->use_variable_block_len = pwd->ahi.flags2 & 0x0004;
 

-       ret = wma_init(pwd, pwd->ahi.flags2, &pwd->ahi);
+       ret = wma_init(pwd);

        if (ret < 0)
                return ret;
        /* init MDCT */
        if (ret < 0)
                return ret;
        /* init MDCT */


@@ -487,14 +489,14 @@ static int wma_decode_init(char *initial_buf, int len, struct private_wmadec_dat
                PARA_INFO_LOG("using noise coding\n");
                init_vlc(&pwd->hgain_vlc, HGAINVLCBITS,
                        sizeof(ff_wma_hgain_huffbits), ff_wma_hgain_huffbits,
                PARA_INFO_LOG("using noise coding\n");
                init_vlc(&pwd->hgain_vlc, HGAINVLCBITS,
                        sizeof(ff_wma_hgain_huffbits), ff_wma_hgain_huffbits,

-                       1, 1, ff_wma_hgain_huffcodes, 2, 2);
+                       ff_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,
        }
 
        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,

-               1, 1, ff_wma_scale_huffcodes, 4, 4);
+               ff_wma_scale_huffcodes, 4);

        } else {
                PARA_INFO_LOG("using curve\n");
                wma_lsp_to_curve_init(pwd, pwd->frame_len);
        } else {
                PARA_INFO_LOG("using curve\n");
                wma_lsp_to_curve_init(pwd, pwd->frame_len);


@@ -572,27 +574,6 @@ static void decode_exp_lsp(struct private_wmadec_data *pwd, int ch)
                pwd->block_len, lsp_coefs);
 }
 
                pwd->block_len, lsp_coefs);
 }
 

-/*
- * Parse a vlc code, faster then get_vlc().
- *
- * \param bits The number of bits which will be read at once, must be
- * identical to nb_bits in init_vlc()
- *
- * \param max_depth The number of times bits bits must be read to completely
- * read the longest vlc code = (max_vlc_length + bits - 1) / bits.
- */
-static int get_vlc2(struct getbit_context *s, VLC_TYPE(*table)[2],
-               int bits, int max_depth)
-{
-       int code;
-
-       OPEN_READER(re, s)
-       UPDATE_CACHE(re, s)
-       GET_VLC(code, re, s, table, bits, max_depth)
-       CLOSE_READER(re, s)
-       return code;
-}
-

 /* Decode exponents coded with VLC codes. */
 static int decode_exp_vlc(struct private_wmadec_data *pwd, int ch)
 {
 /* Decode exponents coded with VLC codes. */
 static int decode_exp_vlc(struct private_wmadec_data *pwd, int ch)
 {


@@ -608,7 +589,7 @@ static int decode_exp_vlc(struct private_wmadec_data *pwd, int ch)
        last_exp = 36;
 
        while (q < q_end) {
        last_exp = 36;
 
        while (q < q_end) {

-               code = get_vlc2(&pwd->gb, pwd->exp_vlc.table, EXPVLCBITS, EXPMAX);
+               code = get_vlc(&pwd->gb, pwd->exp_vlc.table, EXPVLCBITS, EXPMAX);

                if (code < 0)
                        return -1;
                /* NOTE: this offset is the same as MPEG4 AAC ! */
                if (code < 0)
                        return -1;
                /* NOTE: this offset is the same as MPEG4 AAC ! */


@@ -750,10 +731,10 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                return -E_INCOHERENT_BLOCK_LEN;
 
        if (pwd->ahi.channels == 2)
                return -E_INCOHERENT_BLOCK_LEN;
 
        if (pwd->ahi.channels == 2)

-               pwd->ms_stereo = get_bits1(&pwd->gb);
+               pwd->ms_stereo = get_bit(&pwd->gb);

        v = 0;
        for (ch = 0; ch < pwd->ahi.channels; ch++) {
        v = 0;
        for (ch = 0; ch < pwd->ahi.channels; ch++) {

-               int a = get_bits1(&pwd->gb);
+               int a = get_bit(&pwd->gb);

                pwd->channel_coded[ch] = a;
                v |= a;
        }
                pwd->channel_coded[ch] = a;
                v |= a;
        }


@@ -789,7 +770,7 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                                int i, m, a;
                                m = pwd->exponent_high_sizes[bsize];
                                for (i = 0; i < m; i++) {
                                int i, m, a;
                                m = pwd->exponent_high_sizes[bsize];
                                for (i = 0; i < m; i++) {

-                                       a = get_bits1(&pwd->gb);
+                                       a = get_bit(&pwd->gb);

                                        pwd->high_band_coded[ch][i] = a;
                                        /* if noise coding, the coefficients are not transmitted */
                                        if (a)
                                        pwd->high_band_coded[ch][i] = a;
                                        /* if noise coding, the coefficients are not transmitted */
                                        if (a)


@@ -814,7 +795,7 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                                                                     7) - 19;
                                                } else {
                                                        code =
                                                                     7) - 19;
                                                } else {
                                                        code =

-                                                           get_vlc2(&pwd->gb,
+                                                           get_vlc(&pwd->gb,

                                                                     pwd->
                                                                     hgain_vlc.
                                                                     table,
                                                                     pwd->
                                                                     hgain_vlc.
                                                                     table,


@@ -833,7 +814,7 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
        }
 
        /* exponents can be reused in short blocks. */
        }
 
        /* exponents can be reused in short blocks. */

-       if ((pwd->block_len_bits == pwd->frame_len_bits) || get_bits1(&pwd->gb)) {
+       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) {
                for (ch = 0; ch < pwd->ahi.channels; ch++) {
                        if (pwd->channel_coded[ch]) {
                                if (pwd->use_exp_vlc) {


@@ -867,7 +848,7 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                        memset(ptr, 0, pwd->block_len * sizeof(int16_t));
                        for (;;) {
                                code =
                        memset(ptr, 0, pwd->block_len * sizeof(int16_t));
                        for (;;) {
                                code =

-                                   get_vlc2(&pwd->gb, coef_vlc->table, VLCBITS,
+                                   get_vlc(&pwd->gb, coef_vlc->table, VLCBITS,

                                             VLCMAX);
                                if (code < 0)
                                        return -1;
                                             VLCMAX);
                                if (code < 0)
                                        return -1;


@@ -886,7 +867,7 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                                        run = run_table[code];
                                        level = level_table[code];
                                }
                                        run = run_table[code];
                                        level = level_table[code];
                                }

-                               sign = get_bits1(&pwd->gb);
+                               sign = get_bit(&pwd->gb);

                                if (!sign)
                                        level = -level;
                                ptr += run;
                                if (!sign)
                                        level = -level;
                                ptr += run;


@@ -1176,7 +1157,7 @@ static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
                return 0;
        buf_size = pwd->ahi.block_align;
        samples = data;
                return 0;
        buf_size = pwd->ahi.block_align;
        samples = data;

-       init_get_bits(&pwd->gb, buf, buf_size * 8);
+       init_get_bits(&pwd->gb, buf, buf_size);

        if (pwd->use_bit_reservoir) {
                /* read super frame header */
                skip_bits(&pwd->gb, 4); /* super frame index */
        if (pwd->use_bit_reservoir) {
                /* read super frame header */
                skip_bits(&pwd->gb, 4); /* super frame index */


@@ -1206,7 +1187,7 @@ static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
 
                        /* XXX: bit_offset bits into last frame */
                        init_get_bits(&pwd->gb, pwd->last_superframe,
 
                        /* XXX: bit_offset bits into last frame */
                        init_get_bits(&pwd->gb, pwd->last_superframe,

-                               MAX_CODED_SUPERFRAME_SIZE * 8);
+                               MAX_CODED_SUPERFRAME_SIZE);

                        /* skip unused bits */
                        if (pwd->last_bitoffset > 0)
                                skip_bits(&pwd->gb, pwd->last_bitoffset);
                        /* skip unused bits */
                        if (pwd->last_bitoffset > 0)
                                skip_bits(&pwd->gb, pwd->last_bitoffset);


@@ -1224,7 +1205,7 @@ static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
                /* read each frame starting from bit_offset */
                pos = bit_offset + 4 + 4 + pwd->byte_offset_bits + 3;
                init_get_bits(&pwd->gb, buf + (pos >> 3),
                /* read each frame starting from bit_offset */
                pos = bit_offset + 4 + 4 + pwd->byte_offset_bits + 3;
                init_get_bits(&pwd->gb, buf + (pos >> 3),

-                       (MAX_CODED_SUPERFRAME_SIZE - (pos >> 3)) * 8);
+                       (MAX_CODED_SUPERFRAME_SIZE - (pos >> 3)));

                len = pos & 7;
                if (len > 0)
                        skip_bits(&pwd->gb, len);
                len = pos & 7;
                if (len > 0)
                        skip_bits(&pwd->gb, len);