aboutsummaryrefslogtreecommitdiff
path: root/image/codecs/indeo/vlc.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'image/codecs/indeo/vlc.cpp')
-rw-r--r--image/codecs/indeo/vlc.cpp219
1 files changed, 108 insertions, 111 deletions
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<end && cmp(mid, mid+1) <= 0)\
mid++;\
if(mid==end)\
break;\
}\
- if(end-left < left-start){\
- stack[sp ][0]= start;\
- stack[sp++][1]= right;\
- start = left+1;\
- }else{\
- stack[sp ][0]= left+1;\
- stack[sp++][1]= end;\
+ if (end - left < left - start){\
+ stack[sp ][0] = start;\
+ stack[sp++][1] = right;\
+ start = left + 1;\
+ } else {\
+ stack[sp ][0] = left+1;\
+ stack[sp++][1] = end;\
end = right;\
}\
- }else{\
- if(cmp(start, end) > 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<<buf[j].bits)) { \
+ buf[j].code = getData(codes, i, codesWrap, codesSize); \
+ if (buf[j].code >= (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;
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-04 06:24:16 +0000