diff options
34 files changed, 130 insertions, 137 deletions
diff --git a/bench/GrMipMapBench.cpp b/bench/GrMipMapBench.cpp index 096256c6cc..f4e05a0ac7 100644 --- a/bench/GrMipMapBench.cpp +++ b/bench/GrMipMapBench.cpp @@ -37,7 +37,7 @@ protected: return; } SkImageInfo info = SkImageInfo::Make(fW, fH, kN32_SkColorType, kPremul_SkAlphaType, - SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named)); + kSRGB_SkColorProfileType); fSurface = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info); } diff --git a/bench/nanobench.cpp b/bench/nanobench.cpp index 94402cc770..e5a63a022d 100644 --- a/bench/nanobench.cpp +++ b/bench/nanobench.cpp @@ -424,7 +424,7 @@ static void create_config(const SkCommandLineConfig* config, SkTArray<Config>* c Benchmark::kGPU_Backend, kN32_SkColorType, kPremul_SkAlphaType, - nullptr, + kLinear_SkColorProfileType, sampleCount, ctxType, ctxOptions, @@ -436,29 +436,28 @@ static void create_config(const SkCommandLineConfig* config, SkTArray<Config>* c } #endif - #define CPU_CONFIG(name, backend, color, alpha, colorSpace) \ - if (config->getTag().equals(#name)) { \ - Config config = { \ - SkString(#name), Benchmark::backend, color, alpha, colorSpace, \ - 0, kBogusContextType, kBogusContextOptions, false \ - }; \ - configs->push_back(config); \ - return; \ + #define CPU_CONFIG(name, backend, color, alpha, profile) \ + if (config->getTag().equals(#name)) { \ + Config config = { \ + SkString(#name), Benchmark::backend, color, alpha, profile, \ + 0, kBogusContextType, kBogusContextOptions, false \ + }; \ + configs->push_back(config); \ + return; \ } if (FLAGS_cpu) { CPU_CONFIG(nonrendering, kNonRendering_Backend, - kUnknown_SkColorType, kUnpremul_SkAlphaType, nullptr) + kUnknown_SkColorType, kUnpremul_SkAlphaType, kLinear_SkColorProfileType); CPU_CONFIG(8888, kRaster_Backend, - kN32_SkColorType, kPremul_SkAlphaType, nullptr) + kN32_SkColorType, kPremul_SkAlphaType, kLinear_SkColorProfileType) CPU_CONFIG(565, kRaster_Backend, - kRGB_565_SkColorType, kOpaque_SkAlphaType, nullptr) - auto srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named); + kRGB_565_SkColorType, kOpaque_SkAlphaType, kLinear_SkColorProfileType) CPU_CONFIG(srgb, kRaster_Backend, - kN32_SkColorType, kPremul_SkAlphaType, srgbColorSpace) + kN32_SkColorType, kPremul_SkAlphaType, kSRGB_SkColorProfileType) CPU_CONFIG(f16, kRaster_Backend, - kRGBA_F16_SkColorType, kPremul_SkAlphaType, nullptr) + kRGBA_F16_SkColorType, kPremul_SkAlphaType, kLinear_SkColorProfileType) } #undef CPU_CONFIG @@ -466,7 +465,7 @@ static void create_config(const SkCommandLineConfig* config, SkTArray<Config>* c #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK if (config->getTag().equals("hwui")) { Config config = { SkString("hwui"), Benchmark::kHWUI_Backend, - kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr, + kRGBA_8888_SkColorType, kPremul_SkAlphaType, kLinear_SkColorProfileType, 0, kBogusContextType, kBogusContextOptions, false }; configs->push_back(config); } @@ -489,7 +488,7 @@ static Target* is_enabled(Benchmark* bench, const Config& config) { } SkImageInfo info = SkImageInfo::Make(bench->getSize().fX, bench->getSize().fY, - config.color, config.alpha, config.colorSpace); + config.color, config.alpha, config.profile); Target* target = nullptr; diff --git a/bench/nanobench.h b/bench/nanobench.h index ce1e33ec4f..ceab0f6c4f 100644 --- a/bench/nanobench.h +++ b/bench/nanobench.h @@ -26,7 +26,7 @@ struct Config { Benchmark::Backend backend; SkColorType color; SkAlphaType alpha; - sk_sp<SkColorSpace> colorSpace; + SkColorProfileType profile; int samples; #if SK_SUPPORT_GPU sk_gpu_test::GrContextFactory::ContextType ctxType; @@ -802,8 +802,8 @@ static Sink* create_sink(const SkCommandLineConfig* config) { contextOptions = static_cast<GrContextFactory::ContextOptions>( contextOptions | GrContextFactory::kEnableNVPR_ContextOptions); } - if (SkColorAndColorSpaceAreGammaCorrect(gpuConfig->getColorType(), - gpuConfig->getColorSpace())) { + if (SkColorAndProfileAreGammaCorrect(gpuConfig->getColorType(), + gpuConfig->getProfileType())) { contextOptions = static_cast<GrContextFactory::ContextOptions>( contextOptions | GrContextFactory::kRequireSRGBSupport_ContextOptions); } @@ -815,7 +815,7 @@ static Sink* create_sink(const SkCommandLineConfig* config) { } return new GPUSink(contextType, contextOptions, gpuConfig->getSamples(), gpuConfig->getUseDIText(), gpuConfig->getColorType(), - sk_ref_sp(gpuConfig->getColorSpace()), FLAGS_gpu_threading); + gpuConfig->getProfileType(), FLAGS_gpu_threading); } } #endif @@ -827,11 +827,9 @@ static Sink* create_sink(const SkCommandLineConfig* config) { #endif if (FLAGS_cpu) { - auto srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named); - SINK("565", RasterSink, kRGB_565_SkColorType); SINK("8888", RasterSink, kN32_SkColorType); - SINK("srgb", RasterSink, kN32_SkColorType, srgbColorSpace); + SINK("srgb", RasterSink, kN32_SkColorType, kSRGB_SkColorProfileType); SINK("f16", RasterSink, kRGBA_F16_SkColorType); SINK("pdf", PDFSink); SINK("skp", SKPSink); diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp index 97f1e48664..b252290cd5 100644 --- a/dm/DMSrcSink.cpp +++ b/dm/DMSrcSink.cpp @@ -1060,14 +1060,14 @@ GPUSink::GPUSink(GrContextFactory::ContextType ct, int samples, bool diText, SkColorType colorType, - sk_sp<SkColorSpace> colorSpace, + SkColorProfileType profileType, bool threaded) : fContextType(ct) , fContextOptions(options) , fSampleCount(samples) , fUseDIText(diText) , fColorType(colorType) - , fColorSpace(std::move(colorSpace)) + , fProfileType(profileType) , fThreaded(threaded) {} void PreAbandonGpuContextErrorHandler(SkError, void*) {} @@ -1093,7 +1093,7 @@ Error GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log) co const SkISize size = src.size(); const SkImageInfo info = SkImageInfo::Make(size.width(), size.height(), fColorType, - kPremul_SkAlphaType, fColorSpace); + kPremul_SkAlphaType, fProfileType); #if SK_SUPPORT_GPU GrContext* context = factory.getContextInfo(fContextType, fContextOptions).grContext(); const int maxDimension = context->caps()->maxTextureSize(); @@ -1213,9 +1213,9 @@ Error SVGSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ -RasterSink::RasterSink(SkColorType colorType, sk_sp<SkColorSpace> colorSpace) +RasterSink::RasterSink(SkColorType colorType, SkColorProfileType profileType) : fColorType(colorType) - , fColorSpace(std::move(colorSpace)) {} + , fProfileType(profileType) {} Error RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString*) const { const SkISize size = src.size(); @@ -1225,7 +1225,7 @@ Error RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString*) con SkMallocPixelRef::ZeroedPRFactory factory; dst->allocPixels(SkImageInfo::Make(size.width(), size.height(), - fColorType, alphaType, fColorSpace), + fColorType, alphaType, fProfileType), &factory, nullptr/*colortable*/); SkCanvas canvas(*dst); diff --git a/dm/DMSrcSink.h b/dm/DMSrcSink.h index a2bfbca7f3..8cb2b25bf4 100644 --- a/dm/DMSrcSink.h +++ b/dm/DMSrcSink.h @@ -281,7 +281,7 @@ class GPUSink : public Sink { public: GPUSink(sk_gpu_test::GrContextFactory::ContextType, sk_gpu_test::GrContextFactory::ContextOptions, - int samples, bool diText, SkColorType colorType, sk_sp<SkColorSpace> colorSpace, + int samples, bool diText, SkColorType colorType, SkColorProfileType profileType, bool threaded); Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override; @@ -294,7 +294,7 @@ private: int fSampleCount; bool fUseDIText; SkColorType fColorType; - sk_sp<SkColorSpace> fColorSpace; + SkColorProfileType fProfileType; bool fThreaded; }; @@ -318,14 +318,14 @@ public: class RasterSink : public Sink { public: - explicit RasterSink(SkColorType, sk_sp<SkColorSpace> = nullptr); + explicit RasterSink(SkColorType, SkColorProfileType=kLinear_SkColorProfileType); Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override; const char* fileExtension() const override { return "png"; } SinkFlags flags() const override { return SinkFlags{ SinkFlags::kRaster, SinkFlags::kDirect }; } private: - SkColorType fColorType; - sk_sp<SkColorSpace> fColorSpace; + SkColorType fColorType; + SkColorProfileType fProfileType; }; class SKPSink : public Sink { diff --git a/example/HelloWorld.cpp b/example/HelloWorld.cpp index 32bee5dccd..c2dd7d89f1 100644 --- a/example/HelloWorld.cpp +++ b/example/HelloWorld.cpp @@ -155,9 +155,13 @@ void HelloWorldWindow::draw(SkCanvas* canvas) { if (snap->peekPixels(&pmap)) { const SkImageInfo& info = pmap.info(); fRenderTarget->writePixels(0, 0, snap->width(), snap->height(), - SkImageInfo2GrPixelConfig(info, *fContext->caps()), - pmap.addr(), pmap.rowBytes(), - GrContext::kFlushWrites_PixelOp); + SkImageInfo2GrPixelConfig(info.colorType(), + info.alphaType(), + info.profileType(), + *fContext->caps()), + pmap.addr(), + pmap.rowBytes(), + GrContext::kFlushWrites_PixelOp); } } INHERITED::present(); diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h index b28eca817e..664686619f 100644 --- a/include/core/SkBitmap.h +++ b/include/core/SkBitmap.h @@ -85,7 +85,6 @@ public: int height() const { return fInfo.height(); } SkColorType colorType() const { return fInfo.colorType(); } SkAlphaType alphaType() const { return fInfo.alphaType(); } - SkColorSpace* colorSpace() const { return fInfo.colorSpace(); } SkColorProfileType profileType() const { return fInfo.profileType(); } /** diff --git a/include/core/SkImageInfo.h b/include/core/SkImageInfo.h index f7a619f9ea..c0e0be13f9 100644 --- a/include/core/SkImageInfo.h +++ b/include/core/SkImageInfo.h @@ -379,14 +379,12 @@ private: /////////////////////////////////////////////////////////////////////////////// -static inline bool SkColorAndColorSpaceAreGammaCorrect(SkColorType ct, SkColorSpace* cs) { - // Anything with a color-space attached is gamma-correct, as is F16. - // To get legacy behavior, you need to ask for non-F16, with a nullptr color space. - return (cs != nullptr) || kRGBA_F16_SkColorType == ct; +static inline bool SkColorAndProfileAreGammaCorrect(SkColorType ct, SkColorProfileType pt) { + return kSRGB_SkColorProfileType == pt || kRGBA_F16_SkColorType == ct; } static inline bool SkImageInfoIsGammaCorrect(const SkImageInfo& info) { - return SkColorAndColorSpaceAreGammaCorrect(info.colorType(), info.colorSpace()); + return SkColorAndProfileAreGammaCorrect(info.colorType(), info.profileType()); } #endif diff --git a/include/core/SkPixelRef.h b/include/core/SkPixelRef.h index da85863bdb..90e0de540d 100644 --- a/include/core/SkPixelRef.h +++ b/include/core/SkPixelRef.h @@ -248,7 +248,7 @@ public: * not be created with the given config), or this PixelRef does not support deep * copies. */ - virtual SkPixelRef* deepCopy(SkColorType, SkColorSpace*, const SkIRect* /*subset*/) { + virtual SkPixelRef* deepCopy(SkColorType, SkColorProfileType, const SkIRect* /*subset*/) { return NULL; } diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h index c5ba34403f..edfcd6d813 100644 --- a/include/gpu/SkGr.h +++ b/include/gpu/SkGr.h @@ -72,11 +72,10 @@ GrTexture* GrRefCachedBitmapTexture(GrContext*, const SkBitmap&, const GrTexture SkSourceGammaTreatment); // TODO: Move SkImageInfo2GrPixelConfig to SkGrPriv.h (requires cleanup to SkWindow its subclasses). -GrPixelConfig SkImageInfo2GrPixelConfig(SkColorType, SkAlphaType, const SkColorSpace*, - const GrCaps&); +GrPixelConfig SkImageInfo2GrPixelConfig(SkColorType, SkAlphaType, SkColorProfileType, const GrCaps&); static inline GrPixelConfig SkImageInfo2GrPixelConfig(const SkImageInfo& info, const GrCaps& caps) { - return SkImageInfo2GrPixelConfig(info.colorType(), info.alphaType(), info.colorSpace(), caps); + return SkImageInfo2GrPixelConfig(info.colorType(), info.alphaType(), info.profileType(), caps); } GrTextureParams::FilterMode GrSkFilterQualityToGrFilterMode(SkFilterQuality paintFilterQuality, diff --git a/include/gpu/SkGrPixelRef.h b/include/gpu/SkGrPixelRef.h index 2bbe48fa09..b4dbd9d73f 100644 --- a/include/gpu/SkGrPixelRef.h +++ b/include/gpu/SkGrPixelRef.h @@ -50,7 +50,8 @@ public: protected: // overrides from SkPixelRef bool onReadPixels(SkBitmap* dst, SkColorType, const SkIRect* subset) override; - SkPixelRef* deepCopy(SkColorType, SkColorSpace*, const SkIRect* subset) override; + SkPixelRef* deepCopy(SkColorType, SkColorProfileType, + const SkIRect* subset) override; void onNotifyPixelsChanged() override; private: diff --git a/include/views/SkWindow.h b/include/views/SkWindow.h index 50774849a6..341046aacc 100644 --- a/include/views/SkWindow.h +++ b/include/views/SkWindow.h @@ -52,7 +52,7 @@ public: void resize(int width, int height); void resize(const SkImageInfo&); - void setColorType(SkColorType, sk_sp<SkColorSpace>); + void setColorType(SkColorType, SkColorProfileType); bool isDirty() const { return !fDirtyRgn.isEmpty(); } bool update(SkIRect* updateArea); diff --git a/samplecode/SampleApp.cpp b/samplecode/SampleApp.cpp index b80ea44d30..40ead7482f 100644 --- a/samplecode/SampleApp.cpp +++ b/samplecode/SampleApp.cpp @@ -48,18 +48,17 @@ class GrContext; const struct { SkColorType fColorType; - bool fSRGB; + SkColorProfileType fProfileType; const char* fName; } gConfig[] = { - { kN32_SkColorType, false, "L32" }, - { kN32_SkColorType, true, "S32" }, - { kRGBA_F16_SkColorType, false, "F16" }, + { kN32_SkColorType, kLinear_SkColorProfileType, "L32" }, + { kN32_SkColorType, kSRGB_SkColorProfileType, "S32" }, + { kRGBA_F16_SkColorType, kLinear_SkColorProfileType, "F16" }, }; static const char* find_config_name(const SkImageInfo& info) { for (const auto& config : gConfig) { - if (config.fColorType == info.colorType() && - config.fSRGB == (info.colorSpace() != nullptr)) { + if (config.fColorType == info.colorType() && config.fProfileType == info.profileType()) { return config.fName; } } @@ -1533,9 +1532,7 @@ bool SampleWindow::onEvent(const SkEvent& evt) { return true; } if (SkOSMenu::FindListIndex(evt, "ColorType", &selected)) { - auto srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named); - this->setDeviceColorType(gConfig[selected].fColorType, - gConfig[selected].fSRGB ? srgbColorSpace : nullptr); + this->setDeviceColorType(gConfig[selected].fColorType, gConfig[selected].fProfileType); return true; } if (SkOSMenu::FindSwitchState(evt, "Slide Show", nullptr)) { @@ -1750,8 +1747,8 @@ void SampleWindow::setDeviceType(DeviceType type) { this->inval(nullptr); } -void SampleWindow::setDeviceColorType(SkColorType ct, sk_sp<SkColorSpace> cs) { - this->setColorType(ct, std::move(cs)); +void SampleWindow::setDeviceColorType(SkColorType ct, SkColorProfileType pt) { + this->setColorType(ct, pt); fDevManager->tearDownBackend(this); fDevManager->setUpBackend(this, fMSAASampleCount, fDeepColor); diff --git a/samplecode/SampleApp.h b/samplecode/SampleApp.h index f4be093a66..371133b9a2 100644 --- a/samplecode/SampleApp.h +++ b/samplecode/SampleApp.h @@ -116,7 +116,7 @@ public: void draw(SkCanvas*) override; void setDeviceType(DeviceType type); - void setDeviceColorType(SkColorType, sk_sp<SkColorSpace>); + void setDeviceColorType(SkColorType, SkColorProfileType); void toggleRendering(); void toggleSlideshow(); void toggleFPS(); diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp index 8cb8e4d6fc..10a7e3299c 100644 --- a/src/core/SkBitmap.cpp +++ b/src/core/SkBitmap.cpp @@ -742,7 +742,7 @@ bool SkBitmap::extractSubset(SkBitmap* result, const SkIRect& subset) const { if (fPixelRef->getTexture() != nullptr) { // Do a deep copy - SkPixelRef* pixelRef = fPixelRef->deepCopy(this->colorType(), this->colorSpace(), &subset); + SkPixelRef* pixelRef = fPixelRef->deepCopy(this->colorType(), this->profileType(), &subset); if (pixelRef != nullptr) { SkBitmap dst; dst.setInfo(this->info().makeWH(subset.width(), subset.height())); @@ -911,7 +911,7 @@ bool SkBitmap::copyTo(SkBitmap* dst, SkColorType dstColorType, Allocator* alloc) bool SkBitmap::deepCopyTo(SkBitmap* dst) const { const SkColorType dstCT = this->colorType(); - SkColorSpace* dstCS = this->colorSpace(); + const SkColorProfileType dstPT = this->profileType(); if (!this->canCopyTo(dstCT)) { return false; @@ -920,10 +920,10 @@ bool SkBitmap::deepCopyTo(SkBitmap* dst) const { // If we have a PixelRef, and it supports deep copy, use it. // Currently supported only by texture-backed bitmaps. if (fPixelRef) { - SkPixelRef* pixelRef = fPixelRef->deepCopy(dstCT, dstCS, nullptr); + SkPixelRef* pixelRef = fPixelRef->deepCopy(dstCT, dstPT, nullptr); if (pixelRef) { uint32_t rowBytes; - if (this->colorType() == dstCT && this->colorSpace() == dstCS) { + if (this->colorType() == dstCT && this->profileType() == dstPT) { // Since there is no subset to pass to deepCopy, and deepCopy // succeeded, the new pixel ref must be identical. SkASSERT(fPixelRef->info() == pixelRef->info()); diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp index 2759a3e185..a894f983b5 100644 --- a/src/gpu/SkGpuDevice.cpp +++ b/src/gpu/SkGpuDevice.cpp @@ -213,7 +213,7 @@ sk_sp<GrDrawContext> SkGpuDevice::CreateDrawContext(GrContext* context, SkColorType ct = origInfo.colorType(); SkAlphaType at = origInfo.alphaType(); - SkColorSpace* cs = origInfo.colorSpace(); + SkColorProfileType pt = origInfo.profileType(); if (kRGB_565_SkColorType == ct || kGray_8_SkColorType == ct) { at = kOpaque_SkAlphaType; // force this setting } @@ -221,13 +221,13 @@ sk_sp<GrDrawContext> SkGpuDevice::CreateDrawContext(GrContext* context, at = kPremul_SkAlphaType; // force this setting } - GrPixelConfig origConfig = SkImageInfo2GrPixelConfig(ct, at, cs, *context->caps()); + GrPixelConfig origConfig = SkImageInfo2GrPixelConfig(ct, at, pt, *context->caps()); if (!context->caps()->isConfigRenderable(origConfig, sampleCount > 0)) { // Fall back from whatever ct was to default of kRGBA or kBGRA which is aliased as kN32 ct = kN32_SkColorType; } - GrPixelConfig config = SkImageInfo2GrPixelConfig(ct, at, cs, *context->caps()); + GrPixelConfig config = SkImageInfo2GrPixelConfig(ct, at, pt, *context->caps()); return context->newDrawContext(SkBackingFit::kExact, // Why exact? origInfo.width(), origInfo.height(), diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp index 45100f097b..c2e284154a 100644 --- a/src/gpu/SkGr.cpp +++ b/src/gpu/SkGr.cpp @@ -243,7 +243,7 @@ GrTexture* GrUploadPixmapToTexture(GrContext* ctx, const SkPixmap& pixmap, SkBud GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(pixmap.info(), *caps); if (caps->srgbSupport() && !GrPixelConfigIsSRGB(desc.fConfig) && - pixmap.info().colorSpace() && pixmap.info().colorSpace()->gammaCloseToSRGB()) { + kSRGB_SkColorProfileType == pixmap.info().profileType()) { // We were supplied sRGB as the profile type, but we don't have a suitable pixel config. // Convert to 8888 sRGB so we can handle the data correctly. The raster backend doesn't // handle sRGB Index8 -> sRGB 8888 correctly (yet), so lie about both the source and @@ -418,7 +418,7 @@ GrTexture* GrRefCachedBitmapTexture(GrContext* ctx, const SkBitmap& bitmap, // alphatype is ignore for now, but if GrPixelConfig is expanded to encompass // alpha info, that will be considered. -GrPixelConfig SkImageInfo2GrPixelConfig(SkColorType ct, SkAlphaType, const SkColorSpace* cs, +GrPixelConfig SkImageInfo2GrPixelConfig(SkColorType ct, SkAlphaType, SkColorProfileType pt, const GrCaps& caps) { // We intentionally ignore profile type for non-8888 formats. Anything we can't support // in hardware will be expanded to sRGB 8888 in GrUploadPixmapToTexture. @@ -432,10 +432,10 @@ GrPixelConfig SkImageInfo2GrPixelConfig(SkColorType ct, SkAlphaType, const SkCol case kARGB_4444_SkColorType: return kRGBA_4444_GrPixelConfig; case kRGBA_8888_SkColorType: - return (caps.srgbSupport() && cs && cs->gammaCloseToSRGB()) + return (kSRGB_SkColorProfileType == pt && caps.srgbSupport()) ? kSRGBA_8888_GrPixelConfig : kRGBA_8888_GrPixelConfig; case kBGRA_8888_SkColorType: - return (caps.srgbSupport() && cs && cs->gammaCloseToSRGB()) + return (kSRGB_SkColorProfileType == pt && caps.srgbSupport()) ? kSBGRA_8888_GrPixelConfig : kBGRA_8888_GrPixelConfig; case kIndex_8_SkColorType: return kIndex_8_GrPixelConfig; diff --git a/src/gpu/SkGrPixelRef.cpp b/src/gpu/SkGrPixelRef.cpp index df2300369d..df720da551 100644 --- a/src/gpu/SkGrPixelRef.cpp +++ b/src/gpu/SkGrPixelRef.cpp @@ -50,7 +50,7 @@ bool SkROLockPixelsPixelRef::onLockPixelsAreWritable() const { /////////////////////////////////////////////////////////////////////////////// static SkGrPixelRef* copy_to_new_texture_pixelref(GrTexture* texture, SkColorType dstCT, - SkColorSpace* dstCS, const SkIRect* subset) { + SkColorProfileType dstPT, const SkIRect* subset) { if (nullptr == texture || kUnknown_SkColorType == dstCT) { return nullptr; } @@ -74,7 +74,7 @@ static SkGrPixelRef* copy_to_new_texture_pixelref(GrTexture* texture, SkColorTyp srcRect = *subset; } desc.fFlags = kRenderTarget_GrSurfaceFlag; - desc.fConfig = SkImageInfo2GrPixelConfig(dstCT, kPremul_SkAlphaType, dstCS, *context->caps()); + desc.fConfig = SkImageInfo2GrPixelConfig(dstCT, kPremul_SkAlphaType, dstPT, *context->caps()); desc.fIsMipMapped = false; GrTexture* dst = context->textureProvider()->createTexture(desc, SkBudgeted::kNo, nullptr, 0); @@ -89,7 +89,7 @@ static SkGrPixelRef* copy_to_new_texture_pixelref(GrTexture* texture, SkColorTyp context->flushSurfaceWrites(dst); SkImageInfo info = SkImageInfo::Make(desc.fWidth, desc.fHeight, dstCT, kPremul_SkAlphaType, - sk_ref_sp(dstCS)); + dstPT); SkGrPixelRef* pixelRef = new SkGrPixelRef(info, dst); SkSafeUnref(dst); return pixelRef; @@ -130,7 +130,8 @@ void SkGrPixelRef::onNotifyPixelsChanged() { } } -SkPixelRef* SkGrPixelRef::deepCopy(SkColorType dstCT, SkColorSpace* dstCS, const SkIRect* subset) { +SkPixelRef* SkGrPixelRef::deepCopy(SkColorType dstCT, SkColorProfileType dstPT, + const SkIRect* subset) { if (nullptr == fSurface) { return nullptr; } @@ -141,7 +142,7 @@ SkPixelRef* SkGrPixelRef::deepCopy(SkColorType dstCT, SkColorSpace* dstCS, const // a GrTexture owned elsewhere (e.g., SkGpuDevice), and cannot live // independently of that texture. Texture-backed pixel refs, on the other // hand, own their GrTextures, and are thus self-contained. - return copy_to_new_texture_pixelref(fSurface->asTexture(), dstCT, dstCS, subset); + return copy_to_new_texture_pixelref(fSurface->asTexture(), dstCT, dstPT, subset); } static bool tryAllocBitmapPixels(SkBitmap* bitmap) { @@ -182,7 +183,7 @@ bool SkGrPixelRef::onReadPixels(SkBitmap* dst, SkColorType colorType, const SkIR SkBitmap cachedBitmap; cachedBitmap.setInfo(SkImageInfo::Make(bounds.width(), bounds.height(), colorType, this->info().alphaType(), - sk_ref_sp(this->info().colorSpace()))); + this->info().profileType())); // If we can't alloc the pixels, then fail if (!tryAllocBitmapPixels(&cachedBitmap)) { diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp index 7ce6450058..7f459376e7 100644 --- a/src/image/SkImage_Gpu.cpp +++ b/src/image/SkImage_Gpu.cpp @@ -111,7 +111,9 @@ static void apply_premul(const SkImageInfo& info, void* pixels, size_t rowBytes) bool SkImage_Gpu::onReadPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, int srcX, int srcY, CachingHint) const { - GrPixelConfig config = SkImageInfo2GrPixelConfig(info, *fTexture->getContext()->caps()); + GrPixelConfig config = SkImageInfo2GrPixelConfig(info.colorType(), info.alphaType(), + info.profileType(), + *fTexture->getContext()->caps()); uint32_t flags = 0; if (kUnpremul_SkAlphaType == info.alphaType() && kPremul_SkAlphaType == fAlphaType) { // let the GPU perform this transformation for us diff --git a/src/views/SkWindow.cpp b/src/views/SkWindow.cpp index 9165c08ebe..d06d6bb9eb 100644 --- a/src/views/SkWindow.cpp +++ b/src/views/SkWindow.cpp @@ -67,16 +67,15 @@ void SkWindow::resize(int width, int height) { this->resize(fBitmap.info().makeWH(width, height)); } -void SkWindow::setColorType(SkColorType ct, sk_sp<SkColorSpace> cs) { +void SkWindow::setColorType(SkColorType ct, SkColorProfileType pt) { const SkImageInfo& info = fBitmap.info(); - this->resize(SkImageInfo::Make(info.width(), info.height(), ct, kPremul_SkAlphaType, cs)); + this->resize(SkImageInfo::Make(info.width(), info.height(), ct, kPremul_SkAlphaType, pt)); // Set the global flag that enables or disables "legacy" mode, depending on our format. // With sRGB 32-bit or linear FP 16, we turn on gamma-correct handling of inputs: SkSurfaceProps props = this->getSurfaceProps(); uint32_t flags = (props.flags() & ~SkSurfaceProps::kGammaCorrect_Flag) | - (SkColorAndColorSpaceAreGammaCorrect(ct, cs.get()) - ? SkSurfaceProps::kGammaCorrect_Flag : 0); + (SkColorAndProfileAreGammaCorrect(ct, pt) ? SkSurfaceProps::kGammaCorrect_Flag : 0); this->setSurfaceProps(SkSurfaceProps(flags, props.pixelGeometry())); } diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp index a4dbae9eb7..a4c36ffa5d 100644 --- a/tests/ReadPixelsTest.cpp +++ b/tests/ReadPixelsTest.cpp @@ -424,7 +424,7 @@ static void test_readpixels_texture(skiatest::Reporter* reporter, GrTexture* tex GrPixelConfig dstConfig = SkImageInfo2GrPixelConfig(gReadPixelsConfigs[c].fColorType, gReadPixelsConfigs[c].fAlphaType, - nullptr, + kLinear_SkColorProfileType, *texture->getContext()->caps()); uint32_t flags = 0; if (gReadPixelsConfigs[c].fAlphaType == kUnpremul_SkAlphaType) { diff --git a/tests/TestConfigParsing.cpp b/tests/TestConfigParsing.cpp index 63bf120f02..4d64cafb16 100644 --- a/tests/TestConfigParsing.cpp +++ b/tests/TestConfigParsing.cpp @@ -46,7 +46,8 @@ DEF_TEST(ParseConfigs_Gpu, reporter) { REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getUseDIText() == false); REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getSamples() == 0); REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getColorType() == kN32_SkColorType); - REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getColorSpace() == nullptr); + REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getProfileType() + == kLinear_SkColorProfileType); #endif } @@ -82,8 +83,6 @@ DEF_TEST(ParseConfigs_DefaultConfigs, reporter) { SkCommandLineConfigArray configs; ParseConfigs(config1, &configs); - auto srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named); - REPORTER_ASSERT(reporter, configs.count() == config1.count()); for (int i = 0; i < config1.count(); ++i) { REPORTER_ASSERT(reporter, configs[i]->getTag().equals(config1[i])); @@ -119,11 +118,14 @@ DEF_TEST(ParseConfigs_DefaultConfigs, reporter) { REPORTER_ASSERT(reporter, !configs[18]->asConfigGpu()); REPORTER_ASSERT(reporter, !configs[19]->asConfigGpu()); REPORTER_ASSERT(reporter, !configs[24]->asConfigGpu()); - REPORTER_ASSERT(reporter, configs[25]->asConfigGpu()->getColorType() == kRGBA_F16_SkColorType); - REPORTER_ASSERT(reporter, configs[25]->asConfigGpu()->getColorSpace() == nullptr); - REPORTER_ASSERT(reporter, configs[26]->asConfigGpu()->getColorType() == kN32_SkColorType); - REPORTER_ASSERT(reporter, configs[26]->asConfigGpu()->getColorSpace() == srgbColorSpace.get()); - + REPORTER_ASSERT(reporter, configs[25]->asConfigGpu()->getColorType() + == kRGBA_F16_SkColorType); + REPORTER_ASSERT(reporter, configs[25]->asConfigGpu()->getProfileType() + == kLinear_SkColorProfileType); + REPORTER_ASSERT(reporter, configs[26]->asConfigGpu()->getColorType() + == kN32_SkColorType); + REPORTER_ASSERT(reporter, configs[26]->asConfigGpu()->getProfileType() + == kSRGB_SkColorProfileType); #if SK_ANGLE #ifdef SK_BUILD_FOR_WIN REPORTER_ASSERT(reporter, configs[20]->asConfigGpu()); @@ -155,7 +157,8 @@ DEF_TEST(ParseConfigs_DefaultConfigs, reporter) { REPORTER_ASSERT(reporter, configs[29]->asConfigGpu()->getUseDIText()); REPORTER_ASSERT(reporter, configs[30]->asConfigGpu()); REPORTER_ASSERT(reporter, configs[30]->asConfigGpu()->getColorType() == kN32_SkColorType); - REPORTER_ASSERT(reporter, configs[30]->asConfigGpu()->getColorSpace() == srgbColorSpace.get()); + REPORTER_ASSERT(reporter, configs[30]->asConfigGpu()->getProfileType() == + kSRGB_SkColorProfileType); REPORTER_ASSERT(reporter, configs[31]->asConfigGpu()); REPORTER_ASSERT(reporter, configs[31]->asConfigGpu()->getSamples() == 4); #ifdef SK_VULKAN diff --git a/tools/flags/SkCommonFlagsConfig.cpp b/tools/flags/SkCommonFlagsConfig.cpp index d5c7a1d5bf..1c7920eb55 100644 --- a/tools/flags/SkCommonFlagsConfig.cpp +++ b/tools/flags/SkCommonFlagsConfig.cpp @@ -192,14 +192,14 @@ SkCommandLineConfig::~SkCommandLineConfig() { SkCommandLineConfigGpu::SkCommandLineConfigGpu( const SkString& tag, const SkTArray<SkString>& viaParts, ContextType contextType, bool useNVPR, bool useDIText, int samples, - SkColorType colorType, sk_sp<SkColorSpace> colorSpace) + SkColorType colorType, SkColorProfileType profileType) : SkCommandLineConfig(tag, SkString("gpu"), viaParts) , fContextType(contextType) , fUseNVPR(useNVPR) , fUseDIText(useDIText) , fSamples(samples) , fColorType(colorType) - , fColorSpace(std::move(colorSpace)) { + , fProfileType(profileType) { } static bool parse_option_int(const SkString& value, int* outInt) { if (value.isEmpty()) { @@ -276,20 +276,20 @@ static bool parse_option_gpu_api(const SkString& value, } static bool parse_option_gpu_color(const SkString& value, SkColorType* outColorType, - sk_sp<SkColorSpace>* outColorSpace) { + SkColorProfileType* outProfileType) { if (value.equals("8888")) { *outColorType = kN32_SkColorType; - *outColorSpace = nullptr; + *outProfileType = kLinear_SkColorProfileType; return true; } if (value.equals("f16")) { *outColorType = kRGBA_F16_SkColorType; - *outColorSpace = nullptr; + *outProfileType = kLinear_SkColorProfileType; return true; } if (value.equals("srgb")) { *outColorType = kN32_SkColorType; - *outColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named); + *outProfileType = kSRGB_SkColorProfileType; return true; } return false; @@ -309,7 +309,7 @@ SkCommandLineConfigGpu* parse_command_line_config_gpu(const SkString& tag, int samples = 0; bool seenColor = false; SkColorType colorType = kN32_SkColorType; - sk_sp<SkColorSpace> colorSpace = nullptr; + SkColorProfileType profileType = kLinear_SkColorProfileType; SkTArray<SkString> optionParts; SkStrSplit(options.c_str(), ",", kStrict_SkStrSplitMode, &optionParts); @@ -335,7 +335,7 @@ SkCommandLineConfigGpu* parse_command_line_config_gpu(const SkString& tag, valueOk = parse_option_int(value, &samples); seenSamples = true; } else if (key.equals("color") && !seenColor) { - valueOk = parse_option_gpu_color(value, &colorType, &colorSpace); + valueOk = parse_option_gpu_color(value, &colorType, &profileType); seenColor = true; } if (!valueOk) { @@ -343,7 +343,7 @@ SkCommandLineConfigGpu* parse_command_line_config_gpu(const SkString& tag, } } return new SkCommandLineConfigGpu(tag, vias, contextType, useNVPR, useDIText, samples, - colorType, colorSpace); + colorType, profileType); } #endif diff --git a/tools/flags/SkCommonFlagsConfig.h b/tools/flags/SkCommonFlagsConfig.h index dc38977cb8..5d95ef186a 100644 --- a/tools/flags/SkCommonFlagsConfig.h +++ b/tools/flags/SkCommonFlagsConfig.h @@ -53,14 +53,14 @@ class SkCommandLineConfigGpu : public SkCommandLineConfig { typedef sk_gpu_test::GrContextFactory::ContextType ContextType; SkCommandLineConfigGpu(const SkString& tag, const SkTArray<SkString>& viaParts, ContextType contextType, bool useNVPR, bool useDIText, int samples, - SkColorType colorType, sk_sp<SkColorSpace> colorSpace); + SkColorType colorType, SkColorProfileType profileType); const SkCommandLineConfigGpu* asConfigGpu() const override { return this; } ContextType getContextType() const { return fContextType; } bool getUseNVPR() const { return fUseNVPR; } bool getUseDIText() const { return fUseDIText; } int getSamples() const { return fSamples; } SkColorType getColorType() const { return fColorType; } - SkColorSpace* getColorSpace() const { return fColorSpace.get(); } + SkColorProfileType getProfileType() const { return fProfileType; } private: ContextType fContextType; @@ -68,7 +68,7 @@ class SkCommandLineConfigGpu : public SkCommandLineConfig { bool fUseDIText; int fSamples; SkColorType fColorType; - sk_sp<SkColorSpace> fColorSpace; + SkColorProfileType fProfileType; }; #endif diff --git a/tools/picture_utils.cpp b/tools/picture_utils.cpp index a6803c67db..63a48ce3e1 100644 --- a/tools/picture_utils.cpp +++ b/tools/picture_utils.cpp @@ -80,9 +80,8 @@ namespace sk_tools { SkAutoTMalloc<uint32_t> rgba(w*h); - auto srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named); - if (bitmap. colorType() == kN32_SkColorType && - bitmap.colorSpace() == srgbColorSpace.get()) { + if (bitmap. colorType() == kN32_SkColorType && + bitmap.profileType() == kSRGB_SkColorProfileType) { // These are premul sRGB 8-bit pixels in SkPMColor order. // We want unpremul sRGB 8-bit pixels in RGBA order. We'll get there via floats. bitmap.lockPixels(); diff --git a/tools/skiaserve/Request.cpp b/tools/skiaserve/Request.cpp index 756f70e24d..c3eaaff387 100644 --- a/tools/skiaserve/Request.cpp +++ b/tools/skiaserve/Request.cpp @@ -159,14 +159,14 @@ namespace { struct ColorAndProfile { SkColorType fColorType; - bool fSRGB; + SkColorProfileType fProfileType; bool fGammaCorrect; }; ColorAndProfile ColorModes[] = { - { kN32_SkColorType, false, false }, - { kN32_SkColorType, true, true }, - { kRGBA_F16_SkColorType, false, true }, + { kN32_SkColorType, kLinear_SkColorProfileType, false }, + { kN32_SkColorType, kSRGB_SkColorProfileType, true }, + { kRGBA_F16_SkColorType, kLinear_SkColorProfileType, true }, }; } @@ -174,9 +174,8 @@ ColorAndProfile ColorModes[] = { SkSurface* Request::createCPUSurface() { SkIRect bounds = this->getBounds(); ColorAndProfile cap = ColorModes[fColorMode]; - auto srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named); SkImageInfo info = SkImageInfo::Make(bounds.width(), bounds.height(), cap.fColorType, - kPremul_SkAlphaType, cap.fSRGB ? srgbColorSpace : nullptr); + kPremul_SkAlphaType, cap.fProfileType); uint32_t flags = cap.fGammaCorrect ? SkSurfaceProps::kGammaCorrect_Flag : 0; SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType); return SkSurface::MakeRaster(info, &props).release(); @@ -186,9 +185,8 @@ SkSurface* Request::createGPUSurface() { GrContext* context = this->getContext(); SkIRect bounds = this->getBounds(); ColorAndProfile cap = ColorModes[fColorMode]; - auto srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named); SkImageInfo info = SkImageInfo::Make(bounds.width(), bounds.height(), cap.fColorType, - kPremul_SkAlphaType, cap.fSRGB ? srgbColorSpace : nullptr); + kPremul_SkAlphaType, cap.fProfileType); uint32_t flags = cap.fGammaCorrect ? SkSurfaceProps::kGammaCorrect_Flag : 0; SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType); SkSurface* surface = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0, diff --git a/tools/viewer/Viewer.cpp b/tools/viewer/Viewer.cpp index 9aec01f3ec..43697f88b8 100644 --- a/tools/viewer/Viewer.cpp +++ b/tools/viewer/Viewer.cpp @@ -122,8 +122,8 @@ Viewer::Viewer(int argc, char** argv, void* platformData) }); fCommands.addCommand('c', "Modes", "Toggle sRGB color mode", [this]() { DisplayParams params = fWindow->getDisplayParams(); - params.fColorSpace = (nullptr == params.fColorSpace) - ? SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named) : nullptr; + params.fProfileType = (kLinear_SkColorProfileType == params.fProfileType) + ? kSRGB_SkColorProfileType : kLinear_SkColorProfileType; fWindow->setDisplayParams(params); this->updateTitle(); fWindow->inval(); @@ -266,9 +266,7 @@ Viewer::~Viewer() { void Viewer::updateTitle() { SkString title("Viewer: "); title.append(fSlides[fCurrentSlide]->getName()); - - // TODO: For now, any color-space on the window means sRGB - if (fWindow->getDisplayParams().fColorSpace) { + if (kSRGB_SkColorProfileType == fWindow->getDisplayParams().fProfileType) { title.append(" sRGB"); } title.append(kBackendTypeStrings[fBackendType]); diff --git a/tools/viewer/sk_app/DisplayParams.h b/tools/viewer/sk_app/DisplayParams.h index b9a23f322d..8756ff0aac 100644 --- a/tools/viewer/sk_app/DisplayParams.h +++ b/tools/viewer/sk_app/DisplayParams.h @@ -14,14 +14,14 @@ namespace sk_app { struct DisplayParams { DisplayParams() : fColorType(kN32_SkColorType) - , fColorSpace(nullptr) + , fProfileType(kLinear_SkColorProfileType) , fMSAASampleCount(0) , fDeepColor(false) {} - SkColorType fColorType; - sk_sp<SkColorSpace> fColorSpace; - int fMSAASampleCount; - bool fDeepColor; + SkColorType fColorType; + SkColorProfileType fProfileType; + int fMSAASampleCount; + bool fDeepColor; }; } // namespace sk_app diff --git a/tools/viewer/sk_app/GLWindowContext.cpp b/tools/viewer/sk_app/GLWindowContext.cpp index b960da4824..a491321a2a 100644 --- a/tools/viewer/sk_app/GLWindowContext.cpp +++ b/tools/viewer/sk_app/GLWindowContext.cpp @@ -47,8 +47,8 @@ void GLWindowContext::initializeContext(void* platformData, const DisplayParams& // ... and, if we're using a 10-bit/channel FB0, it doesn't do sRGB conversion on write, // so pretend that it's non-sRGB 8888: fPixelConfig = fContext->caps()->srgbSupport() && - SkColorAndColorSpaceAreGammaCorrect(fDisplayParams.fColorType, - fDisplayParams.fColorSpace.get()) && + SkColorAndProfileAreGammaCorrect(fDisplayParams.fColorType, + fDisplayParams.fProfileType) && (fColorBits != 30) ? kSkiaGamma8888_GrPixelConfig : kSkia8888_GrPixelConfig; } diff --git a/tools/viewer/sk_app/VulkanWindowContext.cpp b/tools/viewer/sk_app/VulkanWindowContext.cpp index d892cd4783..9bcf6ca25d 100644 --- a/tools/viewer/sk_app/VulkanWindowContext.cpp +++ b/tools/viewer/sk_app/VulkanWindowContext.cpp @@ -173,8 +173,7 @@ bool VulkanWindowContext::createSwapchain(uint32_t width, uint32_t height, // Pick our surface format. For now, just make sure it matches our sRGB request: VkFormat surfaceFormat = VK_FORMAT_UNDEFINED; VkColorSpaceKHR colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR; - auto srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named); - bool wantSRGB = srgbColorSpace == params.fColorSpace; + bool wantSRGB = kSRGB_SkColorProfileType == params.fProfileType; for (uint32_t i = 0; i < surfaceFormatCount; ++i) { GrPixelConfig config; if (GrVkFormatToPixelConfig(surfaceFormats[i].format, &config) && diff --git a/tools/viewer/sk_app/WindowContext.cpp b/tools/viewer/sk_app/WindowContext.cpp index ecac2cc004..41bbd14576 100755 --- a/tools/viewer/sk_app/WindowContext.cpp +++ b/tools/viewer/sk_app/WindowContext.cpp @@ -36,7 +36,7 @@ sk_sp<SkSurface> WindowContext::createRenderSurface(sk_sp<GrRenderTarget> rt, in SkImageInfo info = SkImageInfo::Make(fWidth, fHeight, fDisplayParams.fColorType, kUnknown_SkAlphaType, - fDisplayParams.fColorSpace); + fDisplayParams.fProfileType); return SkSurface::MakeRenderTarget(fContext, SkBudgeted::kNo, info, fDisplayParams.fMSAASampleCount, &props); } else { @@ -52,7 +52,7 @@ void WindowContext::presentRenderSurface(sk_sp<SkSurface> renderSurface, sk_sp<G SkImageInfo info = SkImageInfo::Make(fWidth, fHeight, fDisplayParams.fColorType, kUnknown_SkAlphaType, - fDisplayParams.fColorSpace); + fDisplayParams.fProfileType); SkBitmap bm; bm.allocPixels(info); renderSurface->getCanvas()->readPixels(&bm, 0, 0); diff --git a/tools/viewer/sk_app/android/GLWindowContext_android.cpp b/tools/viewer/sk_app/android/GLWindowContext_android.cpp index be62ab2b68..79425b4115 100644 --- a/tools/viewer/sk_app/android/GLWindowContext_android.cpp +++ b/tools/viewer/sk_app/android/GLWindowContext_android.cpp @@ -99,8 +99,7 @@ void GLWindowContext_android::onInitializeContext(void* platformData, const Disp EGL_NONE, }; const EGLint* windowAttribs = nullptr; - auto srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named); - if (srgbColorSpace == params.fColorSpace && majorVersion == 1 && minorVersion >= 2) { + if (kSRGB_SkColorProfileType == params.fProfileType && majorVersion == 1 && minorVersion >= 2) { windowAttribs = srgbWindowAttribs; } diff --git a/tools/viewer/sk_app/android/RasterWindowContext_android.cpp b/tools/viewer/sk_app/android/RasterWindowContext_android.cpp index a5f9a657fe..5e1e351b9a 100644 --- a/tools/viewer/sk_app/android/RasterWindowContext_android.cpp +++ b/tools/viewer/sk_app/android/RasterWindowContext_android.cpp @@ -68,7 +68,7 @@ sk_sp<SkSurface> RasterWindowContext_android::getBackbufferSurface() { SkImageInfo info = SkImageInfo::Make(fWidth, fHeight, fDisplayParams.fColorType, kOpaque_SkAlphaType, - fDisplayParams.fColorSpace); + fDisplayParams.fProfileType); fBackbufferSurface = SkSurface::MakeRasterDirect( info, fBuffer.bits, fBuffer.stride * bytePerPixel, nullptr); } |