liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

More bool and const (WIP)

Browse Source
This commit is contained in:
Flössie
2019-12-04 10:23:25 +01:00
parent c4fe355fbb
commit 49f5833002
1 changed files with 215 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

374
rtengine/canon_cr3_decoder.cc
View File

@@ -158,7 +158,7 @@ void DCraw::selectCRXTrack(unsigned short maxTrack)
int tiff_idx = -1; int tiff_idx = -1;
std::int64_t tpixels = 0; std::int64_t tpixels = 0;
for (unsigned int i = 0; i < tiff_nifds; i++) { for (unsigned int i = 0; i < tiff_nifds; ++i) {
if (std::int64_t(tiff_ifd[i].height) * std::int64_t(tiff_ifd[i].height) > tpixels) { if (std::int64_t(tiff_ifd[i].height) * std::int64_t(tiff_ifd[i].height) > tpixels) {
tpixels = std::int64_t(tiff_ifd[i].height) * std::int64_t(tiff_ifd[i].height); tpixels = std::int64_t(tiff_ifd[i].height) * std::int64_t(tiff_ifd[i].height);
tiff_idx = i; tiff_idx = i;
@@ -950,7 +950,7 @@ inline std::int32_t crxPredictKParameter(std::int32_t prevK, std::int32_t bitCod
: maxVal; : maxVal;
} }
inline void crxDecodeSymbolL1(CrxBandParam* param, std::int32_t doMedianPrediction, bool notEOL = false) inline void crxDecodeSymbolL1(CrxBandParam* param, bool doMedianPrediction, bool notEOL = false)
{ {
if (doMedianPrediction) { if (doMedianPrediction) {
const std::int32_t delta = param->lineBuf0[1] - param->lineBuf0[0]; const std::int32_t delta = param->lineBuf0[1] - param->lineBuf0[0];
@@ -1002,7 +1002,7 @@ bool crxDecodeLine(CrxBandParam* param)
for (; length > 1; --length) { for (; length > 1; --length) {
if (param->lineBuf1[0] != param->lineBuf0[1] || param->lineBuf1[0] != param->lineBuf0[2]) { if (param->lineBuf1[0] != param->lineBuf0[1] || param->lineBuf1[0] != param->lineBuf0[2]) {
crxDecodeSymbolL1(param, 1, true); crxDecodeSymbolL1(param, true, true);
} else { } else {
int nSyms = 0; int nSyms = 0;
@@ -1053,13 +1053,13 @@ bool crxDecodeLine(CrxBandParam* param)
} }
if (length > 0) { if (length > 0) {
crxDecodeSymbolL1(param, 0, length > 1); crxDecodeSymbolL1(param, false, length > 1);
} }
} }
} }
if (length == 1) { if (length == 1) {
crxDecodeSymbolL1(param, 1, false); crxDecodeSymbolL1(param, true, false);
} }
param->lineBuf1[1] = param->lineBuf1[0] + 1; param->lineBuf1[1] = param->lineBuf1[0] + 1;
@@ -1197,19 +1197,18 @@ bool crxDecodeLineRounded(CrxBandParam* param)
return true; return true;
} }
int crxDecodeLineNoRefPrevLine(CrxBandParam* param) bool crxDecodeLineNoRefPrevLine(CrxBandParam* param)
{ {
std::int32_t i = 0; std::int32_t i = 0;
for (; i < param->subbandWidth - 1; i++) { for (; i < param->subbandWidth - 1; ++i) {
if (param->lineBuf0[i + 2] | param->lineBuf0[i + 1] | param->lineBuf1[i]) { if (param->lineBuf0[i + 2] || param->lineBuf0[i + 1] || param->lineBuf1[i]) {
std::uint32_t bitCode = crxBitstreamGetZeros(&param->bitStream); std::uint32_t bitCode = crxBitstreamGetZeros(&param->bitStream);
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
param->lineBuf1[i + 1] = -(bitCode & 1) ^ (bitCode >> 1); param->lineBuf1[i + 1] = -(bitCode & 1) ^ (bitCode >> 1);
@@ -1257,11 +1256,11 @@ int crxDecodeLineNoRefPrevLine(CrxBandParam* param)
} }
if (i + nSyms > param->subbandWidth) { if (i + nSyms > param->subbandWidth) {
return -1; return false;
} }
} }
} else if (i > param->subbandWidth) { } else if (i > param->subbandWidth) {
return -1; return false;
} }
if (nSyms > 0) { if (nSyms > 0) {
@@ -1277,8 +1276,7 @@ int crxDecodeLineNoRefPrevLine(CrxBandParam* param)
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
param->lineBuf1[i + 1] = -((bitCode + 1) & 1) ^ ((bitCode + 1) >> 1); param->lineBuf1[i + 1] = -((bitCode + 1) & 1) ^ ((bitCode + 1) >> 1);
@@ -1293,8 +1291,7 @@ int crxDecodeLineNoRefPrevLine(CrxBandParam* param)
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
param->lineBuf1[i + 1] = -((bitCode + 1) & 1) ^ ((bitCode + 1) >> 1); param->lineBuf1[i + 1] = -((bitCode + 1) & 1) ^ ((bitCode + 1) >> 1);
@@ -1319,8 +1316,7 @@ int crxDecodeLineNoRefPrevLine(CrxBandParam* param)
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
param->lineBuf1[i + 1] = -(bitCode & 1) ^ (bitCode >> 1); param->lineBuf1[i + 1] = -(bitCode & 1) ^ (bitCode >> 1);
@@ -1328,10 +1324,10 @@ int crxDecodeLineNoRefPrevLine(CrxBandParam* param)
param->lineBuf2[i] = param->kParam; param->lineBuf2[i] = param->kParam;
} }
return 0; return true;
} }
int crxDecodeTopLine(CrxBandParam* param) bool crxDecodeTopLine(CrxBandParam* param)
{ {
param->lineBuf1[0] = 0; param->lineBuf1[0] = 0;
@@ -1374,7 +1370,7 @@ int crxDecodeTopLine(CrxBandParam* param)
} }
if (nSyms > length) { if (nSyms > length) {
return -1; return false;
} }
} }
@@ -1399,8 +1395,7 @@ int crxDecodeTopLine(CrxBandParam* param)
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
param->lineBuf1[1] += -(bitCode & 1) ^ (bitCode >> 1); param->lineBuf1[1] += -(bitCode & 1) ^ (bitCode >> 1);
@@ -1415,8 +1410,7 @@ int crxDecodeTopLine(CrxBandParam* param)
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
param->lineBuf1[1] += -(bitCode & 1) ^ (bitCode >> 1); param->lineBuf1[1] += -(bitCode & 1) ^ (bitCode >> 1);
@@ -1426,10 +1420,10 @@ int crxDecodeTopLine(CrxBandParam* param)
param->lineBuf1[1] = param->lineBuf1[0] + 1; param->lineBuf1[1] = param->lineBuf1[0] + 1;
return 0; return true;
} }
int crxDecodeTopLineRounded(CrxBandParam* param) bool crxDecodeTopLineRounded(CrxBandParam* param)
{ {
param->lineBuf1[0] = 0; param->lineBuf1[0] = 0;
@@ -1472,7 +1466,7 @@ int crxDecodeTopLineRounded(CrxBandParam* param)
} }
if (nSyms > length) { if (nSyms > length) {
return -1; return false;
} }
} }
} }
@@ -1497,11 +1491,10 @@ int crxDecodeTopLineRounded(CrxBandParam* param)
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
std::int32_t sVal = -(bitCode & 1) ^ (bitCode >> 1); const std::int32_t sVal = -(bitCode & 1) ^ (bitCode >> 1);
param->lineBuf1[1] += param->roundedBitsMask * 2 * sVal + (sVal >> 31); param->lineBuf1[1] += param->roundedBitsMask * 2 * sVal + (sVal >> 31);
param->kParam = crxPredictKParameter(param->kParam, bitCode, 15); param->kParam = crxPredictKParameter(param->kParam, bitCode, 15);
++param->lineBuf1; ++param->lineBuf1;
@@ -1513,11 +1506,10 @@ int crxDecodeTopLineRounded(CrxBandParam* param)
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
std::int32_t sVal = -(bitCode & 1) ^ (bitCode >> 1); const std::int32_t sVal = -(bitCode & 1) ^ (bitCode >> 1);
param->lineBuf1[1] += param->roundedBitsMask * 2 * sVal + (sVal >> 31); param->lineBuf1[1] += param->roundedBitsMask * 2 * sVal + (sVal >> 31);
param->kParam = crxPredictKParameter(param->kParam, bitCode, 15); param->kParam = crxPredictKParameter(param->kParam, bitCode, 15);
++param->lineBuf1; ++param->lineBuf1;
@@ -1525,7 +1517,7 @@ int crxDecodeTopLineRounded(CrxBandParam* param)
param->lineBuf1[1] = param->lineBuf1[0] + 1; param->lineBuf1[1] = param->lineBuf1[0] + 1;
return 0; return true;
} }
bool crxDecodeTopLineNoRefPrevLine(CrxBandParam* param) bool crxDecodeTopLineNoRefPrevLine(CrxBandParam* param)
@@ -1541,8 +1533,7 @@ bool crxDecodeTopLineNoRefPrevLine(CrxBandParam* param)
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
param->lineBuf1[1] = -(bitCode & 1) ^ (bitCode >> 1); param->lineBuf1[1] = -(bitCode & 1) ^ (bitCode >> 1);
@@ -1604,8 +1595,7 @@ bool crxDecodeTopLineNoRefPrevLine(CrxBandParam* param)
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
param->lineBuf1[1] = -((bitCode + 1) & 1) ^ ((bitCode + 1) >> 1); param->lineBuf1[1] = -((bitCode + 1) & 1) ^ ((bitCode + 1) >> 1);
@@ -1623,8 +1613,7 @@ bool crxDecodeTopLineNoRefPrevLine(CrxBandParam* param)
if (bitCode >= 41) { if (bitCode >= 41) {
bitCode = crxBitstreamGetBits(&param->bitStream, 21); bitCode = crxBitstreamGetBits(&param->bitStream, 21);
} else if (param->kParam) { } else if (param->kParam) {
bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | bitCode = crxBitstreamGetBits(&param->bitStream, param->kParam) | (bitCode << param->kParam);
(bitCode << param->kParam);
} }
param->lineBuf1[1] = -(bitCode & 1) ^ (bitCode >> 1); param->lineBuf1[1] = -(bitCode & 1) ^ (bitCode >> 1);
@@ -1658,9 +1647,9 @@ bool crxDecodeLine(CrxBandParam* param, std::uint8_t* bandBuf)
if (param->roundedBitsMask <= 0) { if (param->roundedBitsMask <= 0) {
param->lineBuf0 = param->paramData; param->lineBuf0 = param->paramData;
param->lineBuf1 = param->lineBuf0 + lineLength; param->lineBuf1 = param->lineBuf0 + lineLength;
std::int32_t* const lineBuf = param->lineBuf1 + 1; const std::int32_t* const lineBuf = param->lineBuf1 + 1;
if (crxDecodeTopLine(param)) { if (!crxDecodeTopLine(param)) {
return false; return false;
} }
@@ -1677,9 +1666,9 @@ bool crxDecodeLine(CrxBandParam* param, std::uint8_t* bandBuf)
param->lineBuf0 = param->paramData; param->lineBuf0 = param->paramData;
param->lineBuf1 = param->lineBuf0 + lineLength; param->lineBuf1 = param->lineBuf0 + lineLength;
std::int32_t* lineBuf = param->lineBuf1 + 1; const std::int32_t* const lineBuf = param->lineBuf1 + 1;
if (crxDecodeTopLineRounded(param)) { if (!crxDecodeTopLineRounded(param)) {
return false; return false;
} }
@@ -1690,7 +1679,7 @@ bool crxDecodeLine(CrxBandParam* param, std::uint8_t* bandBuf)
param->lineBuf2 = param->nonProgrData; param->lineBuf2 = param->nonProgrData;
param->lineBuf0 = param->paramData; param->lineBuf0 = param->paramData;
param->lineBuf1 = param->lineBuf0 + lineLength; param->lineBuf1 = param->lineBuf0 + lineLength;
std::int32_t* lineBuf = param->lineBuf1 + 1; const std::int32_t* const lineBuf = param->lineBuf1 + 1;
if (!crxDecodeTopLineNoRefPrevLine(param)) { if (!crxDecodeTopLineNoRefPrevLine(param)) {
return false; return false;
@@ -1700,7 +1689,7 @@ bool crxDecodeLine(CrxBandParam* param, std::uint8_t* bandBuf)
++param->curLine; ++param->curLine;
} }
} else if (!param->supportsPartial) { } else if (!param->supportsPartial) {
std::int32_t lineLength = param->subbandWidth + 2; const std::int32_t lineLength = param->subbandWidth + 2;
param->lineBuf2 = param->nonProgrData; param->lineBuf2 = param->nonProgrData;
if (param->curLine & 1) { if (param->curLine & 1) {
@@ -1711,16 +1700,16 @@ bool crxDecodeLine(CrxBandParam* param, std::uint8_t* bandBuf)
param->lineBuf1 = param->lineBuf0 + lineLength; param->lineBuf1 = param->lineBuf0 + lineLength;
} }
std::int32_t* lineBuf = param->lineBuf1 + 1; const std::int32_t* const lineBuf = param->lineBuf1 + 1;
if (crxDecodeLineNoRefPrevLine(param)) { if (!crxDecodeLineNoRefPrevLine(param)) {
return false; return false;
} }
memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(std::int32_t)); memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(std::int32_t));
++param->curLine; ++param->curLine;
} else if (param->roundedBitsMask <= 0) { } else if (param->roundedBitsMask <= 0) {
std::int32_t lineLength = param->subbandWidth + 2; const std::int32_t lineLength = param->subbandWidth + 2;
if (param->curLine & 1) { if (param->curLine & 1) {
param->lineBuf1 = param->paramData; param->lineBuf1 = param->paramData;
@@ -1730,7 +1719,7 @@ bool crxDecodeLine(CrxBandParam* param, std::uint8_t* bandBuf)
param->lineBuf1 = param->lineBuf0 + lineLength; param->lineBuf1 = param->lineBuf0 + lineLength;
} }
std::int32_t* lineBuf = param->lineBuf1 + 1; const std::int32_t* const lineBuf = param->lineBuf1 + 1;
if (!crxDecodeLine(param)) { if (!crxDecodeLine(param)) {
return false; return false;
@@ -1739,7 +1728,7 @@ bool crxDecodeLine(CrxBandParam* param, std::uint8_t* bandBuf)
memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(std::int32_t)); memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(std::int32_t));
++param->curLine; ++param->curLine;
} else { } else {
std::int32_t lineLength = param->subbandWidth + 2; const std::int32_t lineLength = param->subbandWidth + 2;
if (param->curLine & 1) { if (param->curLine & 1) {
param->lineBuf1 = param->paramData; param->lineBuf1 = param->paramData;
@@ -1749,7 +1738,7 @@ bool crxDecodeLine(CrxBandParam* param, std::uint8_t* bandBuf)
param->lineBuf1 = param->lineBuf0 + lineLength; param->lineBuf1 = param->lineBuf0 + lineLength;
} }
std::int32_t* lineBuf = param->lineBuf1 + 1; const std::int32_t* const lineBuf = param->lineBuf1 + 1;
if (!crxDecodeLineRounded(param)) { if (!crxDecodeLineRounded(param)) {
return false; return false;
@@ -1762,13 +1751,13 @@ bool crxDecodeLine(CrxBandParam* param, std::uint8_t* bandBuf)
return true; return true;
} }
int crxDecodeLineWithIQuantization(CrxSubband* subband) bool crxDecodeLineWithIQuantization(CrxSubband* subband)
{ {
std::int32_t q_step_tbl[6] = {0x28, 0x2D, 0x33, 0x39, 0x40, 0x48}; constexpr std::int32_t q_step_tbl[6] = {0x28, 0x2D, 0x33, 0x39, 0x40, 0x48};
if (!subband->dataSize) { if (!subband->dataSize) {
memset(subband->bandBuf, 0, subband->bandSize); memset(subband->bandBuf, 0, subband->bandSize);
return 0; return true;
} }
if (subband->supportsPartial) { if (subband->supportsPartial) {
@@ -1777,49 +1766,48 @@ int crxDecodeLineWithIQuantization(CrxSubband* subband)
if (bitCode >= 23) { if (bitCode >= 23) {
bitCode = crxBitstreamGetBits(&subband->bandParam->bitStream, 8); bitCode = crxBitstreamGetBits(&subband->bandParam->bitStream, 8);
} else if (subband->paramK) { } else if (subband->paramK) {
bitCode = bitCode = crxBitstreamGetBits(&subband->bandParam->bitStream, subband->paramK) | (bitCode << subband->paramK);
crxBitstreamGetBits(&subband->bandParam->bitStream, subband->paramK) |
(bitCode << subband->paramK);
} }
subband->quantValue += subband->quantValue += -(bitCode & 1) ^ (bitCode >> 1);// converting encoded to signed integer
-(bitCode & 1) ^ (bitCode >> 1);// converting encoded to signed integer
subband->paramK = crxPredictKParameter(subband->paramK, bitCode); subband->paramK = crxPredictKParameter(subband->paramK, bitCode);
if (subband->paramK > 7) { if (subband->paramK > 7) {
return -1; return false;
} }
} }
if (!crxDecodeLine(subband->bandParam, subband->bandBuf)) { if (!crxDecodeLine(subband->bandParam, subband->bandBuf)) {
return -1; return false;
} }
if (subband->width <= 0) { if (subband->width <= 0) {
return 0LL; return true;
} }
// update subband buffers // update subband buffers
std::int32_t* bandBuf = reinterpret_cast<std::int32_t*>(subband->bandBuf); std::int32_t* const bandBuf = reinterpret_cast<std::int32_t*>(subband->bandBuf);
std::int32_t qScale = std::int32_t qScale = q_step_tbl[subband->quantValue % 6] >> (6 - subband->quantValue / 6);
q_step_tbl[subband->quantValue % 6] >> (6 - subband->quantValue / 6);
if (subband->quantValue / 6 >= 6) { if (subband->quantValue / 6 >= 6) {
qScale = q_step_tbl[subband->quantValue % 6] * qScale = q_step_tbl[subband->quantValue % 6] * (1 << (subband->quantValue / 6 + 26));
(1 << (subband->quantValue / 6 + 26));
} }
if (qScale != 1) { if (qScale != 1) {
for (std::int32_t i = 0; i < subband->width; i++) { for (std::int32_t i = 0; i < subband->width; ++i) {
bandBuf[i] *= qScale; bandBuf[i] *= qScale;
} }
} }
return 0; return true;
} }
void crxHorizontal53(std::int32_t* lineBufLA, std::int32_t* lineBufLB, void crxHorizontal53(
CrxWaveletTransform* wavelet, std::uint32_t tileFlag) std::int32_t* lineBufLA,
std::int32_t* lineBufLB,
CrxWaveletTransform* wavelet,
std::uint32_t tileFlag
)
{ {
std::int32_t* band0Buf = wavelet->subband0Buf; std::int32_t* band0Buf = wavelet->subband0Buf;
std::int32_t* band1Buf = wavelet->subband1Buf; std::int32_t* band1Buf = wavelet->subband1Buf;
@@ -1861,10 +1849,10 @@ void crxHorizontal53(std::int32_t* lineBufLA, std::int32_t* lineBufLB,
} }
if (tileFlag & E_HAS_TILES_ON_THE_RIGHT) { if (tileFlag & E_HAS_TILES_ON_THE_RIGHT) {
std::int32_t deltaA = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); const std::int32_t deltaA = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2);
lineBufLA[1] = band1Buf[0] + ((deltaA + lineBufLA[0]) >> 1); lineBufLA[1] = band1Buf[0] + ((deltaA + lineBufLA[0]) >> 1);
std::int32_t deltaB = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2); const std::int32_t deltaB = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2);
lineBufLB[1] = band3Buf[0] + ((deltaB + lineBufLB[0]) >> 1); lineBufLB[1] = band3Buf[0] + ((deltaB + lineBufLB[0]) >> 1);
if (wavelet->width & 1) { if (wavelet->width & 1) {
@@ -1872,14 +1860,10 @@ void crxHorizontal53(std::int32_t* lineBufLA, std::int32_t* lineBufLB,
lineBufLB[2] = deltaB; lineBufLB[2] = deltaB;
} }
} else if (wavelet->width & 1) { } else if (wavelet->width & 1) {
lineBufLA[1] = lineBufLA[1] = band1Buf[0] + ((lineBufLA[0] + band0Buf[0] - ((band1Buf[0] + 1) >> 1)) >> 1);
band1Buf[0] +
((lineBufLA[0] + band0Buf[0] - ((band1Buf[0] + 1) >> 1)) >> 1);
lineBufLA[2] = band0Buf[0] - ((band1Buf[0] + 1) >> 1); lineBufLA[2] = band0Buf[0] - ((band1Buf[0] + 1) >> 1);
lineBufLB[1] = lineBufLB[1] = band3Buf[0] + ((lineBufLB[0] + band2Buf[0] - ((band3Buf[0] + 1) >> 1)) >> 1);
band3Buf[0] +
((lineBufLB[0] + band2Buf[0] - ((band3Buf[0] + 1) >> 1)) >> 1);
lineBufLB[2] = band2Buf[0] - ((band3Buf[0] + 1) >> 1); lineBufLB[2] = band2Buf[0] - ((band3Buf[0] + 1) >> 1);
} else { } else {
lineBufLA[1] = lineBufLA[0] + band1Buf[0]; lineBufLA[1] = lineBufLA[0] + band1Buf[0];
@@ -1890,64 +1874,62 @@ void crxHorizontal53(std::int32_t* lineBufLA, std::int32_t* lineBufLB,
std::int32_t* crxIdwt53FilterGetLine(CrxPlaneComp* comp, std::int32_t level) std::int32_t* crxIdwt53FilterGetLine(CrxPlaneComp* comp, std::int32_t level)
{ {
std::int32_t* result = comp->waveletTransform[level] std::int32_t* const result = comp->waveletTransform[level].lineBuf[
.lineBuf[(comp->waveletTransform[level].fltTapH - (comp->waveletTransform[level].fltTapH - comp->waveletTransform[level].curH + 5) % 5 + 3
comp->waveletTransform[level].curH + 5) % ];
5 + --comp->waveletTransform[level].curH;
3];
comp->waveletTransform[level].curH--;
return result; return result;
} }
int crxIdwt53FilterDecode(CrxPlaneComp* comp, std::int32_t level) bool crxIdwt53FilterDecode(CrxPlaneComp* comp, std::int32_t level)
{ {
if (comp->waveletTransform[level].curH) { if (comp->waveletTransform[level].curH) {
return 0; return true;
} }
CrxSubband* sband = comp->subBands + 3 * level; CrxSubband* const sband = comp->subBands + 3 * level;
if (comp->waveletTransform[level].height - 3 <= if (comp->waveletTransform[level].height - 3 <= comp->waveletTransform[level].curLine && !(comp->tileFlag & E_HAS_TILES_ON_THE_BOTTOM)) {
comp->waveletTransform[level].curLine &&
!(comp->tileFlag & E_HAS_TILES_ON_THE_BOTTOM)) {
if (comp->waveletTransform[level].height & 1) { if (comp->waveletTransform[level].height & 1) {
if (level) { if (level) {
if (crxIdwt53FilterDecode(comp, level - 1)) { if (!crxIdwt53FilterDecode(comp, level - 1)) {
return -1; return false;
} }
} else if (crxDecodeLineWithIQuantization(sband)) { } else if (!crxDecodeLineWithIQuantization(sband)) {
return -1; return false;
} }
if (crxDecodeLineWithIQuantization(sband + 1)) { if (!crxDecodeLineWithIQuantization(sband + 1)) {
return -1; return false;
} }
} }
} else { } else {
if (level) { if (level) {
if (crxIdwt53FilterDecode(comp, level - 1)) { if (!crxIdwt53FilterDecode(comp, level - 1)) {
return -1; return false;
} }
} else if (crxDecodeLineWithIQuantization(sband)) {// LL band } else if (!crxDecodeLineWithIQuantization(sband)) { // LL band
return -1; return false;
} }
if (crxDecodeLineWithIQuantization(sband + 1) ||// HL band if (
crxDecodeLineWithIQuantization(sband + 2) ||// LH band !crxDecodeLineWithIQuantization(sband + 1) // HL band
crxDecodeLineWithIQuantization(sband + 3)) {// HH band || !crxDecodeLineWithIQuantization(sband + 2) // LH band
return -1; || !crxDecodeLineWithIQuantization(sband + 3) // HH band
) {
return false;
} }
} }
return 0; return true;
} }
int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level) bool crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level)
{ {
CrxWaveletTransform* wavelet = comp->waveletTransform + level; CrxWaveletTransform* const wavelet = comp->waveletTransform + level;
if (wavelet->curH) { if (wavelet->curH) {
return 0; return true;
} }
if (wavelet->curLine >= wavelet->height - 3) { if (wavelet->curLine >= wavelet->height - 3) {
@@ -1955,19 +1937,19 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level)
if (wavelet->height & 1) { if (wavelet->height & 1) {
if (level) { if (level) {
if (!wavelet[-1].curH) { if (!wavelet[-1].curH) {
if (crxIdwt53FilterTransform(comp, level - 1)) { if (!crxIdwt53FilterTransform(comp, level - 1)) {
return -1; return false;
} }
} }
wavelet->subband0Buf = crxIdwt53FilterGetLine(comp, level - 1); wavelet->subband0Buf = crxIdwt53FilterGetLine(comp, level - 1);
} }
std::int32_t* band0Buf = wavelet->subband0Buf; const std::int32_t* band0Buf = wavelet->subband0Buf;
std::int32_t* band1Buf = wavelet->subband1Buf; const std::int32_t* band1Buf = wavelet->subband1Buf;
std::int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; const std::int32_t* const lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3];
std::int32_t* lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3]; std::int32_t* const lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3];
std::int32_t* lineBufH2 = wavelet->lineBuf[(wavelet->fltTapH + 2) % 5 + 3]; std::int32_t* const lineBufH2 = wavelet->lineBuf[(wavelet->fltTapH + 2) % 5 + 3];
std::int32_t* lineBufL0 = wavelet->lineBuf[0]; std::int32_t* lineBufL0 = wavelet->lineBuf[0];
std::int32_t* lineBufL1 = wavelet->lineBuf[1]; std::int32_t* lineBufL1 = wavelet->lineBuf[1];
@@ -1988,8 +1970,7 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level)
++band0Buf; ++band0Buf;
for (int i = 0; i < wavelet->width - 3; i += 2) { for (int i = 0; i < wavelet->width - 3; i += 2) {
std::int32_t delta = const std::int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2);
band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2);
lineBufL0[1] = band1Buf[0] + ((lineBufL0[0] + delta) >> 1); lineBufL0[1] = band1Buf[0] + ((lineBufL0[0] + delta) >> 1);
lineBufL0[2] = delta; lineBufL0[2] = delta;
++band0Buf; ++band0Buf;
@@ -1998,15 +1979,14 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level)
} }
if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) { if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) {
std::int32_t delta = const std::int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2);
band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2);
lineBufL0[1] = band1Buf[0] + ((lineBufL0[0] + delta) >> 1); lineBufL0[1] = band1Buf[0] + ((lineBufL0[0] + delta) >> 1);
if (wavelet->width & 1) { if (wavelet->width & 1) {
lineBufL0[2] = delta; lineBufL0[2] = delta;
} }
} else if (wavelet->width & 1) { } else if (wavelet->width & 1) {
std::int32_t delta = band0Buf[0] - ((band1Buf[0] + 1) >> 1); const std::int32_t delta = band0Buf[0] - ((band1Buf[0] + 1) >> 1);
lineBufL0[1] = band1Buf[0] + ((lineBufL0[0] + delta) >> 1); lineBufL0[1] = band1Buf[0] + ((lineBufL0[0] + delta) >> 1);
lineBufL0[2] = delta; lineBufL0[2] = delta;
} else { } else {
@@ -2018,8 +1998,8 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level)
lineBufL0 = wavelet->lineBuf[0]; lineBufL0 = wavelet->lineBuf[0];
lineBufL1 = wavelet->lineBuf[1]; lineBufL1 = wavelet->lineBuf[1];
for (std::int32_t i = 0; i < wavelet->width; i++) { for (std::int32_t i = 0; i < wavelet->width; ++i) {
std::int32_t delta = lineBufL0[i] - ((lineBufL1[i] + 1) >> 1); const std::int32_t delta = lineBufL0[i] - ((lineBufL1[i] + 1) >> 1);
lineBufH1[i] = lineBufL1[i] + ((delta + lineBufH0[i]) >> 1); lineBufH1[i] = lineBufL1[i] + ((delta + lineBufH0[i]) >> 1);
lineBufH2[i] = delta; lineBufH2[i] = delta;
} }
@@ -2028,13 +2008,13 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level)
wavelet->curLine += 3; wavelet->curLine += 3;
wavelet->fltTapH = (wavelet->fltTapH + 3) % 5; wavelet->fltTapH = (wavelet->fltTapH + 3) % 5;
} else { } else {
std::int32_t* lineBufL2 = wavelet->lineBuf[2]; std::int32_t* const lineBufL2 = wavelet->lineBuf[2];
std::int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; const std::int32_t* const lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3];
std::int32_t* lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3]; std::int32_t* const lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3];
wavelet->lineBuf[1] = lineBufL2; wavelet->lineBuf[1] = lineBufL2;
wavelet->lineBuf[2] = wavelet->lineBuf[1]; wavelet->lineBuf[2] = wavelet->lineBuf[1];
for (std::int32_t i = 0; i < wavelet->width; i++) { for (std::int32_t i = 0; i < wavelet->width; ++i) {
lineBufH1[i] = lineBufH0[i] + lineBufL2[i]; lineBufH1[i] = lineBufH0[i] + lineBufL2[i];
} }
@@ -2045,24 +2025,24 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level)
} }
} else { } else {
if (level) { if (level) {
if (!wavelet[-1].curH && crxIdwt53FilterTransform(comp, level - 1)) { if (!wavelet[-1].curH && !crxIdwt53FilterTransform(comp, level - 1)) {
return -1; return false;
} }
wavelet->subband0Buf = crxIdwt53FilterGetLine(comp, level - 1); wavelet->subband0Buf = crxIdwt53FilterGetLine(comp, level - 1);
} }
std::int32_t* band0Buf = wavelet->subband0Buf; const std::int32_t* band0Buf = wavelet->subband0Buf;
std::int32_t* band1Buf = wavelet->subband1Buf; const std::int32_t* band1Buf = wavelet->subband1Buf;
std::int32_t* band2Buf = wavelet->subband2Buf; const std::int32_t* band2Buf = wavelet->subband2Buf;
std::int32_t* band3Buf = wavelet->subband3Buf; const std::int32_t* band3Buf = wavelet->subband3Buf;
std::int32_t* lineBufL0 = wavelet->lineBuf[0]; std::int32_t* lineBufL0 = wavelet->lineBuf[0];
std::int32_t* lineBufL1 = wavelet->lineBuf[1]; std::int32_t* lineBufL1 = wavelet->lineBuf[1];
std::int32_t* lineBufL2 = wavelet->lineBuf[2]; const std::int32_t* lineBufL2 = wavelet->lineBuf[2];
std::int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; const std::int32_t* const lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3];
std::int32_t* lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3]; std::int32_t* const lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3];
std::int32_t* lineBufH2 = wavelet->lineBuf[(wavelet->fltTapH + 2) % 5 + 3]; std::int32_t* const lineBufH2 = wavelet->lineBuf[(wavelet->fltTapH + 2) % 5 + 3];
wavelet->lineBuf[1] = wavelet->lineBuf[2]; wavelet->lineBuf[1] = wavelet->lineBuf[2];
wavelet->lineBuf[2] = lineBufL1; wavelet->lineBuf[2] = lineBufL1;
@@ -2103,10 +2083,10 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level)
} }
if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) { if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) {
std::int32_t deltaA = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); const std::int32_t deltaA = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2);
lineBufL0[1] = band1Buf[0] + ((deltaA + lineBufL0[0]) >> 1); lineBufL0[1] = band1Buf[0] + ((deltaA + lineBufL0[0]) >> 1);
std::int32_t deltaB = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2); const std::int32_t deltaB = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2);
lineBufL1[1] = band3Buf[0] + ((deltaB + lineBufL1[0]) >> 1); lineBufL1[1] = band3Buf[0] + ((deltaB + lineBufL1[0]) >> 1);
if (wavelet->width & 1) { if (wavelet->width & 1) {
@@ -2132,8 +2112,8 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level)
lineBufL1 = wavelet->lineBuf[1]; lineBufL1 = wavelet->lineBuf[1];
lineBufL2 = wavelet->lineBuf[2]; lineBufL2 = wavelet->lineBuf[2];
for (std::int32_t i = 0; i < wavelet->width; i++) { for (std::int32_t i = 0; i < wavelet->width; ++i) {
std::int32_t delta = lineBufL0[i] - ((lineBufL2[i] + lineBufL1[i] + 2) >> 2); const std::int32_t delta = lineBufL0[i] - ((lineBufL2[i] + lineBufL1[i] + 2) >> 2);
lineBufH1[i] = lineBufL1[i] + ((delta + lineBufH0[i]) >> 1); lineBufH1[i] = lineBufL1[i] + ((delta + lineBufH0[i]) >> 1);
lineBufH2[i] = delta; lineBufH2[i] = delta;
} }
@@ -2149,49 +2129,48 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level)
} }
} }
return 0; return true;
} }
int crxIdwt53FilterInitialize(CrxPlaneComp* comp, std::int32_t prevLevel) bool crxIdwt53FilterInitialize(CrxPlaneComp* comp, std::int32_t prevLevel)
{ {
if (prevLevel < 0) { if (prevLevel < 0) {
return 0; return true;
} }
for (int curLevel = 0, curBand = 0; curLevel < prevLevel + 1; for (int curLevel = 0, curBand = 0; curLevel < prevLevel + 1; ++curLevel, curBand += 3) {
curLevel++, curBand += 3) { CrxWaveletTransform* const wavelet = comp->waveletTransform + curLevel;
CrxWaveletTransform* wavelet = comp->waveletTransform + curLevel;
if (curLevel) { if (curLevel) {
wavelet[0].subband0Buf = crxIdwt53FilterGetLine(comp, curLevel - 1); wavelet[0].subband0Buf = crxIdwt53FilterGetLine(comp, curLevel - 1);
} else if (crxDecodeLineWithIQuantization(comp->subBands + curBand)) { } else if (!crxDecodeLineWithIQuantization(comp->subBands + curBand)) {
return -1; return false;
} }
std::int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; std::int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3];
if (wavelet->height > 1) { if (wavelet->height > 1) {
if (crxDecodeLineWithIQuantization(comp->subBands + curBand + 1) || if (
crxDecodeLineWithIQuantization(comp->subBands + curBand + 2) || !crxDecodeLineWithIQuantization(comp->subBands + curBand + 1)
crxDecodeLineWithIQuantization(comp->subBands + curBand + 3)) { || !crxDecodeLineWithIQuantization(comp->subBands + curBand + 2)
return -1; || !crxDecodeLineWithIQuantization(comp->subBands + curBand + 3)
) {
return false;
} }
std::int32_t* lineBufL0 = wavelet->lineBuf[0]; std::int32_t* const lineBufL0 = wavelet->lineBuf[0];
std::int32_t* lineBufL1 = wavelet->lineBuf[1]; const std::int32_t* const lineBufL1 = wavelet->lineBuf[1];
std::int32_t* lineBufL2 = wavelet->lineBuf[2]; std::int32_t* lineBufL2 = wavelet->lineBuf[2];
if (comp->tileFlag & E_HAS_TILES_ON_THE_TOP) { if (comp->tileFlag & E_HAS_TILES_ON_THE_TOP) {
crxHorizontal53(lineBufL0, wavelet->lineBuf[1], wavelet, crxHorizontal53(lineBufL0, wavelet->lineBuf[1], wavelet, comp->tileFlag);
comp->tileFlag);
if (crxDecodeLineWithIQuantization(comp->subBands + curBand + 3) || if (!crxDecodeLineWithIQuantization(comp->subBands + curBand + 3)|| !crxDecodeLineWithIQuantization(comp->subBands + curBand + 2)) {
crxDecodeLineWithIQuantization(comp->subBands + curBand + 2)) { return false;
return -1;
} }
std::int32_t* band2Buf = wavelet->subband2Buf; const std::int32_t* band2Buf = wavelet->subband2Buf;
std::int32_t* band3Buf = wavelet->subband3Buf; const std::int32_t* band3Buf = wavelet->subband3Buf;
// process L band // process L band
if (wavelet->width <= 1) { if (wavelet->width <= 1) {
@@ -2207,8 +2186,7 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, std::int32_t prevLevel)
++band2Buf; ++band2Buf;
for (int i = 0; i < wavelet->width - 3; i += 2) { for (int i = 0; i < wavelet->width - 3; i += 2) {
std::int32_t delta = const std::int32_t delta = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2);
band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2);
lineBufL2[1] = band3Buf[0] + ((lineBufL2[0] + delta) >> 1); lineBufL2[1] = band3Buf[0] + ((lineBufL2[0] + delta) >> 1);
lineBufL2[2] = delta; lineBufL2[2] = delta;
@@ -2218,15 +2196,14 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, std::int32_t prevLevel)
} }
if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) { if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) {
std::int32_t delta = const std::int32_t delta = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2);
band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2);
lineBufL2[1] = band3Buf[0] + ((lineBufL2[0] + delta) >> 1); lineBufL2[1] = band3Buf[0] + ((lineBufL2[0] + delta) >> 1);
if (wavelet->width & 1) { if (wavelet->width & 1) {
lineBufL2[2] = delta; lineBufL2[2] = delta;
} }
} else if (wavelet->width & 1) { } else if (wavelet->width & 1) {
std::int32_t delta = band2Buf[0] - ((band3Buf[0] + 1) >> 1); const std::int32_t delta = band2Buf[0] - ((band3Buf[0] + 1) >> 1);
lineBufL2[1] = band3Buf[0] + ((lineBufL2[0] + delta) >> 1); lineBufL2[1] = band3Buf[0] + ((lineBufL2[0] + delta) >> 1);
lineBufL2[2] = delta; lineBufL2[2] = delta;
@@ -2236,30 +2213,27 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, std::int32_t prevLevel)
} }
// process H band // process H band
for (std::int32_t i = 0; i < wavelet->width; i++) { for (std::int32_t i = 0; i < wavelet->width; ++i) {
lineBufH0[i] = lineBufH0[i] = lineBufL0[i] - ((lineBufL1[i] + lineBufL2[i] + 2) >> 2);
lineBufL0[i] - ((lineBufL1[i] + lineBufL2[i] + 2) >> 2);
} }
} else { } else {
crxHorizontal53(lineBufL0, wavelet->lineBuf[2], wavelet, crxHorizontal53(lineBufL0, wavelet->lineBuf[2], wavelet, comp->tileFlag);
comp->tileFlag);
for (int i = 0; i < wavelet->width; i++) { for (int i = 0; i < wavelet->width; ++i) {
lineBufH0[i] = lineBufL0[i] - ((lineBufL2[i] + 1) >> 1); lineBufH0[i] = lineBufL0[i] - ((lineBufL2[i] + 1) >> 1);
} }
} }
if (crxIdwt53FilterDecode(comp, curLevel) || if (!crxIdwt53FilterDecode(comp, curLevel) || !crxIdwt53FilterTransform(comp, curLevel)) {
crxIdwt53FilterTransform(comp, curLevel)) { return false;
return -1;
} }
} else { } else {
if (crxDecodeLineWithIQuantization(comp->subBands + curBand + 1)) { if (!crxDecodeLineWithIQuantization(comp->subBands + curBand + 1)) {
return -1; return false;
} }
std::int32_t* band0Buf = wavelet->subband0Buf; const std::int32_t* band0Buf = wavelet->subband0Buf;
std::int32_t* band1Buf = wavelet->subband1Buf; const std::int32_t* band1Buf = wavelet->subband1Buf;
// process H band // process H band
if (wavelet->width <= 1) { if (wavelet->width <= 1) {
@@ -2285,11 +2259,11 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, std::int32_t prevLevel)
} }
if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) { if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) {
std::int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); const std::int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2);
lineBufH0[1] = band1Buf[0] + ((lineBufH0[0] + delta) >> 1); lineBufH0[1] = band1Buf[0] + ((lineBufH0[0] + delta) >> 1);
lineBufH0[2] = delta; lineBufH0[2] = delta;
} else if (wavelet->width & 1) { } else if (wavelet->width & 1) {
std::int32_t delta = band0Buf[0] - ((band1Buf[0] + 1) >> 1); const std::int32_t delta = band0Buf[0] - ((band1Buf[0] + 1) >> 1);
lineBufH0[1] = band1Buf[0] + ((lineBufH0[0] + delta) >> 1); lineBufH0[1] = band1Buf[0] + ((lineBufH0[0] + delta) >> 1);
lineBufH0[2] = delta; lineBufH0[2] = delta;
} else { } else {
@@ -2303,7 +2277,7 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, std::int32_t prevLevel)
} }
} }
return 0; return true;
} }
void crxFreeSubbandData(CrxImage* image, CrxPlaneComp* comp) void crxFreeSubbandData(CrxImage* image, CrxPlaneComp* comp)
@@ -2317,7 +2291,7 @@ void crxFreeSubbandData(CrxImage* image, CrxPlaneComp* comp)
return; return;
} }
for (std::int32_t i = 0; i < image->subbandCount; i++) { for (std::int32_t i = 0; i < image->subbandCount; ++i) {
if (comp->subBands[i].bandParam) { if (comp->subBands[i].bandParam) {
free(comp->subBands[i].bandParam); free(comp->subBands[i].bandParam);
comp->subBands[i].bandParam = nullptr; comp->subBands[i].bandParam = nullptr;
@@ -2340,7 +2314,7 @@ void crxConvertPlaneLine(CrxImage* img, int imageRow, int imageCol = 0,
std::int32_t minVal = -maxVal; std::int32_t minVal = -maxVal;
--maxVal; --maxVal;
for (int i = 0; i < lineLength; i++) { for (int i = 0; i < lineLength; ++i) {
img->outBufs[plane][rawOffset + 2 * i] = img->outBufs[plane][rawOffset + 2 * i] =
rtengine::LIM(lineData[i], minVal, maxVal); rtengine::LIM(lineData[i], minVal, maxVal);
} }
@@ -2349,14 +2323,14 @@ void crxConvertPlaneLine(CrxImage* img, int imageRow, int imageCol = 0,
rawOffset = plane * img->planeWidth * img->planeHeight + rawOffset = plane * img->planeWidth * img->planeHeight +
img->planeWidth * imageRow + imageCol; img->planeWidth * imageRow + imageCol;
for (int i = 0; i < lineLength; i++) { for (int i = 0; i < lineLength; ++i) {
img->planeBuf[rawOffset + i] = lineData[i]; img->planeBuf[rawOffset + i] = lineData[i];
} }
} else if (img->nPlanes == 4) { } else if (img->nPlanes == 4) {
std::int32_t median = 1 << (img->nBits - 1); std::int32_t median = 1 << (img->nBits - 1);
std::int32_t maxVal = (1 << img->nBits) - 1; std::int32_t maxVal = (1 << img->nBits) - 1;
for (int i = 0; i < lineLength; i++) { for (int i = 0; i < lineLength; ++i) {
img->outBufs[plane][rawOffset + 2 * i] = img->outBufs[plane][rawOffset + 2 * i] =
rtengine::LIM(median + lineData[i], 0, maxVal); rtengine::LIM(median + lineData[i], 0, maxVal);
} }
@@ -2365,7 +2339,7 @@ void crxConvertPlaneLine(CrxImage* img, int imageRow, int imageCol = 0,
std::int32_t median = 1 << (img->nBits - 1); std::int32_t median = 1 << (img->nBits - 1);
rawOffset = img->planeWidth * imageRow + imageCol; rawOffset = img->planeWidth * imageRow + imageCol;
for (int i = 0; i < lineLength; i++) { for (int i = 0; i < lineLength; ++i) {
img->outBufs[0][rawOffset + i] = img->outBufs[0][rawOffset + i] =
rtengine::LIM(median + lineData[i], 0, maxVal); rtengine::LIM(median + lineData[i], 0, maxVal);
} }
@@ -2382,7 +2356,7 @@ void crxConvertPlaneLine(CrxImage* img, int imageRow, int imageCol = 0,
std::uint32_t rawLineOffset = 4 * img->planeWidth * imageRow; std::uint32_t rawLineOffset = 4 * img->planeWidth * imageRow;
// for this stage - all except imageRow is ignored // for this stage - all except imageRow is ignored
for (int i = 0; i < img->planeWidth; i++) { for (int i = 0; i < img->planeWidth; ++i) {
std::int32_t gr = std::int32_t gr =
median + (plane0[i] << 10) - 168 * plane1[i] - 585 * plane3[i]; median + (plane0[i] << 10) - 168 * plane1[i] - 585 * plane3[i];
std::int32_t val = 0; std::int32_t val = 0;
@@ -2461,7 +2435,7 @@ int crxSetupSubbandData(CrxImage* img, CrxPlaneComp* planeComp,
CrxSubband* subbands = planeComp->subBands; CrxSubband* subbands = planeComp->subBands;
// calculate sizes // calculate sizes
for (std::int32_t subbandNum = 0; subbandNum < toSubbands; subbandNum++) { for (std::int32_t subbandNum = 0; subbandNum < toSubbands; ++subbandNum) {
subbands[subbandNum].bandSize = subbands[subbandNum].bandSize =
subbands[subbandNum].width * sizeof(std::int32_t); // 4bytes subbands[subbandNum].width * sizeof(std::int32_t); // 4bytes
compDataSize += subbands[subbandNum].bandSize; compDataSize += subbands[subbandNum].bandSize;
@@ -2496,7 +2470,7 @@ int crxSetupSubbandData(CrxImage* img, CrxPlaneComp* planeComp,
std::uint64_t subbandMdatOffset = img->mdatOffset + mdatOffset; std::uint64_t subbandMdatOffset = img->mdatOffset + mdatOffset;
std::uint8_t* subbandBuf = planeComp->compBuf; std::uint8_t* subbandBuf = planeComp->compBuf;
for (std::int32_t subbandNum = 0; subbandNum < toSubbands; subbandNum++) { for (std::int32_t subbandNum = 0; subbandNum < toSubbands; ++subbandNum) {
subbands[subbandNum].bandBuf = subbandBuf; subbands[subbandNum].bandBuf = subbandBuf;
subbandBuf += subbands[subbandNum].bandSize; subbandBuf += subbands[subbandNum].bandSize;
subbands[subbandNum].mdatOffset = subbands[subbandNum].mdatOffset =
@@ -2553,7 +2527,7 @@ int crxSetupSubbandData(CrxImage* img, CrxPlaneComp* planeComp,
} }
// decoding params and bitstream initialisation // decoding params and bitstream initialisation
for (std::int32_t subbandNum = 0; subbandNum < toSubbands; subbandNum++) { for (std::int32_t subbandNum = 0; subbandNum < toSubbands; ++subbandNum) {
if (subbands[subbandNum].dataSize) { if (subbands[subbandNum].dataSize) {
std::int32_t supportsPartial = 0; std::int32_t supportsPartial = 0;
std::uint32_t roundedBitsMask = 0; std::uint32_t roundedBitsMask = 0;
@@ -2582,10 +2556,10 @@ int DCraw::crxDecodePlane(void* p, std::uint32_t planeNumber)
CrxImage* img = static_cast<CrxImage*>(p); CrxImage* img = static_cast<CrxImage*>(p);
int imageRow = 0; int imageRow = 0;
for (int tRow = 0; tRow < img->tileRows; tRow++) { for (int tRow = 0; tRow < img->tileRows; ++tRow) {
int imageCol = 0; int imageCol = 0;
for (int tCol = 0; tCol < img->tileCols; tCol++) { for (int tCol = 0; tCol < img->tileCols; ++tCol) {
CrxTile* tile = img->tiles + tRow * img->tileRows + tCol; CrxTile* tile = img->tiles + tRow * img->tileRows + tCol;
CrxPlaneComp* planeComp = tile->comps + planeNumber; CrxPlaneComp* planeComp = tile->comps + planeNumber;
std::uint64_t tileMdatOffset = tile->dataOffset + planeComp->dataOffset; std::uint64_t tileMdatOffset = tile->dataOffset + planeComp->dataOffset;
@@ -2596,13 +2570,13 @@ int DCraw::crxDecodePlane(void* p, std::uint32_t planeNumber)
} }
if (img->levels) { if (img->levels) {
if (crxIdwt53FilterInitialize(planeComp, img->levels - 1)) { if (!crxIdwt53FilterInitialize(planeComp, img->levels - 1)) {
return -1; return -1;
} }
for (int i = 0; i < tile->height; ++i) { for (int i = 0; i < tile->height; ++i) {
if (crxIdwt53FilterDecode(planeComp, img->levels - 1) || if (!crxIdwt53FilterDecode(planeComp, img->levels - 1) ||
crxIdwt53FilterTransform(planeComp, img->levels - 1)) { !crxIdwt53FilterTransform(planeComp, img->levels - 1)) {
return -1; return -1;
} }
@@ -3052,7 +3026,7 @@ int crxFreeImageData(CrxImage* img)
if (img->tiles) { if (img->tiles) {
for (std::int32_t curTile = 0; curTile < nTiles; curTile++, tile++) { for (std::int32_t curTile = 0; curTile < nTiles; curTile++, tile++) {
if (tile[curTile].comps) { if (tile[curTile].comps) {
for (std::int32_t curPlane = 0; curPlane < img->nPlanes; curPlane++) { for (std::int32_t curPlane = 0; curPlane < img->nPlanes; ++curPlane) {
crxFreeSubbandData(img, tile[curTile].comps + curPlane); crxFreeSubbandData(img, tile[curTile].comps + curPlane);
} }
} }