| /* |
| * Copyright 2019 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "src/gpu/GrDataUtils.h" |
| |
| #include "include/private/SkTPin.h" |
| #include "include/third_party/skcms/skcms.h" |
| #include "src/core/SkColorSpaceXformSteps.h" |
| #include "src/core/SkCompressedDataUtils.h" |
| #include "src/core/SkConvertPixels.h" |
| #include "src/core/SkMathPriv.h" |
| #include "src/core/SkMipmap.h" |
| #include "src/core/SkRasterPipeline.h" |
| #include "src/core/SkTLazy.h" |
| #include "src/core/SkTraceEvent.h" |
| #include "src/core/SkUtils.h" |
| #include "src/gpu/GrCaps.h" |
| #include "src/gpu/GrColor.h" |
| #include "src/gpu/GrImageInfo.h" |
| #include "src/gpu/GrPixmap.h" |
| #include "src/gpu/Swizzle.h" |
| |
| struct ETC1Block { |
| uint32_t fHigh; |
| uint32_t fLow; |
| }; |
| |
| constexpr uint32_t kDiffBit = 0x2; // set -> differential; not-set -> individual |
| |
| static inline int extend_5To8bits(int b) { |
| int c = b & 0x1f; |
| return (c << 3) | (c >> 2); |
| } |
| |
| static const int kNumETC1ModifierTables = 8; |
| static const int kNumETC1PixelIndices = 4; |
| |
| // The index of each row in this table is the ETC1 table codeword |
| // The index of each column in this table is the ETC1 pixel index value |
| static const int kETC1ModifierTables[kNumETC1ModifierTables][kNumETC1PixelIndices] = { |
| /* 0 */ { 2, 8, -2, -8 }, |
| /* 1 */ { 5, 17, -5, -17 }, |
| /* 2 */ { 9, 29, -9, -29 }, |
| /* 3 */ { 13, 42, -13, -42 }, |
| /* 4 */ { 18, 60, -18, -60 }, |
| /* 5 */ { 24, 80, -24, -80 }, |
| /* 6 */ { 33, 106, -33, -106 }, |
| /* 7 */ { 47, 183, -47, -183 } |
| }; |
| |
| // Evaluate one of the entries in 'kModifierTables' to see how close it can get (r8,g8,b8) to |
| // the original color (rOrig, gOrib, bOrig). |
| static int test_table_entry(int rOrig, int gOrig, int bOrig, |
| int r8, int g8, int b8, |
| int table, int offset) { |
| SkASSERT(0 <= table && table < 8); |
| SkASSERT(0 <= offset && offset < 4); |
| |
| r8 = SkTPin<int>(r8 + kETC1ModifierTables[table][offset], 0, 255); |
| g8 = SkTPin<int>(g8 + kETC1ModifierTables[table][offset], 0, 255); |
| b8 = SkTPin<int>(b8 + kETC1ModifierTables[table][offset], 0, 255); |
| |
| return SkTAbs(rOrig - r8) + SkTAbs(gOrig - g8) + SkTAbs(bOrig - b8); |
| } |
| |
| // Create an ETC1 compressed block that is filled with 'col' |
| static void create_etc1_block(SkColor col, ETC1Block* block) { |
| uint32_t high = 0; |
| uint32_t low = 0; |
| |
| int rOrig = SkColorGetR(col); |
| int gOrig = SkColorGetG(col); |
| int bOrig = SkColorGetB(col); |
| |
| int r5 = SkMulDiv255Round(31, rOrig); |
| int g5 = SkMulDiv255Round(31, gOrig); |
| int b5 = SkMulDiv255Round(31, bOrig); |
| |
| int r8 = extend_5To8bits(r5); |
| int g8 = extend_5To8bits(g5); |
| int b8 = extend_5To8bits(b5); |
| |
| // We always encode solid color textures in differential mode (i.e., with a 555 base color) but |
| // with zero diffs (i.e., bits 26-24, 18-16 and 10-8 are left 0). |
| high |= (r5 << 27) | (g5 << 19) | (b5 << 11) | kDiffBit; |
| |
| int bestTableIndex = 0, bestPixelIndex = 0; |
| int bestSoFar = 1024; |
| for (int tableIndex = 0; tableIndex < kNumETC1ModifierTables; ++tableIndex) { |
| for (int pixelIndex = 0; pixelIndex < kNumETC1PixelIndices; ++pixelIndex) { |
| int score = test_table_entry(rOrig, gOrig, bOrig, r8, g8, b8, |
| tableIndex, pixelIndex); |
| |
| if (bestSoFar > score) { |
| bestSoFar = score; |
| bestTableIndex = tableIndex; |
| bestPixelIndex = pixelIndex; |
| } |
| } |
| } |
| |
| high |= (bestTableIndex << 5) | (bestTableIndex << 2); |
| |
| if (bestPixelIndex & 0x1) { |
| low |= 0xFFFF; |
| } |
| if (bestPixelIndex & 0x2) { |
| low |= 0xFFFF0000; |
| } |
| |
| block->fHigh = SkBSwap32(high); |
| block->fLow = SkBSwap32(low); |
| } |
| |
| static int num_4x4_blocks(int size) { |
| return ((size + 3) & ~3) >> 2; |
| } |
| |
| static int num_ETC1_blocks(int w, int h) { |
| w = num_4x4_blocks(w); |
| h = num_4x4_blocks(h); |
| |
| return w * h; |
| } |
| |
| struct BC1Block { |
| uint16_t fColor0; |
| uint16_t fColor1; |
| uint32_t fIndices; |
| }; |
| |
| static uint16_t to565(SkColor col) { |
| int r5 = SkMulDiv255Round(31, SkColorGetR(col)); |
| int g6 = SkMulDiv255Round(63, SkColorGetG(col)); |
| int b5 = SkMulDiv255Round(31, SkColorGetB(col)); |
| |
| return (r5 << 11) | (g6 << 5) | b5; |
| } |
| |
| // Create a BC1 compressed block that has two colors but is initialized to 'col0' |
| static void create_BC1_block(SkColor col0, SkColor col1, BC1Block* block) { |
| block->fColor0 = to565(col0); |
| block->fColor1 = to565(col1); |
| SkASSERT(block->fColor0 <= block->fColor1); // we always assume transparent blocks |
| |
| if (col0 == SK_ColorTRANSPARENT) { |
| // This sets all 16 pixels to just use color3 (under the assumption |
| // that this is a kBC1_RGBA8_UNORM texture. Note that in this case |
| // fColor0 will be opaque black. |
| block->fIndices = 0xFFFFFFFF; |
| } else { |
| // This sets all 16 pixels to just use 'fColor0' |
| block->fIndices = 0; |
| } |
| } |
| |
| size_t GrNumBlocks(SkImage::CompressionType type, SkISize baseDimensions) { |
| switch (type) { |
| case SkImage::CompressionType::kNone: |
| return baseDimensions.width() * baseDimensions.height(); |
| case SkImage::CompressionType::kETC2_RGB8_UNORM: |
| case SkImage::CompressionType::kBC1_RGB8_UNORM: |
| case SkImage::CompressionType::kBC1_RGBA8_UNORM: { |
| int numBlocksWidth = num_4x4_blocks(baseDimensions.width()); |
| int numBlocksHeight = num_4x4_blocks(baseDimensions.height()); |
| |
| return numBlocksWidth * numBlocksHeight; |
| } |
| } |
| SkUNREACHABLE; |
| } |
| |
| size_t GrCompressedRowBytes(SkImage::CompressionType type, int width) { |
| switch (type) { |
| case SkImage::CompressionType::kNone: |
| return 0; |
| case SkImage::CompressionType::kETC2_RGB8_UNORM: |
| case SkImage::CompressionType::kBC1_RGB8_UNORM: |
| case SkImage::CompressionType::kBC1_RGBA8_UNORM: { |
| int numBlocksWidth = num_4x4_blocks(width); |
| |
| static_assert(sizeof(ETC1Block) == sizeof(BC1Block)); |
| return numBlocksWidth * sizeof(ETC1Block); |
| } |
| } |
| SkUNREACHABLE; |
| } |
| |
| SkISize GrCompressedDimensions(SkImage::CompressionType type, SkISize baseDimensions) { |
| switch (type) { |
| case SkImage::CompressionType::kNone: |
| return baseDimensions; |
| case SkImage::CompressionType::kETC2_RGB8_UNORM: |
| case SkImage::CompressionType::kBC1_RGB8_UNORM: |
| case SkImage::CompressionType::kBC1_RGBA8_UNORM: { |
| int numBlocksWidth = num_4x4_blocks(baseDimensions.width()); |
| int numBlocksHeight = num_4x4_blocks(baseDimensions.height()); |
| |
| // Each BC1_RGB8_UNORM and ETC1 block has 16 pixels |
| return { 4 * numBlocksWidth, 4 * numBlocksHeight }; |
| } |
| } |
| SkUNREACHABLE; |
| } |
| |
| // Fill in 'dest' with ETC1 blocks derived from 'colorf' |
| static void fillin_ETC1_with_color(SkISize dimensions, const SkColor4f& colorf, char* dest) { |
| SkColor color = colorf.toSkColor(); |
| |
| ETC1Block block; |
| create_etc1_block(color, &block); |
| |
| int numBlocks = num_ETC1_blocks(dimensions.width(), dimensions.height()); |
| |
| for (int i = 0; i < numBlocks; ++i) { |
| memcpy(dest, &block, sizeof(ETC1Block)); |
| dest += sizeof(ETC1Block); |
| } |
| } |
| |
| // Fill in 'dest' with BC1 blocks derived from 'colorf' |
| static void fillin_BC1_with_color(SkISize dimensions, const SkColor4f& colorf, char* dest) { |
| SkColor color = colorf.toSkColor(); |
| |
| BC1Block block; |
| create_BC1_block(color, color, &block); |
| |
| int numBlocks = num_ETC1_blocks(dimensions.width(), dimensions.height()); |
| |
| for (int i = 0; i < numBlocks; ++i) { |
| memcpy(dest, &block, sizeof(BC1Block)); |
| dest += sizeof(BC1Block); |
| } |
| } |
| |
| #if GR_TEST_UTILS |
| |
| // Fill in 'dstPixels' with BC1 blocks derived from the 'pixmap'. |
| void GrTwoColorBC1Compress(const SkPixmap& pixmap, SkColor otherColor, char* dstPixels) { |
| BC1Block* dstBlocks = reinterpret_cast<BC1Block*>(dstPixels); |
| SkASSERT(pixmap.colorType() == SkColorType::kRGBA_8888_SkColorType); |
| |
| BC1Block block; |
| |
| // black -> fColor0, otherColor -> fColor1 |
| create_BC1_block(SK_ColorBLACK, otherColor, &block); |
| |
| int numXBlocks = num_4x4_blocks(pixmap.width()); |
| int numYBlocks = num_4x4_blocks(pixmap.height()); |
| |
| for (int y = 0; y < numYBlocks; ++y) { |
| for (int x = 0; x < numXBlocks; ++x) { |
| int shift = 0; |
| int offsetX = 4 * x, offsetY = 4 * y; |
| block.fIndices = 0; // init all the pixels to color0 (i.e., opaque black) |
| for (int i = 0; i < 4; ++i) { |
| for (int j = 0; j < 4; ++j, shift += 2) { |
| if (offsetX + j >= pixmap.width() || offsetY + i >= pixmap.height()) { |
| // This can happen for the topmost levels of a mipmap and for |
| // non-multiple of 4 textures |
| continue; |
| } |
| |
| SkColor tmp = pixmap.getColor(offsetX + j, offsetY + i); |
| if (tmp == SK_ColorTRANSPARENT) { |
| // For RGBA BC1 images color3 is set to transparent black |
| block.fIndices |= 3 << shift; |
| } else if (tmp != SK_ColorBLACK) { |
| block.fIndices |= 1 << shift; // color1 |
| } |
| } |
| } |
| |
| dstBlocks[y*numXBlocks + x] = block; |
| } |
| } |
| } |
| |
| #endif |
| |
| size_t GrComputeTightCombinedBufferSize(size_t bytesPerPixel, SkISize baseDimensions, |
| SkTArray<size_t>* individualMipOffsets, int mipLevelCount) { |
| SkASSERT(individualMipOffsets && !individualMipOffsets->count()); |
| SkASSERT(mipLevelCount >= 1); |
| |
| individualMipOffsets->push_back(0); |
| |
| size_t combinedBufferSize = baseDimensions.width() * bytesPerPixel * baseDimensions.height(); |
| SkISize levelDimensions = baseDimensions; |
| |
| // The Vulkan spec for copying a buffer to an image requires that the alignment must be at |
| // least 4 bytes and a multiple of the bytes per pixel of the image config. |
| SkASSERT(bytesPerPixel == 1 || bytesPerPixel == 2 || bytesPerPixel == 3 || |
| bytesPerPixel == 4 || bytesPerPixel == 8 || bytesPerPixel == 16); |
| int desiredAlignment = (bytesPerPixel == 3) ? 12 : (bytesPerPixel > 4 ? bytesPerPixel : 4); |
| |
| for (int currentMipLevel = 1; currentMipLevel < mipLevelCount; ++currentMipLevel) { |
| levelDimensions = {std::max(1, levelDimensions.width() /2), |
| std::max(1, levelDimensions.height()/2)}; |
| |
| size_t trimmedSize = levelDimensions.area() * bytesPerPixel; |
| const size_t alignmentDiff = combinedBufferSize % desiredAlignment; |
| if (alignmentDiff != 0) { |
| combinedBufferSize += desiredAlignment - alignmentDiff; |
| } |
| SkASSERT((0 == combinedBufferSize % 4) && (0 == combinedBufferSize % bytesPerPixel)); |
| |
| individualMipOffsets->push_back(combinedBufferSize); |
| combinedBufferSize += trimmedSize; |
| } |
| |
| SkASSERT(individualMipOffsets->count() == mipLevelCount); |
| return combinedBufferSize; |
| } |
| |
| void GrFillInCompressedData(SkImage::CompressionType type, SkISize dimensions, |
| GrMipmapped mipMapped, char* dstPixels, const SkColor4f& colorf) { |
| TRACE_EVENT0("skia.gpu", TRACE_FUNC); |
| |
| int numMipLevels = 1; |
| if (mipMapped == GrMipmapped::kYes) { |
| numMipLevels = SkMipmap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1; |
| } |
| |
| size_t offset = 0; |
| |
| for (int i = 0; i < numMipLevels; ++i) { |
| size_t levelSize = SkCompressedDataSize(type, dimensions, nullptr, false); |
| |
| if (SkImage::CompressionType::kETC2_RGB8_UNORM == type) { |
| fillin_ETC1_with_color(dimensions, colorf, &dstPixels[offset]); |
| } else { |
| SkASSERT(type == SkImage::CompressionType::kBC1_RGB8_UNORM || |
| type == SkImage::CompressionType::kBC1_RGBA8_UNORM); |
| fillin_BC1_with_color(dimensions, colorf, &dstPixels[offset]); |
| } |
| |
| offset += levelSize; |
| dimensions = {std::max(1, dimensions.width()/2), std::max(1, dimensions.height()/2)}; |
| } |
| } |
| |
| static skgpu::Swizzle get_load_and_src_swizzle(GrColorType ct, SkRasterPipeline::StockStage* load, |
| bool* isNormalized, bool* isSRGB) { |
| skgpu::Swizzle swizzle("rgba"); |
| *isNormalized = true; |
| *isSRGB = false; |
| switch (ct) { |
| case GrColorType::kAlpha_8: *load = SkRasterPipeline::load_a8; break; |
| case GrColorType::kAlpha_16: *load = SkRasterPipeline::load_a16; break; |
| case GrColorType::kBGR_565: *load = SkRasterPipeline::load_565; break; |
| case GrColorType::kABGR_4444: *load = SkRasterPipeline::load_4444; break; |
| case GrColorType::kARGB_4444: swizzle = skgpu::Swizzle("bgra"); |
| *load = SkRasterPipeline::load_4444; break; |
| case GrColorType::kBGRA_4444: swizzle = skgpu::Swizzle("gbar"); |
| *load = SkRasterPipeline::load_4444; break; |
| case GrColorType::kRGBA_8888: *load = SkRasterPipeline::load_8888; break; |
| case GrColorType::kRG_88: *load = SkRasterPipeline::load_rg88; break; |
| case GrColorType::kRGBA_1010102: *load = SkRasterPipeline::load_1010102; break; |
| case GrColorType::kBGRA_1010102: *load = SkRasterPipeline::load_1010102; |
| swizzle = skgpu::Swizzle("bgra"); |
| break; |
| case GrColorType::kAlpha_F16: *load = SkRasterPipeline::load_af16; break; |
| case GrColorType::kRGBA_F16_Clamped: *load = SkRasterPipeline::load_f16; break; |
| case GrColorType::kRG_1616: *load = SkRasterPipeline::load_rg1616; break; |
| case GrColorType::kRGBA_16161616: *load = SkRasterPipeline::load_16161616; break; |
| |
| case GrColorType::kRGBA_8888_SRGB: *load = SkRasterPipeline::load_8888; |
| *isSRGB = true; |
| break; |
| case GrColorType::kRG_F16: *load = SkRasterPipeline::load_rgf16; |
| *isNormalized = false; |
| break; |
| case GrColorType::kRGBA_F16: *load = SkRasterPipeline::load_f16; |
| *isNormalized = false; |
| break; |
| case GrColorType::kRGBA_F32: *load = SkRasterPipeline::load_f32; |
| *isNormalized = false; |
| break; |
| case GrColorType::kAlpha_8xxx: *load = SkRasterPipeline::load_8888; |
| swizzle = skgpu::Swizzle("000r"); |
| break; |
| case GrColorType::kAlpha_F32xxx: *load = SkRasterPipeline::load_f32; |
| swizzle = skgpu::Swizzle("000r"); |
| break; |
| case GrColorType::kGray_8xxx: *load = SkRasterPipeline::load_8888; |
| swizzle = skgpu::Swizzle("rrr1"); |
| break; |
| case GrColorType::kGray_8: *load = SkRasterPipeline::load_a8; |
| swizzle = skgpu::Swizzle("aaa1"); |
| break; |
| case GrColorType::kR_8xxx: *load = SkRasterPipeline::load_8888; |
| swizzle = skgpu::Swizzle("r001"); |
| break; |
| case GrColorType::kR_8: *load = SkRasterPipeline::load_a8; |
| swizzle = skgpu::Swizzle("a001"); |
| break; |
| case GrColorType::kGrayAlpha_88: *load = SkRasterPipeline::load_rg88; |
| swizzle = skgpu::Swizzle("rrrg"); |
| break; |
| case GrColorType::kBGRA_8888: *load = SkRasterPipeline::load_8888; |
| swizzle = skgpu::Swizzle("bgra"); |
| break; |
| case GrColorType::kRGB_888x: *load = SkRasterPipeline::load_8888; |
| swizzle = skgpu::Swizzle("rgb1"); |
| break; |
| |
| // These are color types we don't expect to ever have to load. |
| case GrColorType::kRGB_888: |
| case GrColorType::kR_16: |
| case GrColorType::kR_F16: |
| case GrColorType::kGray_F16: |
| case GrColorType::kUnknown: |
| SK_ABORT("unexpected CT"); |
| } |
| return swizzle; |
| } |
| |
| enum class LumMode { |
| kNone, |
| kToRGB, |
| kToAlpha |
| }; |
| |
| static skgpu::Swizzle get_dst_swizzle_and_store(GrColorType ct, SkRasterPipeline::StockStage* store, |
| LumMode* lumMode, bool* isNormalized, |
| bool* isSRGB) { |
| skgpu::Swizzle swizzle("rgba"); |
| *isNormalized = true; |
| *isSRGB = false; |
| *lumMode = LumMode::kNone; |
| switch (ct) { |
| case GrColorType::kAlpha_8: *store = SkRasterPipeline::store_a8; break; |
| case GrColorType::kAlpha_16: *store = SkRasterPipeline::store_a16; break; |
| case GrColorType::kBGR_565: *store = SkRasterPipeline::store_565; break; |
| case GrColorType::kABGR_4444: *store = SkRasterPipeline::store_4444; break; |
| case GrColorType::kARGB_4444: swizzle = skgpu::Swizzle("bgra"); |
| *store = SkRasterPipeline::store_4444; break; |
| case GrColorType::kBGRA_4444: swizzle = skgpu::Swizzle("argb"); |
| *store = SkRasterPipeline::store_4444; break; |
| case GrColorType::kRGBA_8888: *store = SkRasterPipeline::store_8888; break; |
| case GrColorType::kRG_88: *store = SkRasterPipeline::store_rg88; break; |
| case GrColorType::kRGBA_1010102: *store = SkRasterPipeline::store_1010102; break; |
| case GrColorType::kBGRA_1010102: swizzle = skgpu::Swizzle("bgra"); |
| *store = SkRasterPipeline::store_1010102; |
| break; |
| case GrColorType::kRGBA_F16_Clamped: *store = SkRasterPipeline::store_f16; break; |
| case GrColorType::kRG_1616: *store = SkRasterPipeline::store_rg1616; break; |
| case GrColorType::kRGBA_16161616: *store = SkRasterPipeline::store_16161616; break; |
| |
| case GrColorType::kRGBA_8888_SRGB: *store = SkRasterPipeline::store_8888; |
| *isSRGB = true; |
| break; |
| case GrColorType::kRG_F16: *store = SkRasterPipeline::store_rgf16; |
| *isNormalized = false; |
| break; |
| case GrColorType::kAlpha_F16: *store = SkRasterPipeline::store_af16; |
| *isNormalized = false; |
| break; |
| case GrColorType::kRGBA_F16: *store = SkRasterPipeline::store_f16; |
| *isNormalized = false; |
| break; |
| case GrColorType::kRGBA_F32: *store = SkRasterPipeline::store_f32; |
| *isNormalized = false; |
| break; |
| case GrColorType::kAlpha_8xxx: *store = SkRasterPipeline::store_8888; |
| swizzle = skgpu::Swizzle("a000"); |
| break; |
| case GrColorType::kAlpha_F32xxx: *store = SkRasterPipeline::store_f32; |
| swizzle = skgpu::Swizzle("a000"); |
| break; |
| case GrColorType::kBGRA_8888: swizzle = skgpu::Swizzle("bgra"); |
| *store = SkRasterPipeline::store_8888; |
| break; |
| case GrColorType::kRGB_888x: swizzle = skgpu::Swizzle("rgb1"); |
| *store = SkRasterPipeline::store_8888; |
| break; |
| case GrColorType::kR_8xxx: swizzle = skgpu::Swizzle("r001"); |
| *store = SkRasterPipeline::store_8888; |
| break; |
| case GrColorType::kR_8: swizzle = skgpu::Swizzle("agbr"); |
| *store = SkRasterPipeline::store_a8; |
| break; |
| case GrColorType::kR_16: swizzle = skgpu::Swizzle("agbr"); |
| *store = SkRasterPipeline::store_a16; |
| break; |
| case GrColorType::kR_F16: swizzle = skgpu::Swizzle("agbr"); |
| *store = SkRasterPipeline::store_af16; |
| break; |
| case GrColorType::kGray_F16: *lumMode = LumMode::kToAlpha; |
| *store = SkRasterPipeline::store_af16; |
| break; |
| case GrColorType::kGray_8: *lumMode = LumMode::kToAlpha; |
| *store = SkRasterPipeline::store_a8; |
| break; |
| case GrColorType::kGrayAlpha_88: *lumMode = LumMode::kToRGB; |
| swizzle = skgpu::Swizzle("ragb"); |
| *store = SkRasterPipeline::store_rg88; |
| break; |
| case GrColorType::kGray_8xxx: *lumMode = LumMode::kToRGB; |
| *store = SkRasterPipeline::store_8888; |
| swizzle = skgpu::Swizzle("r000"); |
| break; |
| |
| // These are color types we don't expect to ever have to store. |
| case GrColorType::kRGB_888: // This is handled specially in GrConvertPixels. |
| case GrColorType::kUnknown: |
| SK_ABORT("unexpected CT"); |
| } |
| return swizzle; |
| } |
| |
| static inline void append_clamp_gamut(SkRasterPipeline* pipeline) { |
| // SkRasterPipeline may not know our color type and also doesn't like caller to directly |
| // append clamp_gamut. Fake it out. |
| static SkImageInfo fakeII = SkImageInfo::MakeN32Premul(1, 1); |
| pipeline->append_gamut_clamp_if_normalized(fakeII); |
| } |
| |
| bool GrConvertPixels(const GrPixmap& dst, const GrCPixmap& src, bool flipY) { |
| TRACE_EVENT0("skia.gpu", TRACE_FUNC); |
| if (src.dimensions().isEmpty() || dst.dimensions().isEmpty()) { |
| return false; |
| } |
| if (src.colorType() == GrColorType::kUnknown || dst.colorType() == GrColorType::kUnknown) { |
| return false; |
| } |
| if (!src.hasPixels() || !dst.hasPixels()) { |
| return false; |
| } |
| if (dst.dimensions() != src.dimensions()) { |
| return false; |
| } |
| if (dst.colorType() == GrColorType::kRGB_888) { |
| // SkRasterPipeline doesn't handle writing to RGB_888. So we have it write to RGB_888x and |
| // then do another conversion that does the 24bit packing. We could be cleverer and skip the |
| // temp pixmap if this is the only conversion but this is rare so keeping it simple. |
| GrPixmap temp = GrPixmap::Allocate(dst.info().makeColorType(GrColorType::kRGB_888x)); |
| if (!GrConvertPixels(temp, src, flipY)) { |
| return false; |
| } |
| auto* tRow = reinterpret_cast<const char*>(temp.addr()); |
| auto* dRow = reinterpret_cast<char*>(dst.addr()); |
| for (int y = 0; y < dst.height(); ++y, tRow += temp.rowBytes(), dRow += dst.rowBytes()) { |
| for (int x = 0; x < dst.width(); ++x) { |
| auto t = tRow + x*sizeof(uint32_t); |
| auto d = dRow + x*3; |
| memcpy(d, t, 3); |
| } |
| } |
| return true; |
| } else if (src.colorType() == GrColorType::kRGB_888) { |
| // SkRasterPipeline doesn't handle reading from RGB_888. So convert it to RGB_888x and then |
| // do a recursive call if there is any remaining conversion. |
| GrPixmap temp = GrPixmap::Allocate(src.info().makeColorType(GrColorType::kRGB_888x)); |
| auto* sRow = reinterpret_cast<const char*>(src.addr()); |
| auto* tRow = reinterpret_cast<char*>(temp.addr()); |
| for (int y = 0; y < src.height(); ++y, sRow += src.rowBytes(), tRow += temp.rowBytes()) { |
| for (int x = 0; x < src.width(); ++x) { |
| auto s = sRow + x*3; |
| auto t = tRow + x*sizeof(uint32_t); |
| memcpy(t, s, 3); |
| t[3] = static_cast<char>(0xFF); |
| } |
| } |
| return GrConvertPixels(dst, temp, flipY); |
| } |
| |
| size_t srcBpp = src.info().bpp(); |
| size_t dstBpp = dst.info().bpp(); |
| |
| // SkRasterPipeline operates on row-pixels not row-bytes. |
| SkASSERT(dst.rowBytes() % dstBpp == 0); |
| SkASSERT(src.rowBytes() % srcBpp == 0); |
| |
| bool premul = src.alphaType() == kUnpremul_SkAlphaType && |
| dst.alphaType() == kPremul_SkAlphaType; |
| bool unpremul = src.alphaType() == kPremul_SkAlphaType && |
| dst.alphaType() == kUnpremul_SkAlphaType; |
| bool alphaOrCSConversion = |
| premul || unpremul || !SkColorSpace::Equals(src.colorSpace(), dst.colorSpace()); |
| |
| if (src.colorType() == dst.colorType() && !alphaOrCSConversion) { |
| size_t tightRB = dstBpp * dst.width(); |
| if (flipY) { |
| auto s = static_cast<const char*>(src.addr()); |
| auto d = SkTAddOffset<char>(dst.addr(), dst.rowBytes()*(dst.height() - 1)); |
| for (int y = 0; y < dst.height(); ++y, d -= dst.rowBytes(), s += src.rowBytes()) { |
| memcpy(d, s, tightRB); |
| } |
| } else { |
| SkRectMemcpy(dst.addr(), dst.rowBytes(), |
| src.addr(), src.rowBytes(), |
| tightRB, src.height()); |
| } |
| return true; |
| } |
| |
| SkRasterPipeline::StockStage load; |
| bool srcIsNormalized; |
| bool srcIsSRGB; |
| auto loadSwizzle = get_load_and_src_swizzle(src.colorType(), |
| &load, |
| &srcIsNormalized, |
| &srcIsSRGB); |
| |
| SkRasterPipeline::StockStage store; |
| LumMode lumMode; |
| bool dstIsNormalized; |
| bool dstIsSRGB; |
| auto storeSwizzle = get_dst_swizzle_and_store(dst.colorType(), |
| &store, |
| &lumMode, |
| &dstIsNormalized, |
| &dstIsSRGB); |
| |
| bool clampGamut; |
| SkTLazy<SkColorSpaceXformSteps> steps; |
| skgpu::Swizzle loadStoreSwizzle; |
| if (alphaOrCSConversion) { |
| steps.init(src.colorSpace(), src.alphaType(), dst.colorSpace(), dst.alphaType()); |
| clampGamut = dstIsNormalized && dst.alphaType() == kPremul_SkAlphaType; |
| } else { |
| clampGamut = dstIsNormalized && !srcIsNormalized && dst.alphaType() == kPremul_SkAlphaType; |
| if (!clampGamut) { |
| loadStoreSwizzle = skgpu::Swizzle::Concat(loadSwizzle, storeSwizzle); |
| } |
| } |
| int cnt = 1; |
| int height = src.height(); |
| SkRasterPipeline_MemoryCtx |
| srcCtx{const_cast<void*>(src.addr()), SkToInt(src.rowBytes()/srcBpp)}, |
| dstCtx{ dst.addr(), SkToInt(dst.rowBytes()/dstBpp)}; |
| |
| if (flipY) { |
| // It *almost* works to point the src at the last row and negate the stride and run the |
| // whole rectangle. However, SkRasterPipeline::run()'s control loop uses size_t loop |
| // variables so it winds up relying on unsigned overflow math. It works out in practice |
| // but UBSAN says "no!" as it's technically undefined and in theory a compiler could emit |
| // code that didn't do what is intended. So we go one row at a time. :( |
| srcCtx.pixels = static_cast<char*>(srcCtx.pixels) + src.rowBytes()*(height - 1); |
| std::swap(cnt, height); |
| } |
| |
| bool hasConversion = alphaOrCSConversion || clampGamut || lumMode != LumMode::kNone; |
| |
| if (srcIsSRGB && dstIsSRGB && !hasConversion) { |
| // No need to convert from srgb if we are just going to immediately convert it back. |
| srcIsSRGB = dstIsSRGB = false; |
| } |
| |
| hasConversion = hasConversion || srcIsSRGB || dstIsSRGB; |
| |
| for (int i = 0; i < cnt; ++i) { |
| SkRasterPipeline_<256> pipeline; |
| pipeline.append(load, &srcCtx); |
| if (hasConversion) { |
| loadSwizzle.apply(&pipeline); |
| if (srcIsSRGB) { |
| pipeline.append_transfer_function(*skcms_sRGB_TransferFunction()); |
| } |
| if (alphaOrCSConversion) { |
| steps->apply(&pipeline); |
| } |
| if (clampGamut) { |
| append_clamp_gamut(&pipeline); |
| } |
| switch (lumMode) { |
| case LumMode::kNone: |
| break; |
| case LumMode::kToRGB: |
| pipeline.append(SkRasterPipeline::StockStage::bt709_luminance_or_luma_to_rgb); |
| break; |
| case LumMode::kToAlpha: |
| pipeline.append(SkRasterPipeline::StockStage::bt709_luminance_or_luma_to_alpha); |
| // If we ever need to store srgb-encoded gray (e.g. GL_SLUMINANCE8) then we |
| // should use ToRGB and then a swizzle stage rather than ToAlpha. The subsequent |
| // transfer function stage ignores the alpha channel (where we just stashed the |
| // gray). |
| SkASSERT(!dstIsSRGB); |
| break; |
| } |
| if (dstIsSRGB) { |
| pipeline.append_transfer_function(*skcms_sRGB_Inverse_TransferFunction()); |
| } |
| storeSwizzle.apply(&pipeline); |
| } else { |
| loadStoreSwizzle.apply(&pipeline); |
| } |
| pipeline.append(store, &dstCtx); |
| pipeline.run(0, 0, src.width(), height); |
| srcCtx.pixels = static_cast<char*>(srcCtx.pixels) - src.rowBytes(); |
| dstCtx.pixels = static_cast<char*>(dstCtx.pixels) + dst.rowBytes(); |
| } |
| return true; |
| } |
| |
| bool GrClearImage(const GrImageInfo& dstInfo, void* dst, size_t dstRB, std::array<float, 4> color) { |
| TRACE_EVENT0("skia.gpu", TRACE_FUNC); |
| |
| if (!dstInfo.isValid()) { |
| return false; |
| } |
| if (!dst) { |
| return false; |
| } |
| if (dstRB < dstInfo.minRowBytes()) { |
| return false; |
| } |
| if (dstInfo.colorType() == GrColorType::kRGB_888) { |
| // SkRasterPipeline doesn't handle writing to RGB_888. So we handle that specially here. |
| uint32_t rgba = SkColor4f{color[0], color[1], color[2], color[3]}.toBytes_RGBA(); |
| for (int y = 0; y < dstInfo.height(); ++y) { |
| char* d = static_cast<char*>(dst) + y * dstRB; |
| for (int x = 0; x < dstInfo.width(); ++x, d += 3) { |
| memcpy(d, &rgba, 3); |
| } |
| } |
| return true; |
| } |
| |
| LumMode lumMode; |
| bool isNormalized; |
| bool dstIsSRGB; |
| SkRasterPipeline::StockStage store; |
| skgpu::Swizzle storeSwizzle = get_dst_swizzle_and_store(dstInfo.colorType(), &store, &lumMode, |
| &isNormalized, &dstIsSRGB); |
| char block[64]; |
| SkArenaAlloc alloc(block, sizeof(block), 1024); |
| SkRasterPipeline_<256> pipeline; |
| pipeline.append_constant_color(&alloc, color.data()); |
| switch (lumMode) { |
| case LumMode::kNone: |
| break; |
| case LumMode::kToRGB: |
| pipeline.append(SkRasterPipeline::StockStage::bt709_luminance_or_luma_to_rgb); |
| break; |
| case LumMode::kToAlpha: |
| pipeline.append(SkRasterPipeline::StockStage::bt709_luminance_or_luma_to_alpha); |
| // If we ever need to store srgb-encoded gray (e.g. GL_SLUMINANCE8) then we should use |
| // ToRGB and then a swizzle stage rather than ToAlpha. The subsequent transfer function |
| // stage ignores the alpha channel (where we just stashed the gray). |
| SkASSERT(!dstIsSRGB); |
| break; |
| } |
| if (dstIsSRGB) { |
| pipeline.append_transfer_function(*skcms_sRGB_Inverse_TransferFunction()); |
| } |
| storeSwizzle.apply(&pipeline); |
| SkRasterPipeline_MemoryCtx dstCtx{dst, SkToInt(dstRB/dstInfo.bpp())}; |
| pipeline.append(store, &dstCtx); |
| pipeline.run(0, 0, dstInfo.width(), dstInfo.height()); |
| |
| return true; |
| } |
