From 2f7da2d3d9a6c9ef998a8e1b91a4554e6d1b9d74 Mon Sep 17 00:00:00 2001 From: Paul Gilbert Date: Sat, 10 Sep 2016 21:05:49 -0400 Subject: IMAGE: Miscellaneous cleanup for Indeo decompressors --- image/codecs/indeo/indeo.cpp | 19 ++-- image/codecs/indeo/indeo.h | 6 +- image/codecs/indeo/mem.cpp | 12 ++- image/codecs/indeo/mem.h | 1 - image/codecs/indeo/vlc.cpp | 219 +++++++++++++++++++++---------------------- image/codecs/indeo/vlc.h | 45 ++++----- image/codecs/indeo4.cpp | 9 +- image/codecs/indeo4.h | 9 +- image/codecs/indeo5.cpp | 30 +++--- image/codecs/indeo5.h | 5 - 10 files changed, 166 insertions(+), 189 deletions(-) (limited to 'image/codecs') diff --git a/image/codecs/indeo/indeo.cpp b/image/codecs/indeo/indeo.cpp index 1250c57196..0ce3b7d296 100644 --- a/image/codecs/indeo/indeo.cpp +++ b/image/codecs/indeo/indeo.cpp @@ -162,7 +162,7 @@ int IVIHuffTab::decodeHuffDesc(IVI45DecContext *ctx, int descCoded, int whichTab _custDesc.huffDescCopy(&newHuff); if (_custTab._table) - _custTab.ff_free_vlc(); + _custTab.freeVlc(); result = _custDesc.createHuffFromDesc(&_custTab, false); if (result) { // reset faulty description @@ -391,7 +391,7 @@ void IVIPlaneDesc::freeBuffers(IVIPlaneDesc *planes) { avFreeP(&planes[p]._bands[b]._bufs[3]); if (planes[p]._bands[b]._blkVlc._custTab._table) - planes[p]._bands[b]._blkVlc._custTab.ff_free_vlc(); + planes[p]._bands[b]._blkVlc._custTab.freeVlc(); for (t = 0; t < planes[p]._bands[b]._numTiles; t++) avFreeP(&planes[p]._bands[b]._tiles[t]._mbs); avFreeP(&planes[p]._bands[b]._tiles); @@ -462,10 +462,10 @@ IVI45DecContext::IVI45DecContext() : _gb(nullptr), _frameNum(0), _frameType(0), for (int i = 0; i < 8; i++) { _iviMbVlcTabs[i]._table = _tableData + i * 2 * 8192; - _iviMbVlcTabs[i]._table_allocated = 8192; + _iviMbVlcTabs[i]._tableAllocated = 8192; ivi_mb_huff_desc[i].createHuffFromDesc(&_iviMbVlcTabs[i], true); _iviBlkVlcTabs[i]._table = _tableData + (i * 2 + 1) * 8192; - _iviBlkVlcTabs[i]._table_allocated = 8192; + _iviBlkVlcTabs[i]._tableAllocated = 8192; ivi_blk_huff_desc[i].createHuffFromDesc(&_iviBlkVlcTabs[i], true); } } @@ -485,7 +485,7 @@ IndeoDecoderBase::~IndeoDecoderBase() { delete _surface; IVIPlaneDesc::freeBuffers(_ctx._planes); if (_ctx._mbVlc._custTab._table) - _ctx._mbVlc._custTab.ff_free_vlc(); + _ctx._mbVlc._custTab.freeVlc(); delete _ctx._pFrame; } @@ -638,8 +638,8 @@ int IndeoDecoderBase::decode_band(IVIBandDesc *band) { for (i = 0; i < band->_numCorr; i++) { idx1 = band->_corr[i * 2]; idx2 = band->_corr[i * 2 + 1]; - FFSWAP(uint8, band->_rvMap->_runtab[idx1], band->_rvMap->_runtab[idx2]); - FFSWAP(int16, band->_rvMap->_valtab[idx1], band->_rvMap->_valtab[idx2]); + SWAP(band->_rvMap->_runtab[idx1], band->_rvMap->_runtab[idx2]); + SWAP(band->_rvMap->_valtab[idx1], band->_rvMap->_valtab[idx2]); if (idx1 == band->_rvMap->_eobSym || idx2 == band->_rvMap->_eobSym) band->_rvMap->_eobSym ^= idx1 ^ idx2; if (idx1 == band->_rvMap->_escSym || idx2 == band->_rvMap->_escSym) @@ -696,8 +696,8 @@ int IndeoDecoderBase::decode_band(IVIBandDesc *band) { for (i = band->_numCorr - 1; i >= 0; i--) { idx1 = band->_corr[i * 2]; idx2 = band->_corr[i * 2 + 1]; - FFSWAP(uint8, band->_rvMap->_runtab[idx1], band->_rvMap->_runtab[idx2]); - FFSWAP(int16, band->_rvMap->_valtab[idx1], band->_rvMap->_valtab[idx2]); + SWAP(band->_rvMap->_runtab[idx1], band->_rvMap->_runtab[idx2]); + SWAP(band->_rvMap->_valtab[idx1], band->_rvMap->_valtab[idx2]); if (idx1 == band->_rvMap->_eobSym || idx2 == band->_rvMap->_eobSym) band->_rvMap->_eobSym ^= idx1 ^ idx2; if (idx1 == band->_rvMap->_escSym || idx2 == band->_rvMap->_escSym) @@ -1726,6 +1726,5 @@ const RVMapDesc IVI45DecContext::_ff_ivi_rvmap_tabs[9] = { } }; - } // End of namespace Indeo } // End of namespace Image diff --git a/image/codecs/indeo/indeo.h b/image/codecs/indeo/indeo.h index 2c1ed957e2..bff5501bcb 100644 --- a/image/codecs/indeo/indeo.h +++ b/image/codecs/indeo/indeo.h @@ -64,10 +64,10 @@ enum { * Declare inverse transform function types */ typedef void (InvTransformPtr)(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags); -typedef void (DCTransformPtr) (const int32 *in, int16 *out, uint32 pitch, int blkSize); +typedef void (DCTransformPtr)(const int32 *in, int16 *out, uint32 pitch, int blkSize); -typedef void(*IviMCFunc) (int16 *buf, const int16 *refBuf, uint32 pitch, int mcType); -typedef void(*IviMCAvgFunc) (int16 *buf, const int16 *refBuf1, const int16 *refBuf2, +typedef void (*IviMCFunc)(int16 *buf, const int16 *refBuf, uint32 pitch, int mcType); +typedef void (*IviMCAvgFunc)(int16 *buf, const int16 *refBuf1, const int16 *refBuf2, uint32 pitch, int mcType, int mcType2); ///< max number of bits of the ivi's huffman codes diff --git a/image/codecs/indeo/mem.cpp b/image/codecs/indeo/mem.cpp index 89f2af7ad2..326729b27d 100644 --- a/image/codecs/indeo/mem.cpp +++ b/image/codecs/indeo/mem.cpp @@ -166,13 +166,17 @@ uint16 invertBits(uint16 val, int nbits) { } uint8 avClipUint8(int a) { - if (a&(~0xFF)) return (-a) >> 31; - else return a; + if (a & (~0xFF)) + return (-a) >> 31; + else + return a; } unsigned avClipUintp2(int a, int p) { - if (a & ~((1 << p) - 1)) return -a >> 31 & ((1 << p) - 1); - else return a; + if (a & ~((1 << p) - 1)) + return -a >> 31 & ((1 << p) - 1); + else + return a; } } // End of namespace Indeo diff --git a/image/codecs/indeo/mem.h b/image/codecs/indeo/mem.h index 7fadb147cb..c94cc78ee6 100644 --- a/image/codecs/indeo/mem.h +++ b/image/codecs/indeo/mem.h @@ -36,7 +36,6 @@ namespace Indeo { #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0])) #define FFALIGN(x, a) (((x) + (a)-1) & ~((a)-1)) -#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0) #define FFSIGN(a) ((a) > 0 ? 1 : -1) #define MAX_INTEGER 0x7ffffff diff --git a/image/codecs/indeo/vlc.cpp b/image/codecs/indeo/vlc.cpp index 0328bd8b70..e526a0998a 100644 --- a/image/codecs/indeo/vlc.cpp +++ b/image/codecs/indeo/vlc.cpp @@ -32,7 +32,7 @@ #include "common/util.h" namespace Image { - namespace Indeo { +namespace Indeo { /** * Quicksort @@ -42,62 +42,62 @@ namespace Image { */ #define AV_QSORT(p, num, type, cmp) do {\ void *stack[64][2];\ - int sp= 1;\ + int sp = 1;\ stack[0][0] = p;\ stack[0][1] = (p)+(num)-1;\ while(sp){\ - type *start= (type *)stack[--sp][0];\ - type *end = (type *)stack[ sp][1];\ - while(start < end){\ - if(start < end-1) {\ - int checksort=0;\ - type *right = end-2;\ - type *left = start+1;\ - type *mid = start + ((end-start)>>1);\ + type *start = (type *)stack[--sp][0];\ + type *end = (type *)stack[ sp][1];\ + while (start < end) {\ + if (start < end-1) {\ + int checksort = 0;\ + type *right = end - 2;\ + type *left = start + 1;\ + type *mid = start + ((end - start) >> 1);\ if(cmp(start, end) > 0) {\ - if(cmp( end, mid) > 0) FFSWAP(type, *start, *mid);\ - else FFSWAP(type, *start, *end);\ - }else{\ - if(cmp(start, mid) > 0) FFSWAP(type, *start, *mid);\ - else checksort= 1;\ + if(cmp( end, mid) > 0) SWAP(*start, *mid);\ + else SWAP(*start, *end);\ + } else {\ + if(cmp(start, mid) > 0) SWAP(*start, *mid);\ + else checksort = 1;\ }\ - if(cmp(mid, end) > 0){ \ - FFSWAP(type, *mid, *end);\ - checksort=0;\ + if (cmp(mid, end) > 0) { \ + SWAP(*mid, *end);\ + checksort = 0;\ }\ - if(start == end-2) break;\ - FFSWAP(type, end[-1], *mid);\ - while(left <= right){\ - while(left<=right && cmp(left, end-1) < 0)\ + if(start == end - 2) break;\ + SWAP(end[-1], *mid);\ + while (left <= right) {\ + while (left<=right && cmp(left, end - 1) < 0)\ left++;\ - while(left<=right && cmp(right, end-1) > 0)\ + while (left<=right && cmp(right, end - 1) > 0)\ right--;\ - if(left <= right){\ - FFSWAP(type, *left, *right);\ + if (left <= right) {\ + SWAP(*left, *right);\ left++;\ right--;\ }\ }\ - FFSWAP(type, end[-1], *left);\ - if(checksort && (mid == left-1 || mid == left)){\ + SWAP(end[-1], *left);\ + if(checksort && (mid == left - 1 || mid == left)){\ mid= start;\ while(mid 0)\ - FFSWAP(type, *start, *end);\ + } else {\ + if (cmp(start, end) > 0)\ + SWAP(*start, *end);\ break;\ }\ }\ @@ -105,29 +105,29 @@ namespace Image { } while (0) #define COPY(condition)\ - for (i = 0; i < nb_codes; i++) { \ - buf[j].bits = getData(p_bits, i, bits_wrap, bits_size); \ + for (i = 0; i < nbCodes; i++) { \ + buf[j].bits = getData(p_bits, i, bitsWrap, bitsSize); \ if (!(condition)) \ continue; \ - if (buf[j].bits > 3*nb_bits || buf[j].bits>32) { \ + if (buf[j].bits > (3 * nbBits) || buf[j].bits > 32) { \ warning("Too long VLC (%d) in init_vlc", buf[j].bits); \ if (!(flags & INIT_VLC_USE_NEW_STATIC)) \ free(buf); \ return -1; \ } \ - buf[j].code = getData(codes, i, codes_wrap, codes_size); \ - if (buf[j].code >= (1LL<= (1LL << buf[j].bits)) { \ warning("Invalid code %x for %d in init_vlc", buf[j].code, i); \ if (!(flags & INIT_VLC_USE_NEW_STATIC)) \ free(buf); \ return -1; \ } \ if (flags & INIT_VLC_LE) \ - buf[j].code = bitswap32(buf[j].code); \ + buf[j].code = bitswap32(buf[j].code); \ else \ buf[j].code <<= 32 - buf[j].bits; \ if (symbols) \ - buf[j].symbol = getData(symbols, i, symbols_wrap, symbols_size); \ + buf[j].symbol = getData(symbols, i, symbolsWrap, symbolsSize); \ else \ buf[j].symbol = i; \ j++; \ @@ -135,55 +135,55 @@ namespace Image { /*------------------------------------------------------------------------*/ -VLC::VLC() : _bits(0), _table_size(0), _table_allocated(0), _table(nullptr) { +VLC::VLC() : _bits(0), _tableSize(0), _tableAllocated(0), _table(nullptr) { } -int VLC::init_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, int flags) { - return init_vlc(nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, - codes_size, nullptr, 0, 0, flags); +int VLC::init_vlc(int nbBits, int nbCodes, const void *bits, int bitsWrap, int bitsSize, + const void *codes, int codesWrap, int codesSize, int flags) { + return init_vlc(nbBits, nbCodes, bits, bitsWrap, bitsSize, codes, codesWrap, + codesSize, nullptr, 0, 0, flags); } -int VLC::init_vlc(int nb_bits, int nb_codes, const void *p_bits, int bits_wrap, - int bits_size, const void *codes, int codes_wrap, int codes_size, - const void *symbols, int symbols_wrap, int symbols_size, int flags) { +int VLC::init_vlc(int nbBits, int nbCodes, const void *p_bits, int bitsWrap, + int bitsSize, const void *codes, int codesWrap, int codesSize, + const void *symbols, int symbolsWrap, int symbolsSize, int flags) { VLCcode *buf; int i, j, ret; VLCcode localbuf[1500]; // the maximum currently needed is 1296 by rv34 VLC localvlc, *vlc; vlc = this; - vlc->_bits = nb_bits; + vlc->_bits = nbBits; if (flags & INIT_VLC_USE_NEW_STATIC) { - assert((nb_codes + 1) <= FF_ARRAY_ELEMS(localbuf)); + assert((nbCodes + 1) <= FF_ARRAY_ELEMS(localbuf)); buf = localbuf; localvlc = *this; vlc = &localvlc; - vlc->_table_size = 0; + vlc->_tableSize = 0; } else { vlc->_table = NULL; - vlc->_table_allocated = 0; - vlc->_table_size = 0; + vlc->_tableAllocated = 0; + vlc->_tableSize = 0; - buf = (VLCcode *)avMallocArray((nb_codes + 1), sizeof(VLCcode)); + buf = (VLCcode *)avMallocArray((nbCodes + 1), sizeof(VLCcode)); assert(buf); } - assert(symbols_size <= 2 || !symbols); + assert(symbolsSize <= 2 || !symbols); j = 0; - COPY(buf[j].bits > nb_bits); + COPY(buf[j].bits > nbBits); // qsort is the slowest part of init_vlc, and could probably be improved or avoided - AV_QSORT(buf, j, VLCcode, compare_vlcspec); - COPY(buf[j].bits && buf[j].bits <= nb_bits); - nb_codes = j; + AV_QSORT(buf, j, VLCcode, compareVlcSpec); + COPY(buf[j].bits && buf[j].bits <= nbBits); + nbCodes = j; - ret = vlc->build_table(nb_bits, nb_codes, buf, flags); + ret = vlc->buildTable(nbBits, nbCodes, buf, flags); if (flags & INIT_VLC_USE_NEW_STATIC) { - if (vlc->_table_size != vlc->_table_allocated) - warning("needed %d had %d", vlc->_table_size, vlc->_table_allocated); + if (vlc->_tableSize != vlc->_tableAllocated) + warning("needed %d had %d", vlc->_tableSize, vlc->_tableAllocated); assert(ret >= 0); *this = *vlc; @@ -198,43 +198,43 @@ int VLC::init_vlc(int nb_bits, int nb_codes, const void *p_bits, int bits_wrap, return 0; } -void VLC::ff_free_vlc() { +void VLC::freeVlc() { free(_table); } -int VLC::compare_vlcspec(const void *a, const void *b) { +int VLC::compareVlcSpec(const void *a, const void *b) { const VLCcode *sa = (VLCcode *)a, *sb = (VLCcode *)b; return (sa->code >> 1) - (sb->code >> 1); } -int VLC::build_table(int table_nb_bits, int nb_codes, +int VLC::buildTable(int tableNbBits, int nbCodes, VLCcode *codes, int flags) { VLC *vlc = this; - int table_size, table_index, index, code_prefix, symbol, subtable_bits; + int tableSize, tableIndex, index, codePrefix, symbol, subtableBits; int i, j, k, n, nb, inc; uint32 code; VLC_TYPE (*table)[2]; - table_size = 1 << table_nb_bits; - if (table_nb_bits > 30) + tableSize = 1 << tableNbBits; + if (tableNbBits > 30) return -1; - table_index = alloc_table(table_size, flags & INIT_VLC_USE_NEW_STATIC); - //warning("new table index=%d size=%d", table_index, table_size); - if (table_index < 0) - return table_index; - table = &vlc->_table[table_index]; + tableIndex = allocTable(tableSize, flags & INIT_VLC_USE_NEW_STATIC); + //warning("new table index=%d size=%d", tableIndex, tableSize); + if (tableIndex < 0) + return tableIndex; + table = &vlc->_table[tableIndex]; // first pass: map codes and compute auxiliary table sizes - for (i = 0; i < nb_codes; i++) { + for (i = 0; i < nbCodes; i++) { n = codes[i].bits; code = codes[i].code; symbol = codes[i].symbol; //warning("i=%d n=%d code=0x%x", i, n, code); - if (n <= table_nb_bits) { + if (n <= tableNbBits) { // no need to add another table - j = code >> (32 - table_nb_bits); - nb = 1 << (table_nb_bits - n); + j = code >> (32 - tableNbBits); + nb = 1 << (tableNbBits - n); inc = 1; if (flags & INIT_VLC_LE) { j = bitswap32(code); @@ -255,70 +255,67 @@ int VLC::build_table(int table_nb_bits, int nb_codes, } } else { // fill auxiliary table recursively - n -= table_nb_bits; - code_prefix = code >> (32 - table_nb_bits); - subtable_bits = n; + n -= tableNbBits; + codePrefix = code >> (32 - tableNbBits); + subtableBits = n; codes[i].bits = n; - codes[i].code = code << table_nb_bits; - for (k = i + 1; k < nb_codes; k++) { - n = codes[k].bits - table_nb_bits; + codes[i].code = code << tableNbBits; + for (k = i + 1; k < nbCodes; k++) { + n = codes[k].bits - tableNbBits; if (n <= 0) break; code = codes[k].code; - if (code >> (32 - table_nb_bits) != (uint)code_prefix) + if (code >> (32 - tableNbBits) != (uint)codePrefix) break; codes[k].bits = n; - codes[k].code = code << table_nb_bits; - subtable_bits = MAX(subtable_bits, n); + codes[k].code = code << tableNbBits; + subtableBits = MAX(subtableBits, n); } - subtable_bits = MIN(subtable_bits, table_nb_bits); - j = (flags & INIT_VLC_LE) ? bitswap32(code_prefix) >> (32 - table_nb_bits) : code_prefix; - table[j][1] = -subtable_bits; - //warning("%4x: n=%d (subtable)", j, codes[i].bits + table_nb_bits); - index = vlc->build_table(subtable_bits, k - i, codes + i, flags); + subtableBits = MIN(subtableBits, tableNbBits); + j = (flags & INIT_VLC_LE) ? bitswap32(codePrefix) >> (32 - tableNbBits) : codePrefix; + table[j][1] = -subtableBits; + //warning("%4x: n=%d (subtable)", j, codes[i].bits + tableNbBits); + index = vlc->buildTable(subtableBits, k - i, codes + i, flags); if (index < 0) return index; // note: realloc has been done, so reload tables - table = (VLC_TYPE (*)[2])&vlc->_table[table_index]; + table = (VLC_TYPE (*)[2])&vlc->_table[tableIndex]; table[j][0] = index; //code i = k - 1; } } - for (i = 0; i < table_size; i++) { + for (i = 0; i < tableSize; i++) { if (table[i][1] == 0) //bits table[i][0] = -1; //codes } - return table_index; + return tableIndex; } -int VLC::alloc_table(int size, int use_static) { +int VLC::allocTable(int size, int useStatic) { VLC *vlc = this; - int index = vlc->_table_size; + int index = vlc->_tableSize; - vlc->_table_size += size; - if (vlc->_table_size > vlc->_table_allocated) { + vlc->_tableSize += size; + if (vlc->_tableSize > vlc->_tableAllocated) { // cannot do anything, init_vlc() is used with too little memory - assert(!use_static); + assert(!useStatic); - vlc->_table_allocated += (1 << vlc->_bits); - vlc->_table = (int16(*)[2])avReallocF(vlc->_table, vlc->_table_allocated, sizeof(VLC_TYPE) * 2); + vlc->_tableAllocated += (1 << vlc->_bits); + vlc->_table = (int16(*)[2])avReallocF(vlc->_table, vlc->_tableAllocated, sizeof(VLC_TYPE) * 2); if (!vlc->_table) { - vlc->_table_allocated = 0; - vlc->_table_size = 0; + vlc->_tableAllocated = 0; + vlc->_tableSize = 0; return -2; } - memset(vlc->_table + vlc->_table_allocated - (1 << vlc->_bits), 0, sizeof(VLC_TYPE) * 2 << vlc->_bits); + memset(vlc->_table + vlc->_tableAllocated - (1 << vlc->_bits), 0, sizeof(VLC_TYPE) * 2 << vlc->_bits); } return index; } -/** -* VLC decoding -*/ uint VLC::getData(const void *table, uint idx, uint wrap, uint size) { const uint8 *ptr = (const uint8 *)table + idx * wrap; diff --git a/image/codecs/indeo/vlc.h b/image/codecs/indeo/vlc.h index 01c7b1160b..51e887d3ae 100644 --- a/image/codecs/indeo/vlc.h +++ b/image/codecs/indeo/vlc.h @@ -56,7 +56,7 @@ struct VLCcode { struct VLC { private: - static int compare_vlcspec(const void *a, const void *b); + static int compareVlcSpec(const void *a, const void *b); /** * Gets a value of a given size from a table @@ -69,17 +69,17 @@ private: public: int _bits; VLC_TYPE (*_table)[2]; ///< code, bits - int _table_size, _table_allocated; + int _tableSize, _tableAllocated; VLC(); /* Build VLC decoding tables suitable for use with get_vlc(). - 'nb_bits' sets the decoding table size (2^nb_bits) entries. The + 'nbBits' sets the decoding table size (2^nbBits) 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. - 'nb_codes' : number of vlcs codes + 'nbCodes' : number of vlcs codes 'bits' : table which gives the size (in bits) of each vlc code. @@ -96,52 +96,39 @@ public: 'wrap' and 'size' make it possible to use any memory configuration and types (byte/word/long) to store the 'bits', 'codes', and 'symbols' tables. - 'use_static' should be set to 1 for tables, which should be freed - with av_free_static(), 0 if ff_free_vlc() will be used. + 'useStatic' should be set to 1 for tables, which should be freed + with av_free_static(), 0 if freeVlc() will be used. */ - int init_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, - const void *symbols, int symbols_wrap, int symbols_size, int flags); + int init_vlc(int nbBits, int nbCodes, const void *bits, int bitsWrap, + int bitsSize, const void *codes, int codesWrap, int codesSize, + const void *symbols, int symbolsWrap, int symbolsSize, int flags); - int init_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, int flags); + int init_vlc(int nbBits, int nbCodes, const void *bits, int bitsWrap, int bitsSize, + const void *codes, int codesWrap, int codesSize, int flags); /** * Free VLC data */ - void ff_free_vlc(); + void freeVlc(); /** * Build VLC decoding tables suitable for use with get_vlc(). * - * @param table_nb_bits max length of vlc codes to store directly in this table + * @param tableNbBits max length of vlc codes to store directly in this table * (Longer codes are delegated to subtables.) * - * @param nb_codes number of elements in codes[] + * @param nbCodes number of elements in codes[] * * @param codes descriptions of the vlc codes * These must be ordered such that codes going into the same subtable are contiguous. * Sorting by VLCcode.code is sufficient, though not necessary. */ - int build_table(int table_nb_bits, int nb_codes, - VLCcode *codes, int flags); + int buildTable(int tableNbBits, int nbCodes, VLCcode *codes, int flags); - int alloc_table(int size, int use_static); + int allocTable(int size, int useStatic); }; - -/** - * Reverse "nbits" bits of the value "val" and return the result - * in the least significant bits. - */ -extern uint16 inv_bits(uint16 val, int nbits); - -/** - * Swap the order of the bytes in the passed value - */ -extern uint32 bitswap_32(uint32 x); - } // End of namespace Indeo } // End of namespace Image diff --git a/image/codecs/indeo4.cpp b/image/codecs/indeo4.cpp index 60707e6642..7daecf4c20 100644 --- a/image/codecs/indeo4.cpp +++ b/image/codecs/indeo4.cpp @@ -35,6 +35,7 @@ #include "common/util.h" #include "graphics/yuv_to_rgb.h" #include "image/codecs/indeo4.h" +#include "image/codecs/indeo/indeo_dsp.h" #include "image/codecs/indeo/mem.h" namespace Image { @@ -259,10 +260,10 @@ void Indeo4Decoder::switchBuffers() { } if (is_prev_ref && is_ref) { - FFSWAP(int, _ctx._dstBuf, _ctx._refBuf); + SWAP(_ctx._dstBuf, _ctx._refBuf); } else if (is_prev_ref) { - FFSWAP(int, _ctx._refBuf, _ctx._bRefBuf); - FFSWAP(int, _ctx._dstBuf, _ctx._refBuf); + SWAP(_ctx._refBuf, _ctx._bRefBuf); + SWAP(_ctx._dstBuf, _ctx._refBuf); } } @@ -459,7 +460,7 @@ int Indeo4Decoder::decodeMbInfo(IVIBandDesc *band, IVITile *tile) { blksPerMb = band->_mbSize != band->_blkSize ? 4 : 1; mbTypeBits = _ctx._frameType == IVI4_FRAMETYPE_BIDIR ? 2 : 1; - /* scale factor for motion vectors */ + // scale factor for motion vectors mvScale = (_ctx._planes[0]._bands[0]._mbSize >> 3) - (band->_mbSize >> 3); mvX = mvY = 0; diff --git a/image/codecs/indeo4.h b/image/codecs/indeo4.h index 26bddaa4b3..4a6279db37 100644 --- a/image/codecs/indeo4.h +++ b/image/codecs/indeo4.h @@ -20,9 +20,6 @@ * */ -#include "common/scummsys.h" -#include "image/codecs/indeo/get_bits.h" - /* Intel Indeo 4 decompressor, derived from ffmpeg. * * Original copyright note: @@ -35,8 +32,6 @@ #include "image/codecs/indeo/get_bits.h" #include "image/codecs/indeo/indeo.h" -#include "image/codecs/indeo/indeo_dsp.h" -#include "graphics/managed_surface.h" namespace Image { @@ -81,7 +76,7 @@ protected: * Decode Indeo 4 band header. * * @param[in,out] band pointer to the band descriptor - * @return result code: 0 = OK, negative number = error + * @returns result code: 0 = OK, negative number = error */ virtual int decodeBandHeader(IVIBandDesc *band); @@ -91,7 +86,7 @@ protected: * * @param[in,out] band pointer to the band descriptor * @param[in,out] tile pointer to the tile descriptor - * @return result code: 0 = OK, negative number = error + * @returns result code: 0 = OK, negative number = error */ virtual int decodeMbInfo(IVIBandDesc *band, IVITile *tile); private: diff --git a/image/codecs/indeo5.cpp b/image/codecs/indeo5.cpp index 2b33a6b09c..147bf44823 100644 --- a/image/codecs/indeo5.cpp +++ b/image/codecs/indeo5.cpp @@ -35,6 +35,7 @@ #include "common/util.h" #include "graphics/yuv_to_rgb.h" #include "image/codecs/indeo5.h" +#include "image/codecs/indeo/indeo_dsp.h" #include "image/codecs/indeo/mem.h" namespace Image { @@ -104,7 +105,6 @@ const Graphics::Surface *Indeo5Decoder::decodeFrame(Common::SeekableReadStream & } int Indeo5Decoder::decodePictureHeader() { - int picSizeIndx, i, p; IVIPicConfig picConf; int ret; @@ -176,7 +176,7 @@ void Indeo5Decoder::switchBuffers() { _ctx._ref2Buf = 2; _ctx._interScal = 1; } - FFSWAP(int, _ctx._dstBuf, _ctx._ref2Buf); + SWAP(_ctx._dstBuf, _ctx._ref2Buf); _ctx._refBuf = _ctx._ref2Buf; break; @@ -206,8 +206,8 @@ bool Indeo5Decoder::isNonNullFrame() const { } int Indeo5Decoder::decodeBandHeader(IVIBandDesc *band) { - int i, ret; - uint8 bandFlags; + int i, ret; + uint8 bandFlags; bandFlags = _ctx._gb->getBits(8); @@ -369,10 +369,10 @@ int Indeo5Decoder::decodeMbInfo(IVIBandDesc *band, IVITile *tile) { s = band->_isHalfpel; if (mb->_type) - if (x + (mb->_mvX >> s) + (y + (mb->_mvY >> s))*band->_pitch < 0 || + if (x + (mb->_mvX >> s) + (y + (mb->_mvY >> s)) * band->_pitch < 0 || x + ((mb->_mvX + s) >> s) + band->_mbSize - 1 - + (y + band->_mbSize - 1 + ((mb->_mvY + s) >> s))*band->_pitch > band->_bufSize - 1) { - warning("motion vector %d %d outside reference", x*s + mb->_mvX, y*s + mb->_mvY); + + (y + band->_mbSize - 1 + ((mb->_mvY + s) >> s)) * band->_pitch > band->_bufSize - 1) { + warning("motion vector %d %d outside reference", x*s + mb->_mvX, y * s + mb->_mvY); return -1; } @@ -391,7 +391,7 @@ int Indeo5Decoder::decodeMbInfo(IVIBandDesc *band, IVITile *tile) { } int Indeo5Decoder::decode_gop_header() { - int result, i, p, tile_size, picSizeIndx, mbSize, blkSize, isScalable; + int result, i, p, tileSize, picSizeIndx, mbSize, blkSize, isScalable; int quantMat; bool blkSizeChanged = false; IVIBandDesc *band, *band1, *band2; @@ -404,9 +404,9 @@ int Indeo5Decoder::decode_gop_header() { if (_ctx._gopFlags & IVI5_IS_PROTECTED) _ctx._lockWord = _ctx._gb->getBits(32); - tile_size = (_ctx._gopFlags & 0x40) ? 64 << _ctx._gb->getBits(2) : 0; - if (tile_size > 256) { - warning("Invalid tile size: %d", tile_size); + tileSize = (_ctx._gopFlags & 0x40) ? 64 << _ctx._gb->getBits(2) : 0; + if (tileSize > 256) { + warning("Invalid tile size: %d", tileSize); return -1; } @@ -438,11 +438,11 @@ int Indeo5Decoder::decode_gop_header() { picConf._chromaHeight = (picConf._picHeight + 3) >> 2; picConf._chromaWidth = (picConf._picWidth + 3) >> 2; - if (!tile_size) { + if (!tileSize) { picConf._tileHeight = picConf._picHeight; picConf._tileWidth = picConf._picWidth; } else { - picConf._tileHeight = picConf._tileWidth = tile_size; + picConf._tileHeight = picConf._tileWidth = tileSize; } // check if picture layout was changed and reallocate buffers @@ -465,8 +465,8 @@ int Indeo5Decoder::decode_gop_header() { mbSize = _ctx._gb->getBit(); blkSize = 8 >> _ctx._gb->getBit(); - mbSize = blkSize << !mbSize; - + mbSize = blkSize << (!mbSize ? 1 : 0); + if (p == 0 && blkSize == 4) { warning("4x4 luma blocks are unsupported!"); return -2; diff --git a/image/codecs/indeo5.h b/image/codecs/indeo5.h index 169bef9794..704bda5e4b 100644 --- a/image/codecs/indeo5.h +++ b/image/codecs/indeo5.h @@ -20,9 +20,6 @@ * */ -#include "common/scummsys.h" -#include "image/codecs/indeo/get_bits.h" - /* Intel Indeo 4 decompressor, derived from ffmpeg. * * Original copyright note: @@ -35,8 +32,6 @@ #include "image/codecs/indeo/get_bits.h" #include "image/codecs/indeo/indeo.h" -#include "image/codecs/indeo/indeo_dsp.h" -#include "graphics/managed_surface.h" namespace Image { -- cgit v1.2.3