diff options
29 files changed, 206 insertions, 55 deletions
@@ -926,6 +926,8 @@ static Sink* create_sink(const GrContextOptions& grCtxOptions, const SkCommandLi SINK( "esrgb", RasterSink, kRGBA_F16_SkColorType, srgb ); SINK( "narrow", RasterSink, kRGBA_8888_SkColorType, narrow ); SINK("enarrow", RasterSink, kRGBA_F16_SkColorType, narrow ); + + SINK( "f32", RasterSink, kRGBA_F32_SkColorType, srgbLinear); } #undef SINK return nullptr; diff --git a/gm/bitmapcopy.cpp b/gm/bitmapcopy.cpp index 94d6fe6e2c..5f9ae206a0 100644 --- a/gm/bitmapcopy.cpp +++ b/gm/bitmapcopy.cpp @@ -22,6 +22,7 @@ static const char* color_type_name(SkColorType colorType) { case kRGB_101010x_SkColorType: return "101010x"; case kGray_8_SkColorType: return "G8"; case kRGBA_F16_SkColorType: return "F16"; + case kRGBA_F32_SkColorType: return "F32"; } return ""; } diff --git a/gm/gamut.cpp b/gm/gamut.cpp index 55f1b28acf..1e109a924b 100644 --- a/gm/gamut.cpp +++ b/gm/gamut.cpp @@ -141,6 +141,7 @@ static void draw_gamut_grid(SkCanvas* canvas, SkTArray<std::unique_ptr<CellRende wideGamutRGB_toXYZD50); break; case kRGBA_F16_SkColorType: + case kRGBA_F32_SkColorType: srgbCS = SkColorSpace::MakeSRGBLinear(); wideCS = SkColorSpace::MakeRGB(SkColorSpace::kLinear_RenderTargetGamma, wideGamutRGB_toXYZD50); diff --git a/include/core/SkImageInfo.h b/include/core/SkImageInfo.h index db3917f944..33dd8ca1ed 100644 --- a/include/core/SkImageInfo.h +++ b/include/core/SkImageInfo.h @@ -93,7 +93,8 @@ enum SkColorType { kRGB_101010x_SkColorType, //!< pixel with 10 bits each for red, green, blue; in 32-bit word kGray_8_SkColorType, //!< pixel with grayscale level in 8-bit byte kRGBA_F16_SkColorType, //!< pixel with half floats for red, green, blue, alpha; in 64-bit word - kLastEnum_SkColorType = kRGBA_F16_SkColorType,//!< last valid value + kRGBA_F32_SkColorType, //!< pixel with single floats for red, green, blue, alpha + kLastEnum_SkColorType = kRGBA_F32_SkColorType,//!< last valid value #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A) kN32_SkColorType = kBGRA_8888_SkColorType,//!< native ARGB 32-bit encoding diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h index e957f1f893..16f3c4a53e 100644 --- a/include/private/GrTypesPriv.h +++ b/include/private/GrTypesPriv.h @@ -1241,7 +1241,7 @@ static inline SkColorType GrColorTypeToSkColorType(GrColorType ct) { case GrColorType::kAlpha_F16: return kUnknown_SkColorType; case GrColorType::kRGBA_F16: return kRGBA_F16_SkColorType; case GrColorType::kRG_F32: return kUnknown_SkColorType; - case GrColorType::kRGBA_F32: return kUnknown_SkColorType; + case GrColorType::kRGBA_F32: return kRGBA_F32_SkColorType; } SK_ABORT("Invalid GrColorType"); return kUnknown_SkColorType; @@ -1260,6 +1260,7 @@ static inline GrColorType SkColorTypeToGrColorType(SkColorType ct) { case kRGBA_F16_SkColorType: return GrColorType::kRGBA_F16; case kRGBA_1010102_SkColorType: return GrColorType::kRGBA_1010102; case kRGB_101010x_SkColorType: return GrColorType::kUnknown; + case kRGBA_F32_SkColorType: return GrColorType::kRGBA_F32; } SK_ABORT("Invalid SkColorType"); return GrColorType::kUnknown; diff --git a/include/private/SkImageInfoPriv.h b/include/private/SkImageInfoPriv.h index 144ad0a062..df5e3790a3 100644 --- a/include/private/SkImageInfoPriv.h +++ b/include/private/SkImageInfoPriv.h @@ -36,6 +36,7 @@ static inline uint32_t SkColorTypeComponentFlags(SkColorType ct) { case kRGB_101010x_SkColorType: return kRGB_SkColorTypeComponentFlags; case kGray_8_SkColorType: return kGray_SkColorTypeComponentFlag; case kRGBA_F16_SkColorType: return kRGBA_SkColorTypeComponentFlags; + case kRGBA_F32_SkColorType: return kRGBA_SkColorTypeComponentFlags; } return 0; } @@ -68,6 +69,7 @@ static int SkColorTypeShiftPerPixel(SkColorType ct) { case kRGB_101010x_SkColorType: return 2; case kGray_8_SkColorType: return 0; case kRGBA_F16_SkColorType: return 3; + case kRGBA_F32_SkColorType: return 4; } return 0; } diff --git a/src/codec/SkWebpCodec.cpp b/src/codec/SkWebpCodec.cpp index e26f46d074..b6485b1b9c 100644 --- a/src/codec/SkWebpCodec.cpp +++ b/src/codec/SkWebpCodec.cpp @@ -365,6 +365,10 @@ static void pick_memory_stages(SkColorType ct, SkRasterPipeline::StockStage* loa if (load) *load = SkRasterPipeline::load_f16; if (store) *store = SkRasterPipeline::store_f16; break; + case kRGBA_F32_SkColorType: + if (load) *load = SkRasterPipeline::load_f32; + if (store) *store = SkRasterPipeline::store_f32; + break; } } diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp index e942a4c2d2..4ef7abf95c 100644 --- a/src/core/SkBitmap.cpp +++ b/src/core/SkBitmap.cpp @@ -384,6 +384,9 @@ void* SkBitmap::getAddr(int x, int y) const { if (base) { base += y * this->rowBytes(); switch (this->colorType()) { + case kRGBA_F32_SkColorType: + base += x << 4; + break; case kRGBA_F16_SkColorType: base += x << 3; break; diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp index 81ff5bae2a..2361468d56 100644 --- a/src/core/SkBitmapDevice.cpp +++ b/src/core/SkBitmapDevice.cpp @@ -210,6 +210,7 @@ static bool valid_for_bitmap_device(const SkImageInfo& info, case kBGRA_8888_SkColorType: case kRGBA_1010102_SkColorType: case kRGBA_F16_SkColorType: + case kRGBA_F32_SkColorType: break; case kGray_8_SkColorType: case kRGB_565_SkColorType: diff --git a/src/core/SkBlitter_Sprite.cpp b/src/core/SkBlitter_Sprite.cpp index 7385128195..057b2a5d07 100644 --- a/src/core/SkBlitter_Sprite.cpp +++ b/src/core/SkBlitter_Sprite.cpp @@ -123,6 +123,7 @@ public: case kRGBA_8888_SkColorType: p.append(SkRasterPipeline::load_8888, ctx); break; case kRGBA_1010102_SkColorType: p.append(SkRasterPipeline::load_1010102, ctx); break; case kRGBA_F16_SkColorType: p.append(SkRasterPipeline::load_f16, ctx); break; + case kRGBA_F32_SkColorType: p.append(SkRasterPipeline::load_f32, ctx); break; case kRGB_888x_SkColorType: p.append(SkRasterPipeline::load_8888, ctx); p.append(SkRasterPipeline::force_opaque ); break; diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp index be3ebb1a15..b297f98156 100644 --- a/src/core/SkCanvas.cpp +++ b/src/core/SkCanvas.cpp @@ -2871,6 +2871,7 @@ static bool supported_for_raster_canvas(const SkImageInfo& info) { case kRGB_565_SkColorType: case kN32_SkColorType: case kRGBA_F16_SkColorType: + case kRGBA_F32_SkColorType: case kRGBA_1010102_SkColorType: break; default: diff --git a/src/core/SkConvertPixels.cpp b/src/core/SkConvertPixels.cpp index b0d37cd89f..25645d485c 100644 --- a/src/core/SkConvertPixels.cpp +++ b/src/core/SkConvertPixels.cpp @@ -231,6 +231,16 @@ static void convert_to_alpha8(uint8_t* dst, size_t dstRB, const SkImageInfo& src } break; } + case kRGBA_F32_SkColorType: { + auto rgba = (const float*)src; + for (int y = 0; y < srcInfo.height(); y++) { + for (int x = 0; x < srcInfo.width(); x++) { + dst[x] = (uint8_t)(255.0f * rgba[4*x+3]); + } + dst = SkTAddOffset<uint8_t>(dst, dstRB); + rgba = SkTAddOffset<const float>(rgba, srcRB); + } + } break; default: SkASSERT(false); break; @@ -270,6 +280,9 @@ static void convert_with_pipeline(const SkImageInfo& dstInfo, void* dstRow, size case kRGBA_F16_SkColorType: pipeline.append(SkRasterPipeline::load_f16, &src); break; + case kRGBA_F32_SkColorType: + pipeline.append(SkRasterPipeline::load_f32, &src); + break; case kGray_8_SkColorType: pipeline.append(SkRasterPipeline::load_g8, &src); break; @@ -381,6 +394,9 @@ static void convert_with_pipeline(const SkImageInfo& dstInfo, void* dstRow, size case kRGBA_F16_SkColorType: pipeline.append(SkRasterPipeline::store_f16, &dst); break; + case kRGBA_F32_SkColorType: + pipeline.append(SkRasterPipeline::store_f32, &dst); + break; case kARGB_4444_SkColorType: pipeline.append(SkRasterPipeline::store_4444, &dst); break; diff --git a/src/core/SkImageInfo.cpp b/src/core/SkImageInfo.cpp index c0943017d9..0a98c28ace 100644 --- a/src/core/SkImageInfo.cpp +++ b/src/core/SkImageInfo.cpp @@ -23,6 +23,7 @@ int SkColorTypeBytesPerPixel(SkColorType ct) { case kRGB_101010x_SkColorType: return 4; case kGray_8_SkColorType: return 1; case kRGBA_F16_SkColorType: return 8; + case kRGBA_F32_SkColorType: return 16; } return 0; } @@ -74,6 +75,7 @@ bool SkColorTypeValidateAlphaType(SkColorType colorType, SkAlphaType alphaType, case kBGRA_8888_SkColorType: case kRGBA_1010102_SkColorType: case kRGBA_F16_SkColorType: + case kRGBA_F32_SkColorType: if (kUnknown_SkAlphaType == alphaType) { return false; } diff --git a/src/core/SkPixmap.cpp b/src/core/SkPixmap.cpp index 6eaf679715..77b174b154 100644 --- a/src/core/SkPixmap.cpp +++ b/src/core/SkPixmap.cpp @@ -230,6 +230,7 @@ bool SkPixmap::erase(SkColor color, const SkIRect& inArea) const { } case kRGBA_F16_SkColorType: + case kRGBA_F32_SkColorType: // The colorspace is unspecified, so assume linear just like getColor(). this->erase(SkColor4f{(1 / 255.0f) * r, (1 / 255.0f) * g, @@ -254,15 +255,29 @@ bool SkPixmap::erase(const SkColor4f& origColor, const SkIRect* subset) const { const SkColor4f color = origColor.pin(); - if (kRGBA_F16_SkColorType != pm.colorType()) { - return pm.erase(color.toSkColor()); + if (pm.colorType() == kRGBA_F16_SkColorType) { + const uint64_t half4 = color.premul().toF16(); + for (int y = 0; y < pm.height(); ++y) { + sk_memset64(pm.writable_addr64(0, y), half4, pm.width()); + } + return true; } - const uint64_t half4 = color.premul().toF16(); - for (int y = 0; y < pm.height(); ++y) { - sk_memset64(pm.writable_addr64(0, y), half4, pm.width()); + if (pm.colorType() == kRGBA_F32_SkColorType) { + const SkPM4f rgba = color.premul(); + for (int y = 0; y < pm.height(); ++y) { + auto row = (float*)pm.writable_addr(); + for (int x = 0; x < pm.width(); ++x) { + row[4*x+0] = rgba.r(); + row[4*x+1] = rgba.g(); + row[4*x+2] = rgba.b(); + row[4*x+3] = rgba.a(); + } + } + return true; } - return true; + + return pm.erase(color.toSkColor()); } bool SkPixmap::scalePixels(const SkPixmap& actualDst, SkFilterQuality quality) const { @@ -396,17 +411,31 @@ SkColor SkPixmap::getColor(int x, int y) const { | (uint32_t)( a * 255.0f ) << 24; } case kRGBA_F16_SkColorType: { - const uint64_t* addr = - (const uint64_t*)fPixels + y * (fRowBytes >> 3) + x; - Sk4f p4 = SkHalfToFloat_finite_ftz(*addr); - if (p4[3] && needsUnpremul) { - float inva = 1 / p4[3]; - p4 = p4 * Sk4f(inva, inva, inva, 1); - } - SkColor c; - SkNx_cast<uint8_t>(p4 * Sk4f(255) + Sk4f(0.5f)).store(&c); - // p4 is RGBA, but we want BGRA, so we need to swap next - return SkSwizzle_RB(c); + const uint64_t* addr = + (const uint64_t*)fPixels + y * (fRowBytes >> 3) + x; + Sk4f p4 = SkHalfToFloat_finite_ftz(*addr); + if (p4[3] && needsUnpremul) { + float inva = 1 / p4[3]; + p4 = p4 * Sk4f(inva, inva, inva, 1); + } + SkColor c; + SkNx_cast<uint8_t>(p4 * Sk4f(255) + Sk4f(0.5f)).store(&c); + // p4 is RGBA, but we want BGRA, so we need to swap next + return SkSwizzle_RB(c); + } + case kRGBA_F32_SkColorType: { + const float* rgba = + (const float*)fPixels + 4*y*(fRowBytes >> 4) + 4*x; + Sk4f p4 = Sk4f::Load(rgba); + // From here on, just like F16: + if (p4[3] && needsUnpremul) { + float inva = 1 / p4[3]; + p4 = p4 * Sk4f(inva, inva, inva, 1); + } + SkColor c; + SkNx_cast<uint8_t>(p4 * Sk4f(255) + Sk4f(0.5f)).store(&c); + // p4 is RGBA, but we want BGRA, so we need to swap next + return SkSwizzle_RB(c); } default: SkDEBUGFAIL(""); diff --git a/src/core/SkRasterPipeline.h b/src/core/SkRasterPipeline.h index 1dd346f22d..36f7ce3eeb 100644 --- a/src/core/SkRasterPipeline.h +++ b/src/core/SkRasterPipeline.h @@ -49,7 +49,7 @@ M(load_565) M(load_565_dst) M(store_565) M(gather_565) \ M(load_4444) M(load_4444_dst) M(store_4444) M(gather_4444) \ M(load_f16) M(load_f16_dst) M(store_f16) M(gather_f16) \ - M(load_f32) M(load_f32_dst) M(store_f32) \ + M(load_f32) M(load_f32_dst) M(store_f32) M(gather_f32) \ M(load_8888) M(load_8888_dst) M(store_8888) M(gather_8888) \ M(load_bgra) M(load_bgra_dst) M(store_bgra) M(gather_bgra) \ M(load_1010102) M(load_1010102_dst) M(store_1010102) M(gather_1010102) \ diff --git a/src/core/SkRasterPipelineBlitter.cpp b/src/core/SkRasterPipelineBlitter.cpp index 8b37bef24f..66a4a62734 100644 --- a/src/core/SkRasterPipelineBlitter.cpp +++ b/src/core/SkRasterPipelineBlitter.cpp @@ -210,7 +210,8 @@ SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst, // When we're drawing a constant color in Src mode, we can sometimes just memset. // (The previous two optimizations help find more opportunities for this one.) - if (is_constant && blitter->fBlend == SkBlendMode::kSrc) { + if (is_constant && blitter->fBlend == SkBlendMode::kSrc + && blitter->fDst.shiftPerPixel() <= 3 /*TODO: F32*/) { // Run our color pipeline all the way through to produce what we'd memset when we can. // Not all blits can memset, so we need to keep colorPipeline too. SkRasterPipeline_<256> p; @@ -243,6 +244,7 @@ void SkRasterPipelineBlitter::append_load_dst(SkRasterPipeline* p) const { case kRGBA_8888_SkColorType: p->append(SkRasterPipeline::load_8888_dst, ctx); break; case kRGBA_1010102_SkColorType: p->append(SkRasterPipeline::load_1010102_dst, ctx); break; case kRGBA_F16_SkColorType: p->append(SkRasterPipeline::load_f16_dst, ctx); break; + case kRGBA_F32_SkColorType: p->append(SkRasterPipeline::load_f32_dst, ctx); break; case kRGB_888x_SkColorType: p->append(SkRasterPipeline::load_8888_dst, ctx); p->append(SkRasterPipeline::force_opaque_dst ); break; @@ -275,6 +277,7 @@ void SkRasterPipelineBlitter::append_store(SkRasterPipeline* p) const { case kRGBA_8888_SkColorType: p->append(SkRasterPipeline::store_8888, ctx); break; case kRGBA_1010102_SkColorType: p->append(SkRasterPipeline::store_1010102, ctx); break; case kRGBA_F16_SkColorType: p->append(SkRasterPipeline::store_f16, ctx); break; + case kRGBA_F32_SkColorType: p->append(SkRasterPipeline::store_f32, ctx); break; case kRGB_888x_SkColorType: p->append(SkRasterPipeline::force_opaque ); p->append(SkRasterPipeline::store_8888, ctx); break; @@ -305,7 +308,7 @@ void SkRasterPipelineBlitter::blitRect(int x, int y, int w, int h) { case 1: sk_memset16(fDst.writable_addr16(x,y), fMemsetColor, w); break; case 2: sk_memset32(fDst.writable_addr32(x,y), fMemsetColor, w); break; case 3: sk_memset64(fDst.writable_addr64(x,y), fMemsetColor, w); break; - default: break; + default: SkASSERT(false); break; } } return; diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp index f872756159..a0a934094e 100644 --- a/src/gpu/SkGr.cpp +++ b/src/gpu/SkGr.cpp @@ -252,6 +252,8 @@ GrPixelConfig SkColorType2GrPixelConfig(const SkColorType type) { return kGray_8_GrPixelConfig; case kRGBA_F16_SkColorType: return kRGBA_half_GrPixelConfig; + case kRGBA_F32_SkColorType: + return kRGBA_float_GrPixelConfig; } SkASSERT(0); // shouldn't get here return kUnknown_GrPixelConfig; diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp index d180ac264d..43979fa290 100644 --- a/src/gpu/gl/GrGLCaps.cpp +++ b/src/gpu/gl/GrGLCaps.cpp @@ -2894,6 +2894,11 @@ bool validate_sized_format(GrGLenum format, SkColorType ct, GrPixelConfig* confi *config = kRGBA_half_GrPixelConfig; } break; + case kRGBA_F32_SkColorType: + if (GR_GL_RGBA32F == format) { + *config = kRGBA_float_GrPixelConfig; + } + break; } return kUnknown_GrPixelConfig != *config; diff --git a/src/gpu/vk/GrVkCaps.cpp b/src/gpu/vk/GrVkCaps.cpp index cc9d0ca815..1a14648642 100644 --- a/src/gpu/vk/GrVkCaps.cpp +++ b/src/gpu/vk/GrVkCaps.cpp @@ -625,6 +625,11 @@ bool validate_image_info(VkFormat format, SkColorType ct, GrPixelConfig* config) *config = kRGBA_half_GrPixelConfig; } break; + case kRGBA_F32_SkColorType: + if (VK_FORMAT_R32G32B32A32_SFLOAT == format) { + *config = kRGBA_float_GrPixelConfig; + } + break; } return kUnknown_GrPixelConfig != *config; diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp index 8f7958444d..2e55ffd336 100644 --- a/src/image/SkSurface_Gpu.cpp +++ b/src/image/SkSurface_Gpu.cpp @@ -269,6 +269,7 @@ bool SkSurface_Gpu::onDraw(const SkDeferredDisplayList* ddl) { bool SkSurface_Gpu::Valid(const SkImageInfo& info) { switch (info.colorType()) { case kRGBA_F16_SkColorType: + case kRGBA_F32_SkColorType: case kRGBA_8888_SkColorType: case kBGRA_8888_SkColorType: return true; @@ -283,6 +284,7 @@ bool SkSurface_Gpu::Valid(const GrCaps* caps, GrPixelConfig config, SkColorSpace case kSBGRA_8888_GrPixelConfig: return caps->srgbSupport(); case kRGBA_half_GrPixelConfig: + case kRGBA_float_GrPixelConfig: case kRGBA_8888_GrPixelConfig: case kBGRA_8888_GrPixelConfig: return true; diff --git a/src/image/SkSurface_Raster.cpp b/src/image/SkSurface_Raster.cpp index 73ff4bab22..4076dff3a0 100644 --- a/src/image/SkSurface_Raster.cpp +++ b/src/image/SkSurface_Raster.cpp @@ -62,6 +62,7 @@ bool SkSurfaceValidateRasterInfo(const SkImageInfo& info, size_t rowBytes) { case kBGRA_8888_SkColorType: break; case kRGBA_F16_SkColorType: + case kRGBA_F32_SkColorType: break; default: return false; diff --git a/src/images/SkImageEncoderFns.h b/src/images/SkImageEncoderFns.h index d8d1c64bb8..6bf0081b26 100644 --- a/src/images/SkImageEncoderFns.h +++ b/src/images/SkImageEncoderFns.h @@ -410,6 +410,39 @@ static inline void transform_scanline_F16_to_premul_8888(char* SK_RESTRICT dst, p.run(0,0, width,1); } +/** + * Transform from kRGBA_F32 to 8-bytes-per-pixel RGBA. + */ +static inline void transform_scanline_F32(char* SK_RESTRICT dst, const char* SK_RESTRICT src, + int width, int, const SkPMColor*) { + SkJumper_MemoryCtx src_ctx = { (void*)src, 0 }, + dst_ctx = { (void*)dst, 0 }; + SkRasterPipeline_<256> p; + p.append(SkRasterPipeline::load_f32, &src_ctx); + p.append(SkRasterPipeline::clamp_0); // F32 values may be out of [0,1] range, so clamp. + p.append(SkRasterPipeline::clamp_1); + p.append(SkRasterPipeline::to_srgb); + p.append(SkRasterPipeline::store_u16_be, &dst_ctx); + p.run(0,0, width,1); +} + +/** + * Transform from kPremul, kRGBA_F32 to 8-bytes-per-pixel RGBA. + */ +static inline void transform_scanline_F32_premul(char* SK_RESTRICT dst, const char* SK_RESTRICT src, + int width, int, const SkPMColor*) { + SkJumper_MemoryCtx src_ctx = { (void*)src, 0 }, + dst_ctx = { (void*)dst, 0 }; + SkRasterPipeline_<256> p; + p.append(SkRasterPipeline::load_f32, &src_ctx); + p.append(SkRasterPipeline::unpremul); + p.append(SkRasterPipeline::clamp_0); // F32 values may be out of [0,1] range, so clamp. + p.append(SkRasterPipeline::clamp_1); + p.append(SkRasterPipeline::to_srgb); + p.append(SkRasterPipeline::store_u16_be, &dst_ctx); + p.run(0,0, width,1); +} + static inline sk_sp<SkData> icc_from_color_space(const SkImageInfo& info) { SkColorSpace* cs = info.colorSpace(); if (!cs) { @@ -417,7 +450,8 @@ static inline sk_sp<SkData> icc_from_color_space(const SkImageInfo& info) { } sk_sp<SkColorSpace> owned; - if (kRGBA_F16_SkColorType == info.colorType()) { + if (kRGBA_F16_SkColorType == info.colorType() || + kRGBA_F32_SkColorType == info.colorType()) { owned = cs->makeSRGBGamma(); cs = owned.get(); } diff --git a/src/images/SkPngEncoder.cpp b/src/images/SkPngEncoder.cpp index fffda73fd0..7520b9044d 100644 --- a/src/images/SkPngEncoder.cpp +++ b/src/images/SkPngEncoder.cpp @@ -106,6 +106,7 @@ bool SkPngEncoderMgr::setHeader(const SkImageInfo& srcInfo, const SkPngEncoder:: int bitDepth = 8; switch (srcInfo.colorType()) { case kRGBA_F16_SkColorType: + case kRGBA_F32_SkColorType: SkASSERT(srcInfo.colorSpace()); sigBit.red = 16; sigBit.green = 16; @@ -288,6 +289,17 @@ static transform_scanline_proc choose_proc(const SkImageInfo& info, SkASSERT(false); return nullptr; } + case kRGBA_F32_SkColorType: + switch (info.alphaType()) { + case kOpaque_SkAlphaType: + case kUnpremul_SkAlphaType: + return transform_scanline_F32; + case kPremul_SkAlphaType: + return transform_scanline_F32_premul; + default: + SkASSERT(false); + return nullptr; + } case kRGBA_1010102_SkColorType: switch (info.alphaType()) { case kOpaque_SkAlphaType: diff --git a/src/opts/SkRasterPipeline_opts.h b/src/opts/SkRasterPipeline_opts.h index fac5d1b93b..2431ad78f9 100644 --- a/src/opts/SkRasterPipeline_opts.h +++ b/src/opts/SkRasterPipeline_opts.h @@ -1712,15 +1712,23 @@ STAGE(store_u16_be, const SkJumper_MemoryCtx* ctx) { } STAGE(load_f32, const SkJumper_MemoryCtx* ctx) { - auto ptr = ptr_at_xy<const float>(ctx, 4*dx,dy); + auto ptr = ptr_at_xy<const float>(ctx, 4*dx,4*dy); load4(ptr,tail, &r,&g,&b,&a); } STAGE(load_f32_dst, const SkJumper_MemoryCtx* ctx) { - auto ptr = ptr_at_xy<const float>(ctx, 4*dx,dy); + auto ptr = ptr_at_xy<const float>(ctx, 4*dx,4*dy); load4(ptr,tail, &dr,&dg,&db,&da); } +STAGE(gather_f32, const SkJumper_GatherCtx* ctx) { + const float* ptr; + U32 ix = ix_and_ptr(&ptr, ctx, r,g); + r = gather(ptr, 4*ix + 0); + g = gather(ptr, 4*ix + 1); + b = gather(ptr, 4*ix + 2); + a = gather(ptr, 4*ix + 3); +} STAGE(store_f32, const SkJumper_MemoryCtx* ctx) { - auto ptr = ptr_at_xy<float>(ctx, 4*dx,dy); + auto ptr = ptr_at_xy<float>(ctx, 4*dx,4*dy); store4(ptr,tail, r,g,b,a); } diff --git a/src/shaders/SkImageShader.cpp b/src/shaders/SkImageShader.cpp index 97bd6cb04e..aa5ecba1ac 100644 --- a/src/shaders/SkImageShader.cpp +++ b/src/shaders/SkImageShader.cpp @@ -369,6 +369,7 @@ bool SkImageShader::onAppendStages(const StageRec& rec) const { case kRGBA_8888_SkColorType: p->append(SkRasterPipeline::gather_8888, ctx); break; case kRGBA_1010102_SkColorType: p->append(SkRasterPipeline::gather_1010102, ctx); break; case kRGBA_F16_SkColorType: p->append(SkRasterPipeline::gather_f16, ctx); break; + case kRGBA_F32_SkColorType: p->append(SkRasterPipeline::gather_f32, ctx); break; case kRGB_888x_SkColorType: p->append(SkRasterPipeline::gather_8888, ctx); p->append(SkRasterPipeline::force_opaque ); break; diff --git a/tests/DeferredDisplayListTest.cpp b/tests/DeferredDisplayListTest.cpp index 697f00328f..afe93ad61c 100644 --- a/tests/DeferredDisplayListTest.cpp +++ b/tests/DeferredDisplayListTest.cpp @@ -132,6 +132,8 @@ static GrBackendFormat create_backend_format(GrContext* context, return GrBackendFormat::MakeGL(GR_GL_RGBA16F, GR_GL_TEXTURE_2D); } break; + case kRGBA_F32_SkColorType: + return GrBackendFormat(); } } break; @@ -199,6 +201,8 @@ static GrBackendFormat create_backend_format(GrContext* context, return GrBackendFormat::MakeVk(VK_FORMAT_R16G16B16A16_SFLOAT); } break; + case kRGBA_F32_SkColorType: + return GrBackendFormat(); } break; #endif @@ -267,6 +271,8 @@ static GrBackendFormat create_backend_format(GrContext* context, return GrBackendFormat::MakeMock(config); } break; + case kRGBA_F32_SkColorType: + return GrBackendFormat(); } break; default: diff --git a/tests/ImageGeneratorTest.cpp b/tests/ImageGeneratorTest.cpp index 0bddcd939d..735e13ee80 100644 --- a/tests/ImageGeneratorTest.cpp +++ b/tests/ImageGeneratorTest.cpp @@ -104,11 +104,13 @@ DEF_TEST(PictureImageGenerator, reporter) { { kRGBA_8888_SkColorType, kPremul_SkAlphaType, kRGBA_8888_SkColorType == kN32_SkColorType }, { kBGRA_8888_SkColorType, kPremul_SkAlphaType, kBGRA_8888_SkColorType == kN32_SkColorType }, { kRGBA_F16_SkColorType, kPremul_SkAlphaType, true }, + { kRGBA_F32_SkColorType, kPremul_SkAlphaType, true }, { kRGBA_1010102_SkColorType, kPremul_SkAlphaType, true }, { kRGBA_8888_SkColorType, kUnpremul_SkAlphaType, false }, { kBGRA_8888_SkColorType, kUnpremul_SkAlphaType, false }, { kRGBA_F16_SkColorType, kUnpremul_SkAlphaType, false }, + { kRGBA_F32_SkColorType, kUnpremul_SkAlphaType, false }, { kRGBA_1010102_SkColorType, kUnpremul_SkAlphaType, false }, }; @@ -118,7 +120,7 @@ DEF_TEST(PictureImageGenerator, reporter) { SkImage::BitDepth::kU8, colorspace); // worst case for all requests - SkAutoMalloc storage(100 * 100 * SkColorTypeBytesPerPixel(kRGBA_F16_SkColorType)); + SkAutoMalloc storage(100 * 100 * SkColorTypeBytesPerPixel(kRGBA_F32_SkColorType)); for (const auto& rec : recs) { SkImageInfo info = SkImageInfo::Make(100, 100, rec.fColorType, rec.fAlphaType, colorspace); diff --git a/tests/SurfaceTest.cpp b/tests/SurfaceTest.cpp index 9a3a3aae6d..3370e76ad8 100644 --- a/tests/SurfaceTest.cpp +++ b/tests/SurfaceTest.cpp @@ -894,7 +894,8 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SurfaceAttachStencil_Gpu, reporter, ctxInf static void test_surface_creation_and_snapshot_with_color_space( skiatest::Reporter* reporter, const char* prefix, - bool f16Support, + bool supportsF16, + bool supportsF32, bool supports1010102, std::function<sk_sp<SkSurface>(const SkImageInfo&)> surfaceMaker) { @@ -914,17 +915,21 @@ static void test_surface_creation_and_snapshot_with_color_space( bool fShouldWork; const char* fDescription; } testConfigs[] = { - { kN32_SkColorType, nullptr, true, "N32-nullptr" }, - { kN32_SkColorType, linearColorSpace, true, "N32-linear" }, - { kN32_SkColorType, srgbColorSpace, true, "N32-srgb" }, - { kN32_SkColorType, oddColorSpace, true, "N32-odd" }, - { kRGBA_F16_SkColorType, nullptr, true, "F16-nullptr" }, - { kRGBA_F16_SkColorType, linearColorSpace, true, "F16-linear" }, - { kRGBA_F16_SkColorType, srgbColorSpace, true, "F16-srgb" }, - { kRGBA_F16_SkColorType, oddColorSpace, true, "F16-odd" }, - { kRGB_565_SkColorType, srgbColorSpace, false, "565-srgb" }, - { kAlpha_8_SkColorType, srgbColorSpace, false, "A8-srgb" }, - { kRGBA_1010102_SkColorType, nullptr, true, "1010102-nullptr" }, + { kN32_SkColorType, nullptr, true, "N32-nullptr" }, + { kN32_SkColorType, linearColorSpace, true, "N32-linear" }, + { kN32_SkColorType, srgbColorSpace, true, "N32-srgb" }, + { kN32_SkColorType, oddColorSpace, true, "N32-odd" }, + { kRGBA_F16_SkColorType, nullptr, supportsF16, "F16-nullptr" }, + { kRGBA_F16_SkColorType, linearColorSpace, supportsF16, "F16-linear" }, + { kRGBA_F16_SkColorType, srgbColorSpace, supportsF16, "F16-srgb" }, + { kRGBA_F16_SkColorType, oddColorSpace, supportsF16, "F16-odd" }, + { kRGBA_F32_SkColorType, nullptr, supportsF32, "F32-nullptr" }, + { kRGBA_F32_SkColorType, linearColorSpace, supportsF32, "F32-linear" }, + { kRGBA_F32_SkColorType, srgbColorSpace, supportsF32, "F32-srgb" }, + { kRGBA_F32_SkColorType, oddColorSpace, supportsF32, "F32-odd" }, + { kRGB_565_SkColorType, srgbColorSpace, false, "565-srgb" }, + { kAlpha_8_SkColorType, srgbColorSpace, false, "A8-srgb" }, + { kRGBA_1010102_SkColorType, nullptr, supports1010102, "1010102-nullptr" }, }; for (auto& testConfig : testConfigs) { @@ -932,16 +937,11 @@ static void test_surface_creation_and_snapshot_with_color_space( SkImageInfo info = SkImageInfo::Make(10, 10, testConfig.fColorType, kPremul_SkAlphaType, testConfig.fColorSpace); - // For some GPU contexts (eg ANGLE), we don't have f16 support, so we should fail to create - // any surface of that type: - bool shouldWork = testConfig.fShouldWork && - (f16Support || kRGBA_F16_SkColorType != testConfig.fColorType) && - (supports1010102 || kRGBA_1010102_SkColorType != testConfig.fColorType); - auto surface(surfaceMaker(info)); - REPORTER_ASSERT(reporter, SkToBool(surface) == shouldWork, fullTestName.c_str()); + REPORTER_ASSERT(reporter, + SkToBool(surface) == testConfig.fShouldWork, fullTestName.c_str()); - if (shouldWork && surface) { + if (testConfig.fShouldWork && surface) { sk_sp<SkImage> image(surface->makeImageSnapshot()); REPORTER_ASSERT(reporter, image, testConfig.fDescription); SkColorSpace* imageColorSpace = as_IB(image)->onImageInfo().colorSpace(); @@ -956,22 +956,25 @@ DEF_TEST(SurfaceCreationWithColorSpace, reporter) { return SkSurface::MakeRaster(info); }; - test_surface_creation_and_snapshot_with_color_space(reporter, "raster", true, true, + test_surface_creation_and_snapshot_with_color_space(reporter, "raster", + true, true, true, surfaceMaker); } DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCreationWithColorSpace_Gpu, reporter, ctxInfo) { auto context = ctxInfo.grContext(); - bool f16Support = context->contextPriv().caps()->isConfigRenderable(kRGBA_half_GrPixelConfig); - bool supports1010102 = - context->contextPriv().caps()->isConfigRenderable(kRGBA_1010102_GrPixelConfig); + bool supportsF16 = context->contextPriv().caps()->isConfigRenderable(kRGBA_half_GrPixelConfig), + supportsF32 = context->contextPriv().caps()->isConfigRenderable(kRGBA_float_GrPixelConfig), + supports1010102 = context->contextPriv().caps()->isConfigRenderable(kRGBA_1010102_GrPixelConfig); + auto surfaceMaker = [context](const SkImageInfo& info) { return SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info); }; - test_surface_creation_and_snapshot_with_color_space(reporter, "gpu", f16Support, - supports1010102, surfaceMaker); + test_surface_creation_and_snapshot_with_color_space(reporter, "gpu", + supportsF16, supportsF32, supports1010102, + surfaceMaker); std::vector<GrBackendTexture> backendTextures; auto wrappedSurfaceMaker = [ context, &backendTextures ](const SkImageInfo& info) { @@ -996,8 +999,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCreationWithColorSpace_Gpu, reporter, sk_ref_sp(info.colorSpace()), nullptr); }; - test_surface_creation_and_snapshot_with_color_space(reporter, "wrapped", f16Support, - supports1010102, wrappedSurfaceMaker); + test_surface_creation_and_snapshot_with_color_space(reporter, "wrapped", + supportsF16, supportsF32, supports1010102, + wrappedSurfaceMaker); context->flush(); diff --git a/tools/sk_tool_utils.cpp b/tools/sk_tool_utils.cpp index 99b03a4391..df4d75fbe1 100644 --- a/tools/sk_tool_utils.cpp +++ b/tools/sk_tool_utils.cpp @@ -55,6 +55,7 @@ const char* colortype_name(SkColorType ct) { case kRGB_101010x_SkColorType: return "RGB_101010x"; case kGray_8_SkColorType: return "Gray_8"; case kRGBA_F16_SkColorType: return "RGBA_F16"; + case kRGBA_F32_SkColorType: return "RGBA_F32"; } SkASSERT(false); return "unexpected colortype"; |