mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-13 12:39:56 +00:00
IMAGE: Cleanup of miscellaneous methods and arrays in Indeo decoders
This commit is contained in:
parent
e06442afb6
commit
9c6a55a2a6
@ -105,7 +105,7 @@ int IVIHuffDesc::createHuffFromDesc(VLC *vlc, bool flag) const {
|
||||
if (bits[pos] > IVI_VLC_BITS)
|
||||
return -1; // invalid descriptor
|
||||
|
||||
codewords[pos] = inv_bits((prefix | j), bits[pos]);
|
||||
codewords[pos] = invertBits((prefix | j), bits[pos]);
|
||||
if (!bits[pos])
|
||||
bits[pos] = 1;
|
||||
|
||||
@ -227,8 +227,8 @@ int IVIBandDesc::initTiles(IVITile *refTile, int p, int b, int tHeight, int tWid
|
||||
tile->_numMBs = IVI_MBs_PER_TILE(tile->_width, tile->_height,
|
||||
_mbSize);
|
||||
|
||||
av_freep(&tile->_mbs);
|
||||
tile->_mbs = (IVIMbInfo *)av_mallocz_array(tile->_numMBs, sizeof(IVIMbInfo));
|
||||
avFreeP(&tile->_mbs);
|
||||
tile->_mbs = (IVIMbInfo *)avMallocZArray(tile->_numMBs, sizeof(IVIMbInfo));
|
||||
if (!tile->_mbs)
|
||||
return -2;
|
||||
|
||||
@ -289,7 +289,7 @@ int IVIPlaneDesc::initPlanes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool
|
||||
planes[1]._numBands = planes[2]._numBands = cfg->_chromaBands;
|
||||
|
||||
for (p = 0; p < 3; p++) {
|
||||
planes[p]._bands = (IVIBandDesc *)av_mallocz_array(planes[p]._numBands, sizeof(IVIBandDesc));
|
||||
planes[p]._bands = (IVIBandDesc *)avMallocZArray(planes[p]._numBands, sizeof(IVIBandDesc));
|
||||
if (!planes[p]._bands)
|
||||
return -2;
|
||||
|
||||
@ -316,20 +316,20 @@ int IVIPlaneDesc::initPlanes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool
|
||||
band->_height = b_height;
|
||||
band->_pitch = width_aligned;
|
||||
band->_aHeight = height_aligned;
|
||||
band->_bufs[0] = (int16 *)av_mallocz(bufSize);
|
||||
band->_bufs[1] = (int16 *)av_mallocz(bufSize);
|
||||
band->_bufs[0] = (int16 *)avMallocZ(bufSize);
|
||||
band->_bufs[1] = (int16 *)avMallocZ(bufSize);
|
||||
band->_bufSize = bufSize / 2;
|
||||
if (!band->_bufs[0] || !band->_bufs[1])
|
||||
return -2;
|
||||
|
||||
// allocate the 3rd band buffer for scalability mode
|
||||
if (cfg->_lumaBands > 1) {
|
||||
band->_bufs[2] = (int16 *)av_mallocz(bufSize);
|
||||
band->_bufs[2] = (int16 *)avMallocZ(bufSize);
|
||||
if (!band->_bufs[2])
|
||||
return -2;
|
||||
}
|
||||
if (isIndeo4) {
|
||||
band->_bufs[3] = (int16 *)av_mallocz(bufSize);
|
||||
band->_bufs[3] = (int16 *)avMallocZ(bufSize);
|
||||
if (!band->_bufs[3])
|
||||
return -2;
|
||||
}
|
||||
@ -362,8 +362,8 @@ int IVIPlaneDesc::initTiles(IVIPlaneDesc *planes, int tileWidth, int tileHeight)
|
||||
yTiles = IVI_NUM_TILES(band->_height, tHeight);
|
||||
band->_numTiles = xTiles * yTiles;
|
||||
|
||||
av_freep(&band->_tiles);
|
||||
band->_tiles = (IVITile *)av_mallocz_array(band->_numTiles, sizeof(IVITile));
|
||||
avFreeP(&band->_tiles);
|
||||
band->_tiles = (IVITile *)avMallocZArray(band->_numTiles, sizeof(IVITile));
|
||||
if (!band->_tiles)
|
||||
return -2;
|
||||
|
||||
@ -385,18 +385,18 @@ void IVIPlaneDesc::freeBuffers(IVIPlaneDesc *planes) {
|
||||
for (p = 0; p < 3; p++) {
|
||||
if (planes[p]._bands)
|
||||
for (b = 0; b < planes[p]._numBands; b++) {
|
||||
av_freep(&planes[p]._bands[b]._bufs[0]);
|
||||
av_freep(&planes[p]._bands[b]._bufs[1]);
|
||||
av_freep(&planes[p]._bands[b]._bufs[2]);
|
||||
av_freep(&planes[p]._bands[b]._bufs[3]);
|
||||
avFreeP(&planes[p]._bands[b]._bufs[0]);
|
||||
avFreeP(&planes[p]._bands[b]._bufs[1]);
|
||||
avFreeP(&planes[p]._bands[b]._bufs[2]);
|
||||
avFreeP(&planes[p]._bands[b]._bufs[3]);
|
||||
|
||||
if (planes[p]._bands[b]._blkVlc._custTab._table)
|
||||
planes[p]._bands[b]._blkVlc._custTab.ff_free_vlc();
|
||||
for (t = 0; t < planes[p]._bands[b]._numTiles; t++)
|
||||
av_freep(&planes[p]._bands[b]._tiles[t]._mbs);
|
||||
av_freep(&planes[p]._bands[b]._tiles);
|
||||
avFreeP(&planes[p]._bands[b]._tiles[t]._mbs);
|
||||
avFreeP(&planes[p]._bands[b]._tiles);
|
||||
}
|
||||
av_freep(&planes[p]._bands);
|
||||
avFreeP(&planes[p]._bands);
|
||||
planes[p]._numBands = 0;
|
||||
}
|
||||
}
|
||||
@ -427,11 +427,11 @@ int AVFrame::getBuffer(int flags) {
|
||||
freeFrame();
|
||||
|
||||
// Luminance channel
|
||||
_data[0] = (uint8 *)av_mallocz(_width * _height);
|
||||
_data[0] = (uint8 *)avMallocZ(_width * _height);
|
||||
|
||||
// UV Chroma Channels
|
||||
_data[1] = (uint8 *)av_malloc(_width * _height);
|
||||
_data[2] = (uint8 *)av_malloc(_width * _height);
|
||||
_data[1] = (uint8 *)avMalloc(_width * _height);
|
||||
_data[2] = (uint8 *)avMalloc(_width * _height);
|
||||
Common::fill(_data[1], _data[1] + _width * _height, 0x80);
|
||||
Common::fill(_data[2], _data[2] + _width * _height, 0x80);
|
||||
|
||||
@ -439,9 +439,9 @@ int AVFrame::getBuffer(int flags) {
|
||||
}
|
||||
|
||||
void AVFrame::freeFrame() {
|
||||
av_freep(&_data[0]);
|
||||
av_freep(&_data[1]);
|
||||
av_freep(&_data[2]);
|
||||
avFreeP(&_data[0]);
|
||||
avFreeP(&_data[1]);
|
||||
avFreeP(&_data[2]);
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
@ -739,10 +739,10 @@ void IndeoDecoderBase::recomposeHaar(const IVIPlaneDesc *_plane,
|
||||
p3 = (b0 - b1 - b2 + b3 + 2) >> 2;
|
||||
|
||||
// bias, convert and output four pixels
|
||||
dst[x] = av_clip_uint8(p0 + 128);
|
||||
dst[x + 1] = av_clip_uint8(p1 + 128);
|
||||
dst[dstPitch + x] = av_clip_uint8(p2 + 128);
|
||||
dst[dstPitch + x + 1] = av_clip_uint8(p3 + 128);
|
||||
dst[x] = avClipUint8(p0 + 128);
|
||||
dst[x + 1] = avClipUint8(p1 + 128);
|
||||
dst[dstPitch + x] = avClipUint8(p2 + 128);
|
||||
dst[dstPitch + x + 1] = avClipUint8(p3 + 128);
|
||||
}// for x
|
||||
|
||||
dst += dstPitch << 1;
|
||||
@ -893,10 +893,10 @@ void IndeoDecoderBase::recompose53(const IVIPlaneDesc *_plane,
|
||||
}
|
||||
|
||||
// output four pixels
|
||||
dst[x] = av_clip_uint8((p0 >> 6) + 128);
|
||||
dst[x + 1] = av_clip_uint8((p1 >> 6) + 128);
|
||||
dst[dstPitch + x] = av_clip_uint8((p2 >> 6) + 128);
|
||||
dst[dstPitch + x + 1] = av_clip_uint8((p3 >> 6) + 128);
|
||||
dst[x] = avClipUint8((p0 >> 6) + 128);
|
||||
dst[x + 1] = avClipUint8((p1 >> 6) + 128);
|
||||
dst[dstPitch + x] = avClipUint8((p2 >> 6) + 128);
|
||||
dst[dstPitch + x + 1] = avClipUint8((p3 >> 6) + 128);
|
||||
}// for x
|
||||
|
||||
dst += dstPitch << 1;
|
||||
@ -920,7 +920,7 @@ void IndeoDecoderBase::outputPlane(IVIPlaneDesc *_plane, uint8 *dst, int dstPitc
|
||||
|
||||
for (y = 0; y < _plane->_height; y++) {
|
||||
for (x = 0; x < _plane->_width; x++)
|
||||
dst[x] = av_clip_uint8(src[x] + 128);
|
||||
dst[x] = avClipUint8(src[x] + 128);
|
||||
src += pitch;
|
||||
dst += dstPitch;
|
||||
}
|
||||
@ -1006,8 +1006,8 @@ int IndeoDecoderBase::processEmptyTile(IVIBandDesc *band,
|
||||
|
||||
if (band->_inheritMv && needMc) { // apply motion compensation if there is at least one non-zero motion vector
|
||||
numBlocks = (band->_mbSize != band->_blkSize) ? 4 : 1; // number of blocks per mb
|
||||
mcNoDeltaFunc = (band->_blkSize == 8) ? IndeoDSP::ff_ivi_mc_8x8_no_delta
|
||||
: IndeoDSP::ff_ivi_mc_4x4_no_delta;
|
||||
mcNoDeltaFunc = (band->_blkSize == 8) ? IndeoDSP::ffIviMc8x8NoDelta
|
||||
: IndeoDSP::ffIviMc4x4NoDelta;
|
||||
|
||||
for (mbn = 0, mb = tile->_mbs; mbn < tile->_numMBs; mb++, mbn++) {
|
||||
mvX = mb->_mvX;
|
||||
@ -1075,15 +1075,15 @@ int IndeoDecoderBase::decodeBlocks(GetBits *_gb, IVIBandDesc *band, IVITile *til
|
||||
// number of blocks per mb
|
||||
numBlocks = (band->_mbSize != blkSize) ? 4 : 1;
|
||||
if (blkSize == 8) {
|
||||
mcWithDeltaFunc = IndeoDSP::ff_ivi_mc_8x8_delta;
|
||||
mcNoDeltaFunc = IndeoDSP::ff_ivi_mc_8x8_no_delta;
|
||||
mcAvgWithDeltaFunc = IndeoDSP::ff_ivi_mc_avg_8x8_delta;
|
||||
mcAvgNoDeltaFunc = IndeoDSP::ff_ivi_mc_avg_8x8_no_delta;
|
||||
mcWithDeltaFunc = IndeoDSP::ffIviMc8x8Delta;
|
||||
mcNoDeltaFunc = IndeoDSP::ffIviMc8x8NoDelta;
|
||||
mcAvgWithDeltaFunc = IndeoDSP::ffIviMcAvg8x8Delta;
|
||||
mcAvgNoDeltaFunc = IndeoDSP::ffIviMcAvg8x8NoDelta;
|
||||
} else {
|
||||
mcWithDeltaFunc = IndeoDSP::ff_ivi_mc_4x4_delta;
|
||||
mcNoDeltaFunc = IndeoDSP::ff_ivi_mc_4x4_no_delta;
|
||||
mcAvgWithDeltaFunc = IndeoDSP::ff_ivi_mc_avg_4x4_delta;
|
||||
mcAvgNoDeltaFunc = IndeoDSP::ff_ivi_mc_avg_4x4_no_delta;
|
||||
mcWithDeltaFunc = IndeoDSP::ffIviMc4x4Delta;
|
||||
mcNoDeltaFunc = IndeoDSP::ffIviMc4x4NoDelta;
|
||||
mcAvgWithDeltaFunc = IndeoDSP::ffIviMcAvg4x4Delta;
|
||||
mcAvgNoDeltaFunc = IndeoDSP::ffIviMcAvg4x4NoDelta;
|
||||
}
|
||||
|
||||
for (mbn = 0, mb = tile->_mbs; mbn < tile->_numMBs; mb++, mbn++) {
|
||||
@ -1093,7 +1093,7 @@ int IndeoDecoderBase::decodeBlocks(GetBits *_gb, IVIBandDesc *band, IVITile *til
|
||||
|
||||
quant = band->_globQuant + mb->_qDelta;
|
||||
if (_ctx._isIndeo4)
|
||||
quant = av_clip_uintp2(quant, 5);
|
||||
quant = avClipUintp2(quant, 5);
|
||||
else
|
||||
quant = av_clip((int)quant, 0, 23);
|
||||
|
||||
@ -1346,7 +1346,7 @@ int IndeoDecoderBase::ivi_dc_transform(IVIBandDesc *band, int *prevDc,
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
|
||||
const uint8 IndeoDecoderBase::_ff_ivi_vertical_scan_8x8[64] = {
|
||||
const uint8 IndeoDecoderBase::_ffIviVerticalScan8x8[64] = {
|
||||
0, 8, 16, 24, 32, 40, 48, 56,
|
||||
1, 9, 17, 25, 33, 41, 49, 57,
|
||||
2, 10, 18, 26, 34, 42, 50, 58,
|
||||
@ -1357,7 +1357,7 @@ const uint8 IndeoDecoderBase::_ff_ivi_vertical_scan_8x8[64] = {
|
||||
7, 15, 23, 31, 39, 47, 55, 63
|
||||
};
|
||||
|
||||
const uint8 IndeoDecoderBase::_ff_ivi_horizontal_scan_8x8[64] = {
|
||||
const uint8 IndeoDecoderBase::_ffIviHorizontalScan8x8[64] = {
|
||||
0, 1, 2, 3, 4, 5, 6, 7,
|
||||
8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23,
|
||||
@ -1368,7 +1368,7 @@ const uint8 IndeoDecoderBase::_ff_ivi_horizontal_scan_8x8[64] = {
|
||||
56, 57, 58, 59, 60, 61, 62, 63
|
||||
};
|
||||
|
||||
const uint8 IndeoDecoderBase::_ff_ivi_direct_scan_4x4[16] = {
|
||||
const uint8 IndeoDecoderBase::_ffIviDirectScan4x4[16] = {
|
||||
0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
|
||||
};
|
||||
|
||||
|
@ -523,9 +523,9 @@ protected:
|
||||
/**
|
||||
* Scan patterns shared between indeo4 and indeo5
|
||||
*/
|
||||
static const uint8 _ff_ivi_vertical_scan_8x8[64];
|
||||
static const uint8 _ff_ivi_horizontal_scan_8x8[64];
|
||||
static const uint8 _ff_ivi_direct_scan_4x4[16];
|
||||
static const uint8 _ffIviVerticalScan8x8[64];
|
||||
static const uint8 _ffIviHorizontalScan8x8[64];
|
||||
static const uint8 _ffIviDirectScan4x4[16];
|
||||
protected:
|
||||
/**
|
||||
* Returns the pixel format for the decoder's surface
|
||||
|
@ -71,13 +71,13 @@ namespace Indeo {
|
||||
d3 = COMPENSATE(t2);\
|
||||
d4 = COMPENSATE(t3); }
|
||||
|
||||
void IndeoDSP::ff_ivi_inverse_haar_8x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
void IndeoDSP::ffIviInverseHaar8x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags) {
|
||||
int i, shift, sp1, sp2, sp3, sp4;
|
||||
int i, shift, sp1, sp2, sp3, sp4;
|
||||
const int32 *src;
|
||||
int32 *dst;
|
||||
int tmp[64];
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
int32 * dst;
|
||||
int tmp[64];
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
|
||||
// apply the InvHaar8 to all columns
|
||||
#define COMPENSATE(x) (x)
|
||||
@ -126,10 +126,10 @@ void IndeoDSP::ff_ivi_inverse_haar_8x8(const int32 *in, int16 *out, uint32 pitch
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_row_haar8(const int32 *in, int16 *out, uint32 pitch,
|
||||
void IndeoDSP::ffIviRowHaar8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags) {
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
|
||||
// apply the InvHaar8 to all rows
|
||||
#define COMPENSATE(x) (x)
|
||||
@ -150,10 +150,10 @@ void IndeoDSP::ff_ivi_row_haar8(const int32 *in, int16 *out, uint32 pitch,
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_col_haar8(const int32 *in, int16 *out, uint32 pitch,
|
||||
void IndeoDSP::ffIviColHaar8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags) {
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
|
||||
// apply the InvHaar8 to all columns
|
||||
#define COMPENSATE(x) (x)
|
||||
@ -179,13 +179,13 @@ void IndeoDSP::ff_ivi_col_haar8(const int32 *in, int16 *out, uint32 pitch,
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_inverse_haar_4x4(const int32 *in, int16 *out, uint32 pitch,
|
||||
void IndeoDSP::ffIviInverseHaar4x4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags) {
|
||||
int i, shift, sp1, sp2;
|
||||
int i, shift, sp1, sp2;
|
||||
const int32 *src;
|
||||
int32 *dst;
|
||||
int tmp[16];
|
||||
int t0, t1, t2, t3, t4;
|
||||
int32 * dst;
|
||||
int tmp[16];
|
||||
int t0, t1, t2, t3, t4;
|
||||
|
||||
// apply the InvHaar4 to all columns
|
||||
#define COMPENSATE(x) (x)
|
||||
@ -226,10 +226,10 @@ void IndeoDSP::ff_ivi_inverse_haar_4x4(const int32 *in, int16 *out, uint32 pitch
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_row_haar4(const int32 *in, int16 *out, uint32 pitch,
|
||||
void IndeoDSP::ffIviRowHaar4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags) {
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4;
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4;
|
||||
|
||||
// apply the InvHaar4 to all rows
|
||||
#define COMPENSATE(x) (x)
|
||||
@ -247,10 +247,10 @@ void IndeoDSP::ff_ivi_row_haar4(const int32 *in, int16 *out, uint32 pitch,
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_col_haar4(const int32 *in, int16 *out, uint32 pitch,
|
||||
void IndeoDSP::ffIviColHaar4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags) {
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4;
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4;
|
||||
|
||||
// apply the InvHaar8 to all columns
|
||||
#define COMPENSATE(x) (x)
|
||||
@ -271,16 +271,16 @@ void IndeoDSP::ff_ivi_col_haar4(const int32 *in, int16 *out, uint32 pitch,
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_dc_haar_2d(const int32 *in, int16 *out, uint32 pitch,
|
||||
int blk_size) {
|
||||
int x, y;
|
||||
int16 dc_coeff;
|
||||
void IndeoDSP::ffIviDcHaar2d(const int32 *in, int16 *out, uint32 pitch,
|
||||
int blkSize) {
|
||||
int x, y;
|
||||
int16 dcCoeff;
|
||||
|
||||
dc_coeff = (*in + 0) >> 3;
|
||||
dcCoeff = (*in + 0) >> 3;
|
||||
|
||||
for (y = 0; y < blk_size; out += pitch, y++) {
|
||||
for (x = 0; x < blk_size; x++)
|
||||
out[x] = dc_coeff;
|
||||
for (y = 0; y < blkSize; out += pitch, y++) {
|
||||
for (x = 0; x < blkSize; x++)
|
||||
out[x] = dcCoeff;
|
||||
}
|
||||
}
|
||||
|
||||
@ -334,12 +334,12 @@ void IndeoDSP::ff_ivi_dc_haar_2d(const int32 *in, int16 *out, uint32 pitch,
|
||||
d3 = COMPENSATE(t3);\
|
||||
d4 = COMPENSATE(t4);}
|
||||
|
||||
void IndeoDSP::ff_ivi_inverse_slant_8x8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
|
||||
int i;
|
||||
void IndeoDSP::ffIviInverseSlant8x8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
|
||||
int i;
|
||||
const int32 *src;
|
||||
int32 *dst;
|
||||
int tmp[64];
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
int32 * dst;
|
||||
int tmp[64];
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
|
||||
#define COMPENSATE(x) (x)
|
||||
src = in;
|
||||
@ -374,12 +374,12 @@ void IndeoDSP::ff_ivi_inverse_slant_8x8(const int32 *in, int16 *out, uint32 pitc
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_inverse_slant_4x4(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
|
||||
int i;
|
||||
void IndeoDSP::ffIviInverseSlant4x4(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
|
||||
int i;
|
||||
const int32 *src;
|
||||
int32 *dst;
|
||||
int tmp[16];
|
||||
int t0, t1, t2, t3, t4;
|
||||
int32 * dst;
|
||||
int tmp[16];
|
||||
int t0, t1, t2, t3, t4;
|
||||
|
||||
#define COMPENSATE(x) (x)
|
||||
src = in;
|
||||
@ -413,23 +413,23 @@ void IndeoDSP::ff_ivi_inverse_slant_4x4(const int32 *in, int16 *out, uint32 pitc
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_dc_slant_2d(const int32 *in, int16 *out, uint32 pitch,
|
||||
int blk_size) {
|
||||
int x, y;
|
||||
int16 dc_coeff;
|
||||
void IndeoDSP::ffIviDcSlant2d(const int32 *in, int16 *out, uint32 pitch,
|
||||
int blkSize) {
|
||||
int x, y;
|
||||
int16 dcCoeff;
|
||||
|
||||
dc_coeff = (*in + 1) >> 1;
|
||||
dcCoeff = (*in + 1) >> 1;
|
||||
|
||||
for (y = 0; y < blk_size; out += pitch, y++) {
|
||||
for (x = 0; x < blk_size; x++)
|
||||
out[x] = dc_coeff;
|
||||
for (y = 0; y < blkSize; out += pitch, y++) {
|
||||
for (x = 0; x < blkSize; x++)
|
||||
out[x] = dcCoeff;
|
||||
}
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_row_slant8(const int32 *in, int16 *out, uint32 pitch,
|
||||
void IndeoDSP::ffIviRowSlant8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags) {
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
|
||||
#define COMPENSATE(x) (((x) + 1)>>1)
|
||||
for (i = 0; i < 8; i++) {
|
||||
@ -446,26 +446,26 @@ void IndeoDSP::ff_ivi_row_slant8(const int32 *in, int16 *out, uint32 pitch,
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_dc_row_slant(const int32 *in, int16 *out, uint32 pitch, int blk_size) {
|
||||
int x, y;
|
||||
int16 dc_coeff;
|
||||
void IndeoDSP::ffIviDcRowSlant(const int32 *in, int16 *out, uint32 pitch, int blkSize) {
|
||||
int x, y;
|
||||
int16 dcCoeff;
|
||||
|
||||
dc_coeff = (*in + 1) >> 1;
|
||||
dcCoeff = (*in + 1) >> 1;
|
||||
|
||||
for (x = 0; x < blk_size; x++)
|
||||
out[x] = dc_coeff;
|
||||
for (x = 0; x < blkSize; x++)
|
||||
out[x] = dcCoeff;
|
||||
|
||||
out += pitch;
|
||||
|
||||
for (y = 1; y < blk_size; out += pitch, y++) {
|
||||
for (x = 0; x < blk_size; x++)
|
||||
for (y = 1; y < blkSize; out += pitch, y++) {
|
||||
for (x = 0; x < blkSize; x++)
|
||||
out[x] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_col_slant8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
|
||||
int i, row2, row4, row8;
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
void IndeoDSP::ffIviColSlant8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags) {
|
||||
int i, row2, row4, row8;
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7, t8;
|
||||
|
||||
row2 = pitch << 1;
|
||||
row4 = pitch << 2;
|
||||
@ -489,23 +489,23 @@ void IndeoDSP::ff_ivi_col_slant8(const int32 *in, int16 *out, uint32 pitch, cons
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_dc_col_slant(const int32 *in, int16 *out, uint32 pitch, int blk_size) {
|
||||
int x, y;
|
||||
int16 dc_coeff;
|
||||
void IndeoDSP::ffIviDcColSlant(const int32 *in, int16 *out, uint32 pitch, int blkSize) {
|
||||
int x, y;
|
||||
int16 dcCoeff;
|
||||
|
||||
dc_coeff = (*in + 1) >> 1;
|
||||
dcCoeff = (*in + 1) >> 1;
|
||||
|
||||
for (y = 0; y < blk_size; out += pitch, y++) {
|
||||
out[0] = dc_coeff;
|
||||
for (x = 1; x < blk_size; x++)
|
||||
for (y = 0; y < blkSize; out += pitch, y++) {
|
||||
out[0] = dcCoeff;
|
||||
for (x = 1; x < blkSize; x++)
|
||||
out[x] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_row_slant4(const int32 *in, int16 *out,
|
||||
void IndeoDSP::ffIviRowSlant4(const int32 *in, int16 *out,
|
||||
uint32 pitch, const uint8 *flags) {
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4;
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4;
|
||||
|
||||
#define COMPENSATE(x) (((x) + 1)>>1)
|
||||
for (i = 0; i < 4; i++) {
|
||||
@ -522,10 +522,10 @@ void IndeoDSP::ff_ivi_row_slant4(const int32 *in, int16 *out,
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_col_slant4(const int32 *in, int16 *out, uint32 pitch,
|
||||
void IndeoDSP::ffIviColSlant4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags) {
|
||||
int i, row2;
|
||||
int t0, t1, t2, t3, t4;
|
||||
int i, row2;
|
||||
int t0, t1, t2, t3, t4;
|
||||
|
||||
row2 = pitch << 1;
|
||||
|
||||
@ -545,18 +545,18 @@ void IndeoDSP::ff_ivi_col_slant4(const int32 *in, int16 *out, uint32 pitch,
|
||||
#undef COMPENSATE
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_put_pixels_8x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
void IndeoDSP::ffIviPutPixels8x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags) {
|
||||
int x, y;
|
||||
int x, y;
|
||||
|
||||
for (y = 0; y < 8; out += pitch, in += 8, y++)
|
||||
for (x = 0; x < 8; x++)
|
||||
out[x] = in[x];
|
||||
}
|
||||
|
||||
void IndeoDSP::ff_ivi_put_dc_pixel_8x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
int blk_size) {
|
||||
int y;
|
||||
void IndeoDSP::ffIviPutDcPixel8x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
int blkSize) {
|
||||
int y;
|
||||
|
||||
out[0] = in[0];
|
||||
memset(out + 1, 0, 7*sizeof(out[0]));
|
||||
@ -567,60 +567,60 @@ void IndeoDSP::ff_ivi_put_dc_pixel_8x8(const int32 *in, int16 *out, uint32 pitch
|
||||
}
|
||||
|
||||
#define IVI_MC_TEMPLATE(size, suffix, OP) \
|
||||
static void ivi_mc_ ## size ##x## size ## suffix(int16 *buf, \
|
||||
static void iviMc ## size ##x## size ## suffix(int16 *buf, \
|
||||
uint32 dpitch, \
|
||||
const int16 *ref_buf, \
|
||||
uint32 pitch, int mc_type) \
|
||||
const int16 *refBuf, \
|
||||
uint32 pitch, int mcType) \
|
||||
{ \
|
||||
int i, j; \
|
||||
int i, j; \
|
||||
const int16 *wptr; \
|
||||
\
|
||||
switch (mc_type) { \
|
||||
switch (mcType) { \
|
||||
case 0: /* fullpel (no interpolation) */ \
|
||||
for (i = 0; i < size; i++, buf += dpitch, ref_buf += pitch) { \
|
||||
for (i = 0; i < size; i++, buf += dpitch, refBuf += pitch) { \
|
||||
for (j = 0; j < size; j++) {\
|
||||
OP(buf[j], ref_buf[j]); \
|
||||
OP(buf[j], refBuf[j]); \
|
||||
} \
|
||||
} \
|
||||
break; \
|
||||
case 1: /* horizontal halfpel interpolation */ \
|
||||
for (i = 0; i < size; i++, buf += dpitch, ref_buf += pitch) \
|
||||
for (i = 0; i < size; i++, buf += dpitch, refBuf += pitch) \
|
||||
for (j = 0; j < size; j++) \
|
||||
OP(buf[j], (ref_buf[j] + ref_buf[j+1]) >> 1); \
|
||||
OP(buf[j], (refBuf[j] + refBuf[j+1]) >> 1); \
|
||||
break; \
|
||||
case 2: /* vertical halfpel interpolation */ \
|
||||
wptr = ref_buf + pitch; \
|
||||
for (i = 0; i < size; i++, buf += dpitch, wptr += pitch, ref_buf += pitch) \
|
||||
wptr = refBuf + pitch; \
|
||||
for (i = 0; i < size; i++, buf += dpitch, wptr += pitch, refBuf += pitch) \
|
||||
for (j = 0; j < size; j++) \
|
||||
OP(buf[j], (ref_buf[j] + wptr[j]) >> 1); \
|
||||
OP(buf[j], (refBuf[j] + wptr[j]) >> 1); \
|
||||
break; \
|
||||
case 3: /* vertical and horizontal halfpel interpolation */ \
|
||||
wptr = ref_buf + pitch; \
|
||||
for (i = 0; i < size; i++, buf += dpitch, wptr += pitch, ref_buf += pitch) \
|
||||
wptr = refBuf + pitch; \
|
||||
for (i = 0; i < size; i++, buf += dpitch, wptr += pitch, refBuf += pitch) \
|
||||
for (j = 0; j < size; j++) \
|
||||
OP(buf[j], (ref_buf[j] + ref_buf[j+1] + wptr[j] + wptr[j+1]) >> 2); \
|
||||
OP(buf[j], (refBuf[j] + refBuf[j+1] + wptr[j] + wptr[j+1]) >> 2); \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
void IndeoDSP::ff_ivi_mc_ ## size ##x## size ## suffix(int16 *buf, const int16 *ref_buf, \
|
||||
uint32 pitch, int mc_type) \
|
||||
void IndeoDSP::ffIviMc ## size ##x## size ## suffix(int16 *buf, const int16 *refBuf, \
|
||||
uint32 pitch, int mcType) \
|
||||
{ \
|
||||
ivi_mc_ ## size ##x## size ## suffix(buf, pitch, ref_buf, pitch, mc_type); \
|
||||
iviMc ## size ##x## size ## suffix(buf, pitch, refBuf, pitch, mcType); \
|
||||
}
|
||||
|
||||
#define IVI_MC_AVG_TEMPLATE(size, suffix, OP) \
|
||||
void IndeoDSP::ff_ivi_mc_avg_ ## size ##x## size ## suffix(int16 *buf, \
|
||||
const int16 *ref_buf, \
|
||||
const int16 *ref_buf2, \
|
||||
void IndeoDSP::ffIviMcAvg ## size ##x## size ## suffix(int16 *buf, \
|
||||
const int16 *refBuf, \
|
||||
const int16 *refBuf2, \
|
||||
uint32 pitch, \
|
||||
int mc_type, int mc_type2) \
|
||||
int mcType, int mcType2) \
|
||||
{ \
|
||||
int16 tmp[size * size]; \
|
||||
int i, j; \
|
||||
\
|
||||
ivi_mc_ ## size ##x## size ## _no_delta(tmp, size, ref_buf, pitch, mc_type); \
|
||||
ivi_mc_ ## size ##x## size ## _delta(tmp, size, ref_buf2, pitch, mc_type2); \
|
||||
iviMc ## size ##x## size ## NoDelta(tmp, size, refBuf, pitch, mcType); \
|
||||
iviMc ## size ##x## size ## Delta(tmp, size, refBuf2, pitch, mcType2); \
|
||||
for (i = 0; i < size; i++, buf += pitch) { \
|
||||
for (j = 0; j < size; j++) {\
|
||||
OP(buf[j], tmp[i * size + j] >> 1); \
|
||||
@ -631,14 +631,14 @@ void IndeoDSP::ff_ivi_mc_avg_ ## size ##x## size ## suffix(int16 *buf, \
|
||||
#define OP_PUT(a, b) (a) = (b)
|
||||
#define OP_ADD(a, b) (a) += (b)
|
||||
|
||||
IVI_MC_TEMPLATE(8, _no_delta, OP_PUT)
|
||||
IVI_MC_TEMPLATE(8, _delta, OP_ADD)
|
||||
IVI_MC_TEMPLATE(4, _no_delta, OP_PUT)
|
||||
IVI_MC_TEMPLATE(4, _delta, OP_ADD)
|
||||
IVI_MC_AVG_TEMPLATE(8, _no_delta, OP_PUT)
|
||||
IVI_MC_AVG_TEMPLATE(8, _delta, OP_ADD)
|
||||
IVI_MC_AVG_TEMPLATE(4, _no_delta, OP_PUT)
|
||||
IVI_MC_AVG_TEMPLATE(4, _delta, OP_ADD)
|
||||
IVI_MC_TEMPLATE(8, NoDelta, OP_PUT)
|
||||
IVI_MC_TEMPLATE(8, Delta, OP_ADD)
|
||||
IVI_MC_TEMPLATE(4, NoDelta, OP_PUT)
|
||||
IVI_MC_TEMPLATE(4, Delta, OP_ADD)
|
||||
IVI_MC_AVG_TEMPLATE(8, NoDelta, OP_PUT)
|
||||
IVI_MC_AVG_TEMPLATE(8, Delta, OP_ADD)
|
||||
IVI_MC_AVG_TEMPLATE(4, NoDelta, OP_PUT)
|
||||
IVI_MC_AVG_TEMPLATE(4, Delta, OP_ADD)
|
||||
|
||||
} // End of namespace Indeo
|
||||
} // End of namespace Image
|
||||
|
@ -43,293 +43,293 @@ public:
|
||||
/**
|
||||
* two-dimensional inverse Haar 8x8 transform for Indeo 4
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
*/
|
||||
static void ff_ivi_inverse_haar_8x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ff_ivi_inverse_haar_8x1(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ff_ivi_inverse_haar_1x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviInverseHaar8x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviInverseHaar8x1(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviInverseHaar1x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* one-dimensional inverse 8-point Haar transform on rows for Indeo 4
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
*/
|
||||
static void ff_ivi_row_haar8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviRowHaar8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* one-dimensional inverse 8-point Haar transform on columns for Indeo 4
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
*/
|
||||
static void ff_ivi_col_haar8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviColHaar8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* two-dimensional inverse Haar 4x4 transform for Indeo 4
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
*/
|
||||
static void ff_ivi_inverse_haar_4x4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviInverseHaar4x4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* one-dimensional inverse 4-point Haar transform on rows for Indeo 4
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
*/
|
||||
static void ff_ivi_row_haar4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviRowHaar4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* one-dimensional inverse 4-point Haar transform on columns for Indeo 4
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
*/
|
||||
static void ff_ivi_col_haar4(const int32 *in, int16 *out, uint32 pitch,
|
||||
static void ffIviColHaar4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* DC-only two-dimensional inverse Haar transform for Indeo 4.
|
||||
* Performing the inverse transform in this case is equivalent to
|
||||
* spreading DC_coeff >> 3 over the whole block.
|
||||
* spreading dcCoeff >> 3 over the whole block.
|
||||
*
|
||||
* @param[in] in pointer to the dc coefficient
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] blk_size transform block size
|
||||
* @param[in] in Pointer to the dc coefficient
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] blkSize Transform block size
|
||||
*/
|
||||
static void ff_ivi_dc_haar_2d(const int32 *in, int16 *out, uint32 pitch,
|
||||
int blk_size);
|
||||
static void ffIviDcHaar2d(const int32 *in, int16 *out, uint32 pitch,
|
||||
int blkSize);
|
||||
|
||||
/**
|
||||
* two-dimensional inverse slant 8x8 transform
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
*/
|
||||
static void ff_ivi_inverse_slant_8x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviInverseSlant8x8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* two-dimensional inverse slant 4x4 transform
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
*/
|
||||
static void ff_ivi_inverse_slant_4x4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviInverseSlant4x4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* DC-only two-dimensional inverse slant transform.
|
||||
* Performing the inverse slant transform in this case is equivalent to
|
||||
* spreading (DC_coeff + 1)/2 over the whole block.
|
||||
* spreading (dcCoeff + 1)/2 over the whole block.
|
||||
* It works much faster than performing the slant transform on a vector of zeroes.
|
||||
*
|
||||
* @param[in] in pointer to the dc coefficient
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] blk_size transform block size
|
||||
* @param[in] in Pointer to the dc coefficient
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] blkSize Transform block size
|
||||
*/
|
||||
static void ff_ivi_dc_slant_2d(const int32 *in, int16 *out, uint32 pitch, int blk_size);
|
||||
static void ffIviDcSlant2d(const int32 *in, int16 *out, uint32 pitch, int blkSize);
|
||||
|
||||
/**
|
||||
* inverse 1D row slant transform
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags (unused here)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags (unused here)
|
||||
*/
|
||||
static void ff_ivi_row_slant8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviRowSlant8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* inverse 1D column slant transform
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
*/
|
||||
static void ff_ivi_col_slant8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviColSlant8(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* inverse 1D row slant transform
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags (unused here)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags (unused here)
|
||||
*/
|
||||
static void ff_ivi_row_slant4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviRowSlant4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* inverse 1D column slant transform
|
||||
*
|
||||
* @param[in] in pointer to the vector of transform coefficients
|
||||
* @param[out] out pointer to the output buffer (frame)
|
||||
* @param[in] pitch pitch to move to the next y line
|
||||
* @param[in] flags pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
* @param[in] in Pointer to the vector of transform coefficients
|
||||
* @param[out] out Pointer to the output buffer (frame)
|
||||
* @param[in] pitch Pitch to move to the next y line
|
||||
* @param[in] flags Pointer to the array of column flags:
|
||||
* != 0 - non_empty column, 0 - empty one
|
||||
* (this array must be filled by caller)
|
||||
*/
|
||||
static void ff_ivi_col_slant4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
static void ffIviColSlant4(const int32 *in, int16 *out, uint32 pitch,
|
||||
const uint8 *flags);
|
||||
|
||||
/**
|
||||
* DC-only inverse row slant transform
|
||||
*/
|
||||
static void ff_ivi_dc_row_slant(const int32 *in, int16 *out, uint32 pitch, int blk_size);
|
||||
static void ffIviDcRowSlant(const int32 *in, int16 *out, uint32 pitch, int blkSize);
|
||||
|
||||
/**
|
||||
* DC-only inverse column slant transform
|
||||
*/
|
||||
static void ff_ivi_dc_col_slant(const int32 *in, int16 *out, uint32 pitch, int blk_size);
|
||||
static void ffIviDcColSlant(const int32 *in, int16 *out, uint32 pitch, int blkSize);
|
||||
|
||||
/**
|
||||
* Copy the pixels into the frame buffer.
|
||||
*/
|
||||
static void ff_ivi_put_pixels_8x8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags);
|
||||
static void ffIviPutPixels8x8(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags);
|
||||
|
||||
/**
|
||||
* Copy the DC coefficient into the first pixel of the block and
|
||||
* zero all others.
|
||||
*/
|
||||
static void ff_ivi_put_dc_pixel_8x8(const int32 *in, int16 *out, uint32 pitch, int blk_size);
|
||||
static void ffIviPutDcPixel8x8(const int32 *in, int16 *out, uint32 pitch, int blkSize);
|
||||
|
||||
/**
|
||||
* 8x8 block motion compensation with adding delta
|
||||
*
|
||||
* @param[in,out] buf pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] ref_buf pointer to the corresponding block in the reference frame
|
||||
* @param[in] pitch pitch for moving to the next y line
|
||||
* @param[in] mc_type interpolation type
|
||||
* @param[in,out] buf Pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] refBuf Pointer to the corresponding block in the reference frame
|
||||
* @param[in] pitch Pitch for moving to the next y line
|
||||
* @param[in] mcType Interpolation type
|
||||
*/
|
||||
static void ff_ivi_mc_8x8_delta(int16 *buf, const int16 *ref_buf, uint32 pitch, int mc_type);
|
||||
static void ffIviMc8x8Delta(int16 *buf, const int16 *refBuf, uint32 pitch, int mcType);
|
||||
|
||||
/**
|
||||
* 4x4 block motion compensation with adding delta
|
||||
*
|
||||
* @param[in,out] buf pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] ref_buf pointer to the corresponding block in the reference frame
|
||||
* @param[in] pitch pitch for moving to the next y line
|
||||
* @param[in] mc_type interpolation type
|
||||
* @param[in,out] buf Pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] refBuf Pointer to the corresponding block in the reference frame
|
||||
* @param[in] pitch Pitch for moving to the next y line
|
||||
* @param[in] mcType Interpolation type
|
||||
*/
|
||||
static void ff_ivi_mc_4x4_delta(int16 *buf, const int16 *ref_buf, uint32 pitch, int mc_type);
|
||||
static void ffIviMc4x4Delta(int16 *buf, const int16 *refBuf, uint32 pitch, int mcType);
|
||||
|
||||
/**
|
||||
* motion compensation without adding delta
|
||||
*
|
||||
* @param[in,out] buf pointer to the block in the current frame receiving the result
|
||||
* @param[in] ref_buf pointer to the corresponding block in the reference frame
|
||||
* @param[in] pitch pitch for moving to the next y line
|
||||
* @param[in] mc_type interpolation type
|
||||
* @param[in,out] buf Pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] refBuf Pointer to the corresponding block in the reference frame
|
||||
* @param[in] pitch Pitch for moving to the next y line
|
||||
* @param[in] mcType Interpolation type
|
||||
*/
|
||||
static void ff_ivi_mc_8x8_no_delta(int16 *buf, const int16 *ref_buf, uint32 pitch, int mc_type);
|
||||
static void ffIviMc8x8NoDelta(int16 *buf, const int16 *refBuf, uint32 pitch, int mcType);
|
||||
|
||||
/**
|
||||
* 4x4 block motion compensation without adding delta
|
||||
*
|
||||
* @param[in,out] buf pointer to the block in the current frame receiving the result
|
||||
* @param[in] ref_buf pointer to the corresponding block in the reference frame
|
||||
* @param[in] pitch pitch for moving to the next y line
|
||||
* @param[in] mc_type interpolation type
|
||||
* @param[in,out] buf Pointer to the block in the current frame receiving the result
|
||||
* @param[in] refBuf Pointer to the corresponding block in the reference frame
|
||||
* @param[in] pitch Pitch for moving to the next y line
|
||||
* @param[in] mcType Interpolation type
|
||||
*/
|
||||
static void ff_ivi_mc_4x4_no_delta(int16 *buf, const int16 *ref_buf, uint32 pitch, int mc_type);
|
||||
static void ffIviMc4x4NoDelta(int16 *buf, const int16 *refBuf, uint32 pitch, int mcType);
|
||||
|
||||
/**
|
||||
* 8x8 block motion compensation with adding delta
|
||||
*
|
||||
* @param[in,out] buf pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] ref_buf pointer to the corresponding block in the backward reference frame
|
||||
* @param[in] ref_buf2 pointer to the corresponding block in the forward reference frame
|
||||
* @param[in] pitch pitch for moving to the next y line
|
||||
* @param[in] mc_type interpolation type for backward reference
|
||||
* @param[in] mc_type2 interpolation type for forward reference
|
||||
* @param[in,out] buf Pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] refBuf Pointer to the corresponding block in the backward reference frame
|
||||
* @param[in] refBuf2 Pointer to the corresponding block in the forward reference frame
|
||||
* @param[in] pitch Pitch for moving to the next y line
|
||||
* @param[in] mcType Interpolation type for backward reference
|
||||
* @param[in] mcType2 Interpolation type for forward reference
|
||||
*/
|
||||
static void ff_ivi_mc_avg_8x8_delta(int16 *buf, const int16 *ref_buf, const int16 *ref_buf2, uint32 pitch, int mc_type, int mc_type2);
|
||||
static void ffIviMcAvg8x8Delta(int16 *buf, const int16 *refBuf, const int16 *refBuf2, uint32 pitch, int mcType, int mcType2);
|
||||
|
||||
/**
|
||||
* 4x4 block motion compensation with adding delta
|
||||
*
|
||||
* @param[in,out] buf pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] ref_buf pointer to the corresponding block in the backward reference frame
|
||||
* @param[in] ref_buf2 pointer to the corresponding block in the forward reference frame
|
||||
* @param[in] pitch pitch for moving to the next y line
|
||||
* @param[in] mc_type interpolation type for backward reference
|
||||
* @param[in] mc_type2 interpolation type for forward reference
|
||||
* @param[in,out] buf Pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] refBuf Pointer to the corresponding block in the backward reference frame
|
||||
* @param[in] refBuf2 Pointer to the corresponding block in the forward reference frame
|
||||
* @param[in] pitch Pitch for moving to the next y line
|
||||
* @param[in] mcType Interpolation type for backward reference
|
||||
* @param[in] mcType2 Interpolation type for forward reference
|
||||
*/
|
||||
static void ff_ivi_mc_avg_4x4_delta(int16 *buf, const int16 *ref_buf, const int16 *ref_buf2, uint32 pitch, int mc_type, int mc_type2);
|
||||
static void ffIviMcAvg4x4Delta(int16 *buf, const int16 *refBuf, const int16 *refBuf2, uint32 pitch, int mcType, int mcType2);
|
||||
|
||||
/**
|
||||
* motion compensation without adding delta for B-frames
|
||||
*
|
||||
* @param[in,out] buf pointer to the block in the current frame receiving the result
|
||||
* @param[in] ref_buf pointer to the corresponding block in the backward reference frame
|
||||
* @param[in] ref_buf2 pointer to the corresponding block in the forward reference frame
|
||||
* @param[in] pitch pitch for moving to the next y line
|
||||
* @param[in] mc_type interpolation type for backward reference
|
||||
* @param[in] mc_type2 interpolation type for forward reference
|
||||
* @param[in,out] buf Pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] refBuf Pointer to the corresponding block in the backward reference frame
|
||||
* @param[in] refBuf2 Pointer to the corresponding block in the forward reference frame
|
||||
* @param[in] pitch Pitch for moving to the next y line
|
||||
* @param[in] mcType Interpolation type for backward reference
|
||||
* @param[in] mcType2 Interpolation type for forward reference
|
||||
*/
|
||||
static void ff_ivi_mc_avg_8x8_no_delta(int16 *buf, const int16 *ref_buf, const int16 *ref_buf2, uint32 pitch, int mc_type, int mc_type2);
|
||||
static void ffIviMcAvg8x8NoDelta(int16 *buf, const int16 *refBuf, const int16 *refBuf2, uint32 pitch, int mcType, int mcType2);
|
||||
|
||||
/**
|
||||
* 4x4 block motion compensation without adding delta for B-frames
|
||||
*
|
||||
* @param[in,out] buf pointer to the block in the current frame receiving the result
|
||||
* @param[in] ref_buf pointer to the corresponding block in the backward reference frame
|
||||
* @param[in] ref_buf2 pointer to the corresponding block in the forward reference frame
|
||||
* @param[in] pitch pitch for moving to the next y line
|
||||
* @param[in] mc_type interpolation type for backward reference
|
||||
* @param[in] mc_type2 interpolation type for forward reference
|
||||
* @param[in,out] buf Pointer to the block in the current frame buffer containing delta
|
||||
* @param[in] refBuf Pointer to the corresponding block in the backward reference frame
|
||||
* @param[in] refBuf2 Pointer to the corresponding block in the forward reference frame
|
||||
* @param[in] pitch Pitch for moving to the next y line
|
||||
* @param[in] mcType Interpolation type for backward reference
|
||||
* @param[in] mcType2 Interpolation type for forward reference
|
||||
*/
|
||||
static void ff_ivi_mc_avg_4x4_no_delta(int16 *buf, const int16 *ref_buf, const int16 *ref_buf2, uint32 pitch, int mc_type, int mc_type2);
|
||||
static void ffIviMcAvg4x4NoDelta(int16 *buf, const int16 *refBuf, const int16 *refBuf2, uint32 pitch, int mcType, int mcType2);
|
||||
};
|
||||
|
||||
} // End of namespace Indeo
|
||||
|
@ -31,7 +31,7 @@
|
||||
namespace Image {
|
||||
namespace Indeo {
|
||||
|
||||
const uint8 ff_reverse[256] = {
|
||||
const uint8 ffReverse[256] = {
|
||||
0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
|
||||
0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
|
||||
0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
|
||||
@ -50,6 +50,17 @@ const uint8 ff_reverse[256] = {
|
||||
0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF,
|
||||
};
|
||||
|
||||
const uint8 ffZigZagDirect[64] = {
|
||||
0, 1, 8, 16, 9, 2, 3, 10,
|
||||
17, 24, 32, 25, 18, 11, 4, 5,
|
||||
12, 19, 26, 33, 40, 48, 41, 34,
|
||||
27, 20, 13, 6, 7, 14, 21, 28,
|
||||
35, 42, 49, 56, 57, 50, 43, 36,
|
||||
29, 22, 15, 23, 30, 37, 44, 51,
|
||||
58, 59, 52, 45, 38, 31, 39, 46,
|
||||
53, 60, 61, 54, 47, 55, 62, 63
|
||||
};
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
@ -59,7 +70,7 @@ const uint8 ff_reverse[256] = {
|
||||
* @param[out] r Pointer to the result of the operation
|
||||
* @return 0 on success, AVERROR(EINVAL) on overflow
|
||||
*/
|
||||
static inline int av_size_mult(size_t a, size_t b, size_t *r) {
|
||||
static inline int avSizeMult(size_t a, size_t b, size_t *r) {
|
||||
size_t t = a * b;
|
||||
|
||||
// Hack inspired from glibc: don't try the division if nelem and elsize
|
||||
@ -72,56 +83,56 @@ static inline int av_size_mult(size_t a, size_t b, size_t *r) {
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
|
||||
void *av_malloc(size_t size) {
|
||||
void *avMalloc(size_t size) {
|
||||
return malloc(size);
|
||||
}
|
||||
|
||||
void *av_mallocz(size_t size) {
|
||||
void *ptr = av_malloc(size);
|
||||
void *avMallocZ(size_t size) {
|
||||
void *ptr = avMalloc(size);
|
||||
if (ptr)
|
||||
memset(ptr, 0, size);
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void *av_malloc_array(size_t nmemb, size_t size) {
|
||||
void *avMallocArray(size_t nmemb, size_t size) {
|
||||
if (!size || nmemb >= MAX_INTEGER / size)
|
||||
return nullptr;
|
||||
return malloc(nmemb * size);
|
||||
}
|
||||
|
||||
void *av_mallocz_array(size_t nmemb, size_t size) {
|
||||
void *avMallocZArray(size_t nmemb, size_t size) {
|
||||
if (!size || nmemb >= MAX_INTEGER / size)
|
||||
return NULL;
|
||||
|
||||
return av_mallocz(nmemb * size);
|
||||
return avMallocZ(nmemb * size);
|
||||
}
|
||||
|
||||
void av_free(void *ptr) {
|
||||
void avFree(void *ptr) {
|
||||
free(ptr);
|
||||
}
|
||||
|
||||
void av_freep(void *arg) {
|
||||
void avFreeP(void *arg) {
|
||||
void **ptr = (void **)arg;
|
||||
free(*ptr);
|
||||
*ptr = nullptr;
|
||||
}
|
||||
|
||||
static void *av_realloc(void *ptr, size_t size) {
|
||||
static void *avRealloc(void *ptr, size_t size) {
|
||||
return realloc(ptr, size + !size);
|
||||
}
|
||||
|
||||
void *av_realloc_f(void *ptr, size_t nelem, size_t elsize) {
|
||||
void *avReallocF(void *ptr, size_t nelem, size_t elsize) {
|
||||
size_t size;
|
||||
void *r;
|
||||
|
||||
if (av_size_mult(elsize, nelem, &size)) {
|
||||
av_free(ptr);
|
||||
if (avSizeMult(elsize, nelem, &size)) {
|
||||
avFree(ptr);
|
||||
return nullptr;
|
||||
}
|
||||
r = av_realloc(ptr, size);
|
||||
r = avRealloc(ptr, size);
|
||||
if (!r)
|
||||
av_free(ptr);
|
||||
avFree(ptr);
|
||||
|
||||
return r;
|
||||
}
|
||||
@ -130,53 +141,39 @@ void *av_realloc_f(void *ptr, size_t nelem, size_t elsize) {
|
||||
/**
|
||||
* Swap the order of the bytes in the passed value
|
||||
*/
|
||||
uint32 bitswap_32(uint32 x) {
|
||||
return (uint32)ff_reverse[x & 0xFF] << 24 |
|
||||
(uint32)ff_reverse[(x >> 8) & 0xFF] << 16 |
|
||||
(uint32)ff_reverse[(x >> 16) & 0xFF] << 8 |
|
||||
(uint32)ff_reverse[x >> 24];
|
||||
uint32 bitswap32(uint32 x) {
|
||||
return (uint32)ffReverse[x & 0xFF] << 24 |
|
||||
(uint32)ffReverse[(x >> 8) & 0xFF] << 16 |
|
||||
(uint32)ffReverse[(x >> 16) & 0xFF] << 8 |
|
||||
(uint32)ffReverse[x >> 24];
|
||||
}
|
||||
|
||||
/**
|
||||
* Reverse "nbits" bits of the value "val" and return the result
|
||||
* in the least significant bits.
|
||||
*/
|
||||
uint16 inv_bits(uint16 val, int nbits) {
|
||||
uint16 invertBits(uint16 val, int nbits) {
|
||||
uint16 res;
|
||||
|
||||
if (nbits <= 8) {
|
||||
res = ff_reverse[val] >> (8 - nbits);
|
||||
res = ffReverse[val] >> (8 - nbits);
|
||||
} else {
|
||||
res = ((ff_reverse[val & 0xFF] << 8) +
|
||||
(ff_reverse[val >> 8])) >> (16 - nbits);
|
||||
res = ((ffReverse[val & 0xFF] << 8) +
|
||||
(ffReverse[val >> 8])) >> (16 - nbits);
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
uint8 av_clip_uint8(int a) {
|
||||
uint8 avClipUint8(int a) {
|
||||
if (a&(~0xFF)) return (-a) >> 31;
|
||||
else return a;
|
||||
}
|
||||
|
||||
unsigned av_clip_uintp2(int a, int p) {
|
||||
unsigned avClipUintp2(int a, int p) {
|
||||
if (a & ~((1 << p) - 1)) return -a >> 31 & ((1 << p) - 1);
|
||||
else return a;
|
||||
}
|
||||
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
|
||||
const uint8 ff_zigzag_direct[64] = {
|
||||
0, 1, 8, 16, 9, 2, 3, 10,
|
||||
17, 24, 32, 25, 18, 11, 4, 5,
|
||||
12, 19, 26, 33, 40, 48, 41, 34,
|
||||
27, 20, 13, 6, 7, 14, 21, 28,
|
||||
35, 42, 49, 56, 57, 50, 43, 36,
|
||||
29, 22, 15, 23, 30, 37, 44, 51,
|
||||
58, 59, 52, 45, 38, 31, 39, 46,
|
||||
53, 60, 61, 54, 47, 55, 62, 63
|
||||
};
|
||||
|
||||
} // End of namespace Indeo
|
||||
} // End of namespace Image
|
||||
|
@ -49,7 +49,7 @@ namespace Indeo {
|
||||
* be allocated
|
||||
* @see av_mallocz()
|
||||
*/
|
||||
extern void *av_malloc(size_t size);
|
||||
extern void *avMalloc(size_t size);
|
||||
|
||||
/**
|
||||
* Allocate a memory block with alignment suitable for all memory accesses
|
||||
@ -60,7 +60,7 @@ extern void *av_malloc(size_t size);
|
||||
* @return Pointer to the allocated block, or `NULL` if it cannot be allocated
|
||||
* @see av_malloc()
|
||||
*/
|
||||
extern void *av_mallocz(size_t size);
|
||||
extern void *avMallocZ(size_t size);
|
||||
|
||||
/**
|
||||
* Allocate a memory block for an array with av_malloc().
|
||||
@ -73,7 +73,7 @@ extern void *av_mallocz(size_t size);
|
||||
* be allocated
|
||||
* @see av_malloc()
|
||||
*/
|
||||
extern void *av_malloc_array(size_t nmemb, size_t size);
|
||||
extern void *avMallocArray(size_t nmemb, size_t size);
|
||||
|
||||
/**
|
||||
* Allocate a memory block for an array with av_mallocz().
|
||||
@ -88,7 +88,7 @@ extern void *av_malloc_array(size_t nmemb, size_t size);
|
||||
* @see av_mallocz()
|
||||
* @see av_malloc_array()
|
||||
*/
|
||||
extern void *av_mallocz_array(size_t nmemb, size_t size);
|
||||
extern void *avMallocZArray(size_t nmemb, size_t size);
|
||||
|
||||
/**
|
||||
* Free a memory block which has been allocated with a function of av_malloc()
|
||||
@ -101,7 +101,7 @@ extern void *av_mallocz_array(size_t nmemb, size_t size);
|
||||
* behind dangling pointers.
|
||||
* @see av_freep()
|
||||
*/
|
||||
extern void av_free(void *ptr);
|
||||
extern void avFree(void *ptr);
|
||||
|
||||
/**
|
||||
* Free a memory block which has been allocated with a function of av_malloc()
|
||||
@ -110,7 +110,7 @@ extern void av_free(void *ptr);
|
||||
* @param ptr Pointer to the pointer to the memory block which should be freed
|
||||
* @note `*ptr = NULL` is safe and leads to no action.
|
||||
*/
|
||||
extern void av_freep(void *arg);
|
||||
extern void avFreeP(void *arg);
|
||||
|
||||
|
||||
/**
|
||||
@ -128,25 +128,25 @@ extern void av_freep(void *arg);
|
||||
* @endcode
|
||||
* pattern.
|
||||
*/
|
||||
extern void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
|
||||
extern void *avReallocF(void *ptr, size_t nelem, size_t elsize);
|
||||
|
||||
/**
|
||||
* Reverse "nbits" bits of the value "val" and return the result
|
||||
* in the least significant bits.
|
||||
*/
|
||||
extern uint16 inv_bits(uint16 val, int nbits);
|
||||
extern uint16 invertBits(uint16 val, int nbits);
|
||||
|
||||
/**
|
||||
* Swap the order of the bytes in the passed value
|
||||
*/
|
||||
extern uint32 bitswap_32(uint32 x);
|
||||
extern uint32 bitswap32(uint32 x);
|
||||
|
||||
/**
|
||||
* Clip a signed integer value into the 0-255 range.
|
||||
* @param a value to clip
|
||||
* @return clipped value
|
||||
*/
|
||||
extern uint8 av_clip_uint8(int a);
|
||||
extern uint8 avClipUint8(int a);
|
||||
|
||||
/**
|
||||
* Clip a signed integer to an unsigned power of two range.
|
||||
@ -154,7 +154,7 @@ extern uint8 av_clip_uint8(int a);
|
||||
* @param p bit position to clip at
|
||||
* @return clipped value
|
||||
*/
|
||||
extern unsigned av_clip_uintp2(int a, int p);
|
||||
extern unsigned avClipUintp2(int a, int p);
|
||||
|
||||
/**
|
||||
* Clip a signed integer value into the amin-amax range.
|
||||
@ -165,9 +165,7 @@ extern unsigned av_clip_uintp2(int a, int p);
|
||||
*/
|
||||
#define av_clip CLIP
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
|
||||
extern const uint8 ff_zigzag_direct[64];
|
||||
extern const uint8 ffZigZagDirect[64];
|
||||
|
||||
} // End of namespace Indeo
|
||||
} // End of namespace Image
|
||||
|
@ -123,7 +123,7 @@ namespace Image {
|
||||
return -1; \
|
||||
} \
|
||||
if (flags & INIT_VLC_LE) \
|
||||
buf[j].code = bitswap_32(buf[j].code); \
|
||||
buf[j].code = bitswap32(buf[j].code); \
|
||||
else \
|
||||
buf[j].code <<= 32 - buf[j].bits; \
|
||||
if (symbols) \
|
||||
@ -165,7 +165,7 @@ int VLC::init_vlc(int nb_bits, int nb_codes, const void *p_bits, int bits_wrap,
|
||||
vlc->_table_allocated = 0;
|
||||
vlc->_table_size = 0;
|
||||
|
||||
buf = (VLCcode *)av_malloc_array((nb_codes + 1), sizeof(VLCcode));
|
||||
buf = (VLCcode *)avMallocArray((nb_codes + 1), sizeof(VLCcode));
|
||||
assert(buf);
|
||||
}
|
||||
|
||||
@ -190,7 +190,7 @@ int VLC::init_vlc(int nb_bits, int nb_codes, const void *p_bits, int bits_wrap,
|
||||
} else {
|
||||
free(buf);
|
||||
if (ret < 0) {
|
||||
av_freep(&vlc->_table);
|
||||
avFreeP(&vlc->_table);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
@ -237,7 +237,7 @@ int VLC::build_table(int table_nb_bits, int nb_codes,
|
||||
nb = 1 << (table_nb_bits - n);
|
||||
inc = 1;
|
||||
if (flags & INIT_VLC_LE) {
|
||||
j = bitswap_32(code);
|
||||
j = bitswap32(code);
|
||||
inc = 1 << n;
|
||||
}
|
||||
for (k = 0; k < nb; k++) {
|
||||
@ -272,7 +272,7 @@ int VLC::build_table(int table_nb_bits, int nb_codes,
|
||||
subtable_bits = MAX(subtable_bits, n);
|
||||
}
|
||||
subtable_bits = MIN(subtable_bits, table_nb_bits);
|
||||
j = (flags & INIT_VLC_LE) ? bitswap_32(code_prefix) >> (32 - table_nb_bits) : code_prefix;
|
||||
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);
|
||||
@ -304,7 +304,7 @@ int VLC::alloc_table(int size, int use_static) {
|
||||
assert(!use_static);
|
||||
|
||||
vlc->_table_allocated += (1 << vlc->_bits);
|
||||
vlc->_table = (int16(*)[2])av_realloc_f(vlc->_table, vlc->_table_allocated, sizeof(VLC_TYPE) * 2);
|
||||
vlc->_table = (int16(*)[2])avReallocF(vlc->_table, vlc->_table_allocated, sizeof(VLC_TYPE) * 2);
|
||||
if (!vlc->_table) {
|
||||
vlc->_table_allocated = 0;
|
||||
vlc->_table_size = 0;
|
||||
|
@ -624,22 +624,22 @@ int Indeo4Decoder::decodePlaneSubdivision() {
|
||||
/**
|
||||
* Indeo 4 8x8 scan (zigzag) patterns
|
||||
*/
|
||||
static const uint8 ivi4_alternate_scan_8x8[64] = {
|
||||
static const uint8 ivi4AlternateScan8x8[64] = {
|
||||
0, 8, 1, 9, 16, 24, 2, 3, 17, 25, 10, 11, 32, 40, 48, 56,
|
||||
4, 5, 6, 7, 33, 41, 49, 57, 18, 19, 26, 27, 12, 13, 14, 15,
|
||||
34, 35, 43, 42, 50, 51, 59, 58, 20, 21, 22, 23, 31, 30, 29, 28,
|
||||
36, 37, 38, 39, 47, 46, 45, 44, 52, 53, 54, 55, 63, 62, 61, 60
|
||||
};
|
||||
|
||||
static const uint8 ivi4_alternate_scan_4x4[16] = {
|
||||
static const uint8 ivi4AlternateScan4x4[16] = {
|
||||
0, 1, 4, 5, 8, 12, 2, 3, 9, 13, 6, 7, 10, 11, 14, 15
|
||||
};
|
||||
|
||||
static const uint8 ivi4_vertical_scan_4x4[16] = {
|
||||
static const uint8 ivi4VerticalScan4x4[16] = {
|
||||
0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15
|
||||
};
|
||||
|
||||
static const uint8 ivi4_horizontal_scan_4x4[16] = {
|
||||
static const uint8 ivi4HorizontalScan4x4[16] = {
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
|
||||
};
|
||||
|
||||
@ -648,47 +648,47 @@ const uint Indeo4Decoder::_ivi4_common_pic_sizes[14] = {
|
||||
};
|
||||
|
||||
Indeo4Decoder::Transform Indeo4Decoder::_transforms[18] = {
|
||||
{ IndeoDSP::ff_ivi_inverse_haar_8x8, IndeoDSP::ff_ivi_dc_haar_2d, 1 },
|
||||
{ IndeoDSP::ff_ivi_row_haar8, IndeoDSP::ff_ivi_dc_haar_2d, 0 },
|
||||
{ IndeoDSP::ff_ivi_col_haar8, IndeoDSP::ff_ivi_dc_haar_2d, 0 },
|
||||
{ IndeoDSP::ff_ivi_put_pixels_8x8, IndeoDSP::ff_ivi_put_dc_pixel_8x8, 1 },
|
||||
{ IndeoDSP::ff_ivi_inverse_slant_8x8, IndeoDSP::ff_ivi_dc_slant_2d, 1 },
|
||||
{ IndeoDSP::ff_ivi_row_slant8, IndeoDSP::ff_ivi_dc_row_slant, 1 },
|
||||
{ IndeoDSP::ff_ivi_col_slant8, IndeoDSP::ff_ivi_dc_col_slant, 1 },
|
||||
{ IndeoDSP::ffIviInverseHaar8x8, IndeoDSP::ffIviDcHaar2d, 1 },
|
||||
{ IndeoDSP::ffIviRowHaar8, IndeoDSP::ffIviDcHaar2d, 0 },
|
||||
{ IndeoDSP::ffIviColHaar8, IndeoDSP::ffIviDcHaar2d, 0 },
|
||||
{ IndeoDSP::ffIviPutPixels8x8, IndeoDSP::ffIviPutDcPixel8x8, 1 },
|
||||
{ IndeoDSP::ffIviInverseSlant8x8, IndeoDSP::ffIviDcSlant2d, 1 },
|
||||
{ IndeoDSP::ffIviRowSlant8, IndeoDSP::ffIviDcRowSlant, 1 },
|
||||
{ IndeoDSP::ffIviColSlant8, IndeoDSP::ffIviDcColSlant, 1 },
|
||||
{ NULL, NULL, 0 }, // inverse DCT 8x8
|
||||
{ NULL, NULL, 0 }, // inverse DCT 8x1
|
||||
{ NULL, NULL, 0 }, // inverse DCT 1x8
|
||||
{ IndeoDSP::ff_ivi_inverse_haar_4x4, IndeoDSP::ff_ivi_dc_haar_2d, 1 },
|
||||
{ IndeoDSP::ff_ivi_inverse_slant_4x4, IndeoDSP::ff_ivi_dc_slant_2d, 1 },
|
||||
{ IndeoDSP::ffIviInverseHaar4x4, IndeoDSP::ffIviDcHaar2d, 1 },
|
||||
{ IndeoDSP::ffIviInverseSlant4x4, IndeoDSP::ffIviDcSlant2d, 1 },
|
||||
{ NULL, NULL, 0 }, // no transform 4x4
|
||||
{ IndeoDSP::ff_ivi_row_haar4, IndeoDSP::ff_ivi_dc_haar_2d, 0 },
|
||||
{ IndeoDSP::ff_ivi_col_haar4, IndeoDSP::ff_ivi_dc_haar_2d, 0 },
|
||||
{ IndeoDSP::ff_ivi_row_slant4, IndeoDSP::ff_ivi_dc_row_slant, 0 },
|
||||
{ IndeoDSP::ff_ivi_col_slant4, IndeoDSP::ff_ivi_dc_col_slant, 0 },
|
||||
{ IndeoDSP::ffIviRowHaar4, IndeoDSP::ffIviDcHaar2d, 0 },
|
||||
{ IndeoDSP::ffIviColHaar4, IndeoDSP::ffIviDcHaar2d, 0 },
|
||||
{ IndeoDSP::ffIviRowSlant4, IndeoDSP::ffIviDcRowSlant, 0 },
|
||||
{ IndeoDSP::ffIviColSlant4, IndeoDSP::ffIviDcColSlant, 0 },
|
||||
{ NULL, NULL, 0 }, // inverse DCT 4x4
|
||||
};
|
||||
|
||||
const uint8 *const Indeo4Decoder::_scan_index_to_tab[15] = {
|
||||
// for 8x8 transforms
|
||||
ff_zigzag_direct,
|
||||
ivi4_alternate_scan_8x8,
|
||||
_ff_ivi_horizontal_scan_8x8,
|
||||
_ff_ivi_vertical_scan_8x8,
|
||||
ff_zigzag_direct,
|
||||
ffZigZagDirect,
|
||||
ivi4AlternateScan8x8,
|
||||
_ffIviHorizontalScan8x8,
|
||||
_ffIviVerticalScan8x8,
|
||||
ffZigZagDirect,
|
||||
|
||||
// for 4x4 transforms
|
||||
_ff_ivi_direct_scan_4x4,
|
||||
ivi4_alternate_scan_4x4,
|
||||
ivi4_vertical_scan_4x4,
|
||||
ivi4_horizontal_scan_4x4,
|
||||
_ff_ivi_direct_scan_4x4,
|
||||
_ffIviDirectScan4x4,
|
||||
ivi4AlternateScan4x4,
|
||||
ivi4VerticalScan4x4,
|
||||
ivi4HorizontalScan4x4,
|
||||
_ffIviDirectScan4x4,
|
||||
|
||||
// TODO: check if those are needed
|
||||
_ff_ivi_horizontal_scan_8x8,
|
||||
_ff_ivi_horizontal_scan_8x8,
|
||||
_ff_ivi_horizontal_scan_8x8,
|
||||
_ff_ivi_horizontal_scan_8x8,
|
||||
_ff_ivi_horizontal_scan_8x8
|
||||
_ffIviHorizontalScan8x8,
|
||||
_ffIviHorizontalScan8x8,
|
||||
_ffIviHorizontalScan8x8,
|
||||
_ffIviHorizontalScan8x8,
|
||||
_ffIviHorizontalScan8x8
|
||||
};
|
||||
|
||||
/**
|
||||
|
@ -425,8 +425,8 @@ int Indeo5Decoder::decode_gop_header() {
|
||||
picConf._picHeight = _ctx._gb->getBits(13);
|
||||
picConf._picWidth = _ctx._gb->getBits(13);
|
||||
} else {
|
||||
picConf._picHeight = _ivi5_common_pic_sizes[picSizeIndx * 2 + 1] << 2;
|
||||
picConf._picWidth = _ivi5_common_pic_sizes[picSizeIndx * 2] << 2;
|
||||
picConf._picHeight = _commonPicSizes[picSizeIndx * 2 + 1] << 2;
|
||||
picConf._picWidth = _commonPicSizes[picSizeIndx * 2] << 2;
|
||||
}
|
||||
|
||||
if (_ctx._gopFlags & 2) {
|
||||
@ -485,43 +485,43 @@ int Indeo5Decoder::decode_gop_header() {
|
||||
// select transform function and scan pattern according to plane and band number
|
||||
switch ((p << 2) + i) {
|
||||
case 0:
|
||||
band->_invTransform = IndeoDSP::ff_ivi_inverse_slant_8x8;
|
||||
band->_dcTransform = IndeoDSP::ff_ivi_dc_slant_2d;
|
||||
band->_scan = ff_zigzag_direct;
|
||||
band->_invTransform = IndeoDSP::ffIviInverseSlant8x8;
|
||||
band->_dcTransform = IndeoDSP::ffIviDcSlant2d;
|
||||
band->_scan = ffZigZagDirect;
|
||||
band->_transformSize = 8;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
band->_invTransform = IndeoDSP::ff_ivi_row_slant8;
|
||||
band->_dcTransform = IndeoDSP::ff_ivi_dc_row_slant;
|
||||
band->_scan = _ff_ivi_vertical_scan_8x8;
|
||||
band->_invTransform = IndeoDSP::ffIviRowSlant8;
|
||||
band->_dcTransform = IndeoDSP::ffIviDcRowSlant;
|
||||
band->_scan = _ffIviVerticalScan8x8;
|
||||
band->_transformSize = 8;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
band->_invTransform = IndeoDSP::ff_ivi_col_slant8;
|
||||
band->_dcTransform = IndeoDSP::ff_ivi_dc_col_slant;
|
||||
band->_scan = _ff_ivi_horizontal_scan_8x8;
|
||||
band->_invTransform = IndeoDSP::ffIviColSlant8;
|
||||
band->_dcTransform = IndeoDSP::ffIviDcColSlant;
|
||||
band->_scan = _ffIviHorizontalScan8x8;
|
||||
band->_transformSize = 8;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
band->_invTransform = IndeoDSP::ff_ivi_put_pixels_8x8;
|
||||
band->_dcTransform = IndeoDSP::ff_ivi_put_dc_pixel_8x8;
|
||||
band->_scan = _ff_ivi_horizontal_scan_8x8;
|
||||
band->_invTransform = IndeoDSP::ffIviPutPixels8x8;
|
||||
band->_dcTransform = IndeoDSP::ffIviPutDcPixel8x8;
|
||||
band->_scan = _ffIviHorizontalScan8x8;
|
||||
band->_transformSize = 8;
|
||||
break;
|
||||
|
||||
case 4:
|
||||
band->_invTransform = IndeoDSP::ff_ivi_inverse_slant_4x4;
|
||||
band->_dcTransform = IndeoDSP::ff_ivi_dc_slant_2d;
|
||||
band->_scan = _ff_ivi_direct_scan_4x4;
|
||||
band->_invTransform = IndeoDSP::ffIviInverseSlant4x4;
|
||||
band->_dcTransform = IndeoDSP::ffIviDcSlant2d;
|
||||
band->_scan = _ffIviDirectScan4x4;
|
||||
band->_transformSize = 4;
|
||||
break;
|
||||
}
|
||||
|
||||
band->_is2dTrans = band->_invTransform == IndeoDSP::ff_ivi_inverse_slant_8x8 ||
|
||||
band->_invTransform == IndeoDSP::ff_ivi_inverse_slant_4x4;
|
||||
band->_is2dTrans = band->_invTransform == IndeoDSP::ffIviInverseSlant8x8 ||
|
||||
band->_invTransform == IndeoDSP::ffIviInverseSlant4x4;
|
||||
|
||||
if (band->_transformSize != band->_blkSize) {
|
||||
warning("transform and block size mismatch (%d != %d)", band->_transformSize, band->_blkSize);
|
||||
@ -540,15 +540,15 @@ int Indeo5Decoder::decode_gop_header() {
|
||||
warning("_quantMat %d too large!", quantMat);
|
||||
return -1;
|
||||
}
|
||||
band->_intraBase = &_ivi5_base_quant_8x8_intra[quantMat][0];
|
||||
band->_interBase = &_ivi5_base_quant_8x8_inter[quantMat][0];
|
||||
band->_intraScale = &_ivi5_scale_quant_8x8_intra[quantMat][0];
|
||||
band->_interScale = &_ivi5_scale_quant_8x8_inter[quantMat][0];
|
||||
band->_intraBase = &_baseQuant8x8Intra[quantMat][0];
|
||||
band->_interBase = &_baseQuant8x8Inter[quantMat][0];
|
||||
band->_intraScale = &_scaleQuant8x8Intra[quantMat][0];
|
||||
band->_interScale = &_scaleQuant8x8Inter[quantMat][0];
|
||||
} else {
|
||||
band->_intraBase = _ivi5_base_quant_4x4_intra;
|
||||
band->_interBase = _ivi5_base_quant_4x4_inter;
|
||||
band->_intraScale = _ivi5_scale_quant_4x4_intra;
|
||||
band->_interScale = _ivi5_scale_quant_4x4_inter;
|
||||
band->_intraBase = _baseQuant4x4Intra;
|
||||
band->_interBase = _baseQuant4x4Inter;
|
||||
band->_intraScale = _scaleQuant4x4Intra;
|
||||
band->_interScale = _scaleQuant4x4Inter;
|
||||
}
|
||||
|
||||
if (_ctx._gb->getBits(2)) {
|
||||
@ -631,17 +631,12 @@ int Indeo5Decoder::skip_hdr_extension() {
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
|
||||
const uint8 Indeo5Decoder::_ivi5_common_pic_sizes[30] = {
|
||||
const uint8 Indeo5Decoder::_commonPicSizes[30] = {
|
||||
160, 120, 80, 60, 40, 30, 176, 120, 88, 60, 88, 72, 44, 36, 60, 45, 160, 60,
|
||||
176, 60, 20, 15, 22, 18, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
const uint8 Indeo5Decoder::ivi5_common_pic_sizes[30] = {
|
||||
160, 120, 80, 60, 40, 30, 176, 120, 88, 60, 88, 72, 44, 36, 60, 45, 160, 60,
|
||||
176, 60, 20, 15, 22, 18, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
const uint16 Indeo5Decoder::_ivi5_base_quant_8x8_inter[5][64] = {
|
||||
const uint16 Indeo5Decoder::_baseQuant8x8Inter[5][64] = {
|
||||
{0x26, 0x3a, 0x3e, 0x46, 0x4a, 0x4e, 0x52, 0x5a, 0x3a, 0x3e, 0x42, 0x46, 0x4a, 0x4e, 0x56, 0x5e,
|
||||
0x3e, 0x42, 0x46, 0x48, 0x4c, 0x52, 0x5a, 0x62, 0x46, 0x46, 0x48, 0x4a, 0x4e, 0x56, 0x5e, 0x66,
|
||||
0x4a, 0x4a, 0x4c, 0x4e, 0x52, 0x5a, 0x62, 0x6a, 0x4e, 0x4e, 0x52, 0x56, 0x5a, 0x5e, 0x66, 0x6e,
|
||||
@ -669,7 +664,7 @@ const uint16 Indeo5Decoder::_ivi5_base_quant_8x8_inter[5][64] = {
|
||||
}
|
||||
};
|
||||
|
||||
const uint16 Indeo5Decoder::_ivi5_base_quant_8x8_intra[5][64] = {
|
||||
const uint16 Indeo5Decoder::_baseQuant8x8Intra[5][64] = {
|
||||
{0x1a, 0x2e, 0x36, 0x42, 0x46, 0x4a, 0x4e, 0x5a, 0x2e, 0x32, 0x3e, 0x42, 0x46, 0x4e, 0x56, 0x6a,
|
||||
0x36, 0x3e, 0x3e, 0x44, 0x4a, 0x54, 0x66, 0x72, 0x42, 0x42, 0x44, 0x4a, 0x52, 0x62, 0x6c, 0x7a,
|
||||
0x46, 0x46, 0x4a, 0x52, 0x5e, 0x66, 0x72, 0x8e, 0x4a, 0x4e, 0x54, 0x62, 0x66, 0x6e, 0x86, 0xa6,
|
||||
@ -697,16 +692,16 @@ const uint16 Indeo5Decoder::_ivi5_base_quant_8x8_intra[5][64] = {
|
||||
}
|
||||
};
|
||||
|
||||
const uint16 Indeo5Decoder::_ivi5_base_quant_4x4_inter[16] = {
|
||||
const uint16 Indeo5Decoder::_baseQuant4x4Inter[16] = {
|
||||
0x1e, 0x3e, 0x4a, 0x52, 0x3e, 0x4a, 0x52, 0x56, 0x4a, 0x52, 0x56, 0x5e, 0x52, 0x56, 0x5e, 0x66
|
||||
};
|
||||
|
||||
const uint16 Indeo5Decoder::_ivi5_base_quant_4x4_intra[16] = {
|
||||
const uint16 Indeo5Decoder::_baseQuant4x4Intra[16] = {
|
||||
0x1e, 0x3e, 0x4a, 0x52, 0x3e, 0x4a, 0x52, 0x5e, 0x4a, 0x52, 0x5e, 0x7a, 0x52, 0x5e, 0x7a, 0x92
|
||||
};
|
||||
|
||||
|
||||
const uint8 Indeo5Decoder::_ivi5_scale_quant_8x8_inter[5][24] = {
|
||||
const uint8 Indeo5Decoder::_scaleQuant8x8Inter[5][24] = {
|
||||
{0x0b, 0x11, 0x13, 0x14, 0x15, 0x16, 0x18, 0x1a, 0x1b, 0x1d, 0x20, 0x22,
|
||||
0x23, 0x25, 0x28, 0x2a, 0x2e, 0x32, 0x35, 0x39, 0x3d, 0x41, 0x44, 0x4a,
|
||||
},
|
||||
@ -724,7 +719,7 @@ const uint8 Indeo5Decoder::_ivi5_scale_quant_8x8_inter[5][24] = {
|
||||
},
|
||||
};
|
||||
|
||||
const uint8 Indeo5Decoder::_ivi5_scale_quant_8x8_intra[5][24] = {
|
||||
const uint8 Indeo5Decoder::_scaleQuant8x8Intra[5][24] = {
|
||||
{0x0b, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x17, 0x18, 0x1a, 0x1c, 0x1e, 0x20,
|
||||
0x22, 0x24, 0x27, 0x28, 0x2a, 0x2d, 0x2f, 0x31, 0x34, 0x37, 0x39, 0x3c,
|
||||
},
|
||||
@ -742,12 +737,12 @@ const uint8 Indeo5Decoder::_ivi5_scale_quant_8x8_intra[5][24] = {
|
||||
}
|
||||
};
|
||||
|
||||
const uint8 Indeo5Decoder::_ivi5_scale_quant_4x4_inter[24] = {
|
||||
const uint8 Indeo5Decoder::_scaleQuant4x4Inter[24] = {
|
||||
0x0b, 0x0d, 0x0d, 0x0e, 0x11, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
||||
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
|
||||
};
|
||||
|
||||
const uint8 Indeo5Decoder::_ivi5_scale_quant_4x4_intra[24] = {
|
||||
const uint8 Indeo5Decoder::_scaleQuant4x4Intra[24] = {
|
||||
0x01, 0x0b, 0x0b, 0x0d, 0x0d, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x13, 0x14,
|
||||
0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20
|
||||
};
|
||||
|
@ -112,12 +112,7 @@ private:
|
||||
/**
|
||||
* standard picture dimensions (width, height divided by 4)
|
||||
*/
|
||||
static const uint8 _ivi5_common_pic_sizes[30];
|
||||
|
||||
/**
|
||||
* standard picture dimensions (width, height divided by 4)
|
||||
*/
|
||||
static const uint8 ivi5_common_pic_sizes[30];
|
||||
static const uint8 _commonPicSizes[30];
|
||||
|
||||
/**
|
||||
* Indeo5 dequantization matrixes consist of two tables: base table
|
||||
@ -128,17 +123,17 @@ private:
|
||||
* ivi5_base_quant_bbb_ttt - base tables for block size 'bbb' of type 'ttt'
|
||||
* ivi5_scale_quant_bbb_ttt - scale tables for block size 'bbb' of type 'ttt'
|
||||
*/
|
||||
static const uint16 _ivi5_base_quant_8x8_inter[5][64];
|
||||
static const uint16 _ivi5_base_quant_8x8_intra[5][64];
|
||||
static const uint16 _baseQuant8x8Inter[5][64];
|
||||
static const uint16 _baseQuant8x8Intra[5][64];
|
||||
|
||||
static const uint16 _ivi5_base_quant_4x4_inter[16];
|
||||
static const uint16 _ivi5_base_quant_4x4_intra[16];
|
||||
static const uint16 _baseQuant4x4Inter[16];
|
||||
static const uint16 _baseQuant4x4Intra[16];
|
||||
|
||||
static const uint8 _ivi5_scale_quant_8x8_inter[5][24];
|
||||
static const uint8 _ivi5_scale_quant_8x8_intra[5][24];
|
||||
static const uint8 _scaleQuant8x8Inter[5][24];
|
||||
static const uint8 _scaleQuant8x8Intra[5][24];
|
||||
|
||||
static const uint8 _ivi5_scale_quant_4x4_inter[24];
|
||||
static const uint8 _ivi5_scale_quant_4x4_intra[24];
|
||||
static const uint8 _scaleQuant4x4Inter[24];
|
||||
static const uint8 _scaleQuant4x4Intra[24];
|
||||
};
|
||||
|
||||
} // End of namespace Image
|
||||
|
Loading…
Reference in New Issue
Block a user