36 #define YUVoffset4 8 // 2^3 37 #define YUVoffset6 32 // 2^5 38 #define YUVoffset8 128 // 2^7 39 #define YUVoffset16 32768 // 2^15 47 OSError GetLastPGFError() {
48 OSError tmp = _PGF_Error_;
49 _PGF_Error_ = NoError;
56 struct DebugBGRImage {
57 int width, height, pitch;
73 m_levelLength =
nullptr;
76 #ifdef __PGFROISUPPORT__ 77 m_streamReinitialized =
false;
83 m_favorSpeedOverSize =
false;
84 m_useOMPinEncoder =
true;
85 m_useOMPinDecoder =
true;
93 memcpy(m_preHeader.magic,
PGFMagic, 3);
95 m_preHeader.hSize = 0;
98 m_postHeader.userData =
nullptr;
99 m_postHeader.userDataLen = 0;
100 m_postHeader.cachedUserDataLen = 0;
104 m_channel[i] =
nullptr;
105 m_wtChannel[i] =
nullptr;
118 m_currentLevel = -100;
125 for (
int i = 0; i < m_header.channels; i++) {
126 delete m_wtChannel[i];
128 delete[] m_postHeader.userData;
129 delete[] m_levelLength;
133 if (m_currentLevel != -100) Init();
145 m_decoder =
new CDecoder(stream, m_preHeader, m_header, m_postHeader, m_levelLength,
146 m_userDataPos, m_useOMPinDecoder, m_userDataPolicy);
148 if (m_header.nLevels >
MaxLevel) ReturnWithError(FormatCannotRead);
151 m_currentLevel = m_header.nLevels;
154 m_width[0] = m_header.width;
155 m_height[0] = m_header.height;
158 if (!CompleteHeader()) ReturnWithError(FormatCannotRead);
170 m_quant = m_header.quality - 1;
172 m_downsample =
false;
173 m_quant = m_header.quality;
178 for (
int i=1; i < m_header.channels; i++) {
179 m_width[i] = (m_width[0] + 1) >> 1;
180 m_height[i] = (m_height[0] + 1) >> 1;
183 for (
int i=1; i < m_header.channels; i++) {
184 m_width[i] = m_width[0];
185 m_height[i] = m_height[0];
189 if (m_header.nLevels > 0) {
191 for (
int i=0; i < m_header.channels; i++) {
192 m_wtChannel[i] =
new CWaveletTransform(m_width[i], m_height[i], m_header.nLevels);
196 m_percent = pow(0.25, m_header.nLevels);
202 for (
int c=0; c < m_header.channels; c++) {
203 const UINT32 size = m_width[c]*m_height[c];
204 m_channel[c] =
new(std::nothrow)
DataT[size];
205 if (!m_channel[c]) ReturnWithError(InsufficientMemory);
208 for (UINT32 i=0; i < size; i++) {
210 stream->
Read(&count, &m_channel[c][i]);
211 if (count !=
DataTSize) ReturnWithError(MissingData);
224 switch(m_header.bpp) {
237 switch(m_header.mode) {
277 if (m_header.mode ==
ImageModeBitmap && m_header.bpp != 1)
return false;
280 if (m_header.mode ==
ImageModeGray16 && m_header.bpp != 16)
return false;
281 if (m_header.mode ==
ImageModeGray32 && m_header.bpp != 32)
return false;
283 if (m_header.mode ==
ImageModeRGBA && m_header.bpp != 32)
return false;
284 if (m_header.mode ==
ImageModeRGB12 && m_header.bpp != 12)
return false;
285 if (m_header.mode ==
ImageModeRGB16 && m_header.bpp != 16)
return false;
286 if (m_header.mode ==
ImageModeRGB48 && m_header.bpp != 48)
return false;
288 if (m_header.mode ==
ImageModeLab48 && m_header.bpp != 48)
return false;
290 if (m_header.mode ==
ImageModeCMYK64 && m_header.bpp != 64)
return false;
293 if (!m_header.channels) {
294 switch(m_header.mode) {
300 m_header.channels = 1;
308 m_header.channels = 3;
313 m_header.channels = 4;
321 UINT8 bpc = m_header.bpp/m_header.channels;
322 if (bpc > 31) bpc = 31;
323 if (!m_header.usedBitsPerChannel || m_header.usedBitsPerChannel > bpc) {
324 m_header.usedBitsPerChannel = bpc;
338 cachedSize = m_postHeader.cachedUserDataLen;
339 if (pTotalSize) *pTotalSize = m_postHeader.userDataLen;
340 return m_postHeader.userData;
349 if (m_header.nLevels == 0) {
352 for (
int i=0; i < m_header.channels; i++) {
353 ASSERT(m_wtChannel[i]);
354 m_channel[i] = m_wtChannel[i]->GetSubband(0,
LL)->GetBuffer();
358 int currentLevel = m_header.nLevels;
360 #ifdef __PGFROISUPPORT__ 361 if (ROIisSupported()) {
363 SetROI(
PGFRect(0, 0, m_header.width, m_header.height));
367 while (currentLevel > level) {
368 for (
int i=0; i < m_header.channels; i++) {
369 ASSERT(m_wtChannel[i]);
371 if (currentLevel == m_header.nLevels) {
373 m_wtChannel[i]->GetSubband(currentLevel,
LL)->Dequantize(m_quant);
375 m_wtChannel[i]->GetSubband(currentLevel,
HL)->Dequantize(m_quant);
376 m_wtChannel[i]->GetSubband(currentLevel,
LH)->Dequantize(m_quant);
377 m_wtChannel[i]->GetSubband(currentLevel,
HH)->Dequantize(m_quant);
380 OSError err = m_wtChannel[i]->InverseTransform(currentLevel, &m_width[i], &m_height[i], &m_channel[i]);
381 if (err != NoError) ReturnWithError(err);
382 ASSERT(m_channel[i]);
403 ASSERT((level >= 0 && level < m_header.nLevels) || m_header.nLevels == 0);
406 #ifdef __PGFROISUPPORT__ 407 if (ROIisSupported() && m_header.nLevels > 0) {
409 PGFRect rect(0, 0, m_header.width, m_header.height);
410 Read(rect, level, cb, data);
415 if (m_header.nLevels == 0) {
420 if ((*cb)(1.0,
true, data)) ReturnWithError(EscapePressed);
424 const int levelDiff = m_currentLevel - level;
425 double percent = (m_progressMode ==
PM_Relative) ? pow(0.25, levelDiff) : m_percent;
428 while (m_currentLevel > level) {
429 for (
int i=0; i < m_header.channels; i++) {
434 if (m_currentLevel == m_header.nLevels) {
438 if (m_preHeader.version &
Version5) {
444 m_decoder->DecodeInterleaved(wtChannel, m_currentLevel, m_quant);
449 volatile OSError error = NoError;
450 #ifdef LIBPGF_USE_OPENMP 451 #pragma omp parallel for default(shared) 453 for (
int i=0; i < m_header.channels; i++) {
455 if (error == NoError) {
456 OSError err = m_wtChannel[i]->InverseTransform(m_currentLevel, &m_width[i], &m_height[i], &m_channel[i]);
457 if (err != NoError) error = err;
459 ASSERT(m_channel[i]);
461 if (error != NoError) ReturnWithError(error);
467 if (m_cb) m_cb(m_cbArg);
472 if (m_progressMode ==
PM_Absolute) m_percent = percent;
473 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
479 #ifdef __PGFROISUPPORT__ 490 ASSERT((level >= 0 && level < m_header.nLevels) || m_header.nLevels == 0);
493 if (m_header.nLevels == 0 || !ROIisSupported()) {
495 rect.
right = m_header.width; rect.
bottom = m_header.height;
496 Read(level, cb, data);
498 ASSERT(ROIisSupported());
500 ASSERT(rect.
left < m_header.width && rect.
top < m_header.height);
503 if (rect.
right == 0 || rect.
right > m_header.width) rect.
right = m_header.width;
506 const int levelDiff = m_currentLevel - level;
507 double percent = (m_progressMode ==
PM_Relative) ? pow(0.25, levelDiff) : m_percent;
510 if (levelDiff <= 0) {
512 m_currentLevel = m_header.nLevels;
513 m_decoder->SetStreamPosToData();
519 while (m_currentLevel > level) {
520 for (
int i=0; i < m_header.channels; i++) {
525 const UINT32 nTiles = wtChannel->GetNofTiles(m_currentLevel);
528 if (m_currentLevel == m_header.nLevels) {
530 m_decoder->GetNextMacroBlock();
533 for (UINT32 tileY=0; tileY < nTiles; tileY++) {
534 for (UINT32 tileX=0; tileX < nTiles; tileX++) {
536 if (wtChannel->TileIsRelevant(m_currentLevel, tileX, tileY)) {
537 m_decoder->GetNextMacroBlock();
543 m_decoder->SkipTileBuffer();
549 volatile OSError error = NoError;
550 #ifdef LIBPGF_USE_OPENMP 551 #pragma omp parallel for default(shared) 553 for (
int i=0; i < m_header.channels; i++) {
555 if (error == NoError) {
556 OSError err = m_wtChannel[i]->InverseTransform(m_currentLevel, &m_width[i], &m_height[i], &m_channel[i]);
557 if (err != NoError) error = err;
559 ASSERT(m_channel[i]);
561 if (error != NoError) ReturnWithError(error);
567 if (m_cb) m_cb(m_cbArg);
572 if (m_progressMode ==
PM_Absolute) m_percent = percent;
573 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
584 if (m_currentLevel == 0) {
587 const UINT32 rLeft = LevelSizeL(m_roi.left, m_currentLevel);
588 const UINT32 rRight = LevelSizeL(m_roi.right, m_currentLevel);
589 const UINT32 rTop = LevelSizeL(m_roi.top, m_currentLevel);
590 const UINT32 rBottom = LevelSizeL(m_roi.bottom, m_currentLevel);
591 return PGFRect(rLeft, rTop, rRight - rLeft, rBottom - rTop);
599 PGFRect roi(0, 0, m_width[c], m_height[c]);
601 if (ROIisSupported()) {
602 ASSERT(m_wtChannel[c]);
604 roi = m_wtChannel[c]->GetAlignedROI(m_currentLevel);
606 ASSERT(roi.
Width() == m_width[c]);
607 ASSERT(roi.
Height() == m_height[c]);
617 ASSERT(ROIisSupported());
618 ASSERT(m_wtChannel[0]);
627 m_wtChannel[0]->SetROI(rect);
629 if (m_downsample && m_header.channels > 1) {
636 for (
int i=1; i < m_header.channels; i++) {
637 ASSERT(m_wtChannel[i]);
638 m_wtChannel[i]->SetROI(rect);
642 #endif // __PGFROISUPPORT__ 650 return m_decoder->GetEncodedHeaderLength();
662 ASSERT(targetLen > 0);
666 m_decoder->SetStreamPosToStart();
669 UINT32 len =
__min(targetLen, GetEncodedHeaderLength());
672 len = m_decoder->ReadEncodedData(target, len);
673 ASSERT(len >= 0 && len <= targetLen);
685 m_decoder->SetStreamPosToData();
688 m_decoder->SetStreamPosToStart();
689 }
else if (m_encoder) {
690 m_encoder->SetStreamPosToStart();
707 ASSERT(level >= 0 && level < m_header.nLevels);
709 ASSERT(targetLen > 0);
713 m_decoder->SetStreamPosToData();
718 for (
int i=m_header.nLevels - 1; i > level; i--) {
719 offset += m_levelLength[m_header.nLevels - 1 - i];
721 m_decoder->Skip(offset);
724 UINT32 len =
__min(targetLen, GetEncodedLevelLength(level));
727 len = m_decoder->ReadEncodedData(target, len);
728 ASSERT(len >= 0 && len <= targetLen);
738 const BYTE bpc = m_header.bpp/m_header.channels;
741 while(maxValue > 0) {
746 if (pot > bpc) pot = bpc;
747 if (pot > 31) pot = 31;
748 m_header.usedBitsPerChannel = pot;
756 const BYTE bpc = m_header.bpp/m_header.channels;
759 return m_header.usedBitsPerChannel;
793 ASSERT(m_channel[0]);
796 RgbToYuv(pitch, buff, bpp, channelMap, cb, data);
800 for (
int i=1; i < m_header.channels; i++) {
812 const int w = m_width[0];
814 const int h2 = m_height[0]/2;
815 const int oddW = w%2;
816 const int oddH = m_height[0]%2;
820 DataT* buff = m_channel[ch]; ASSERT(buff);
822 for (
int i=0; i < h2; i++) {
823 for (
int j=0; j < w2; j++) {
825 buff[sampledPos] = (buff[loPos] + buff[loPos + 1] + buff[hiPos] + buff[hiPos + 1]) >> 2;
826 loPos += 2; hiPos += 2;
830 buff[sampledPos] = (buff[loPos] + buff[hiPos]) >> 1;
834 loPos += w; hiPos += w;
837 for (
int j=0; j < w2; j++) {
838 buff[sampledPos] = (buff[loPos] + buff[loPos+1]) >> 1;
839 loPos += 2; hiPos += 2;
843 buff[sampledPos] = buff[loPos];
848 m_width[ch] = (m_width[ch] + 1)/2;
849 m_height[ch] = (m_height[ch] + 1)/2;
855 const int m =
__min(m_header.width, m_header.height);
858 if (m_header.nLevels < 1 || m_header.nLevels >
MaxLevel) {
859 m_header.nLevels = 1;
861 while (s > maxThumbnailWidth) {
867 int levels = m_header.nLevels;
876 else if (levels < 0) m_header.nLevels = 0;
877 else m_header.nLevels = (UINT8)levels;
880 m_percent = pow(0.25, m_header.nLevels);
882 ASSERT(0 <= m_header.nLevels && m_header.nLevels <=
MaxLevel);
899 #ifdef __PGFROISUPPORT__ 900 m_streamReinitialized =
false;
904 memcpy(m_preHeader.magic,
PGFMagic, 3);
929 m_quant = m_header.quality - 1;
931 m_downsample =
false;
932 m_quant = m_header.quality;
940 if (userDataLength && userData) {
942 m_postHeader.userData =
new(std::nothrow) UINT8[userDataLength];
943 if (!m_postHeader.userData) ReturnWithError(InsufficientMemory);
944 m_postHeader.userDataLen = m_postHeader.cachedUserDataLen = userDataLength;
945 memcpy(m_postHeader.userData, userData, userDataLength);
947 m_preHeader.hSize += userDataLength;
951 for (
int i=0; i < m_header.channels; i++) {
953 m_width[i] = m_header.width;
954 m_height[i] = m_header.height;
957 ASSERT(!m_channel[i]);
958 m_channel[i] =
new(std::nothrow)
DataT[m_header.width*m_header.height];
962 delete[] m_channel[i]; m_channel[i] = 0;
965 ReturnWithError(InsufficientMemory);
979 ASSERT(m_header.nLevels <=
MaxLevel);
982 if (m_header.nLevels > 0) {
983 volatile OSError error = NoError;
985 #ifdef LIBPGF_USE_OPENMP 986 #pragma omp parallel for default(shared) 988 for (
int i=0; i < m_header.channels; i++) {
989 DataT *temp =
nullptr;
990 if (error == NoError) {
991 if (m_wtChannel[i]) {
992 ASSERT(m_channel[i]);
994 int size = m_height[i]*m_width[i];
995 temp =
new(std::nothrow)
DataT[size];
997 memcpy(temp, m_channel[i], size*
DataTSize);
998 delete m_wtChannel[i];
999 m_channel[i] =
nullptr;
1001 error = InsufficientMemory;
1004 if (error == NoError) {
1006 ASSERT(!m_channel[i]);
1007 m_channel[i] = temp;
1009 m_wtChannel[i] =
new CWaveletTransform(m_width[i], m_height[i], m_header.nLevels, m_channel[i]);
1010 if (m_wtChannel[i]) {
1011 #ifdef __PGFROISUPPORT__ 1012 m_wtChannel[i]->SetROI(
PGFRect(0, 0, m_width[i], m_height[i]));
1016 for (
int l=0; error == NoError && l < m_header.nLevels; l++) {
1017 OSError err = m_wtChannel[i]->ForwardTransform(l, m_quant);
1018 if (err != NoError) error = err;
1021 delete[] m_channel[i];
1022 error = InsufficientMemory;
1027 if (error != NoError) {
1029 for (
int i=0; i < m_header.channels; i++) {
1030 delete m_wtChannel[i];
1032 ReturnWithError(error);
1035 m_currentLevel = m_header.nLevels;
1038 m_encoder =
new CEncoder(stream, m_preHeader, m_header, m_postHeader, m_userDataPos, m_useOMPinEncoder);
1039 if (m_favorSpeedOverSize) m_encoder->FavorSpeedOverSize();
1041 #ifdef __PGFROISUPPORT__ 1042 if (ROIisSupported()) {
1044 m_encoder->SetROI();
1052 m_encoder =
new CEncoder(stream, m_preHeader, m_header, m_postHeader, m_userDataPos, m_useOMPinEncoder);
1055 INT64 nBytes = m_encoder->ComputeHeaderLength();
1056 return (nBytes > 0) ? (UINT32)nBytes : 0;
1069 ASSERT(m_currentLevel > 0);
1070 ASSERT(m_header.nLevels > 0);
1072 #ifdef __PGFROISUPPORT__ 1073 if (ROIisSupported()) {
1074 const int lastChannel = m_header.channels - 1;
1076 for (
int i=0; i < m_header.channels; i++) {
1078 const UINT32 nTiles = m_wtChannel[i]->GetNofTiles(m_currentLevel);
1079 const UINT32 lastTile = nTiles - 1;
1081 if (m_currentLevel == m_header.nLevels) {
1083 ASSERT(nTiles == 1);
1084 m_wtChannel[i]->GetSubband(m_currentLevel,
LL)->ExtractTile(*m_encoder);
1085 m_encoder->EncodeTileBuffer();
1087 for (UINT32 tileY=0; tileY < nTiles; tileY++) {
1088 for (UINT32 tileX=0; tileX < nTiles; tileX++) {
1090 m_wtChannel[i]->GetSubband(m_currentLevel,
HL)->ExtractTile(*m_encoder,
true, tileX, tileY);
1091 m_wtChannel[i]->GetSubband(m_currentLevel,
LH)->ExtractTile(*m_encoder,
true, tileX, tileY);
1092 m_wtChannel[i]->GetSubband(m_currentLevel,
HH)->ExtractTile(*m_encoder,
true, tileX, tileY);
1093 if (i == lastChannel && tileY == lastTile && tileX == lastTile) {
1095 m_encoder->SetEncodedLevel(--m_currentLevel);
1097 m_encoder->EncodeTileBuffer();
1104 for (
int i=0; i < m_header.channels; i++) {
1105 ASSERT(m_wtChannel[i]);
1106 if (m_currentLevel == m_header.nLevels) {
1108 m_wtChannel[i]->GetSubband(m_currentLevel,
LL)->ExtractTile(*m_encoder);
1111 m_wtChannel[i]->GetSubband(m_currentLevel,
HL)->ExtractTile(*m_encoder);
1112 m_wtChannel[i]->GetSubband(m_currentLevel,
LH)->ExtractTile(*m_encoder);
1113 m_wtChannel[i]->GetSubband(m_currentLevel,
HH)->ExtractTile(*m_encoder);
1117 m_encoder->SetEncodedLevel(--m_currentLevel);
1126 INT64 offset = m_encoder->ComputeOffset(); ASSERT(offset >= 0);
1130 m_preHeader.hSize += (UINT32)offset;
1131 m_encoder->UpdatePostHeaderSize(m_preHeader);
1135 return m_encoder->WriteLevelLength(m_levelLength);
1151 ASSERT(m_preHeader.hSize);
1153 int levels = m_header.nLevels;
1154 double percent = pow(0.25, levels);
1157 UINT32 nWrittenBytes = UpdatePostHeaderSize();
1161 for (
int c=0; c < m_header.channels; c++) {
1162 const UINT32 size = m_width[c]*m_height[c];
1165 for (UINT32 i=0; i < size; i++) {
1167 stream->
Write(&count, &m_channel[c][i]);
1173 if ((*cb)(1,
true, data)) ReturnWithError(EscapePressed);
1182 for (m_currentLevel = levels; m_currentLevel > 0; ) {
1188 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1197 nWrittenBytes += m_encoder->UpdateLevelLength();
1200 delete m_encoder; m_encoder =
nullptr;
1204 return nWrittenBytes;
1222 ASSERT(m_preHeader.hSize);
1225 UINT32 nBytes = WriteHeader(stream);
1228 nBytes += WriteImage(stream, cb, data);
1231 if (nWrittenBytes) *nWrittenBytes += nBytes;
1234 #ifdef __PGFROISUPPORT__ 1250 ASSERT(m_header.nLevels > 0);
1251 ASSERT(0 <= level && level < m_header.nLevels);
1253 ASSERT(ROIisSupported());
1255 const int levelDiff = m_currentLevel - level;
1256 double percent = (m_progressMode ==
PM_Relative) ? pow(0.25, levelDiff) : m_percent;
1257 UINT32 nWrittenBytes = 0;
1259 if (m_currentLevel == m_header.nLevels) {
1261 nWrittenBytes = UpdatePostHeaderSize();
1264 if (m_encoder->ComputeBufferLength()) {
1265 m_streamReinitialized =
true;
1270 while (m_currentLevel > level) {
1273 if (m_levelLength) {
1274 nWrittenBytes += m_levelLength[m_header.nLevels - m_currentLevel - 1];
1280 if (m_progressMode ==
PM_Absolute) m_percent = percent;
1281 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1286 if (m_currentLevel == 0) {
1287 if (!m_streamReinitialized) {
1289 m_encoder->UpdateLevelLength();
1292 delete m_encoder; m_encoder =
nullptr;
1295 return nWrittenBytes;
1297 #endif // __PGFROISUPPORT__ 1350 if (iFirstColor + nColors >
ColorTableLen) ReturnWithError(ColorTableError);
1352 for (UINT32 i=iFirstColor, j=0; j < nColors; i++, j++) {
1353 prgbColors[j] = m_postHeader.clut[i];
1364 if (iFirstColor + nColors >
ColorTableLen) ReturnWithError(ColorTableError);
1366 for (UINT32 i=iFirstColor, j=0; j < nColors; i++, j++) {
1367 m_postHeader.clut[i] = prgbColors[j];
1390 UINT32 yPos = 0, cnt = 0;
1392 const double dP = 1.0/m_header.height;
1393 int defMap[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; ASSERT(
sizeof(defMap)/
sizeof(defMap[0]) ==
MaxChannels);
1395 if (channelMap ==
nullptr) channelMap = defMap;
1397 switch(m_header.mode) {
1400 ASSERT(m_header.channels == 1);
1401 ASSERT(m_header.bpp == 1);
1404 const UINT32 w = m_header.width;
1405 const UINT32 w2 = (m_header.width + 7)/8;
1406 DataT* y = m_channel[0]; ASSERT(y);
1409 for (UINT32 h = 0; h < m_header.height; h++) {
1411 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1415 for (UINT32 j = 0; j < w2; j++) {
1416 UINT8 byte = buff[j];
1417 for (
int k = 0; k < 8; k++) {
1418 UINT8 bit = (byte & 0x80) >> 7;
1419 if (cnt < w) y[yPos++] = bit;
1451 ASSERT(m_header.channels >= 1);
1452 ASSERT(m_header.bpp == m_header.channels*8);
1454 const int channels = bpp/8; ASSERT(channels >= m_header.channels);
1456 for (UINT32 h=0; h < m_header.height; h++) {
1458 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1463 for (UINT32 w=0; w < m_header.width; w++) {
1464 for (
int c=0; c < m_header.channels; c++) {
1465 m_channel[c][yPos] = buff[cnt + channelMap[c]] -
YUVoffset8;
1477 ASSERT(m_header.channels >= 1);
1478 ASSERT(m_header.bpp == m_header.channels*16);
1479 ASSERT(bpp%16 == 0);
1481 UINT16 *buff16 = (UINT16 *)buff;
1482 const int pitch16 = pitch/2;
1483 const int channels = bpp/16; ASSERT(channels >= m_header.channels);
1484 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1485 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
1487 for (UINT32 h=0; h < m_header.height; h++) {
1489 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1494 for (UINT32 w=0; w < m_header.width; w++) {
1495 for (
int c=0; c < m_header.channels; c++) {
1496 m_channel[c][yPos] = (buff16[cnt + channelMap[c]] >> shift) - yuvOffset16;
1507 ASSERT(m_header.channels == 3);
1508 ASSERT(m_header.bpp == m_header.channels*8);
1511 DataT* y = m_channel[0]; ASSERT(y);
1512 DataT* u = m_channel[1]; ASSERT(u);
1513 DataT* v = m_channel[2]; ASSERT(v);
1514 const int channels = bpp/8; ASSERT(channels >= m_header.channels);
1517 for (UINT32 h=0; h < m_header.height; h++) {
1519 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1524 for (UINT32 w=0; w < m_header.width; w++) {
1525 b = buff[cnt + channelMap[0]];
1526 g = buff[cnt + channelMap[1]];
1527 r = buff[cnt + channelMap[2]];
1529 y[yPos] = ((b + (g << 1) + r) >> 2) -
YUVoffset8;
1541 ASSERT(m_header.channels == 3);
1542 ASSERT(m_header.bpp == m_header.channels*16);
1543 ASSERT(bpp%16 == 0);
1545 UINT16 *buff16 = (UINT16 *)buff;
1546 const int pitch16 = pitch/2;
1547 const int channels = bpp/16; ASSERT(channels >= m_header.channels);
1548 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1549 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
1551 DataT* y = m_channel[0]; ASSERT(y);
1552 DataT* u = m_channel[1]; ASSERT(u);
1553 DataT* v = m_channel[2]; ASSERT(v);
1556 for (UINT32 h=0; h < m_header.height; h++) {
1558 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1563 for (UINT32 w=0; w < m_header.width; w++) {
1564 b = buff16[cnt + channelMap[0]] >> shift;
1565 g = buff16[cnt + channelMap[1]] >> shift;
1566 r = buff16[cnt + channelMap[2]] >> shift;
1568 y[yPos] = ((b + (g << 1) + r) >> 2) - yuvOffset16;
1581 ASSERT(m_header.channels == 4);
1582 ASSERT(m_header.bpp == m_header.channels*8);
1584 const int channels = bpp/8; ASSERT(channels >= m_header.channels);
1586 DataT* y = m_channel[0]; ASSERT(y);
1587 DataT* u = m_channel[1]; ASSERT(u);
1588 DataT* v = m_channel[2]; ASSERT(v);
1589 DataT* a = m_channel[3]; ASSERT(a);
1592 for (UINT32 h=0; h < m_header.height; h++) {
1594 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1599 for (UINT32 w=0; w < m_header.width; w++) {
1600 b = buff[cnt + channelMap[0]];
1601 g = buff[cnt + channelMap[1]];
1602 r = buff[cnt + channelMap[2]];
1604 y[yPos] = ((b + (g << 1) + r) >> 2) -
YUVoffset8;
1607 a[yPos++] = buff[cnt + channelMap[3]] -
YUVoffset8;
1616 ASSERT(m_header.channels == 4);
1617 ASSERT(m_header.bpp == m_header.channels*16);
1618 ASSERT(bpp%16 == 0);
1620 UINT16 *buff16 = (UINT16 *)buff;
1621 const int pitch16 = pitch/2;
1622 const int channels = bpp/16; ASSERT(channels >= m_header.channels);
1623 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1624 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
1626 DataT* y = m_channel[0]; ASSERT(y);
1627 DataT* u = m_channel[1]; ASSERT(u);
1628 DataT* v = m_channel[2]; ASSERT(v);
1629 DataT* a = m_channel[3]; ASSERT(a);
1632 for (UINT32 h=0; h < m_header.height; h++) {
1634 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1639 for (UINT32 w=0; w < m_header.width; w++) {
1640 b = buff16[cnt + channelMap[0]] >> shift;
1641 g = buff16[cnt + channelMap[1]] >> shift;
1642 r = buff16[cnt + channelMap[2]] >> shift;
1644 y[yPos] = ((b + (g << 1) + r) >> 2) - yuvOffset16;
1647 a[yPos++] = (buff16[cnt + channelMap[3]] >> shift) - yuvOffset16;
1654 #ifdef __PGF32SUPPORT__ 1657 ASSERT(m_header.channels == 1);
1658 ASSERT(m_header.bpp == 32);
1662 DataT* y = m_channel[0]; ASSERT(y);
1664 UINT32 *buff32 = (UINT32 *)buff;
1665 const int pitch32 = pitch/4;
1666 const int shift = 31 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1667 const DataT yuvOffset31 = 1 << (UsedBitsPerChannel() - 1);
1669 for (UINT32 h=0; h < m_header.height; h++) {
1671 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1675 for (UINT32 w=0; w < m_header.width; w++) {
1676 y[yPos++] = (buff32[w] >> shift) - yuvOffset31;
1685 ASSERT(m_header.channels == 3);
1686 ASSERT(m_header.bpp == m_header.channels*4);
1687 ASSERT(bpp == m_header.channels*4);
1689 DataT* y = m_channel[0]; ASSERT(y);
1690 DataT* u = m_channel[1]; ASSERT(u);
1691 DataT* v = m_channel[2]; ASSERT(v);
1693 UINT8 rgb = 0, b, g, r;
1695 for (UINT32 h=0; h < m_header.height; h++) {
1697 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1702 for (UINT32 w=0; w < m_header.width; w++) {
1707 g = (rgb & 0xF0) >> 4;
1713 b = (rgb & 0xF0) >> 4;
1717 r = (rgb & 0xF0) >> 4;
1722 y[yPos] = ((b + (g << 1) + r) >> 2) -
YUVoffset4;
1733 ASSERT(m_header.channels == 3);
1734 ASSERT(m_header.bpp == 16);
1737 DataT* y = m_channel[0]; ASSERT(y);
1738 DataT* u = m_channel[1]; ASSERT(u);
1739 DataT* v = m_channel[2]; ASSERT(v);
1741 UINT16 *buff16 = (UINT16 *)buff;
1742 UINT16 rgb, b, g, r;
1743 const int pitch16 = pitch/2;
1745 for (UINT32 h=0; h < m_header.height; h++) {
1747 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1750 for (UINT32 w=0; w < m_header.width; w++) {
1752 r = (rgb & 0xF800) >> 10;
1753 g = (rgb & 0x07E0) >> 5;
1754 b = (rgb & 0x001F) << 1;
1756 y[yPos] = ((b + (g << 1) + r) >> 2) -
YUVoffset6;
1788 void CPGFImage::GetBitmap(
int pitch, UINT8* buff, BYTE bpp,
int channelMap[] , CallbackPtr cb ,
void *data )
const {
1790 UINT32 w = m_width[0];
1791 UINT32 h = m_height[0];
1793 UINT32 uw = m_width[1];
1794 UINT32 roiOffsetX = 0;
1795 UINT32 roiOffsetY = 0;
1799 #ifdef __PGFROISUPPORT__ 1800 const PGFRect& roi = GetAlignedROI();
1802 const PGFRect levelRoi = ComputeLevelROI();
1803 ASSERT(roi.
left <= levelRoi.left && levelRoi.right <= roi.
right);
1804 ASSERT(roi.
top <= levelRoi.top && levelRoi.bottom <= roi.
bottom);
1806 if (ROIisSupported() && (levelRoi.Width() < w || levelRoi.Height() < h)) {
1808 w = levelRoi.Width();
1809 h = levelRoi.Height();
1810 roiOffsetX = levelRoi.left - roi.
left;
1811 roiOffsetY = levelRoi.top - roi.
top;
1812 yOffset = roiOffsetX + roiOffsetY*yw;
1815 const PGFRect& downsampledRoi = GetAlignedROI(1);
1816 uOffset = levelRoi.left/2 - downsampledRoi.
left + (levelRoi.top/2 - downsampledRoi.
top)*m_width[1];
1823 const double dP = 1.0/h;
1824 int defMap[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; ASSERT(
sizeof(defMap)/
sizeof(defMap[0]) ==
MaxChannels);
1825 if (channelMap ==
nullptr) channelMap = defMap;
1830 switch(m_header.mode) {
1833 ASSERT(m_header.channels == 1);
1834 ASSERT(m_header.bpp == 1);
1837 const UINT32 w2 = (w + 7)/8;
1838 DataT* y = m_channel[0]; ASSERT(y);
1840 if (m_preHeader.version &
Version7) {
1843 for (i = 0; i < h; i++) {
1845 for (j = 0; j < w2; j++) {
1847 for (
int k = 0; k < 8; k++) {
1851 bit = y[yOffset + cnt] & 1;
1863 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1869 if (!(m_preHeader.version &
Version5)) yw = w2;
1870 yOffset = roiOffsetX/8 + roiOffsetY*yw;
1871 for (i = 0; i < h; i++) {
1872 for (j = 0; j < w2; j++) {
1873 buff[j] = Clamp8(y[yOffset + j] +
YUVoffset8);
1880 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1891 ASSERT(m_header.channels >= 1);
1892 ASSERT(m_header.bpp == m_header.channels*8);
1895 UINT32 cnt, channels = bpp/8; ASSERT(channels >= m_header.channels);
1897 for (i=0; i < h; i++) {
1898 UINT32 yPos = yOffset;
1900 for (j=0; j < w; j++) {
1901 for (UINT32 c=0; c < m_header.channels; c++) {
1902 buff[cnt + channelMap[c]] = Clamp8(m_channel[c][yPos] +
YUVoffset8);
1912 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1919 ASSERT(m_header.channels >= 1);
1920 ASSERT(m_header.bpp == m_header.channels*16);
1922 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
1923 UINT32 cnt, channels;
1926 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
1927 UINT16 *buff16 = (UINT16 *)buff;
1928 int pitch16 = pitch/2;
1929 channels = bpp/16; ASSERT(channels >= m_header.channels);
1931 for (i=0; i < h; i++) {
1932 UINT32 yPos = yOffset;
1934 for (j=0; j < w; j++) {
1935 for (UINT32 c=0; c < m_header.channels; c++) {
1936 buff16[cnt + channelMap[c]] = Clamp16((m_channel[c][yPos] + yuvOffset16) << shift);
1946 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1951 const int shift =
__max(0, UsedBitsPerChannel() - 8);
1952 channels = bpp/8; ASSERT(channels >= m_header.channels);
1954 for (i=0; i < h; i++) {
1955 UINT32 yPos = yOffset;
1957 for (j=0; j < w; j++) {
1958 for (UINT32 c=0; c < m_header.channels; c++) {
1959 buff[cnt + channelMap[c]] = Clamp8((m_channel[c][yPos] + yuvOffset16) >> shift);
1969 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1977 ASSERT(m_header.channels == 3);
1978 ASSERT(m_header.bpp == m_header.channels*8);
1980 ASSERT(bpp >= m_header.bpp);
1982 DataT* y = m_channel[0]; ASSERT(y);
1983 DataT* u = m_channel[1]; ASSERT(u);
1984 DataT* v = m_channel[2]; ASSERT(v);
1985 UINT8 *buffg = &buff[channelMap[1]],
1986 *buffr = &buff[channelMap[2]],
1987 *buffb = &buff[channelMap[0]];
1989 UINT32 cnt, channels = bpp/8;
1992 for (i=0; i < h; i++) {
1993 UINT32 uPos = uOffset;
1994 UINT32 yPos = yOffset;
1996 for (j=0; j < w; j++) {
2001 buffg[cnt] = g = Clamp8(y[yPos] +
YUVoffset8 - ((uAvg + vAvg ) >> 2));
2002 buffr[cnt] = Clamp8(uAvg + g);
2003 buffb[cnt] = Clamp8(vAvg + g);
2008 if (i & 1) uOffset += uw;
2016 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2021 for (i=0; i < h; i++) {
2023 UINT32 yPos = yOffset;
2024 for (j = 0; j < w; j++) {
2028 buffg[cnt] = g = Clamp8(y[yPos] +
YUVoffset8 - ((uAvg + vAvg ) >> 2));
2029 buffr[cnt] = Clamp8(uAvg + g);
2030 buffb[cnt] = Clamp8(vAvg + g);
2041 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2049 ASSERT(m_header.channels == 3);
2050 ASSERT(m_header.bpp == 48);
2052 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
2054 DataT* y = m_channel[0]; ASSERT(y);
2055 DataT* u = m_channel[1]; ASSERT(u);
2056 DataT* v = m_channel[2]; ASSERT(v);
2057 UINT32 cnt, channels;
2060 if (bpp >= 48 && bpp%16 == 0) {
2061 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
2062 UINT16 *buff16 = (UINT16 *)buff;
2063 int pitch16 = pitch/2;
2064 channels = bpp/16; ASSERT(channels >= m_header.channels);
2066 for (i=0; i < h; i++) {
2067 UINT32 uPos = uOffset;
2068 UINT32 yPos = yOffset;
2070 for (j=0; j < w; j++) {
2074 g = y[yPos] + yuvOffset16 - ((uAvg + vAvg ) >> 2);
2075 buff16[cnt + channelMap[1]] = Clamp16(g << shift);
2076 buff16[cnt + channelMap[2]] = Clamp16((uAvg + g) << shift);
2077 buff16[cnt + channelMap[0]] = Clamp16((vAvg + g) << shift);
2079 if (!m_downsample || (j & 1)) uPos++;
2082 if (!m_downsample || (i & 1)) uOffset += uw;
2088 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2093 const int shift =
__max(0, UsedBitsPerChannel() - 8);
2094 channels = bpp/8; ASSERT(channels >= m_header.channels);
2096 for (i=0; i < h; i++) {
2097 UINT32 uPos = uOffset;
2098 UINT32 yPos = yOffset;
2100 for (j=0; j < w; j++) {
2104 g = y[yPos] + yuvOffset16 - ((uAvg + vAvg ) >> 2);
2105 buff[cnt + channelMap[1]] = Clamp8(g >> shift);
2106 buff[cnt + channelMap[2]] = Clamp8((uAvg + g) >> shift);
2107 buff[cnt + channelMap[0]] = Clamp8((vAvg + g) >> shift);
2109 if (!m_downsample || (j & 1)) uPos++;
2112 if (!m_downsample || (i & 1)) uOffset += uw;
2118 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2126 ASSERT(m_header.channels == 3);
2127 ASSERT(m_header.bpp == m_header.channels*8);
2130 DataT* l = m_channel[0]; ASSERT(l);
2131 DataT* a = m_channel[1]; ASSERT(a);
2132 DataT* b = m_channel[2]; ASSERT(b);
2133 UINT32 cnt, channels = bpp/8; ASSERT(channels >= m_header.channels);
2135 for (i=0; i < h; i++) {
2136 UINT32 uPos = uOffset;
2137 UINT32 yPos = yOffset;
2139 for (j=0; j < w; j++) {
2142 buff[cnt + channelMap[0]] = Clamp8(l[yPos] +
YUVoffset8);
2143 buff[cnt + channelMap[1]] = Clamp8(uAvg +
YUVoffset8);
2144 buff[cnt + channelMap[2]] = Clamp8(vAvg +
YUVoffset8);
2146 if (!m_downsample || (j & 1)) uPos++;
2149 if (!m_downsample || (i & 1)) uOffset += uw;
2155 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2162 ASSERT(m_header.channels == 3);
2163 ASSERT(m_header.bpp == m_header.channels*16);
2165 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
2167 DataT* l = m_channel[0]; ASSERT(l);
2168 DataT* a = m_channel[1]; ASSERT(a);
2169 DataT* b = m_channel[2]; ASSERT(b);
2170 UINT32 cnt, channels;
2173 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
2174 UINT16 *buff16 = (UINT16 *)buff;
2175 int pitch16 = pitch/2;
2176 channels = bpp/16; ASSERT(channels >= m_header.channels);
2178 for (i=0; i < h; i++) {
2179 UINT32 uPos = uOffset;
2180 UINT32 yPos = yOffset;
2182 for (j=0; j < w; j++) {
2185 buff16[cnt + channelMap[0]] = Clamp16((l[yPos] + yuvOffset16) << shift);
2186 buff16[cnt + channelMap[1]] = Clamp16((uAvg + yuvOffset16) << shift);
2187 buff16[cnt + channelMap[2]] = Clamp16((vAvg + yuvOffset16) << shift);
2189 if (!m_downsample || (j & 1)) uPos++;
2192 if (!m_downsample || (i & 1)) uOffset += uw;
2198 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2203 const int shift =
__max(0, UsedBitsPerChannel() - 8);
2204 channels = bpp/8; ASSERT(channels >= m_header.channels);
2206 for (i=0; i < h; i++) {
2207 UINT32 uPos = uOffset;
2208 UINT32 yPos = yOffset;
2210 for (j=0; j < w; j++) {
2213 buff[cnt + channelMap[0]] = Clamp8((l[yPos] + yuvOffset16) >> shift);
2214 buff[cnt + channelMap[1]] = Clamp8((uAvg + yuvOffset16) >> shift);
2215 buff[cnt + channelMap[2]] = Clamp8((vAvg + yuvOffset16) >> shift);
2217 if (!m_downsample || (j & 1)) uPos++;
2220 if (!m_downsample || (i & 1)) uOffset += uw;
2226 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2235 ASSERT(m_header.channels == 4);
2236 ASSERT(m_header.bpp == m_header.channels*8);
2239 DataT* y = m_channel[0]; ASSERT(y);
2240 DataT* u = m_channel[1]; ASSERT(u);
2241 DataT* v = m_channel[2]; ASSERT(v);
2242 DataT* a = m_channel[3]; ASSERT(a);
2244 UINT32 cnt, channels = bpp/8; ASSERT(channels >= m_header.channels);
2246 for (i=0; i < h; i++) {
2247 UINT32 uPos = uOffset;
2248 UINT32 yPos = yOffset;
2250 for (j=0; j < w; j++) {
2255 buff[cnt + channelMap[1]] = g = Clamp8(y[yPos] +
YUVoffset8 - ((uAvg + vAvg ) >> 2));
2256 buff[cnt + channelMap[2]] = Clamp8(uAvg + g);
2257 buff[cnt + channelMap[0]] = Clamp8(vAvg + g);
2258 buff[cnt + channelMap[3]] = aAvg;
2260 if (!m_downsample || (j & 1)) uPos++;
2263 if (!m_downsample || (i & 1)) uOffset += uw;
2269 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2276 ASSERT(m_header.channels == 4);
2277 ASSERT(m_header.bpp == 64);
2279 const DataT yuvOffset16 = 1 << (UsedBitsPerChannel() - 1);
2281 DataT* y = m_channel[0]; ASSERT(y);
2282 DataT* u = m_channel[1]; ASSERT(u);
2283 DataT* v = m_channel[2]; ASSERT(v);
2284 DataT* a = m_channel[3]; ASSERT(a);
2286 UINT32 cnt, channels;
2289 const int shift = 16 - UsedBitsPerChannel(); ASSERT(shift >= 0);
2290 UINT16 *buff16 = (UINT16 *)buff;
2291 int pitch16 = pitch/2;
2292 channels = bpp/16; ASSERT(channels >= m_header.channels);
2294 for (i=0; i < h; i++) {
2295 UINT32 uPos = uOffset;
2296 UINT32 yPos = yOffset;
2298 for (j=0; j < w; j++) {
2301 aAvg = a[uPos] + yuvOffset16;
2303 g = y[yPos] + yuvOffset16 - ((uAvg + vAvg ) >> 2);
2304 buff16[cnt + channelMap[1]] = Clamp16(g << shift);
2305 buff16[cnt + channelMap[2]] = Clamp16((uAvg + g) << shift);
2306 buff16[cnt + channelMap[0]] = Clamp16((vAvg + g) << shift);
2307 buff16[cnt + channelMap[3]] = Clamp16(aAvg << shift);
2309 if (!m_downsample || (j & 1)) uPos++;
2312 if (!m_downsample || (i & 1)) uOffset += uw;
2318 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2323 const int shift =
__max(0, UsedBitsPerChannel() - 8);
2324 channels = bpp/8; ASSERT(channels >= m_header.channels);
2326 for (i=0; i < h; i++) {
2327 UINT32 uPos = uOffset;
2328 UINT32 yPos = yOffset;
2330 for (j=0; j < w; j++) {
2333 aAvg = a[uPos] + yuvOffset16;
2335 g = y[yPos] + yuvOffset16 - ((uAvg + vAvg ) >> 2);
2336 buff[cnt + channelMap[1]] = Clamp8(g >> shift);
2337 buff[cnt + channelMap[2]] = Clamp8((uAvg + g) >> shift);
2338 buff[cnt + channelMap[0]] = Clamp8((vAvg + g) >> shift);
2339 buff[cnt + channelMap[3]] = Clamp8(aAvg >> shift);
2341 if (!m_downsample || (j & 1)) uPos++;
2344 if (!m_downsample || (i & 1)) uOffset += uw;
2350 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2356 #ifdef __PGF32SUPPORT__ 2359 ASSERT(m_header.channels == 1);
2360 ASSERT(m_header.bpp == 32);
2362 const int yuvOffset31 = 1 << (UsedBitsPerChannel() - 1);
2363 DataT* y = m_channel[0]; ASSERT(y);
2366 const int shift = 31 - UsedBitsPerChannel(); ASSERT(shift >= 0);
2367 UINT32 *buff32 = (UINT32 *)buff;
2368 int pitch32 = pitch/4;
2370 for (i=0; i < h; i++) {
2371 UINT32 yPos = yOffset;
2372 for (j = 0; j < w; j++) {
2373 buff32[j] = Clamp31((y[yPos++] + yuvOffset31) << shift);
2380 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2383 }
else if (bpp == 16) {
2384 const int usedBits = UsedBitsPerChannel();
2385 UINT16 *buff16 = (UINT16 *)buff;
2386 int pitch16 = pitch/2;
2388 if (usedBits < 16) {
2389 const int shift = 16 - usedBits;
2390 for (i=0; i < h; i++) {
2391 UINT32 yPos = yOffset;
2392 for (j = 0; j < w; j++) {
2393 buff16[j] = Clamp16((y[yPos++] + yuvOffset31) << shift);
2400 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2404 const int shift =
__max(0, usedBits - 16);
2405 for (i=0; i < h; i++) {
2406 UINT32 yPos = yOffset;
2407 for (j = 0; j < w; j++) {
2408 buff16[j] = Clamp16((y[yPos++] + yuvOffset31) >> shift);
2415 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2421 const int shift =
__max(0, UsedBitsPerChannel() - 8);
2423 for (i=0; i < h; i++) {
2424 UINT32 yPos = yOffset;
2425 for (j = 0; j < w; j++) {
2426 buff[j] = Clamp8((y[yPos++] + yuvOffset31) >> shift);
2433 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2442 ASSERT(m_header.channels == 3);
2443 ASSERT(m_header.bpp == m_header.channels*4);
2444 ASSERT(bpp == m_header.channels*4);
2445 ASSERT(!m_downsample);
2447 DataT* y = m_channel[0]; ASSERT(y);
2448 DataT* u = m_channel[1]; ASSERT(u);
2449 DataT* v = m_channel[2]; ASSERT(v);
2453 for (i=0; i < h; i++) {
2454 UINT32 yPos = yOffset;
2456 for (j=0; j < w; j++) {
2460 yval = Clamp4(y[yPos] +
YUVoffset4 - ((uAvg + vAvg ) >> 2));
2462 buff[cnt] = UINT8(Clamp4(vAvg + yval) | (yval << 4));
2464 buff[cnt] = Clamp4(uAvg + yval);
2466 buff[cnt] |= Clamp4(vAvg + yval) << 4;
2468 buff[cnt] = UINT8(yval | (Clamp4(uAvg + yval) << 4));
2478 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2485 ASSERT(m_header.channels == 3);
2486 ASSERT(m_header.bpp == 16);
2488 ASSERT(!m_downsample);
2490 DataT* y = m_channel[0]; ASSERT(y);
2491 DataT* u = m_channel[1]; ASSERT(u);
2492 DataT* v = m_channel[2]; ASSERT(v);
2494 UINT16 *buff16 = (UINT16 *)buff;
2495 int pitch16 = pitch/2;
2497 for (i=0; i < h; i++) {
2498 UINT32 yPos = yOffset;
2499 for (j = 0; j < w; j++) {
2503 yval = Clamp6(y[yPos++] +
YUVoffset6 - ((uAvg + vAvg ) >> 2));
2504 buff16[j] = (yval << 5) | ((Clamp6(uAvg + yval) >> 1) << 11) | (Clamp6(vAvg + yval) >> 1);
2511 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2523 roiimage.height = h;
2525 roiimage.pitch = pitch;
2526 roiimage.data = buff;
2528 roiimage.pitch = -pitch;
2529 roiimage.data = buff + (h - 1)*pitch;
2551 const UINT32 w = m_width[0];
2552 const UINT32 h = m_height[0];
2553 const bool wOdd = (1 == w%2);
2554 const int dataBits =
DataTSize*8; ASSERT(dataBits == 16 || dataBits == 32);
2557 const double dP = 1.0/h;
2559 int defMap[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; ASSERT(
sizeof(defMap)/
sizeof(defMap[0]) ==
MaxChannels);
2560 if (channelMap ==
nullptr) channelMap = defMap;
2561 int sampledPos = 0, yPos = 0;
2566 if (m_header.channels == 3) {
2567 ASSERT(bpp%dataBits == 0);
2569 DataT* y = m_channel[0]; ASSERT(y);
2570 DataT* u = m_channel[1]; ASSERT(u);
2571 DataT* v = m_channel[2]; ASSERT(v);
2572 int cnt, channels = bpp/dataBits; ASSERT(channels >= m_header.channels);
2574 for (i=0; i < h; i++) {
2575 if (i%2) sampledPos -= (w + 1)/2;
2577 for (j=0; j < w; j++) {
2580 uAvg = u[sampledPos];
2581 vAvg = v[sampledPos];
2586 buff[cnt + channelMap[0]] = y[yPos];
2587 buff[cnt + channelMap[1]] = uAvg;
2588 buff[cnt + channelMap[2]] = vAvg;
2591 if (j%2) sampledPos++;
2594 if (wOdd) sampledPos++;
2598 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2601 }
else if (m_header.channels == 4) {
2602 ASSERT(m_header.bpp == m_header.channels*8);
2603 ASSERT(bpp%dataBits == 0);
2605 DataT* y = m_channel[0]; ASSERT(y);
2606 DataT* u = m_channel[1]; ASSERT(u);
2607 DataT* v = m_channel[2]; ASSERT(v);
2608 DataT* a = m_channel[3]; ASSERT(a);
2610 int cnt, channels = bpp/dataBits; ASSERT(channels >= m_header.channels);
2612 for (i=0; i < h; i++) {
2613 if (i%2) sampledPos -= (w + 1)/2;
2615 for (j=0; j < w; j++) {
2618 uAvg = u[sampledPos];
2619 vAvg = v[sampledPos];
2620 aAvg = Clamp8(a[sampledPos] + yuvOffset);
2624 aAvg = Clamp8(a[yPos] + yuvOffset);
2627 buff[cnt + channelMap[0]] = y[yPos];
2628 buff[cnt + channelMap[1]] = uAvg;
2629 buff[cnt + channelMap[2]] = vAvg;
2630 buff[cnt + channelMap[3]] = aAvg;
2633 if (j%2) sampledPos++;
2636 if (wOdd) sampledPos++;
2640 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2662 const double dP = 1.0/m_header.height;
2663 const int dataBits =
DataTSize*8; ASSERT(dataBits == 16 || dataBits == 32);
2667 int yPos = 0, cnt = 0;
2669 int defMap[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; ASSERT(
sizeof(defMap)/
sizeof(defMap[0]) ==
MaxChannels);
2671 if (channelMap ==
nullptr) channelMap = defMap;
2673 if (m_header.channels == 3) {
2674 ASSERT(bpp%dataBits == 0);
2676 DataT* y = m_channel[0]; ASSERT(y);
2677 DataT* u = m_channel[1]; ASSERT(u);
2678 DataT* v = m_channel[2]; ASSERT(v);
2679 const int channels = bpp/dataBits; ASSERT(channels >= m_header.channels);
2681 for (UINT32 h=0; h < m_header.height; h++) {
2683 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2688 for (UINT32 w=0; w < m_header.width; w++) {
2689 y[yPos] = buff[cnt + channelMap[0]];
2690 u[yPos] = buff[cnt + channelMap[1]];
2691 v[yPos] = buff[cnt + channelMap[2]];
2697 }
else if (m_header.channels == 4) {
2698 ASSERT(bpp%dataBits == 0);
2700 DataT* y = m_channel[0]; ASSERT(y);
2701 DataT* u = m_channel[1]; ASSERT(u);
2702 DataT* v = m_channel[2]; ASSERT(v);
2703 DataT* a = m_channel[3]; ASSERT(a);
2704 const int channels = bpp/dataBits; ASSERT(channels >= m_header.channels);
2706 for (UINT32 h=0; h < m_header.height; h++) {
2708 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2713 for (UINT32 w=0; w < m_header.width; w++) {
2714 y[yPos] = buff[cnt + channelMap[0]];
2715 u[yPos] = buff[cnt + channelMap[1]];
2716 v[yPos] = buff[cnt + channelMap[2]];
2717 a[yPos] = buff[cnt + channelMap[3]] - yuvOffset;
2727 for (
int i=1; i < m_header.channels; i++) {
void Open(CPGFStream *stream)
void SetColorTable(UINT32 iFirstColor, UINT32 nColors, const RGBQUAD *prgbColors)
const RGBQUAD * GetColorTable() const
virtual void Read(int *count, void *buffer)=0
void Read(int level=0, CallbackPtr cb=nullptr, void *data=nullptr)
BYTE UsedBitsPerChannel() const
#define PGFVersion
current standard version
PGFRect ComputeLevelROI() const
virtual void Write(int *count, void *buffer)=0
#define MaxChannels
maximum number of (color) channels
Abstract stream base class.
void ImportYUV(int pitch, DataT *buff, BYTE bpp, int channelMap[]=nullptr, CallbackPtr cb=nullptr, void *data=nullptr)
void SetROI(PGFRect rect)
#define PGFMagic
PGF identification.
UINT32 WriteImage(CPGFStream *stream, CallbackPtr cb=nullptr, void *data=nullptr)
#define Version6
hSize in PGFPreHeader uses 32 bits instead of 16 bits
static BYTE CodecMajorVersion(BYTE version=PGFVersion)
Return major version.
#define ColorTableLen
size of color lookup table (clut)
#define MaxLevel
maximum number of transform levels
UINT32 ReadEncodedHeader(UINT8 *target, UINT32 targetLen) const
void PlaceTile(CDecoder &decoder, int quantParam, bool tile=false, UINT32 tileX=0, UINT32 tileY=0)
#define DownsampleThreshold
if quality is larger than this threshold than downsampling is used
UINT32 WriteHeader(CPGFStream *stream)
#define Version2
data structure PGFHeader of major version 2
CPGFImage()
Standard constructor.
const UINT8 * GetUserData(UINT32 &cachedSize, UINT32 *pTotalSize=nullptr) const
void SetHeader(const PGFHeader &header, BYTE flags=0, const UINT8 *userData=0, UINT32 userDataLength=0)
PGFRect GetAlignedROI(int c=0) const
#define MaxQuality
maximum quality
void GetYUV(int pitch, DataT *buff, BYTE bpp, int channelMap[]=nullptr, CallbackPtr cb=nullptr, void *data=nullptr) const
virtual ~CPGFImage()
Destructor.
void GetBitmap(int pitch, UINT8 *buff, BYTE bpp, int channelMap[]=nullptr, CallbackPtr cb=nullptr, void *data=nullptr) const
void Reconstruct(int level=0)
UINT32 ReadEncodedData(int level, UINT8 *target, UINT32 targetLen) const
#define Version7
Codec major and minor version number stored in PGFHeader.
void RgbToYuv(int pitch, UINT8 *rgbBuff, BYTE bpp, int channelMap[], CallbackPtr cb, void *data)
void ImportBitmap(int pitch, UINT8 *buff, BYTE bpp, int channelMap[]=nullptr, CallbackPtr cb=nullptr, void *data=nullptr)
void ResetStreamPos(bool startOfData)
void SetMaxValue(UINT32 maxValue)
static bool ImportIsSupported(BYTE mode)
UINT32 GetEncodedHeaderLength() const
void Downsample(int nChannel)
void Write(CPGFStream *stream, UINT32 *nWrittenBytes=nullptr, CallbackPtr cb=nullptr, void *data=nullptr)
version number stored in header since major version 7
#define Version5
new coding scheme since major version 5
UINT32 UpdatePostHeaderSize()