diff --git a/rtengine/canon_cr3_decoder.cc b/rtengine/canon_cr3_decoder.cc index 01bca72f8..609f0c849 100644 --- a/rtengine/canon_cr3_decoder.cc +++ b/rtengine/canon_cr3_decoder.cc @@ -51,42 +51,40 @@ */ +#include +#include #include -#include #include "dcraw.h" void DCraw::parse_canon_cr3() { - int err; - unsigned long long szAtomList; + strncpy(make, "Canon", sizeof(make)); + + unsigned long long szAtomList = ifp->size; short nesting = -1; + char AtomNameStack[128]; unsigned short nTrack = 0; short TrackType; - char AtomNameStack[128]; - strcpy(make, "Canon"); - szAtomList = ifp->size; - err = parseCR3(0ULL, szAtomList, nesting, AtomNameStack, nTrack, TrackType); + const int err = parseCR3(0, szAtomList, nesting, AtomNameStack, nTrack, TrackType); if (err == 0 || err == -14) { // no error, or too deep nesting selectCRXTrack(nTrack); } } -#define LIBRAW_CRXTRACKS_MAXCOUNT RT_canon_CR3_data.CRXTRACKS_MAXCOUNT - void DCraw::selectCRXTrack(unsigned short maxTrack) { - INT64 bitcounts[LIBRAW_CRXTRACKS_MAXCOUNT], maxbitcount = 0; - uint32_t maxjpegbytes = 0; - memset(bitcounts, 0, sizeof(bitcounts)); + std::int64_t bitcounts[RT_canon_CR3_data.CRXTRACKS_MAXCOUNT] = {}; + std::int64_t maxbitcount = 0; + std::uint32_t maxjpegbytes = 0; - for (unsigned int i = 0; i <= maxTrack && i < LIBRAW_CRXTRACKS_MAXCOUNT; i++) { - CanonCR3Data::crx_data_header_t* d = &RT_canon_CR3_data.crx_header[i]; + for (unsigned int i = 0; i <= maxTrack && i < RT_canon_CR3_data.CRXTRACKS_MAXCOUNT; ++i) { + CanonCR3Data::crx_data_header_t* const d = &RT_canon_CR3_data.crx_header[i]; if (d->MediaType == 1) {// RAW - bitcounts[i] = INT64(d->nBits) * INT64(d->f_width) * INT64(d->f_height); + bitcounts[i] = std::int64_t(d->nBits) * std::int64_t(d->f_width) * std::int64_t(d->f_height); if (bitcounts[i] > maxbitcount) { maxbitcount = bitcounts[i]; @@ -105,9 +103,10 @@ void DCraw::selectCRXTrack(unsigned short maxTrack) } bool has_framei = false; - unsigned int framei = 0, framecnt = 0; + unsigned int framei = 0; + unsigned int framecnt = 0; - for (unsigned int i = 0; i <= maxTrack && i < LIBRAW_CRXTRACKS_MAXCOUNT; i++) { + for (unsigned int i = 0; i <= maxTrack && i < RT_canon_CR3_data.CRXTRACKS_MAXCOUNT; ++i) { if (bitcounts[i] == maxbitcount) { if (framecnt <= shot_select) { has_framei = true; @@ -121,8 +120,7 @@ void DCraw::selectCRXTrack(unsigned short maxTrack) is_raw = framecnt; if (has_framei) { - CanonCR3Data::crx_data_header_t* d = - &RT_canon_CR3_data.crx_header[framei]; + CanonCR3Data::crx_data_header_t* const d = &RT_canon_CR3_data.crx_header[framei]; data_offset = d->MediaOffset; // data_size = d->MediaSize; raw_width = d->f_width; @@ -154,11 +152,11 @@ void DCraw::selectCRXTrack(unsigned short maxTrack) RT_canon_CR3_data.crx_track_selected = framei; int tiff_idx = -1; - INT64 tpixels = 0; + std::int64_t tpixels = 0; for (unsigned int i = 0; i < tiff_nifds; i++) { - if (INT64(tiff_ifd[i].height) * INT64(tiff_ifd[i].height) > tpixels) { - tpixels = INT64(tiff_ifd[i].height) * INT64(tiff_ifd[i].height); + 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); tiff_idx = i; } } @@ -169,14 +167,14 @@ void DCraw::selectCRXTrack(unsigned short maxTrack) } } -#define FORC4 for (c = 0; c < 4; c++) - -#define bad_hdr \ - (((order != 0x4d4d) && (order != 0x4949)) || (get2() != 0x002a) || \ - (get4() != 0x00000008)) -int DCraw::parseCR3(unsigned long long oAtomList, - unsigned long long szAtomList, short& nesting, - char* AtomNameStack, unsigned short& nTrack, short& TrackType) +int DCraw::parseCR3( + unsigned long long oAtomList, + unsigned long long szAtomList, + short& nesting, + char* AtomNameStack, + unsigned short& nTrack, + short& TrackType +) { /* Atom starts with 4 bytes for Atom size and 4 bytes containing Atom name @@ -289,17 +287,22 @@ int DCraw::parseCR3(unsigned long long oAtomList, ushort tL; // Atom length represented in 4 or 8 bytes char nmAtom[5]; // Atom name - unsigned long long oAtom, szAtom; // Atom offset and Atom size - unsigned long long oAtomContent, - szAtomContent; // offset and size of Atom content + unsigned long long oAtom; + unsigned long long szAtom; // Atom offset and Atom size + unsigned long long oAtomContent; + unsigned long long szAtomContent; // offset and size of Atom content unsigned long long lHdr; char UIID[16]; uchar CMP1[36]; - char HandlerType[5], MediaFormatID[5]; + char HandlerType[5]; + char MediaFormatID[5]; // unsigned ImageWidth, ImageHeight; - long relpos_inDir, relpos_inBox; - unsigned szItem, Tag, lTag; + long relpos_inDir; + long relpos_inBox; + unsigned szItem; + unsigned Tag; + unsigned lTag; ushort tItem; nmAtom[0] = MediaFormatID[0] = nmAtom[4] = MediaFormatID[4] = '\0'; @@ -314,13 +317,27 @@ int DCraw::parseCR3(unsigned long long oAtomList, short s_order = order; + const auto is_bad_header = + [this]() -> bool + { + return + ( + order != 0x4D4D + && order != 0x4949 + ) + || get2() != 0x002A + || get4() != 0x00000008; + }; + while ((oAtom + 8ULL) <= (oAtomList + szAtomList)) { lHdr = 0ULL; err = 0; order = 0x4d4d; fseek(ifp, oAtom, SEEK_SET); szAtom = get4(); - FORC4 nmAtom[c] = AtomNameStack[nesting * 4 + c] = fgetc(ifp); + for (c = 0; c < 4; c++) { + nmAtom[c] = AtomNameStack[nesting * 4 + c] = fgetc(ifp); + } AtomNameStack[(nesting + 1) * 4] = '\0'; tL = 4; AtomType = 0; @@ -364,7 +381,7 @@ int DCraw::parseCR3(unsigned long long oAtomList, nTrack++; TrackType = 0; - if (nTrack >= LIBRAW_CRXTRACKS_MAXCOUNT) { + if (nTrack >= RT_canon_CR3_data.CRXTRACKS_MAXCOUNT) { break; } } @@ -384,7 +401,7 @@ int DCraw::parseCR3(unsigned long long oAtomList, short q_order = order; order = get2(); - if ((tL != 4) || bad_hdr) { + if ((tL != 4) || is_bad_header()) { err = -4; goto fin; } @@ -395,7 +412,7 @@ int DCraw::parseCR3(unsigned long long oAtomList, short q_order = order; order = get2(); - if ((tL != 4) || bad_hdr) { + if ((tL != 4) || is_bad_header()) { err = -5; goto fin; } @@ -406,7 +423,7 @@ int DCraw::parseCR3(unsigned long long oAtomList, short q_order = order; order = get2(); - if ((tL != 4) || bad_hdr) { + if ((tL != 4) || is_bad_header()) { err = -6; goto fin; } @@ -418,19 +435,21 @@ int DCraw::parseCR3(unsigned long long oAtomList, short q_order = order; order = get2(); - if ((tL != 4) || bad_hdr) { + if ((tL != 4) || is_bad_header()) { err = -6; goto fin; } - INT64 off = ftell(ifp); + std::int64_t off = ftell(ifp); parse_gps(oAtomContent); fseek(ifp, off, SEEK_SET); // parse_gps_libraw(oAtomContent); order = q_order; } else if (!strcmp(AtomNameStack, "moovtrakmdiahdlr")) { fseek(ifp, 8L, SEEK_CUR); - FORC4 HandlerType[c] = fgetc(ifp); + for (c = 0; c < 4; c++) { + HandlerType[c] = fgetc(ifp); + } for (c = 1; c < sizeof sHandlerType / sizeof * sHandlerType; c++) { if (!strcmp(HandlerType, sHandlerType[c])) { @@ -447,7 +466,9 @@ int DCraw::parseCR3(unsigned long long oAtomList, goto fin; } - FORC4 MediaFormatID[c] = fgetc(ifp); + for (c = 0; c < 4; c++) { + MediaFormatID[c] = fgetc(ifp); + } if ((TrackType == 2) && (!strcmp(MediaFormatID, "CRAW"))) { if (szAtomContent >= 44) { @@ -541,7 +562,7 @@ int DCraw::parseCR3(unsigned long long oAtomList, short q_order = order; order = get2(); - if (bad_hdr) { + if (is_bad_header()) { err = -13; goto fin; } @@ -627,13 +648,13 @@ static unsigned sgetn(int n, unsigned char* s) #define CRX_BUF_SIZE 0x10000 #if !defined (_WIN32) || (defined (__GNUC__) && !defined (__INTRINSIC_SPECIAL__BitScanReverse)) /* __INTRINSIC_SPECIAL__BitScanReverse found in MinGW32-W64 v7.30 headers, may be there is a better solution? */ -using DWORD = uint32_t; -using byte = uint8_t; +using DWORD = std::uint32_t; +using byte = std::uint8_t; libraw_inline void _BitScanReverse(DWORD* Index, unsigned long Mask) { *Index = sizeof(unsigned long) * 8 - 1 - __builtin_clzl(Mask); } -uint32_t _byteswap_ulong(uint32_t x) +std::uint32_t _byteswap_ulong(std::uint32_t x) { #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ return x; @@ -665,98 +686,98 @@ struct LibRaw_abstract_datastream { }; struct CrxBitstream { - uint8_t mdatBuf[CRX_BUF_SIZE]; - uint64_t mdatSize; - uint64_t curBufOffset; - uint32_t curPos; - uint32_t curBufSize; - uint32_t bitData; - int32_t bitsLeft; + std::uint8_t mdatBuf[CRX_BUF_SIZE]; + std::uint64_t mdatSize; + std::uint64_t curBufOffset; + std::uint32_t curPos; + std::uint32_t curBufSize; + std::uint32_t bitData; + std::int32_t bitsLeft; LibRaw_abstract_datastream* input; }; struct CrxBandParam { CrxBitstream bitStream; - int16_t subbandWidth; - int16_t subbandHeight; - int32_t roundedBitsMask; - int32_t roundedBits; - int16_t curLine; - int32_t* lineBuf0; - int32_t* lineBuf1; - int32_t* lineBuf2; - int32_t sParam; - int32_t kParam; - int32_t* paramData; - int32_t* nonProgrData; - int8_t supportsPartial; + std::int16_t subbandWidth; + std::int16_t subbandHeight; + std::int32_t roundedBitsMask; + std::int32_t roundedBits; + std::int16_t curLine; + std::int32_t* lineBuf0; + std::int32_t* lineBuf1; + std::int32_t* lineBuf2; + std::int32_t sParam; + std::int32_t kParam; + std::int32_t* paramData; + std::int32_t* nonProgrData; + std::int8_t supportsPartial; }; struct CrxWaveletTransform { - int32_t* subband0Buf; - int32_t* subband1Buf; - int32_t* subband2Buf; - int32_t* subband3Buf; - int32_t* lineBuf[8]; - int16_t curLine; - int16_t curH; - int8_t fltTapH; - int16_t height; - int16_t width; + std::int32_t* subband0Buf; + std::int32_t* subband1Buf; + std::int32_t* subband2Buf; + std::int32_t* subband3Buf; + std::int32_t* lineBuf[8]; + std::int16_t curLine; + std::int16_t curH; + std::int8_t fltTapH; + std::int16_t height; + std::int16_t width; }; struct CrxSubband { CrxBandParam* bandParam; - uint64_t mdatOffset; - uint8_t* bandBuf; - int32_t bandSize; - uint64_t dataSize; - int8_t supportsPartial; - int32_t quantValue; - uint16_t width; - uint16_t height; - int32_t paramK; - int64_t dataOffset; + std::uint64_t mdatOffset; + std::uint8_t* bandBuf; + std::int32_t bandSize; + std::uint64_t dataSize; + std::int8_t supportsPartial; + std::int32_t quantValue; + std::uint16_t width; + std::uint16_t height; + std::int32_t paramK; + std::int64_t dataOffset; }; struct CrxPlaneComp { byte* compBuf; CrxSubband* subBands; CrxWaveletTransform* waveletTransform; - int8_t compNumber; - int64_t dataOffset; - int32_t compSize; - int8_t supportsPartial; - int32_t roundedBitsMask; - int8_t tileFlag; + std::int8_t compNumber; + std::int64_t dataOffset; + std::int32_t compSize; + std::int8_t supportsPartial; + std::int32_t roundedBitsMask; + std::int8_t tileFlag; }; struct CrxTile { CrxPlaneComp* comps; - int8_t tileFlag; - int8_t tileNumber; - int64_t dataOffset; - int32_t tileSize; - uint16_t width; - uint16_t height; + std::int8_t tileFlag; + std::int8_t tileNumber; + std::int64_t dataOffset; + std::int32_t tileSize; + std::uint16_t width; + std::uint16_t height; }; struct CrxImage { - uint8_t nPlanes; - uint16_t planeWidth; - uint16_t planeHeight; - uint8_t samplePrecision; - uint8_t subbandCount; - uint8_t levels; - uint8_t nBits; - uint8_t encType; - uint8_t tileCols; - uint8_t tileRows; + std::uint8_t nPlanes; + std::uint16_t planeWidth; + std::uint16_t planeHeight; + std::uint8_t samplePrecision; + std::uint8_t subbandCount; + std::uint8_t levels; + std::uint8_t nBits; + std::uint8_t encType; + std::uint8_t tileCols; + std::uint8_t tileRows; CrxTile* tiles; - uint64_t mdatOffset; - uint64_t mdatSize; - int16_t* outBufs[4];// one per plane - int16_t* planeBuf; + std::uint64_t mdatOffset; + std::uint64_t mdatSize; + std::int16_t* outBufs[4];// one per plane + std::int16_t* planeBuf; LibRaw_abstract_datastream* input; }; @@ -767,7 +788,7 @@ enum TileFlags { E_HAS_TILES_ON_THE_TOP = 8 }; -int32_t exCoefNumTbl[0x120] = { +std::int32_t exCoefNumTbl[0x120] = { // level 1 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, @@ -787,13 +808,13 @@ int32_t exCoefNumTbl[0x120] = { 8, 8, 2, 1, 4, 3, 1, 1, 1, 1, 1, 1, 8, 7, 1, 1, 3, 3, 1, 1, 1, 1 }; -uint32_t JS[32] = {1, 1, 1, 1, 2, 2, 2, 2, +std::uint32_t JS[32] = {1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 8, 8, 8, 8, 0x10, 0x10, 0x20, 0x20, 0x40, 0x40, 0x80, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000 }; -uint32_t J[32] = {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, +std::uint32_t J[32] = {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 9, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; @@ -828,10 +849,10 @@ static inline void crxFillBuffer(CrxBitstream* bitStrm) libraw_inline int crxBitstreamGetZeros(CrxBitstream* bitStrm) { -// uint32_t bitData = bitStrm->bitData; - uint32_t nonZeroBit = 0; - uint64_t nextData = 0; - int32_t result = 0; +// std::uint32_t bitData = bitStrm->bitData; + std::uint32_t nonZeroBit = 0; + std::uint64_t nextData = 0; + std::int32_t result = 0; if (bitStrm->bitData) { _BitScanReverse((DWORD*)&nonZeroBit, (DWORD)bitStrm->bitData); @@ -839,12 +860,12 @@ libraw_inline int crxBitstreamGetZeros(CrxBitstream* bitStrm) bitStrm->bitData <<= 32 - nonZeroBit; bitStrm->bitsLeft -= 32 - nonZeroBit; } else { - uint32_t bitsLeft = bitStrm->bitsLeft; + std::uint32_t bitsLeft = bitStrm->bitsLeft; while (true) { while (bitStrm->curPos + 4 <= bitStrm->curBufSize) { nextData = - _byteswap_ulong(*(uint32_t*)(bitStrm->mdatBuf + bitStrm->curPos)); + _byteswap_ulong(*(std::uint32_t*)(bitStrm->mdatBuf + bitStrm->curPos)); bitStrm->curPos += 4; crxFillBuffer(bitStrm); @@ -874,7 +895,7 @@ libraw_inline int crxBitstreamGetZeros(CrxBitstream* bitStrm) } _BitScanReverse((DWORD*)&nonZeroBit, (DWORD)nextData); - result = (uint32_t)(bitsLeft + 7 - nonZeroBit); + result = (std::uint32_t)(bitsLeft + 7 - nonZeroBit); bitStrm->bitData = nextData << (32 - nonZeroBit); bitStrm->bitsLeft = nonZeroBit; } @@ -882,19 +903,19 @@ libraw_inline int crxBitstreamGetZeros(CrxBitstream* bitStrm) return result; } -libraw_inline uint32_t crxBitstreamGetBits(CrxBitstream* bitStrm, int bits) +libraw_inline std::uint32_t crxBitstreamGetBits(CrxBitstream* bitStrm, int bits) { int bitsLeft = bitStrm->bitsLeft; - uint32_t bitData = bitStrm->bitData; - uint32_t nextWord; - uint8_t nextByte; - uint32_t result; + std::uint32_t bitData = bitStrm->bitData; + std::uint32_t nextWord; + std::uint8_t nextByte; + std::uint32_t result; if (bitsLeft < bits) { // get them from stream if (bitStrm->curPos + 4 <= bitStrm->curBufSize) { nextWord = - _byteswap_ulong(*(uint32_t*)(bitStrm->mdatBuf + bitStrm->curPos)); + _byteswap_ulong(*(std::uint32_t*)(bitStrm->mdatBuf + bitStrm->curPos)); bitStrm->curPos += 4; crxFillBuffer(bitStrm); bitStrm->bitsLeft = 32 - (bits - bitsLeft); @@ -922,23 +943,23 @@ libraw_inline uint32_t crxBitstreamGetBits(CrxBitstream* bitStrm, int bits) return result; } -libraw_inline int crxPredictKParameter(int32_t prevK, int32_t bitCode, - int32_t maxVal = 0) +libraw_inline int crxPredictKParameter(std::int32_t prevK, std::int32_t bitCode, + std::int32_t maxVal = 0) { - int32_t newKParam = prevK - (bitCode < (1 << prevK >> 1)) + + std::int32_t newKParam = prevK - (bitCode < (1 << prevK >> 1)) + ((bitCode >> prevK) > 2) + ((bitCode >> prevK) > 5); return !maxVal || newKParam < maxVal ? newKParam : maxVal; } libraw_inline void crxDecodeSymbolL1(CrxBandParam* param, - int32_t doMedianPrediction, - int32_t notEOL = 0) + std::int32_t doMedianPrediction, + std::int32_t notEOL = 0) { if (doMedianPrediction) { - int32_t symb[4]; + std::int32_t symb[4]; - int32_t delta = param->lineBuf0[1] - param->lineBuf0[0]; + std::int32_t delta = param->lineBuf0[1] - param->lineBuf0[0]; symb[2] = param->lineBuf1[0]; symb[0] = symb[1] = delta + symb[2]; symb[3] = param->lineBuf0[1]; @@ -951,7 +972,7 @@ libraw_inline void crxDecodeSymbolL1(CrxBandParam* param, } // get next error symbol - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -965,7 +986,7 @@ libraw_inline void crxDecodeSymbolL1(CrxBandParam* param, // for not end of the line - use one symbol ahead to estimate next K if (notEOL) { - int32_t nextDelta = (param->lineBuf0[2] - param->lineBuf0[1]) << 1; + std::int32_t nextDelta = (param->lineBuf0[2] - param->lineBuf0[1]) << 1; bitCode = (bitCode + _abs(nextDelta)) >> 1; ++param->lineBuf0; } @@ -1051,15 +1072,15 @@ int crxDecodeLine(CrxBandParam* param) } libraw_inline void crxDecodeSymbolL1Rounded(CrxBandParam* param, - int32_t doSym = 1, - int32_t doCode = 1) + std::int32_t doSym = 1, + std::int32_t doCode = 1) { - int32_t sym = param->lineBuf0[1]; + std::int32_t sym = param->lineBuf0[1]; if (doSym) { // calculate the next symbol gradient - int32_t symb[4]; - int32_t deltaH = param->lineBuf0[1] - param->lineBuf0[0]; + std::int32_t symb[4]; + std::int32_t deltaH = param->lineBuf0[1] - param->lineBuf0[0]; symb[2] = param->lineBuf1[0]; symb[0] = symb[1] = deltaH + symb[2]; symb[3] = param->lineBuf0[1]; @@ -1068,7 +1089,7 @@ libraw_inline void crxDecodeSymbolL1Rounded(CrxBandParam* param, ((param->lineBuf1[0] < param->lineBuf0[1]) ^ (deltaH < 0))]; } - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1077,7 +1098,7 @@ libraw_inline void crxDecodeSymbolL1Rounded(CrxBandParam* param, (bitCode << param->kParam); } - int32_t code = -(bitCode & 1) ^ (bitCode >> 1); + std::int32_t code = -(bitCode & 1) ^ (bitCode >> 1); param->lineBuf1[1] = param->roundedBitsMask * 2 * code + static_cast(code < 0) + sym; if (doCode) { @@ -1102,11 +1123,11 @@ libraw_inline void crxDecodeSymbolL1Rounded(CrxBandParam* param, int crxDecodeLineRounded(CrxBandParam* param) { - int32_t valueReached = 0; + std::int32_t valueReached = 0; param->lineBuf0[0] = param->lineBuf0[1]; param->lineBuf1[0] = param->lineBuf0[1]; - int32_t length = param->subbandWidth; + std::int32_t length = param->subbandWidth; for (; length > 1; --length) { if (_abs(param->lineBuf0[2] - param->lineBuf0[1]) > param->roundedBitsMask) { @@ -1189,11 +1210,11 @@ int crxDecodeLineRounded(CrxBandParam* param) int crxDecodeLineNoRefPrevLine(CrxBandParam* param) { - int32_t i = 0; + std::int32_t i = 0; for (; i < param->subbandWidth - 1; i++) { if (param->lineBuf0[i + 2] | param->lineBuf0[i + 1] | param->lineBuf1[i]) { - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1255,14 +1276,14 @@ int crxDecodeLineNoRefPrevLine(CrxBandParam* param) } if (nSyms > 0) { - memset(param->lineBuf1 + i + 1, 0, nSyms * sizeof(int32_t)); - memset(param->lineBuf2 + i, 0, nSyms * sizeof(int32_t)); + memset(param->lineBuf1 + i + 1, 0, nSyms * sizeof(std::int32_t)); + memset(param->lineBuf2 + i, 0, nSyms * sizeof(std::int32_t)); i += nSyms; } if (i >= param->subbandWidth - 1) { if (i == param->subbandWidth - 1) { - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1278,7 +1299,7 @@ int crxDecodeLineNoRefPrevLine(CrxBandParam* param) continue; } else { - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1304,7 +1325,7 @@ int crxDecodeLineNoRefPrevLine(CrxBandParam* param) } if (i == param->subbandWidth - 1) { - int32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::int32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1325,7 +1346,7 @@ int crxDecodeTopLine(CrxBandParam* param) { param->lineBuf1[0] = 0; - int32_t length = param->subbandWidth; + std::int32_t length = param->subbandWidth; // read the line from bitstream for (; length > 1; --length) { @@ -1384,7 +1405,7 @@ int crxDecodeTopLine(CrxBandParam* param) param->lineBuf1[1] = 0; } - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1400,7 +1421,7 @@ int crxDecodeTopLine(CrxBandParam* param) if (length == 1) { param->lineBuf1[1] = param->lineBuf1[0]; - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1423,7 +1444,7 @@ int crxDecodeTopLineRounded(CrxBandParam* param) { param->lineBuf1[0] = 0; - int32_t length = param->subbandWidth; + std::int32_t length = param->subbandWidth; // read the line from bitstream for (; length > 1; --length) { @@ -1482,7 +1503,7 @@ int crxDecodeTopLineRounded(CrxBandParam* param) param->lineBuf1[1] = 0; } - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1491,14 +1512,14 @@ int crxDecodeTopLineRounded(CrxBandParam* param) (bitCode << param->kParam); } - int32_t sVal = -(bitCode & 1) ^ (bitCode >> 1); + std::int32_t sVal = -(bitCode & 1) ^ (bitCode >> 1); param->lineBuf1[1] += param->roundedBitsMask * 2 * sVal + (sVal >> 31); param->kParam = crxPredictKParameter(param->kParam, bitCode, 15); ++param->lineBuf1; } if (length == 1) { - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1507,7 +1528,7 @@ int crxDecodeTopLineRounded(CrxBandParam* param) (bitCode << param->kParam); } - int32_t sVal = -(bitCode & 1) ^ (bitCode >> 1); + std::int32_t sVal = -(bitCode & 1) ^ (bitCode >> 1); param->lineBuf1[1] += param->roundedBitsMask * 2 * sVal + (sVal >> 31); param->kParam = crxPredictKParameter(param->kParam, bitCode, 15); ++param->lineBuf1; @@ -1522,11 +1543,11 @@ int crxDecodeTopLineNoRefPrevLine(CrxBandParam* param) { param->lineBuf0[0] = 0; param->lineBuf1[0] = 0; - int32_t length = param->subbandWidth; + std::int32_t length = param->subbandWidth; for (; length > 1; --length) { if (param->lineBuf1[0]) { - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1589,7 +1610,7 @@ int crxDecodeTopLineNoRefPrevLine(CrxBandParam* param) break; } - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1608,7 +1629,7 @@ int crxDecodeTopLineNoRefPrevLine(CrxBandParam* param) } if (length == 1) { - uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(¶m->bitStream); if (bitCode >= 41) { bitCode = crxBitstreamGetBits(¶m->bitStream, 21); @@ -1628,7 +1649,7 @@ int crxDecodeTopLineNoRefPrevLine(CrxBandParam* param) return 0; } -int crxDecodeLine(CrxBandParam* param, uint8_t* bandBuf) +int crxDecodeLine(CrxBandParam* param, std::uint8_t* bandBuf) { if (!param || !bandBuf) { return -1; @@ -1639,22 +1660,22 @@ int crxDecodeLine(CrxBandParam* param, uint8_t* bandBuf) } if (param->curLine == 0) { - int32_t lineLength = param->subbandWidth + 2; + std::int32_t lineLength = param->subbandWidth + 2; param->sParam = 0; param->kParam = 0; if (param->supportsPartial) { if (param->roundedBitsMask <= 0) { - param->lineBuf0 = (int32_t*)param->paramData; + param->lineBuf0 = (std::int32_t*)param->paramData; param->lineBuf1 = param->lineBuf0 + lineLength; - int32_t* lineBuf = param->lineBuf1 + 1; + std::int32_t* lineBuf = param->lineBuf1 + 1; if (crxDecodeTopLine(param)) { return -1; } - memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(int32_t)); + memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(std::int32_t)); ++param->curLine; } else { param->roundedBits = 1; @@ -1665,87 +1686,87 @@ int crxDecodeLine(CrxBandParam* param, uint8_t* bandBuf) } } - param->lineBuf0 = (int32_t*)param->paramData; + param->lineBuf0 = (std::int32_t*)param->paramData; param->lineBuf1 = param->lineBuf0 + lineLength; - int32_t* lineBuf = param->lineBuf1 + 1; + std::int32_t* lineBuf = param->lineBuf1 + 1; if (crxDecodeTopLineRounded(param)) { return -1; } - memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(int32_t)); + memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(std::int32_t)); ++param->curLine; } } else { - param->lineBuf2 = (int32_t*)param->nonProgrData; - param->lineBuf0 = (int32_t*)param->paramData; + param->lineBuf2 = (std::int32_t*)param->nonProgrData; + param->lineBuf0 = (std::int32_t*)param->paramData; param->lineBuf1 = param->lineBuf0 + lineLength; - int32_t* lineBuf = param->lineBuf1 + 1; + std::int32_t* lineBuf = param->lineBuf1 + 1; if (crxDecodeTopLineNoRefPrevLine(param)) { return -1; } - memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(int32_t)); + memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(std::int32_t)); ++param->curLine; } } else if (!param->supportsPartial) { - int32_t lineLength = param->subbandWidth + 2; - param->lineBuf2 = (int32_t*)param->nonProgrData; + std::int32_t lineLength = param->subbandWidth + 2; + param->lineBuf2 = (std::int32_t*)param->nonProgrData; if (param->curLine & 1) { - param->lineBuf1 = (int32_t*)param->paramData; + param->lineBuf1 = (std::int32_t*)param->paramData; param->lineBuf0 = param->lineBuf1 + lineLength; } else { - param->lineBuf0 = (int32_t*)param->paramData; + param->lineBuf0 = (std::int32_t*)param->paramData; param->lineBuf1 = param->lineBuf0 + lineLength; } - int32_t* lineBuf = param->lineBuf1 + 1; + std::int32_t* lineBuf = param->lineBuf1 + 1; if (crxDecodeLineNoRefPrevLine(param)) { return -1; } - memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(int32_t)); + memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(std::int32_t)); ++param->curLine; } else if (param->roundedBitsMask <= 0) { - int32_t lineLength = param->subbandWidth + 2; + std::int32_t lineLength = param->subbandWidth + 2; if (param->curLine & 1) { - param->lineBuf1 = (int32_t*)param->paramData; + param->lineBuf1 = (std::int32_t*)param->paramData; param->lineBuf0 = param->lineBuf1 + lineLength; } else { - param->lineBuf0 = (int32_t*)param->paramData; + param->lineBuf0 = (std::int32_t*)param->paramData; param->lineBuf1 = param->lineBuf0 + lineLength; } - int32_t* lineBuf = param->lineBuf1 + 1; + std::int32_t* lineBuf = param->lineBuf1 + 1; if (crxDecodeLine(param)) { return -1; } - memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(int32_t)); + memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(std::int32_t)); ++param->curLine; } else { - int32_t lineLength = param->subbandWidth + 2; + std::int32_t lineLength = param->subbandWidth + 2; if (param->curLine & 1) { - param->lineBuf1 = (int32_t*)param->paramData; + param->lineBuf1 = (std::int32_t*)param->paramData; param->lineBuf0 = param->lineBuf1 + lineLength; } else { - param->lineBuf0 = (int32_t*)param->paramData; + param->lineBuf0 = (std::int32_t*)param->paramData; param->lineBuf1 = param->lineBuf0 + lineLength; } - int32_t* lineBuf = param->lineBuf1 + 1; + std::int32_t* lineBuf = param->lineBuf1 + 1; if (crxDecodeLineRounded(param)) { return -1; } - memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(int32_t)); + memcpy(bandBuf, lineBuf, param->subbandWidth * sizeof(std::int32_t)); ++param->curLine; } @@ -1754,7 +1775,7 @@ int crxDecodeLine(CrxBandParam* param, uint8_t* bandBuf) int crxDecodeLineWithIQuantization(CrxSubband* subband) { - int32_t q_step_tbl[6] = {0x28, 0x2D, 0x33, 0x39, 0x40, 0x48}; + std::int32_t q_step_tbl[6] = {0x28, 0x2D, 0x33, 0x39, 0x40, 0x48}; if (!subband->dataSize) { memset(subband->bandBuf, 0, subband->bandSize); @@ -1762,7 +1783,7 @@ int crxDecodeLineWithIQuantization(CrxSubband* subband) } if (subband->supportsPartial) { - uint32_t bitCode = crxBitstreamGetZeros(&subband->bandParam->bitStream); + std::uint32_t bitCode = crxBitstreamGetZeros(&subband->bandParam->bitStream); if (bitCode >= 23) { bitCode = crxBitstreamGetBits(&subband->bandParam->bitStream, 8); @@ -1790,8 +1811,8 @@ int crxDecodeLineWithIQuantization(CrxSubband* subband) } // update subband buffers - int32_t* bandBuf = (int32_t*)subband->bandBuf; - int32_t qScale = + std::int32_t* bandBuf = (std::int32_t*)subband->bandBuf; + std::int32_t qScale = q_step_tbl[subband->quantValue % 6] >> (6 - subband->quantValue / 6); if (subband->quantValue / 6 >= 6) { @@ -1800,7 +1821,7 @@ int crxDecodeLineWithIQuantization(CrxSubband* subband) } if (qScale != 1) { - for (int32_t i = 0; i < subband->width; i++) { + for (std::int32_t i = 0; i < subband->width; i++) { bandBuf[i] *= qScale; } } @@ -1808,13 +1829,13 @@ int crxDecodeLineWithIQuantization(CrxSubband* subband) return 0; } -void crxHorizontal53(int32_t* lineBufLA, int32_t* lineBufLB, - CrxWaveletTransform* wavelet, uint32_t tileFlag) +void crxHorizontal53(std::int32_t* lineBufLA, std::int32_t* lineBufLB, + CrxWaveletTransform* wavelet, std::uint32_t tileFlag) { - int32_t* band0Buf = wavelet->subband0Buf; - int32_t* band1Buf = wavelet->subband1Buf; - int32_t* band2Buf = wavelet->subband2Buf; - int32_t* band3Buf = wavelet->subband3Buf; + std::int32_t* band0Buf = wavelet->subband0Buf; + std::int32_t* band1Buf = wavelet->subband1Buf; + std::int32_t* band2Buf = wavelet->subband2Buf; + std::int32_t* band3Buf = wavelet->subband3Buf; if (wavelet->width <= 1) { lineBufLA[0] = band0Buf[0]; @@ -1834,7 +1855,7 @@ void crxHorizontal53(int32_t* lineBufLA, int32_t* lineBufLB, ++band2Buf; for (int i = 0; i < wavelet->width - 3; i += 2) { - int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); + std::int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); lineBufLA[1] = band1Buf[0] + ((delta + lineBufLA[0]) >> 1); lineBufLA[2] = delta; @@ -1851,10 +1872,10 @@ void crxHorizontal53(int32_t* lineBufLA, int32_t* lineBufLB, } if (tileFlag & E_HAS_TILES_ON_THE_RIGHT) { - int32_t deltaA = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); + std::int32_t deltaA = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); lineBufLA[1] = band1Buf[0] + ((deltaA + lineBufLA[0]) >> 1); - int32_t deltaB = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2); + std::int32_t deltaB = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2); lineBufLB[1] = band3Buf[0] + ((deltaB + lineBufLB[0]) >> 1); if (wavelet->width & 1) { @@ -1878,9 +1899,9 @@ void crxHorizontal53(int32_t* lineBufLA, int32_t* lineBufLB, } } -int32_t* crxIdwt53FilterGetLine(CrxPlaneComp* comp, int32_t level) +std::int32_t* crxIdwt53FilterGetLine(CrxPlaneComp* comp, std::int32_t level) { - int32_t* result = comp->waveletTransform[level] + std::int32_t* result = comp->waveletTransform[level] .lineBuf[(comp->waveletTransform[level].fltTapH - comp->waveletTransform[level].curH + 5) % 5 + @@ -1889,7 +1910,7 @@ int32_t* crxIdwt53FilterGetLine(CrxPlaneComp* comp, int32_t level) return result; } -int crxIdwt53FilterDecode(CrxPlaneComp* comp, int32_t level) +int crxIdwt53FilterDecode(CrxPlaneComp* comp, std::int32_t level) { if (comp->waveletTransform[level].curH) { return 0; @@ -1932,7 +1953,7 @@ int crxIdwt53FilterDecode(CrxPlaneComp* comp, int32_t level) return 0; } -int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) +int crxIdwt53FilterTransform(CrxPlaneComp* comp, std::uint32_t level) { CrxWaveletTransform* wavelet = comp->waveletTransform + level; @@ -1953,14 +1974,14 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) wavelet->subband0Buf = crxIdwt53FilterGetLine(comp, level - 1); } - int32_t* band0Buf = wavelet->subband0Buf; - int32_t* band1Buf = wavelet->subband1Buf; - int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; - int32_t* lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3]; - int32_t* lineBufH2 = wavelet->lineBuf[(wavelet->fltTapH + 2) % 5 + 3]; + std::int32_t* band0Buf = wavelet->subband0Buf; + std::int32_t* band1Buf = wavelet->subband1Buf; + std::int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; + std::int32_t* lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3]; + std::int32_t* lineBufH2 = wavelet->lineBuf[(wavelet->fltTapH + 2) % 5 + 3]; - int32_t* lineBufL0 = wavelet->lineBuf[0]; - int32_t* lineBufL1 = wavelet->lineBuf[1]; + std::int32_t* lineBufL0 = wavelet->lineBuf[0]; + std::int32_t* lineBufL1 = wavelet->lineBuf[1]; wavelet->lineBuf[1] = wavelet->lineBuf[2]; wavelet->lineBuf[2] = lineBufL1; @@ -1978,7 +1999,7 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) ++band0Buf; for (int i = 0; i < wavelet->width - 3; i += 2) { - int32_t delta = + std::int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); lineBufL0[1] = band1Buf[0] + ((lineBufL0[0] + delta) >> 1); lineBufL0[2] = delta; @@ -1988,7 +2009,7 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) } if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) { - int32_t delta = + std::int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); lineBufL0[1] = band1Buf[0] + ((lineBufL0[0] + delta) >> 1); @@ -1996,7 +2017,7 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) lineBufL0[2] = delta; } } else if (wavelet->width & 1) { - int32_t delta = band0Buf[0] - ((band1Buf[0] + 1) >> 1); + std::int32_t delta = band0Buf[0] - ((band1Buf[0] + 1) >> 1); lineBufL0[1] = band1Buf[0] + ((lineBufL0[0] + delta) >> 1); lineBufL0[2] = delta; } else { @@ -2008,8 +2029,8 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) lineBufL0 = wavelet->lineBuf[0]; lineBufL1 = wavelet->lineBuf[1]; - for (int32_t i = 0; i < wavelet->width; i++) { - int32_t delta = lineBufL0[i] - ((lineBufL1[i] + 1) >> 1); + for (std::int32_t i = 0; i < wavelet->width; i++) { + std::int32_t delta = lineBufL0[i] - ((lineBufL1[i] + 1) >> 1); lineBufH1[i] = lineBufL1[i] + ((delta + lineBufH0[i]) >> 1); lineBufH2[i] = delta; } @@ -2018,13 +2039,13 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) wavelet->curLine += 3; wavelet->fltTapH = (wavelet->fltTapH + 3) % 5; } else { - int32_t* lineBufL2 = wavelet->lineBuf[2]; - int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; - int32_t* lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3]; + std::int32_t* lineBufL2 = wavelet->lineBuf[2]; + std::int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; + std::int32_t* lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3]; wavelet->lineBuf[1] = lineBufL2; wavelet->lineBuf[2] = wavelet->lineBuf[1]; - for (int32_t i = 0; i < wavelet->width; i++) { + for (std::int32_t i = 0; i < wavelet->width; i++) { lineBufH1[i] = lineBufH0[i] + lineBufL2[i]; } @@ -2042,17 +2063,17 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) wavelet->subband0Buf = crxIdwt53FilterGetLine(comp, level - 1); } - int32_t* band0Buf = wavelet->subband0Buf; - int32_t* band1Buf = wavelet->subband1Buf; - int32_t* band2Buf = wavelet->subband2Buf; - int32_t* band3Buf = wavelet->subband3Buf; + std::int32_t* band0Buf = wavelet->subband0Buf; + std::int32_t* band1Buf = wavelet->subband1Buf; + std::int32_t* band2Buf = wavelet->subband2Buf; + std::int32_t* band3Buf = wavelet->subband3Buf; - int32_t* lineBufL0 = wavelet->lineBuf[0]; - int32_t* lineBufL1 = wavelet->lineBuf[1]; - int32_t* lineBufL2 = wavelet->lineBuf[2]; - int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; - int32_t* lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3]; - int32_t* lineBufH2 = wavelet->lineBuf[(wavelet->fltTapH + 2) % 5 + 3]; + std::int32_t* lineBufL0 = wavelet->lineBuf[0]; + std::int32_t* lineBufL1 = wavelet->lineBuf[1]; + std::int32_t* lineBufL2 = wavelet->lineBuf[2]; + std::int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; + std::int32_t* lineBufH1 = wavelet->lineBuf[(wavelet->fltTapH + 1) % 5 + 3]; + std::int32_t* lineBufH2 = wavelet->lineBuf[(wavelet->fltTapH + 2) % 5 + 3]; wavelet->lineBuf[1] = wavelet->lineBuf[2]; wavelet->lineBuf[2] = lineBufL1; @@ -2076,7 +2097,7 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) ++band2Buf; for (int i = 0; i < wavelet->width - 3; i += 2) { - int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); + std::int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); lineBufL0[1] = band1Buf[0] + ((delta + lineBufL0[0]) >> 1); lineBufL0[2] = delta; @@ -2093,10 +2114,10 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) } if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) { - int32_t deltaA = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); + std::int32_t deltaA = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); lineBufL0[1] = band1Buf[0] + ((deltaA + lineBufL0[0]) >> 1); - int32_t deltaB = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2); + std::int32_t deltaB = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2); lineBufL1[1] = band3Buf[0] + ((deltaB + lineBufL1[0]) >> 1); if (wavelet->width & 1) { @@ -2104,7 +2125,7 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) lineBufL1[2] = deltaB; } } else if (wavelet->width & 1) { - int32_t delta = band0Buf[0] - ((band1Buf[0] + 1) >> 1); + std::int32_t delta = band0Buf[0] - ((band1Buf[0] + 1) >> 1); lineBufL0[1] = band1Buf[0] + ((delta + lineBufL0[0]) >> 1); lineBufL0[2] = delta; @@ -2122,8 +2143,8 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) lineBufL1 = wavelet->lineBuf[1]; lineBufL2 = wavelet->lineBuf[2]; - for (int32_t i = 0; i < wavelet->width; i++) { - int32_t delta = lineBufL0[i] - ((lineBufL2[i] + lineBufL1[i] + 2) >> 2); + for (std::int32_t i = 0; i < wavelet->width; i++) { + std::int32_t delta = lineBufL0[i] - ((lineBufL2[i] + lineBufL1[i] + 2) >> 2); lineBufH1[i] = lineBufL1[i] + ((delta + lineBufH0[i]) >> 1); lineBufH2[i] = delta; } @@ -2142,7 +2163,7 @@ int crxIdwt53FilterTransform(CrxPlaneComp* comp, uint32_t level) return 0; } -int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) +int crxIdwt53FilterInitialize(CrxPlaneComp* comp, std::int32_t prevLevel) { if (prevLevel < 0) { return 0; @@ -2158,7 +2179,7 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) return -1; } - int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; + std::int32_t* lineBufH0 = wavelet->lineBuf[wavelet->fltTapH + 3]; if (wavelet->height > 1) { if (crxDecodeLineWithIQuantization(comp->subBands + curBand + 1) || @@ -2167,9 +2188,9 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) return -1; } - int32_t* lineBufL0 = wavelet->lineBuf[0]; - int32_t* lineBufL1 = wavelet->lineBuf[1]; - int32_t* lineBufL2 = wavelet->lineBuf[2]; + std::int32_t* lineBufL0 = wavelet->lineBuf[0]; + std::int32_t* lineBufL1 = wavelet->lineBuf[1]; + std::int32_t* lineBufL2 = wavelet->lineBuf[2]; if (comp->tileFlag & E_HAS_TILES_ON_THE_TOP) { crxHorizontal53(lineBufL0, wavelet->lineBuf[1], wavelet, @@ -2180,8 +2201,8 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) return -1; } - int32_t* band2Buf = wavelet->subband2Buf; - int32_t* band3Buf = wavelet->subband3Buf; + std::int32_t* band2Buf = wavelet->subband2Buf; + std::int32_t* band3Buf = wavelet->subband3Buf; // process L band if (wavelet->width <= 1) { @@ -2197,7 +2218,7 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) ++band2Buf; for (int i = 0; i < wavelet->width - 3; i += 2) { - int32_t delta = + std::int32_t delta = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2); lineBufL2[1] = band3Buf[0] + ((lineBufL2[0] + delta) >> 1); lineBufL2[2] = delta; @@ -2208,7 +2229,7 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) } if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) { - int32_t delta = + std::int32_t delta = band2Buf[0] - ((band3Buf[0] + band3Buf[1] + 2) >> 2); lineBufL2[1] = band3Buf[0] + ((lineBufL2[0] + delta) >> 1); @@ -2216,7 +2237,7 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) lineBufL2[2] = delta; } } else if (wavelet->width & 1) { - int32_t delta = band2Buf[0] - ((band3Buf[0] + 1) >> 1); + std::int32_t delta = band2Buf[0] - ((band3Buf[0] + 1) >> 1); lineBufL2[1] = band3Buf[0] + ((lineBufL2[0] + delta) >> 1); lineBufL2[2] = delta; @@ -2226,7 +2247,7 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) } // process H band - for (int32_t i = 0; i < wavelet->width; i++) { + for (std::int32_t i = 0; i < wavelet->width; i++) { lineBufH0[i] = lineBufL0[i] - ((lineBufL1[i] + lineBufL2[i] + 2) >> 2); } @@ -2248,8 +2269,8 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) return -1; } - int32_t* band0Buf = wavelet->subband0Buf; - int32_t* band1Buf = wavelet->subband1Buf; + std::int32_t* band0Buf = wavelet->subband0Buf; + std::int32_t* band1Buf = wavelet->subband1Buf; // process H band if (wavelet->width <= 1) { @@ -2265,7 +2286,7 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) ++band0Buf; for (int i = 0; i < wavelet->width - 3; i += 2) { - int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); + std::int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); lineBufH0[1] = band1Buf[0] + ((lineBufH0[0] + delta) >> 1); lineBufH0[2] = delta; @@ -2275,11 +2296,11 @@ int crxIdwt53FilterInitialize(CrxPlaneComp* comp, int32_t prevLevel) } if (comp->tileFlag & E_HAS_TILES_ON_THE_RIGHT) { - int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); + std::int32_t delta = band0Buf[0] - ((band1Buf[0] + band1Buf[1] + 2) >> 2); lineBufH0[1] = band1Buf[0] + ((lineBufH0[0] + delta) >> 1); lineBufH0[2] = delta; } else if (wavelet->width & 1) { - int32_t delta = band0Buf[0] - ((band1Buf[0] + 1) >> 1); + std::int32_t delta = band0Buf[0] - ((band1Buf[0] + 1) >> 1); lineBufH0[1] = band1Buf[0] + ((lineBufH0[0] + delta) >> 1); lineBufH0[2] = delta; } else { @@ -2307,7 +2328,7 @@ void crxFreeSubbandData(CrxImage* image, CrxPlaneComp* comp) return; } - for (int32_t i = 0; i < image->subbandCount; i++) { + for (std::int32_t i = 0; i < image->subbandCount; i++) { if (comp->subBands[i].bandParam) { free(comp->subBands[i].bandParam); comp->subBands[i].bandParam = nullptr; @@ -2319,15 +2340,15 @@ void crxFreeSubbandData(CrxImage* image, CrxPlaneComp* comp) } void crxConvertPlaneLine(CrxImage* img, int imageRow, int imageCol = 0, - int plane = 0, const int32_t* lineData = nullptr, + int plane = 0, const std::int32_t* lineData = nullptr, int lineLength = 0) { if (lineData) { - uint64_t rawOffset = 4 * img->planeWidth * imageRow + 2 * imageCol; + std::uint64_t rawOffset = 4 * img->planeWidth * imageRow + 2 * imageCol; if (img->encType == 1) { - int32_t maxVal = 1 << (img->nBits - 1); - int32_t minVal = -maxVal; + std::int32_t maxVal = 1 << (img->nBits - 1); + std::int32_t minVal = -maxVal; --maxVal; for (int i = 0; i < lineLength; i++) { @@ -2343,16 +2364,16 @@ void crxConvertPlaneLine(CrxImage* img, int imageRow, int imageCol = 0, img->planeBuf[rawOffset + i] = lineData[i]; } } else if (img->nPlanes == 4) { - int32_t median = 1 << (img->nBits - 1); - int32_t maxVal = (1 << img->nBits) - 1; + std::int32_t median = 1 << (img->nBits - 1); + std::int32_t maxVal = (1 << img->nBits) - 1; for (int i = 0; i < lineLength; i++) { img->outBufs[plane][rawOffset + 2 * i] = _constrain(median + lineData[i], 0, maxVal); } } else if (img->nPlanes == 1) { - int32_t maxVal = (1 << img->nBits) - 1; - int32_t median = 1 << (img->nBits - 1); + std::int32_t maxVal = (1 << img->nBits) - 1; + std::int32_t median = 1 << (img->nBits - 1); rawOffset = img->planeWidth * imageRow + imageCol; for (int i = 0; i < lineLength; i++) { @@ -2361,21 +2382,21 @@ void crxConvertPlaneLine(CrxImage* img, int imageRow, int imageCol = 0, } } } else if (img->encType == 3 && img->planeBuf) { - int32_t planeSize = img->planeWidth * img->planeHeight; - int16_t* plane0 = img->planeBuf + imageRow * img->planeWidth; - int16_t* plane1 = plane0 + planeSize; - int16_t* plane2 = plane1 + planeSize; - int16_t* plane3 = plane2 + planeSize; + std::int32_t planeSize = img->planeWidth * img->planeHeight; + std::int16_t* plane0 = img->planeBuf + imageRow * img->planeWidth; + std::int16_t* plane1 = plane0 + planeSize; + std::int16_t* plane2 = plane1 + planeSize; + std::int16_t* plane3 = plane2 + planeSize; - int32_t median = 1 << (img->nBits - 1) << 10; - int32_t maxVal = (1 << img->nBits) - 1; - uint32_t rawLineOffset = 4 * img->planeWidth * imageRow; + std::int32_t median = 1 << (img->nBits - 1) << 10; + std::int32_t maxVal = (1 << img->nBits) - 1; + std::uint32_t rawLineOffset = 4 * img->planeWidth * imageRow; // for this stage - all except imageRow is ignored for (int i = 0; i < img->planeWidth; i++) { - int32_t gr = + std::int32_t gr = median + (plane0[i] << 10) - 168 * plane1[i] - 585 * plane3[i]; - int32_t val = 0; + std::int32_t val = 0; if (gr < 0) { gr = -(((_abs(gr) + 512) >> 9) & ~1); @@ -2399,15 +2420,15 @@ void crxConvertPlaneLine(CrxImage* img, int imageRow, int imageCol = 0, } } -int crxParamInit(CrxBandParam** param, uint64_t subbandMdatOffset, - uint64_t subbandDataSize, uint32_t subbandWidth, - uint32_t subbandHeight, int32_t supportsPartial, - uint32_t roundedBitsMask, LibRaw_abstract_datastream* input) +int crxParamInit(CrxBandParam** param, std::uint64_t subbandMdatOffset, + std::uint64_t subbandDataSize, std::uint32_t subbandWidth, + std::uint32_t subbandHeight, std::int32_t supportsPartial, + std::uint32_t roundedBitsMask, LibRaw_abstract_datastream* input) { - int32_t progrDataSize = supportsPartial ? 0 : sizeof(int32_t) * subbandWidth; - int32_t paramLength = 2 * subbandWidth + 4; - uint8_t* paramBuf = (uint8_t*)calloc( - 1, sizeof(CrxBandParam) + sizeof(int32_t) * paramLength + progrDataSize); + std::int32_t progrDataSize = supportsPartial ? 0 : sizeof(std::int32_t) * subbandWidth; + std::int32_t paramLength = 2 * subbandWidth + 4; + std::uint8_t* paramBuf = (std::uint8_t*)calloc( + 1, sizeof(CrxBandParam) + sizeof(std::int32_t) * paramLength + progrDataSize); if (!paramBuf) { return -1; @@ -2417,7 +2438,7 @@ int crxParamInit(CrxBandParam** param, uint64_t subbandMdatOffset, paramBuf += sizeof(CrxBandParam); - (*param)->paramData = (int32_t*)paramBuf; + (*param)->paramData = (std::int32_t*)paramBuf; (*param)->nonProgrData = progrDataSize ? (*param)->paramData + paramLength : nullptr; (*param)->subbandWidth = subbandWidth; @@ -2440,25 +2461,25 @@ int crxParamInit(CrxBandParam** param, uint64_t subbandMdatOffset, } int crxSetupSubbandData(CrxImage* img, CrxPlaneComp* planeComp, - const CrxTile* tile, uint32_t mdatOffset) + const CrxTile* tile, std::uint32_t mdatOffset) { long compDataSize = 0; long waveletDataOffset = 0; long compCoeffDataOffset = 0; - int32_t toSubbands = 3 * img->levels + 1; - int32_t transformWidth = 0; + std::int32_t toSubbands = 3 * img->levels + 1; + std::int32_t transformWidth = 0; CrxSubband* subbands = planeComp->subBands; // calculate sizes - for (int32_t subbandNum = 0; subbandNum < toSubbands; subbandNum++) { + for (std::int32_t subbandNum = 0; subbandNum < toSubbands; subbandNum++) { subbands[subbandNum].bandSize = - subbands[subbandNum].width * sizeof(int32_t); // 4bytes + subbands[subbandNum].width * sizeof(std::int32_t); // 4bytes compDataSize += subbands[subbandNum].bandSize; } if (img->levels) { - int32_t encLevels = img->levels ? img->levels : 1; + std::int32_t encLevels = img->levels ? img->levels : 1; waveletDataOffset = (compDataSize + 7) & ~7; compDataSize = (sizeof(CrxWaveletTransform) * encLevels + waveletDataOffset + 7) & ~7; @@ -2467,26 +2488,26 @@ int crxSetupSubbandData(CrxImage* img, CrxPlaneComp* planeComp, // calc wavelet line buffer sizes (always at one level up from current) for (int level = 0; level < img->levels; ++level) { if (level < img->levels - 1) { - compDataSize += 8 * sizeof(int32_t) * + compDataSize += 8 * sizeof(std::int32_t) * planeComp->subBands[3 * (level + 1) + 2].width; } else { - compDataSize += 8 * sizeof(int32_t) * tile->width; + compDataSize += 8 * sizeof(std::int32_t) * tile->width; } } } // buffer allocation - planeComp->compBuf = (uint8_t*)malloc(compDataSize); + planeComp->compBuf = (std::uint8_t*)malloc(compDataSize); if (!planeComp->compBuf) { return -1; } // subbands buffer and sizes initialisation - uint64_t subbandMdatOffset = img->mdatOffset + mdatOffset; - uint8_t* subbandBuf = planeComp->compBuf; + std::uint64_t subbandMdatOffset = img->mdatOffset + mdatOffset; + std::uint8_t* subbandBuf = planeComp->compBuf; - for (int32_t subbandNum = 0; subbandNum < toSubbands; subbandNum++) { + for (std::int32_t subbandNum = 0; subbandNum < toSubbands; subbandNum++) { subbands[subbandNum].bandBuf = subbandBuf; subbandBuf += subbands[subbandNum].bandSize; subbands[subbandNum].mdatOffset = @@ -2497,13 +2518,13 @@ int crxSetupSubbandData(CrxImage* img, CrxPlaneComp* planeComp, if (img->levels) { CrxWaveletTransform* waveletTransforms = (CrxWaveletTransform*)(planeComp->compBuf + waveletDataOffset); - int32_t* paramData = (int32_t*)(planeComp->compBuf + compCoeffDataOffset); + std::int32_t* paramData = (std::int32_t*)(planeComp->compBuf + compCoeffDataOffset); planeComp->waveletTransform = waveletTransforms; - waveletTransforms[0].subband0Buf = (int32_t*)subbands->bandBuf; + waveletTransforms[0].subband0Buf = (std::int32_t*)subbands->bandBuf; for (int level = 0; level < img->levels; ++level) { - int32_t band = 3 * level + 1; + std::int32_t band = 3 * level + 1; if (level >= img->levels - 1) { waveletTransforms[level].height = tile->height; @@ -2532,21 +2553,21 @@ int crxSetupSubbandData(CrxImage* img, CrxPlaneComp* planeComp, waveletTransforms[level].curLine = 0; waveletTransforms[level].curH = 0; waveletTransforms[level].fltTapH = 0; - waveletTransforms[level].subband1Buf = (int32_t*)subbands[band].bandBuf; + waveletTransforms[level].subband1Buf = (std::int32_t*)subbands[band].bandBuf; waveletTransforms[level].subband2Buf = - (int32_t*)subbands[band + 1].bandBuf; + (std::int32_t*)subbands[band + 1].bandBuf; waveletTransforms[level].subband3Buf = - (int32_t*)subbands[band + 2].bandBuf; + (std::int32_t*)subbands[band + 2].bandBuf; paramData = waveletTransforms[level].lineBuf[7] + transformWidth; } } // decoding params and bitstream initialisation - for (int32_t subbandNum = 0; subbandNum < toSubbands; subbandNum++) { + for (std::int32_t subbandNum = 0; subbandNum < toSubbands; subbandNum++) { if (subbands[subbandNum].dataSize) { - int32_t supportsPartial = 0; - uint32_t roundedBitsMask = 0; + std::int32_t supportsPartial = 0; + std::uint32_t roundedBitsMask = 0; if (planeComp->supportsPartial && subbandNum == 0) { roundedBitsMask = planeComp->roundedBitsMask; @@ -2567,7 +2588,7 @@ int crxSetupSubbandData(CrxImage* img, CrxPlaneComp* planeComp, } } // namespace -int DCraw::crxDecodePlane(void* p, uint32_t planeNumber) +int DCraw::crxDecodePlane(void* p, std::uint32_t planeNumber) { CrxImage* img = (CrxImage*)p; int imageRow = 0; @@ -2578,7 +2599,7 @@ int DCraw::crxDecodePlane(void* p, uint32_t planeNumber) for (int tCol = 0; tCol < img->tileCols; tCol++) { CrxTile* tile = img->tiles + tRow * img->tileRows + tCol; CrxPlaneComp* planeComp = tile->comps + planeNumber; - uint64_t tileMdatOffset = tile->dataOffset + planeComp->dataOffset; + std::uint64_t tileMdatOffset = tile->dataOffset + planeComp->dataOffset; // decode single tile if (crxSetupSubbandData(img, planeComp, tile, tileMdatOffset)) { @@ -2596,7 +2617,7 @@ int DCraw::crxDecodePlane(void* p, uint32_t planeNumber) return -1; } - int32_t* lineData = + std::int32_t* lineData = crxIdwt53FilterGetLine(planeComp, img->levels - 1); crxConvertPlaneLine(img, imageRow + i, imageCol, planeNumber, lineData, tile->width); @@ -2615,7 +2636,7 @@ int DCraw::crxDecodePlane(void* p, uint32_t planeNumber) return -1; } - int32_t* lineData = (int32_t*)planeComp->subBands->bandBuf; + std::int32_t* lineData = (std::int32_t*)planeComp->subBands->bandBuf; crxConvertPlaneLine(img, imageRow + i, imageCol, planeNumber, lineData, tile->width); } @@ -2635,14 +2656,14 @@ namespace using crx_data_header_t = DCraw::CanonCR3Data::crx_data_header_t; int crxReadSubbandHeaders(crx_data_header_t* hdr, CrxImage* img, CrxTile* tile, - CrxPlaneComp* comp, uint8_t** subbandMdatPtr, - uint32_t* mdatSize) + CrxPlaneComp* comp, std::uint8_t** subbandMdatPtr, + std::uint32_t* mdatSize) { CrxSubband* band = comp->subBands + img->subbandCount - 1; // set to last band - uint32_t bandHeight = tile->height; - uint32_t bandWidth = tile->width; - int32_t bandWidthExCoef = 0; - int32_t bandHeightExCoef = 0; + std::uint32_t bandHeight = tile->height; + std::uint32_t bandWidth = tile->width; + std::int32_t bandWidthExCoef = 0; + std::int32_t bandHeightExCoef = 0; if (img->levels) { // Build up subband sequences to crxDecode to a level in a header @@ -2650,21 +2671,21 @@ int crxReadSubbandHeaders(crx_data_header_t* hdr, CrxImage* img, CrxTile* tile, // Coefficient structure is a bit unclear and convoluted: // 3 levels max - 8 groups (for tile width rounded to 8 bytes) // of 3 band per level 4 sets of coefficients for each - int32_t* rowExCoef = + std::int32_t* rowExCoef = exCoefNumTbl + 0x60 * (img->levels - 1) + 12 * (tile->width & 7); - int32_t* colExCoef = + std::int32_t* colExCoef = exCoefNumTbl + 0x60 * (img->levels - 1) + 12 * (tile->height & 7); for (int level = 0; level < img->levels; ++level) { - int32_t widthOddPixel = bandWidth & 1; - int32_t heightOddPixel = bandHeight & 1; + std::int32_t widthOddPixel = bandWidth & 1; + std::int32_t heightOddPixel = bandHeight & 1; bandWidth = (widthOddPixel + bandWidth) >> 1; bandHeight = (heightOddPixel + bandHeight) >> 1; - int32_t bandWidthExCoef0 = 0; - int32_t bandWidthExCoef1 = 0; - int32_t bandHeightExCoef0 = 0; - int32_t bandHeightExCoef1 = 0; + std::int32_t bandWidthExCoef0 = 0; + std::int32_t bandWidthExCoef1 = 0; + std::int32_t bandHeightExCoef0 = 0; + std::int32_t bandHeightExCoef1 = 0; if (tile->tileFlag & E_HAS_TILES_ON_THE_RIGHT) { bandWidthExCoef0 = rowExCoef[0]; @@ -2720,7 +2741,7 @@ int crxReadSubbandHeaders(crx_data_header_t* hdr, CrxImage* img, CrxTile* tile, return 0; } - int32_t subbandOffset = 0; + std::int32_t subbandOffset = 0; band = comp->subBands; for (unsigned int curSubband = 0; curSubband < img->subbandCount; curSubband++, band++) { @@ -2732,8 +2753,8 @@ int crxReadSubbandHeaders(crx_data_header_t* hdr, CrxImage* img, CrxTile* tile, return -1; } - uint32_t bitData = sgetn(4, *subbandMdatPtr + 8); - uint32_t subbandSize = sgetn(4, *subbandMdatPtr + 4); + std::uint32_t bitData = sgetn(4, *subbandMdatPtr + 8); + std::uint32_t subbandSize = sgetn(4, *subbandMdatPtr + 4); if (curSubband != bitData >> 28) { band->dataSize = subbandSize; @@ -2758,8 +2779,8 @@ int crxReadSubbandHeaders(crx_data_header_t* hdr, CrxImage* img, CrxTile* tile, return 0; } -int crxReadImageHeaders(crx_data_header_t* hdr, CrxImage* img, uint8_t* mdatPtr, - uint32_t mdatSize) +int crxReadImageHeaders(crx_data_header_t* hdr, CrxImage* img, std::uint8_t* mdatPtr, + std::uint32_t mdatSize) { unsigned int nTiles = img->tileRows * img->tileCols; @@ -2855,9 +2876,9 @@ int crxReadImageHeaders(crx_data_header_t* hdr, CrxImage* img, uint8_t* mdatPtr, } } - uint32_t tileOffset = 0; - uint32_t dataSize = mdatSize; - uint8_t* dataPtr = mdatPtr; + std::uint32_t tileOffset = 0; + std::uint32_t dataSize = mdatSize; + std::uint8_t* dataPtr = mdatPtr; CrxTile* tile = img->tiles; for (unsigned int curTile = 0; curTile < nTiles; curTile++, tile++) { @@ -2878,12 +2899,12 @@ int crxReadImageHeaders(crx_data_header_t* hdr, CrxImage* img, uint8_t* mdatPtr, tile->tileSize = sgetn(4, dataPtr + 4); tile->dataOffset = tileOffset; - int32_t hdrExtraBytes = sgetn(2, dataPtr + 2) - 8; + std::int32_t hdrExtraBytes = sgetn(2, dataPtr + 2) - 8; tileOffset += tile->tileSize; dataPtr += hdrExtraBytes + 0xC; dataSize -= hdrExtraBytes; - uint32_t compOffset = 0; + std::uint32_t compOffset = 0; CrxPlaneComp* comp = tile->comps; for (int compNum = 0; compNum < img->nPlanes; compNum++, comp++) { @@ -2901,7 +2922,7 @@ int crxReadImageHeaders(crx_data_header_t* hdr, CrxImage* img, uint8_t* mdatPtr, comp->compSize = sgetn(4, dataPtr + 4); - int32_t compHdrRoundedBits = (dataPtr[8] >> 1) & 3; + std::int32_t compHdrRoundedBits = (dataPtr[8] >> 1) & 3; comp->supportsPartial = (dataPtr[8] & 8) != 0; comp->dataOffset = compOffset; @@ -2930,9 +2951,9 @@ int crxReadImageHeaders(crx_data_header_t* hdr, CrxImage* img, uint8_t* mdatPtr, return 0; } -int crxSetupImageData(crx_data_header_t* hdr, CrxImage* img, int16_t* outBuf, - uint64_t mdatOffset, uint32_t mdatSize, - uint8_t* mdatHdrPtr) +int crxSetupImageData(crx_data_header_t* hdr, CrxImage* img, std::int16_t* outBuf, + std::uint64_t mdatOffset, std::uint32_t mdatSize, + std::uint8_t* mdatHdrPtr) { int IncrBitTable[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0 @@ -2975,7 +2996,7 @@ int crxSetupImageData(crx_data_header_t* hdr, CrxImage* img, int16_t* outBuf, // left as is. if (img->encType == 3 && img->nPlanes == 4 && img->nBits > 8) { img->planeBuf = - (int16_t*)malloc(img->planeHeight * img->planeWidth * img->nPlanes * + (std::int16_t*)malloc(img->planeHeight * img->planeWidth * img->nPlanes * ((img->samplePrecision + 7) >> 3)); if (!img->planeBuf) { @@ -2983,7 +3004,7 @@ int crxSetupImageData(crx_data_header_t* hdr, CrxImage* img, int16_t* outBuf, } } - int32_t rowSize = 2 * img->planeWidth; + std::int32_t rowSize = 2 * img->planeWidth; if (img->nPlanes == 1) { img->outBufs[0] = outBuf; @@ -3041,9 +3062,9 @@ int crxFreeImageData(CrxImage* img) int nTiles = img->tileRows * img->tileCols; if (img->tiles) { - for (int32_t curTile = 0; curTile < nTiles; curTile++, tile++) { + for (std::int32_t curTile = 0; curTile < nTiles; curTile++, tile++) { if (tile[curTile].comps) { - for (int32_t curPlane = 0; curPlane < img->nPlanes; curPlane++) { + for (std::int32_t curPlane = 0; curPlane < img->nPlanes; curPlane++) { crxFreeSubbandData(img, tile[curTile].comps + curPlane); } } @@ -3068,11 +3089,11 @@ void DCraw::crxLoadDecodeLoop(void* img, int nPlanes) int results[4]; // nPlanes is always <= 4 #pragma omp parallel for - for (int32_t plane = 0; plane < nPlanes; ++plane) { + for (std::int32_t plane = 0; plane < nPlanes; ++plane) { results[plane] = crxDecodePlane(img, plane); } - for (int32_t plane = 0; plane < nPlanes; ++plane) { + for (std::int32_t plane = 0; plane < nPlanes; ++plane) { if (results[plane]) { derror(); } @@ -3080,7 +3101,7 @@ void DCraw::crxLoadDecodeLoop(void* img, int nPlanes) #else - for (int32_t plane = 0; plane < nPlanes; ++plane) { + for (std::int32_t plane = 0; plane < nPlanes; ++plane) { if (crxDecodePlane(img, plane)) { derror(); } @@ -3110,7 +3131,7 @@ void DCraw::crxLoadRaw() CrxImage img; if (RT_canon_CR3_data.crx_track_selected >= - LIBRAW_CRXTRACKS_MAXCOUNT) { + RT_canon_CR3_data.CRXTRACKS_MAXCOUNT) { derror(); } @@ -3131,7 +3152,7 @@ void DCraw::crxLoadRaw() // /*imgdata.color.*/maximum = (1 << hdr.nBits) - 1; - uint8_t* hdrBuf = (uint8_t*)malloc(hdr.mdatHdrSize); + std::uint8_t* hdrBuf = (std::uint8_t*)malloc(hdr.mdatHdrSize); // read image header #ifdef _OPENMP @@ -3150,7 +3171,7 @@ void DCraw::crxLoadRaw() } // parse and setup the image data - if (crxSetupImageData(&hdr, &img, (int16_t*)raw_image, + if (crxSetupImageData(&hdr, &img, (std::int16_t*)raw_image, hdr.MediaOffset /*data_offset*/, hdr.MediaSize /*RT_canon_CR3_data.data_size*/, hdrBuf)) { derror(); @@ -3169,7 +3190,7 @@ void DCraw::crxLoadRaw() int DCraw::crxParseImageHeader(uchar* cmp1TagData, unsigned int nTrack) { - if (nTrack >= LIBRAW_CRXTRACKS_MAXCOUNT) { + if (nTrack >= RT_canon_CR3_data.CRXTRACKS_MAXCOUNT) { return -1; } @@ -3243,4 +3264,3 @@ int DCraw::crxParseImageHeader(uchar* cmp1TagData, unsigned int nTrack) #undef _min #undef _constrain #undef libraw_inline -#undef LIBRAW_CRXTRACKS_MAXCOUNT