trivial whitespace fixes.

[paraslash.git] / wmadec_filter.c

diff --git a/wmadec_filter.c b/wmadec_filter.c
index e41e8c505e88e8cdbd325d1e299ed292c49e488b..e39dc7f04bfaf3be53ed2ebc836561653cc4a1a1 100644 (file)
--- a/wmadec_filter.c
+++ b/wmadec_filter.c
@@ -83,7 +83,6 @@ struct private_wmadec_data {
        struct vlc coef_vlc[2];
        uint16_t *run_table[2];
        uint16_t *level_table[2];
-       uint16_t *int_table[2];
        const struct coef_vlc_table *coef_vlcs[2];
        /* frame info */
        int frame_len;          ///< frame length in samples
@@ -166,33 +165,27 @@ static void wmadec_cleanup(struct private_wmadec_data *pwd)
                free_vlc(&pwd->coef_vlc[i]);
                free(pwd->run_table[i]);
                free(pwd->level_table[i]);
-               free(pwd->int_table[i]);
        }
 }
 
-/* XXX: use same run/length optimization as mpeg decoders */
-//FIXME maybe split decode / encode or pass flag
 static void init_coef_vlc(struct vlc *vlc, uint16_t **prun_table,
-               uint16_t **plevel_table, uint16_t **pint_table,
-               const struct coef_vlc_table *vlc_table)
+               uint16_t **plevel_table, const struct coef_vlc_table *vlc_table)
 {
        int n = vlc_table->n;
        const uint8_t *table_bits = vlc_table->huffbits;
        const uint32_t *table_codes = vlc_table->huffcodes;
        const uint16_t *levels_table = vlc_table->levels;
-       uint16_t *run_table, *level_table, *int_table;
+       uint16_t *run_table, *level_table;
        int i, l, j, k, level;
 
        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));
-       int_table = para_malloc(n * sizeof(uint16_t));
        i = 2;
        level = 1;
        k = 0;
        while (i < n) {
-               int_table[k] = i;
                l = levels_table[k++];
                for (j = 0; j < l; j++) {
                        run_table[i] = j;
@@ -203,7 +196,6 @@ static void init_coef_vlc(struct vlc *vlc, uint16_t **prun_table,
        }
        *prun_table = run_table;
        *plevel_table = level_table;
-       *pint_table = int_table;
 }
 
 /* compute the scale factor band sizes for each MDCT block size */
@@ -426,9 +418,9 @@ static int wma_init(struct private_wmadec_data *pwd)
        pwd->coef_vlcs[0] = &coef_vlcs[coef_vlc_table * 2];
        pwd->coef_vlcs[1] = &coef_vlcs[coef_vlc_table * 2 + 1];
        init_coef_vlc(&pwd->coef_vlc[0], &pwd->run_table[0], &pwd->level_table[0],
-               &pwd->int_table[0], pwd->coef_vlcs[0]);
+               pwd->coef_vlcs[0]);
        init_coef_vlc(&pwd->coef_vlc[1], &pwd->run_table[1], &pwd->level_table[1],
-               &pwd->int_table[1], pwd->coef_vlcs[1]);
+               pwd->coef_vlcs[1]);
        return 0;
 }
 
@@ -847,23 +839,17 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                        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);
+                               code = get_vlc(&pwd->gb, coef_vlc->table,
+                                       VLCBITS, VLCMAX);
                                if (code < 0)
                                        return -1;
-                               if (code == 1) {
-                                       /* EOB */
+                               if (code == 1) /* EOB */
                                        break;
-                               } else if (code == 0) {
-                                       /* escape */
+                               if (code == 0) { /* escape */
                                        level = get_bits(&pwd->gb, coef_nb_bits);
-                                       /* NOTE: this is rather suboptimal. reading
-                                          block_len_bits would be better */
-                                       run =
-                                           get_bits(&pwd->gb, pwd->frame_len_bits);
-                               } else {
-                                       /* normal code */
+                                       /* 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];
                                }
@@ -876,8 +862,7 @@ static int wma_decode_block(struct private_wmadec_data *pwd)
                                        break;
                                }
                                *ptr++ = level;
-                               /* NOTE: EOB can be omitted */
-                               if (ptr >= eptr)
+                               if (ptr >= eptr) /* EOB can be omitted */
                                        break;
                        }
                }
@@ -1144,8 +1129,7 @@ static int wma_decode_frame(struct private_wmadec_data *pwd, int16_t *samples)
 static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
                int *data_size, const uint8_t *buf, int buf_size)
 {
-       int ret, nb_frames, bit_offset, i, pos, len;
-       uint8_t *q;
+       int ret;
        int16_t *samples;
        static int frame_count;
 
@@ -1159,6 +1143,9 @@ static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
        samples = data;
        init_get_bits(&pwd->gb, buf, buf_size);
        if (pwd->use_bit_reservoir) {
+               int i, nb_frames, bit_offset, pos, len;
+               uint8_t *q;
+
                /* read super frame header */
                skip_bits(&pwd->gb, 4); /* super frame index */
                nb_frames = get_bits(&pwd->gb, 4) - 1;