X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=bitstream.c;h=dfc1e55e67aced611014fc90b86128e8bd61a457;hp=c4c465e8a24904347bcc739399a09140734ff6ac;hb=HEAD;hpb=226ce82aaccff7e74a6fadd028743b731a3744d2 diff --git a/bitstream.c b/bitstream.c index c4c465e8..a1c7c943 100644 --- a/bitstream.c +++ b/bitstream.c @@ -6,136 +6,116 @@ * Copyright (c) 2000, 2001 Fabrice Bellard * Copyright (c) 2002-2004 Michael Niedermayer * alternative bitstream reader & writer by Michael Niedermayer + * Copyright (C) 2009 Andre Noll * - * Licensed under the GNU Lesser General Public License. - * For licencing details see COPYING.LIB. + * Licensed under the GNU Lesser General Public License. see file COPYING.LIB. */ -/** - * \file bitstream.c Bitstream API. - */ +/** \file bitstream.c Bitstream API for the wma decoder. */ -#include -#include -#include -#include #include #include "para.h" #include "error.h" #include "string.h" #include "wma.h" +#include "portable_io.h" #include "bitstream.h" -#define GET_DATA(v, table, i, wrap, size) \ -{\ - const uint8_t *ptr = (const uint8_t *)table + i * wrap;\ - switch(size) {\ - case 1:\ - v = *(const uint8_t *)ptr;\ - break;\ - case 2:\ - v = *(const uint16_t *)ptr;\ - break;\ - default:\ - v = *(const uint32_t *)ptr;\ - break;\ - }\ +static inline uint32_t get_data(const void *table, int i, int size) +{ + const uint8_t *ptr = (const uint8_t *)table + i * size; + uint32_t v; + + switch (size) { + case 1: + v = *(const uint8_t *)ptr; + break; + case 2: + v = *(const uint16_t *)ptr; + break; + default: + v = *(const uint32_t *)ptr; + break; + } + return v; } -static int alloc_table(struct vlc *vlc, int size) +static void alloc_table(struct vlc *vlc, int size) { - int idx; - - idx = vlc->table_size; vlc->table_size += size; if (vlc->table_size > vlc->table_allocated) { vlc->table_allocated += (1 << vlc->bits); - vlc->table = realloc(vlc->table, - sizeof(VLC_TYPE) * 2 * vlc->table_allocated); - if (!vlc->table) - return -E_TABLE_ALLOC; + vlc->table = arr_realloc(vlc->table, vlc->table_allocated, + sizeof(int16_t) * 2); } - return idx; } -static int build_table(struct vlc *vlc, int table_nb_bits, - int nb_codes, const void *bits, int bits_wrap, int bits_size, - const void *codes, int codes_wrap, int codes_size, +static int build_table(struct vlc *vlc, int table_nb_bits, int nb_codes, + const void *bits, const void *codes, int codes_size, uint32_t code_prefix, int n_prefix) { - int ret, i, j, k, n, table_size, table_index, nb, n1, idx, code_prefix2, - symbol; + int i, j, k, n, table_size, table_index, nb, n1, idx; uint32_t code; - VLC_TYPE(*table)[2]; + int16_t (*table)[2]; table_size = 1 << table_nb_bits; - ret = alloc_table(vlc, table_size); - if (ret < 0) - return ret; - table_index = ret; + table_index = vlc->table_size; + alloc_table(vlc, table_size); table = &vlc->table[table_index]; for (i = 0; i < table_size; i++) { - table[i][1] = 0; //bits - table[i][0] = -1; //codes + table[i][1] = 0; /* bits */ + table[i][0] = -1; /* codes */ } - /* first pass: map codes and compute auxillary table sizes */ + /* map codes and compute auxiliary table sizes */ for (i = 0; i < nb_codes; i++) { - GET_DATA(n, bits, i, bits_wrap, bits_size); - GET_DATA(code, codes, i, codes_wrap, codes_size); + n = get_data(bits, i, 1); /* we accept tables with holes */ + n -= n_prefix; if (n <= 0) continue; - symbol = i; + code = get_data(codes, i, codes_size); /* if code matches the prefix, it is in the table */ - n -= n_prefix; - code_prefix2 = code >> n; - if (n > 0 && code_prefix2 == code_prefix) { - if (n <= table_nb_bits) { - /* no need to add another table */ - j = (code << (table_nb_bits - n)) & (table_size - 1); - nb = 1 << (table_nb_bits - n); - for (k = 0; k < nb; k++) { - if (table[j][1] /* bits */ != 0) - return -E_BAD_CODES; - table[j][1] = n; //bits - table[j][0] = symbol; - j++; - } - } else { - n -= table_nb_bits; - j = (code >> n) & ((1 << table_nb_bits) - 1); - /* compute table size */ - n1 = -table[j][1]; //bits - if (n > n1) - n1 = n; - table[j][1] = -n1; //bits + if ((code >> n) != code_prefix) + continue; + if (n <= table_nb_bits) { + /* no need to add another table */ + j = (code << (table_nb_bits - n)) & (table_size - 1); + nb = 1 << (table_nb_bits - n); + for (k = 0; k < nb; k++) { + assert(table[j][1] == 0); /* incorrect code */ + table[j][1] = n; /* bits */ + table[j][0] = i; + j++; } + } else { + n -= table_nb_bits; + j = (code >> n) & ((1 << table_nb_bits) - 1); + /* compute table size */ + n1 = -table[j][1]; /* bits */ + if (n > n1) + n1 = n; + table[j][1] = -n1; /* bits */ } } - /* second pass : fill auxillary tables recursively */ + /* fill auxiliary tables recursively */ for (i = 0; i < table_size; i++) { - n = table[i][1]; //bits + n = table[i][1]; /* bits */ if (n < 0) { n = -n; if (n > table_nb_bits) { n = table_nb_bits; - table[i][1] = -n; //bits + table[i][1] = -n; /* bits */ } - ret = build_table(vlc, n, nb_codes, - bits, bits_wrap, bits_size, - codes, codes_wrap, codes_size, - (code_prefix << table_nb_bits) | i, + idx = build_table(vlc, n, nb_codes, bits, codes, + codes_size, (code_prefix << table_nb_bits) | i, n_prefix + table_nb_bits); - if (ret < 0) - return ret; - idx = ret; - /* note: realloc has been done, so reload tables */ + /* vlc->table might have changed */ table = &vlc->table[table_index]; - table[i][0] = idx; //code + table[i][0] = idx; /* code */ } } return table_index; @@ -144,51 +124,72 @@ static int build_table(struct vlc *vlc, int table_nb_bits, /** * Build VLC decoding tables suitable for use with get_vlc(). * - * \param nb_bits Set the decoding table size (2^nb_bits) - * entries. The bigger it is, the faster is the decoding. But - * it should not be too big to save memory and L1 cache. '9' - * is a good compromise. - * - * \param nb_codes Number of vlcs codes. - * - * \param bits Table which gives the size (in bits) of each - * vlc code. - * - * \param codes Table which gives the bit pattern of of each - * vlc code. + * \param vlc The structure to be initialized. + * \param nb_bits Set the decoding table size (2^nb_bits) entries. + * \param nb_codes Number of vlc codes. + * \param bits Table which gives the size (in bits) of each vlc code. + * \param codes Table which gives the bit pattern of of each vlc code. + * \param codes_size The number of bytes of each entry of the \a codes tables. * - * \param bits_wrap The number of bytes between each entry of the - * 'bits' or 'codes' tables. - * - * - * \param bits_size The number of bytes of each entry of the - * 'bits' or 'codes' tables. - * - * \param codes_wrap Same as bits_wrap but uses the 'codes' table. - * \param codes_size Same as bits_size but for the 'codes' table. + * The bigger \a nb_bits is, the faster is the decoding. But it should not be + * too big to save memory and L1 cache. '9' is a good compromise. * * The wrap and size parameters allow to use any memory configuration and * types (byte/word/long) to store the bits and codes tables. */ -int init_vlc(struct vlc *vlc, int nb_bits, int nb_codes, - const void *bits, int bits_wrap, int bits_size, - const void *codes, int codes_wrap, int codes_size) +void init_vlc(struct vlc *vlc, int nb_bits, int nb_codes, const void *bits, + const void *codes, int codes_size) { - int ret; - - PARA_INFO_LOG("nb_codes=%d\n", nb_codes); + PARA_INFO_LOG("nb_codes: %d\n", nb_codes); vlc->bits = nb_bits; vlc->table = NULL; vlc->table_allocated = 0; vlc->table_size = 0; - ret = build_table(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, - codes, codes_wrap, codes_size, 0, 0); - if (ret < 0) - freep(&vlc->table); - return ret; + build_table(vlc, nb_bits, nb_codes, bits, codes, codes_size, 0, 0); } +/** + * Deallocate all resources of a VLC table. + * + * \param vlc Pointer to an initialized vlc structure. + * + * The table given by \a vlc must have been initialized earlier via \ref + * init_vlc(). + */ void free_vlc(struct vlc *vlc) { freep(&vlc->table); } + +/** + * Parse a vlc code. + * + * \param gbc The getbit context structure. + * \param vlc The vlc tables to use. + * + * \return The vlc code. + */ +int get_vlc(struct getbit_context *gbc, const struct vlc *vlc) +{ + int n, idx, nb_bits, code; + + idx = show_bits(gbc, vlc->bits); + code = vlc->table[idx][0]; + n = vlc->table[idx][1]; + if (n < 0) { + skip_bits(gbc, vlc->bits); + nb_bits = -n; + idx = show_bits(gbc, nb_bits) + code; + code = vlc->table[idx][0]; + n = vlc->table[idx][1]; + if (n < 0) { + skip_bits(gbc, nb_bits); + nb_bits = -n; + idx = show_bits(gbc, nb_bits) + code; + code = vlc->table[idx][0]; + n = vlc->table[idx][1]; + } + } + skip_bits(gbc, n); + return code >= 0? code : -E_VLC; +}