bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2012 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #include "GrConfigConversionEffect.h" |
Brian Salomon | c65aec9 | 2017-03-09 09:03:58 -0500 | [diff] [blame] | 9 | #include "../private/GrGLSL.h" |
| 10 | #include "GrClip.h" |
bsalomon@google.com | b1456d7 | 2012-11-02 18:23:45 +0000 | [diff] [blame] | 11 | #include "GrContext.h" |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 12 | #include "GrRenderTargetContext.h" |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 13 | #include "SkMatrix.h" |
egdaniel | 64c4728 | 2015-11-13 06:54:19 -0800 | [diff] [blame] | 14 | #include "glsl/GrGLSLFragmentProcessor.h" |
egdaniel | 2d721d3 | 2015-11-11 13:06:05 -0800 | [diff] [blame] | 15 | #include "glsl/GrGLSLFragmentShaderBuilder.h" |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 16 | |
egdaniel | 64c4728 | 2015-11-13 06:54:19 -0800 | [diff] [blame] | 17 | class GrGLConfigConversionEffect : public GrGLSLFragmentProcessor { |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 18 | public: |
robertphillips | 9cdb992 | 2016-02-03 12:25:40 -0800 | [diff] [blame] | 19 | void emitCode(EmitArgs& args) override { |
bsalomon | 6c9cd55 | 2016-01-22 07:17:34 -0800 | [diff] [blame] | 20 | const GrConfigConversionEffect& cce = args.fFp.cast<GrConfigConversionEffect>(); |
cdalton | 8528541 | 2016-02-18 12:37:07 -0800 | [diff] [blame] | 21 | GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 22 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame] | 23 | // Use highp throughout the shader to avoid some precision issues on specific GPUs. |
| 24 | fragBuilder->elevateDefaultPrecision(kHigh_GrSLPrecision); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 25 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame] | 26 | if (nullptr == args.fInputColor) { |
| 27 | // could optimize this case, but we aren't for now. |
| 28 | args.fInputColor = "vec4(1)"; |
| 29 | } |
Brian Osman | 9f903e4 | 2017-04-10 13:42:48 -0400 | [diff] [blame] | 30 | |
| 31 | // Aggressively round to the nearest exact (N / 255) floating point value. This lets us |
| 32 | // find a round-trip preserving pair on some GPUs that do odd byte to float conversion. |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 33 | fragBuilder->codeAppendf("vec4 color = floor(%s * 255.0 + 0.5) / 255.0;", args.fInputColor); |
changjun.yang | cecc91c | 2014-08-19 18:24:30 -0700 | [diff] [blame] | 34 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame] | 35 | switch (cce.pmConversion()) { |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 36 | case GrConfigConversionEffect::kToPremul_PMConversion: |
Brian Osman | 9f903e4 | 2017-04-10 13:42:48 -0400 | [diff] [blame] | 37 | fragBuilder->codeAppend( |
| 38 | "color.rgb = floor(color.rgb * color.a * 255.0 + 0.5) / 255.0;"); |
| 39 | break; |
| 40 | |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 41 | case GrConfigConversionEffect::kToUnpremul_PMConversion: |
Brian Osman | 9f903e4 | 2017-04-10 13:42:48 -0400 | [diff] [blame] | 42 | fragBuilder->codeAppend( |
| 43 | "color.rgb = color.a <= 0.0 ? vec3(0,0,0) : floor(color.rgb / color.a * 255.0 + 0.5) / 255.0;"); |
| 44 | break; |
| 45 | |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 46 | default: |
| 47 | SkFAIL("Unknown conversion op."); |
| 48 | break; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 49 | } |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame] | 50 | fragBuilder->codeAppendf("%s = color;", args.fOutputColor); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 51 | } |
| 52 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 53 | static inline void GenKey(const GrProcessor& processor, const GrShaderCaps&, |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 54 | GrProcessorKeyBuilder* b) { |
bsalomon | 6c9cd55 | 2016-01-22 07:17:34 -0800 | [diff] [blame] | 55 | const GrConfigConversionEffect& cce = processor.cast<GrConfigConversionEffect>(); |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 56 | uint32_t key = cce.pmConversion(); |
bsalomon | 63e99f7 | 2014-07-21 08:03:14 -0700 | [diff] [blame] | 57 | b->add32(key); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | private: |
egdaniel | 64c4728 | 2015-11-13 06:54:19 -0800 | [diff] [blame] | 61 | typedef GrGLSLFragmentProcessor INHERITED; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 62 | |
| 63 | }; |
| 64 | |
| 65 | /////////////////////////////////////////////////////////////////////////////// |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame] | 66 | |
| 67 | GrConfigConversionEffect::GrConfigConversionEffect(PMConversion pmConversion) |
| 68 | : INHERITED(kNone_OptimizationFlags) |
Brian Osman | 31f96a6 | 2017-03-24 18:27:56 +0000 | [diff] [blame] | 69 | , fPMConversion(pmConversion) { |
| 70 | this->initClassID<GrConfigConversionEffect>(); |
Robert Phillips | 757914d | 2017-01-25 15:48:30 -0500 | [diff] [blame] | 71 | } |
| 72 | |
bsalomon | 0e08fc1 | 2014-10-15 08:19:04 -0700 | [diff] [blame] | 73 | bool GrConfigConversionEffect::onIsEqual(const GrFragmentProcessor& s) const { |
joshualitt | 49586be | 2014-09-16 08:21:41 -0700 | [diff] [blame] | 74 | const GrConfigConversionEffect& other = s.cast<GrConfigConversionEffect>(); |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 75 | return other.fPMConversion == fPMConversion; |
bsalomon@google.com | 68b58c9 | 2013-01-17 16:50:08 +0000 | [diff] [blame] | 76 | } |
| 77 | |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 78 | /////////////////////////////////////////////////////////////////////////////// |
| 79 | |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 80 | GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConfigConversionEffect); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 81 | |
Hal Canary | 6f6961e | 2017-01-31 13:50:44 -0500 | [diff] [blame] | 82 | #if GR_TEST_UTILS |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 83 | sk_sp<GrFragmentProcessor> GrConfigConversionEffect::TestCreate(GrProcessorTestData* d) { |
joshualitt | 0067ff5 | 2015-07-08 14:26:19 -0700 | [diff] [blame] | 84 | PMConversion pmConv = static_cast<PMConversion>(d->fRandom->nextULessThan(kPMConversionCnt)); |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame] | 85 | return sk_sp<GrFragmentProcessor>(new GrConfigConversionEffect(pmConv)); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 86 | } |
Hal Canary | 6f6961e | 2017-01-31 13:50:44 -0500 | [diff] [blame] | 87 | #endif |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 88 | |
| 89 | /////////////////////////////////////////////////////////////////////////////// |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 90 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 91 | void GrConfigConversionEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps, |
egdaniel | 57d3b03 | 2015-11-13 11:57:27 -0800 | [diff] [blame] | 92 | GrProcessorKeyBuilder* b) const { |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 93 | GrGLConfigConversionEffect::GenKey(*this, caps, b); |
| 94 | } |
| 95 | |
egdaniel | 57d3b03 | 2015-11-13 11:57:27 -0800 | [diff] [blame] | 96 | GrGLSLFragmentProcessor* GrConfigConversionEffect::onCreateGLSLInstance() const { |
bsalomon | 6c9cd55 | 2016-01-22 07:17:34 -0800 | [diff] [blame] | 97 | return new GrGLConfigConversionEffect(); |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 98 | } |
| 99 | |
robertphillips | e85a32d | 2015-02-10 08:16:55 -0800 | [diff] [blame] | 100 | |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 101 | bool GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context) { |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 102 | static constexpr int kSize = 256; |
| 103 | static constexpr GrPixelConfig kConfig = kRGBA_8888_GrPixelConfig; |
| 104 | SkAutoTMalloc<uint32_t> data(kSize * kSize * 3); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 105 | uint32_t* srcData = data.get(); |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 106 | uint32_t* firstRead = data.get() + kSize * kSize; |
| 107 | uint32_t* secondRead = data.get() + 2 * kSize * kSize; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 108 | |
| 109 | // Fill with every possible premultiplied A, color channel value. There will be 256-y duplicate |
| 110 | // values in row y. We set r,g, and b to the same value since they are handled identically. |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 111 | for (int y = 0; y < kSize; ++y) { |
| 112 | for (int x = 0; x < kSize; ++x) { |
| 113 | uint8_t* color = reinterpret_cast<uint8_t*>(&srcData[kSize*y + x]); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 114 | color[3] = y; |
commit-bot@chromium.org | 972f9cd | 2014-03-28 17:58:28 +0000 | [diff] [blame] | 115 | color[2] = SkTMin(x, y); |
| 116 | color[1] = SkTMin(x, y); |
| 117 | color[0] = SkTMin(x, y); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 118 | } |
| 119 | } |
| 120 | |
Robert Phillips | c949ce9 | 2017-01-19 16:59:04 -0500 | [diff] [blame] | 121 | const SkImageInfo ii = SkImageInfo::Make(kSize, kSize, |
| 122 | kRGBA_8888_SkColorType, kPremul_SkAlphaType); |
| 123 | |
Robert Phillips | dd3b3f4 | 2017-04-24 10:57:28 -0400 | [diff] [blame] | 124 | sk_sp<GrRenderTargetContext> readRTC(context->makeDeferredRenderTargetContext( |
| 125 | SkBackingFit::kExact, |
Brian Osman | 693a540 | 2016-10-27 15:13:22 -0400 | [diff] [blame] | 126 | kSize, kSize, |
| 127 | kConfig, nullptr)); |
Robert Phillips | dd3b3f4 | 2017-04-24 10:57:28 -0400 | [diff] [blame] | 128 | sk_sp<GrRenderTargetContext> tempRTC(context->makeDeferredRenderTargetContext( |
| 129 | SkBackingFit::kExact, |
Brian Osman | 693a540 | 2016-10-27 15:13:22 -0400 | [diff] [blame] | 130 | kSize, kSize, |
| 131 | kConfig, nullptr)); |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 132 | if (!readRTC || !readRTC->asTextureProxy() || !tempRTC) { |
| 133 | return false; |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 134 | } |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 135 | GrSurfaceDesc desc; |
bsalomon | 49b264c | 2016-07-19 08:38:09 -0700 | [diff] [blame] | 136 | desc.fWidth = kSize; |
| 137 | desc.fHeight = kSize; |
| 138 | desc.fConfig = kConfig; |
Robert Phillips | 757914d | 2017-01-25 15:48:30 -0500 | [diff] [blame] | 139 | |
Robert Phillips | fbcef6e | 2017-06-15 12:07:18 -0400 | [diff] [blame] | 140 | sk_sp<GrTextureProxy> dataProxy = GrSurfaceProxy::MakeDeferred(context->resourceProvider(), |
| 141 | desc, |
Brian Osman | ce42551 | 2017-03-22 14:37:50 -0400 | [diff] [blame] | 142 | SkBudgeted::kYes, data, 0); |
Robert Phillips | 2f49314 | 2017-03-02 18:18:38 -0500 | [diff] [blame] | 143 | if (!dataProxy) { |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 144 | return false; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 145 | } |
| 146 | |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 147 | static const SkRect kRect = SkRect::MakeIWH(kSize, kSize); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 148 | |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 149 | // We do a PM->UPM draw from dataTex to readTex and read the data. Then we do a UPM->PM draw |
| 150 | // from readTex to tempTex followed by a PM->UPM draw to readTex and finally read the data. |
| 151 | // We then verify that two reads produced the same values. |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 152 | |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 153 | GrPaint paint1; |
| 154 | GrPaint paint2; |
| 155 | GrPaint paint3; |
| 156 | sk_sp<GrFragmentProcessor> pmToUPM(new GrConfigConversionEffect(kToUnpremul_PMConversion)); |
| 157 | sk_sp<GrFragmentProcessor> upmToPM(new GrConfigConversionEffect(kToPremul_PMConversion)); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 158 | |
Robert Phillips | fbcef6e | 2017-06-15 12:07:18 -0400 | [diff] [blame] | 159 | paint1.addColorTextureProcessor(dataProxy, nullptr, SkMatrix::I()); |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 160 | paint1.addColorFragmentProcessor(pmToUPM); |
| 161 | paint1.setPorterDuffXPFactory(SkBlendMode::kSrc); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 162 | |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 163 | readRTC->fillRectToRect(GrNoClip(), std::move(paint1), GrAA::kNo, SkMatrix::I(), kRect, kRect); |
| 164 | if (!readRTC->readPixels(ii, firstRead, 0, 0, 0)) { |
| 165 | return false; |
| 166 | } |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 167 | |
Robert Phillips | fbcef6e | 2017-06-15 12:07:18 -0400 | [diff] [blame] | 168 | paint2.addColorTextureProcessor(readRTC->asTextureProxyRef(), nullptr, |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 169 | SkMatrix::I()); |
| 170 | paint2.addColorFragmentProcessor(std::move(upmToPM)); |
| 171 | paint2.setPorterDuffXPFactory(SkBlendMode::kSrc); |
robertphillips | ff0ca5e | 2015-07-22 11:54:44 -0700 | [diff] [blame] | 172 | |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 173 | tempRTC->fillRectToRect(GrNoClip(), std::move(paint2), GrAA::kNo, SkMatrix::I(), kRect, kRect); |
robertphillips | ff0ca5e | 2015-07-22 11:54:44 -0700 | [diff] [blame] | 174 | |
Robert Phillips | fbcef6e | 2017-06-15 12:07:18 -0400 | [diff] [blame] | 175 | paint3.addColorTextureProcessor(tempRTC->asTextureProxyRef(), nullptr, |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 176 | SkMatrix::I()); |
| 177 | paint3.addColorFragmentProcessor(std::move(pmToUPM)); |
| 178 | paint3.setPorterDuffXPFactory(SkBlendMode::kSrc); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 179 | |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 180 | readRTC->fillRectToRect(GrNoClip(), std::move(paint3), GrAA::kNo, SkMatrix::I(), kRect, kRect); |
robertphillips | ff0ca5e | 2015-07-22 11:54:44 -0700 | [diff] [blame] | 181 | |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 182 | if (!readRTC->readPixels(ii, secondRead, 0, 0, 0)) { |
| 183 | return false; |
| 184 | } |
commit-bot@chromium.org | 42dacab | 2013-07-13 17:24:24 +0000 | [diff] [blame] | 185 | |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 186 | for (int y = 0; y < kSize; ++y) { |
| 187 | for (int x = 0; x <= y; ++x) { |
| 188 | if (firstRead[kSize * y + x] != secondRead[kSize * y + x]) { |
| 189 | return false; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 190 | } |
| 191 | } |
| 192 | } |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 193 | |
| 194 | return true; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 195 | } |
| 196 | |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame] | 197 | sk_sp<GrFragmentProcessor> GrConfigConversionEffect::Make(sk_sp<GrFragmentProcessor> fp, |
| 198 | PMConversion pmConversion) { |
| 199 | if (!fp) { |
Brian Osman | 31f96a6 | 2017-03-24 18:27:56 +0000 | [diff] [blame] | 200 | return nullptr; |
| 201 | } |
Brian Osman | ee80532 | 2017-04-05 10:09:00 -0400 | [diff] [blame] | 202 | sk_sp<GrFragmentProcessor> ccFP(new GrConfigConversionEffect(pmConversion)); |
| 203 | sk_sp<GrFragmentProcessor> fpPipeline[] = { fp, ccFP }; |
| 204 | return GrFragmentProcessor::RunInSeries(fpPipeline, 2); |
Robert Phillips | 757914d | 2017-01-25 15:48:30 -0500 | [diff] [blame] | 205 | } |