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;
76 #ifdef __PGFROISUPPORT__ 205 if (!
m_channel[c]) ReturnWithError(InsufficientMemory);
208 for (UINT32 i=0; i < size; i++) {
211 if (count !=
DataTSize) ReturnWithError(MissingData);
322 if (bpc > 31) bpc = 31;
360 #ifdef __PGFROISUPPORT__ 367 while (currentLevel > level) {
381 if (err != NoError) ReturnWithError(err);
406 #ifdef __PGFROISUPPORT__ 410 Read(rect, level, cb, data);
420 if ((*cb)(1.0,
true, data)) ReturnWithError(EscapePressed);
449 volatile OSError error = NoError;
450 #ifdef LIBPGF_USE_OPENMP 451 #pragma omp parallel for default(shared) 455 if (error == NoError) {
457 if (err != NoError) error = err;
461 if (error != NoError) ReturnWithError(error);
473 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
479 #ifdef __PGFROISUPPORT__ 496 Read(level, cb, data);
510 if (levelDiff <= 0) {
533 for (UINT32 tileY=0; tileY < nTiles; tileY++) {
534 for (UINT32 tileX=0; tileX < nTiles; tileX++) {
549 volatile OSError error = NoError;
550 #ifdef LIBPGF_USE_OPENMP 551 #pragma omp parallel for default(shared) 555 if (error == NoError) {
557 if (err != NoError) error = err;
561 if (error != NoError) ReturnWithError(error);
573 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
591 return PGFRect(rLeft, rTop, rRight - rLeft, rBottom - rTop);
606 ASSERT(roi.Width() ==
m_width[c]);
607 ASSERT(roi.Height() ==
m_height[c]);
642 #endif // __PGFROISUPPORT__ 662 ASSERT(targetLen > 0);
673 ASSERT(len >= 0 && len <= targetLen);
709 ASSERT(targetLen > 0);
728 ASSERT(len >= 0 && len <= targetLen);
741 while(maxValue > 0) {
746 if (pot > bpc) pot = bpc;
747 if (pot > 31) pot = 31;
796 RgbToYuv(pitch, buff, bpp, channelMap, cb, data);
815 const int oddW = w%2;
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];
861 while (s > maxThumbnailWidth) {
899 #ifdef __PGFROISUPPORT__ 940 if (userDataLength && userData) {
965 ReturnWithError(InsufficientMemory);
983 volatile OSError error = NoError;
985 #ifdef LIBPGF_USE_OPENMP 986 #pragma omp parallel for default(shared) 989 DataT *temp =
nullptr;
990 if (error == NoError) {
995 temp =
new(std::nothrow)
DataT[size];
1001 error = InsufficientMemory;
1004 if (error == NoError) {
1011 #ifdef __PGFROISUPPORT__ 1018 if (err != NoError) error = err;
1022 error = InsufficientMemory;
1027 if (error != NoError) {
1032 ReturnWithError(error);
1041 #ifdef __PGFROISUPPORT__ 1056 return (nBytes > 0) ? (UINT32)nBytes : 0;
1072 #ifdef __PGFROISUPPORT__ 1079 const UINT32 lastTile = nTiles - 1;
1083 ASSERT(nTiles == 1);
1087 for (UINT32 tileY=0; tileY < nTiles; tileY++) {
1088 for (UINT32 tileX=0; tileX < nTiles; tileX++) {
1093 if (i == lastChannel && tileY == lastTile && tileX == lastTile) {
1154 double percent = pow(0.25, levels);
1165 for (UINT32 i=0; i < size; i++) {
1173 if ((*cb)(1,
true, data)) ReturnWithError(EscapePressed);
1188 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1204 return nWrittenBytes;
1231 if (nWrittenBytes) *nWrittenBytes += nBytes;
1234 #ifdef __PGFROISUPPORT__ 1257 UINT32 nWrittenBytes = 0;
1281 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1295 return nWrittenBytes;
1297 #endif // __PGFROISUPPORT__ 1350 if (iFirstColor + nColors >
ColorTableLen) ReturnWithError(ColorTableError);
1352 for (UINT32 i=iFirstColor, j=0; j < nColors; i++, j++) {
1364 if (iFirstColor + nColors >
ColorTableLen) ReturnWithError(ColorTableError);
1366 for (UINT32 i=iFirstColor, j=0; j < nColors; i++, j++) {
1390 UINT32 yPos = 0, cnt = 0;
1393 int defMap[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; ASSERT(
sizeof(defMap)/
sizeof(defMap[0]) ==
MaxChannels);
1395 if (channelMap ==
nullptr) channelMap = defMap;
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;
1458 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1479 ASSERT(bpp%16 == 0);
1481 UINT16 *buff16 = (UINT16 *)buff;
1482 const int pitch16 = pitch/2;
1489 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1496 m_channel[c][yPos] = (buff16[cnt + channelMap[c]] >> shift) - yuvOffset16;
1519 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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;
1543 ASSERT(bpp%16 == 0);
1545 UINT16 *buff16 = (UINT16 *)buff;
1546 const int pitch16 = pitch/2;
1558 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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;
1594 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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;
1618 ASSERT(bpp%16 == 0);
1620 UINT16 *buff16 = (UINT16 *)buff;
1621 const int pitch16 = pitch/2;
1634 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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__ 1664 UINT32 *buff32 = (UINT32 *)buff;
1665 const int pitch32 = pitch/4;
1671 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1676 y[yPos++] = (buff32[w] >> shift) - yuvOffset31;
1693 UINT8 rgb = 0, b, g, r;
1697 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1707 g = (rgb & 0xF0) >> 4;
1713 b = (rgb & 0xF0) >> 4;
1717 r = (rgb & 0xF0) >> 4;
1722 y[yPos] = ((b + (g << 1) + r) >> 2) -
YUVoffset4;
1741 UINT16 *buff16 = (UINT16 *)buff;
1742 UINT16 rgb, b, g, r;
1743 const int pitch16 = pitch/2;
1747 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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 {
1794 UINT32 roiOffsetX = 0;
1795 UINT32 roiOffsetY = 0;
1799 #ifdef __PGFROISUPPORT__ 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;
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;
1837 const UINT32 w2 = (w + 7)/8;
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);
1870 yOffset = roiOffsetX/8 + roiOffsetY*yw;
1871 for (i = 0; i < h; i++) {
1872 for (j = 0; j < w2; j++) {
1880 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1897 for (i=0; i < h; i++) {
1898 UINT32 yPos = yOffset;
1900 for (j=0; j < w; j++) {
1912 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1923 UINT32 cnt, channels;
1927 UINT16 *buff16 = (UINT16 *)buff;
1928 int pitch16 = pitch/2;
1931 for (i=0; i < h; i++) {
1932 UINT32 yPos = yOffset;
1934 for (j=0; j < w; j++) {
1936 buff16[cnt + channelMap[c]] =
Clamp16((
m_channel[c][yPos] + yuvOffset16) << shift);
1946 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
1954 for (i=0; i < h; i++) {
1955 UINT32 yPos = yOffset;
1957 for (j=0; j < w; j++) {
1959 buff[cnt + channelMap[c]] =
Clamp8((
m_channel[c][yPos] + yuvOffset16) >> shift);
1969 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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++) {
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++) {
2029 buffr[cnt] =
Clamp8(uAvg + g);
2030 buffb[cnt] =
Clamp8(vAvg + g);
2041 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2057 UINT32 cnt, channels;
2060 if (bpp >= 48 && bpp%16 == 0) {
2062 UINT16 *buff16 = (UINT16 *)buff;
2063 int pitch16 = pitch/2;
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);
2088 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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);
2118 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2135 for (i=0; i < h; i++) {
2136 UINT32 uPos = uOffset;
2137 UINT32 yPos = yOffset;
2139 for (j=0; j < w; j++) {
2155 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2170 UINT32 cnt, channels;
2174 UINT16 *buff16 = (UINT16 *)buff;
2175 int pitch16 = pitch/2;
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);
2198 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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);
2226 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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;
2269 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2286 UINT32 cnt, channels;
2290 UINT16 *buff16 = (UINT16 *)buff;
2291 int pitch16 = pitch/2;
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);
2318 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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);
2350 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2356 #ifdef __PGF32SUPPORT__ 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) {
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);
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);
2453 for (i=0; i < h; i++) {
2454 UINT32 yPos = yOffset;
2456 for (j=0; j < w; j++) {
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);
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++) {
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;
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;
2567 ASSERT(bpp%dataBits == 0);
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);
2603 ASSERT(bpp%dataBits == 0);
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);
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;
2674 ASSERT(bpp%dataBits == 0);
2683 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
2689 y[yPos] = buff[cnt + channelMap[0]];
2690 u[yPos] = buff[cnt + channelMap[1]];
2691 v[yPos] = buff[cnt + channelMap[2]];
2698 ASSERT(bpp%dataBits == 0);
2708 if ((*cb)(percent,
true, data)) ReturnWithError(EscapePressed);
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;
void Open(CPGFStream *stream)
void SetColorTable(UINT32 iFirstColor, UINT32 nColors, const RGBQUAD *prgbColors)
virtual void Read(int *count, void *buffer)=0
void Read(int level=0, CallbackPtr cb=nullptr, void *data=nullptr)
bool m_favorSpeedOverSize
favor encoding speed over compression ratio
UINT64 m_userDataPos
stream position of user data
bool m_useOMPinDecoder
use Open MP in decoder
UINT8 version
PGF version.
UINT32 ReadEncodedHeader(UINT8 *target, UINT32 targetLen) const
#define PGFVersion
current standard version
void GetYUV(int pitch, DataT *buff, BYTE bpp, int channelMap[]=nullptr, CallbackPtr cb=nullptr, void *data=nullptr) const
void Dequantize(int quantParam)
const UINT8 * GetUserData(UINT32 &cachedSize, UINT32 *pTotalSize=nullptr) const
virtual void Write(int *count, void *buffer)=0
#define MaxChannels
maximum number of (color) channels
Abstract stream base class.
BYTE UsedBitsPerChannel() const
void GetBitmap(int pitch, UINT8 *buff, BYTE bpp, int channelMap[]=nullptr, CallbackPtr cb=nullptr, void *data=nullptr) const
void ExtractTile(CEncoder &encoder, bool tile=false, UINT32 tileX=0, UINT32 tileY=0)
UINT32 ReadEncodedData(int level, UINT8 *target, UINT32 targetLen) const
CDecoder * m_decoder
PGF decoder.
UINT32 GetEncodedLevelLength(int level) const
void ImportYUV(int pitch, DataT *buff, BYTE bpp, int channelMap[]=nullptr, CallbackPtr cb=nullptr, void *data=nullptr)
PGFHeader m_header
PGF file header.
bool m_streamReinitialized
stream has been reinitialized
void DecodeInterleaved(CWaveletTransform *wtChannel, int level, int quantParam)
BYTE m_quant
quantization parameter
void * m_cbArg
refresh callback argument
DataT * m_channel[MaxChannels]
untransformed channels in YUV format
PGFPreHeader m_preHeader
PGF pre-header.
void SetStreamPosToData()
Resets stream position to beginning of data block.
UINT32 GetEncodedHeaderLength() const
static UINT32 LevelSizeL(UINT32 size, int level)
UINT32 WriteLevelLength(UINT32 *&levelLength)
void SetROI(PGFRect rect)
const RGBQUAD * GetColorTable() const
#define PGFMagic
PGF identification.
PGFRect GetAlignedROI(int c=0) const
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.
UINT16 Clamp6(DataT v) const
#define ColorTableLen
size of color lookup table (clut)
#define MaxLevel
maximum number of transform levels
void UpdatePostHeaderSize(PGFPreHeader preHeader)
ProgressMode m_progressMode
progress mode used in Read and Write; PM_Relative is default mode
CWaveletTransform * m_wtChannel[MaxChannels]
wavelet transformed color channels
void PlaceTile(CDecoder &decoder, int quantParam, bool tile=false, UINT32 tileX=0, UINT32 tileY=0)
char magic[3]
PGF identification = "PGF".
PGFPostHeader m_postHeader
PGF post-header.
UINT32 Clamp31(DataT v) const
UINT16 Clamp16(DataT v) const
INT64 ComputeBufferLength() const
bool m_downsample
chrominance channels are downsampled
#define DownsampleThreshold
if quality is larger than this threshold than downsampling is used
UINT32 * m_levelLength
length of each level in bytes; first level starts immediately after this array
UINT32 WriteHeader(CPGFStream *stream)
UINT32 m_width[MaxChannels]
width of each channel at current level
#define Version2
data structure PGFHeader of major version 2
CPGFImage()
Standard constructor.
void SetStreamPosToStart()
Resets stream position to beginning of PGF pre-header.
void SetHeader(const PGFHeader &header, BYTE flags=0, const UINT8 *userData=0, UINT32 userDataLength=0)
bool ROIisSupported() const
#define MaxQuality
maximum quality
bool m_useOMPinEncoder
use Open MP in encoder
INT64 ComputeHeaderLength() const
virtual ~CPGFImage()
Destructor.
UINT32 UpdateLevelLength()
void Reconstruct(int level=0)
UINT8 Clamp8(DataT v) const
UINT8 Clamp4(DataT v) const
UINT32 ReadEncodedData(UINT8 *target, UINT32 len) const
void FavorSpeedOverSize()
Encoder favors speed over compression size.
UINT32 GetEncodedHeaderLength() const
UINT32 m_userDataPolicy
user data (metadata) policy during open
double m_percent
progress [0..1]
#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)
RefreshCB m_cb
pointer to refresh callback procedure
static bool ImportIsSupported(BYTE mode)
CEncoder * m_encoder
PGF encoder.
void SetStreamPosToStart()
Resets stream position to beginning of PGF pre-header.
INT64 ComputeOffset() const
void Downsample(int nChannel)
int m_currentLevel
transform level of current image
PGFRect ComputeLevelROI() const
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 m_height[MaxChannels]
height of each channel at current level
UINT32 UpdatePostHeaderSize()
PGFRect m_roi
region of interest
void SetEncodedLevel(int currentLevel)