The Tor Browser / file comparison
comparison: gfx/skia/trunk/src/gpu/effects/GrConfigConversionEffect.cpp
gfx/skia/trunk/src/gpu/effects/GrConfigConversionEffect.cpp
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:3f40f9783b8f |
|---|---|
| 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" | |
| 9 #include "GrContext.h" | |
| 10 #include "GrTBackendEffectFactory.h" | |
| 11 #include "GrSimpleTextureEffect.h" | |
| 12 #include "gl/GrGLEffect.h" | |
| 13 #include "SkMatrix.h" | |
| 14 | |
| 15 class GrGLConfigConversionEffect : public GrGLEffect { | |
| 16 public: | |
| 17 GrGLConfigConversionEffect(const GrBackendEffectFactory& factory, | |
| 18 const GrDrawEffect& drawEffect) | |
| 19 : INHERITED (factory) { | |
| 20 const GrConfigConversionEffect& effect = drawEffect.castEffect<GrConfigConversionEffect>(); | |
| 21 fSwapRedAndBlue = effect.swapsRedAndBlue(); | |
| 22 fPMConversion = effect.pmConversion(); | |
| 23 } | |
| 24 | |
| 25 virtual void emitCode(GrGLShaderBuilder* builder, | |
| 26 const GrDrawEffect&, | |
| 27 EffectKey key, | |
| 28 const char* outputColor, | |
| 29 const char* inputColor, | |
| 30 const TransformedCoordsArray& coords, | |
| 31 const TextureSamplerArray& samplers) SK_OVERRIDE { | |
| 32 builder->fsCodeAppendf("\t\t%s = ", outputColor); | |
| 33 builder->fsAppendTextureLookup(samplers[0], coords[0].c_str(), coords[0].type()); | |
| 34 builder->fsCodeAppend(";\n"); | |
| 35 if (GrConfigConversionEffect::kNone_PMConversion == fPMConversion) { | |
| 36 SkASSERT(fSwapRedAndBlue); | |
| 37 builder->fsCodeAppendf("\t%s = %s.bgra;\n", outputColor, outputColor); | |
| 38 } else { | |
| 39 const char* swiz = fSwapRedAndBlue ? "bgr" : "rgb"; | |
| 40 switch (fPMConversion) { | |
| 41 case GrConfigConversionEffect::kMulByAlpha_RoundUp_PMConversion: | |
| 42 builder->fsCodeAppendf( | |
| 43 "\t\t%s = vec4(ceil(%s.%s * %s.a * 255.0) / 255.0, %s.a);\n", | |
| 44 outputColor, outputColor, swiz, outputColor, outputColor); | |
| 45 break; | |
| 46 case GrConfigConversionEffect::kMulByAlpha_RoundDown_PMConversion: | |
| 47 // Add a compensation(0.001) here to avoid the side effect of the floor operation. | |
| 48 // In Intel GPUs, the integer value converted from floor(%s.r * 255.0) / 255.0 | |
| 49 // is less than the integer value converted from %s.r by 1 when the %s.r is | |
| 50 // converted from the integer value 2^n, such as 1, 2, 4, 8, etc. | |
| 51 builder->fsCodeAppendf( | |
| 52 "\t\t%s = vec4(floor(%s.%s * %s.a * 255.0 + 0.001) / 255.0, %s.a);\n", | |
| 53 outputColor, outputColor, swiz, outputColor, outputColor); | |
| 54 break; | |
| 55 case GrConfigConversionEffect::kDivByAlpha_RoundUp_PMConversion: | |
| 56 builder->fsCodeAppendf("\t\t%s = %s.a <= 0.0 ? vec4(0,0,0,0) : vec4(ceil(%s.%s / %s.a * 255.0) / 255.0, %s.a);\n", | |
| 57 outputColor, outputColor, outputColor, swiz, outputColor, outputColor); | |
| 58 break; | |
| 59 case GrConfigConversionEffect::kDivByAlpha_RoundDown_PMConversion: | |
| 60 builder->fsCodeAppendf("\t\t%s = %s.a <= 0.0 ? vec4(0,0,0,0) : vec4(floor(%s.%s / %s.a * 255.0) / 255.0, %s.a);\n", | |
| 61 outputColor, outputColor, outputColor, swiz, outputColor, outputColor); | |
| 62 break; | |
| 63 default: | |
| 64 GrCrash("Unknown conversion op."); | |
| 65 break; | |
| 66 } | |
| 67 } | |
| 68 SkString modulate; | |
| 69 GrGLSLMulVarBy4f(&modulate, 2, outputColor, inputColor); | |
| 70 builder->fsCodeAppend(modulate.c_str()); | |
| 71 } | |
| 72 | |
| 73 static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) { | |
| 74 const GrConfigConversionEffect& conv = drawEffect.castEffect<GrConfigConversionEffect>(); | |
| 75 return static_cast<EffectKey>(conv.swapsRedAndBlue()) | (conv.pmConversion() << 1); | |
| 76 } | |
| 77 | |
| 78 private: | |
| 79 bool fSwapRedAndBlue; | |
| 80 GrConfigConversionEffect::PMConversion fPMConversion; | |
| 81 | |
| 82 typedef GrGLEffect INHERITED; | |
| 83 | |
| 84 }; | |
| 85 | |
| 86 /////////////////////////////////////////////////////////////////////////////// | |
| 87 | |
| 88 GrConfigConversionEffect::GrConfigConversionEffect(GrTexture* texture, | |
| 89 bool swapRedAndBlue, | |
| 90 PMConversion pmConversion, | |
| 91 const SkMatrix& matrix) | |
| 92 : GrSingleTextureEffect(texture, matrix) | |
| 93 , fSwapRedAndBlue(swapRedAndBlue) | |
| 94 , fPMConversion(pmConversion) { | |
| 95 SkASSERT(kRGBA_8888_GrPixelConfig == texture->config() || | |
| 96 kBGRA_8888_GrPixelConfig == texture->config()); | |
| 97 // Why did we pollute our texture cache instead of using a GrSingleTextureEffect? | |
| 98 SkASSERT(swapRedAndBlue || kNone_PMConversion != pmConversion); | |
| 99 } | |
| 100 | |
| 101 const GrBackendEffectFactory& GrConfigConversionEffect::getFactory() const { | |
| 102 return GrTBackendEffectFactory<GrConfigConversionEffect>::getInstance(); | |
| 103 } | |
| 104 | |
| 105 bool GrConfigConversionEffect::onIsEqual(const GrEffect& s) const { | |
| 106 const GrConfigConversionEffect& other = CastEffect<GrConfigConversionEffect>(s); | |
| 107 return this->texture(0) == s.texture(0) && | |
| 108 other.fSwapRedAndBlue == fSwapRedAndBlue && | |
| 109 other.fPMConversion == fPMConversion; | |
| 110 } | |
| 111 | |
| 112 void GrConfigConversionEffect::getConstantColorComponents(GrColor* color, | |
| 113 uint32_t* validFlags) const { | |
| 114 this->updateConstantColorComponentsForModulation(color, validFlags); | |
| 115 } | |
| 116 | |
| 117 /////////////////////////////////////////////////////////////////////////////// | |
| 118 | |
| 119 GR_DEFINE_EFFECT_TEST(GrConfigConversionEffect); | |
| 120 | |
| 121 GrEffectRef* GrConfigConversionEffect::TestCreate(SkRandom* random, | |
| 122 GrContext*, | |
| 123 const GrDrawTargetCaps&, | |
| 124 GrTexture* textures[]) { | |
| 125 PMConversion pmConv = static_cast<PMConversion>(random->nextULessThan(kPMConversionCnt)); | |
| 126 bool swapRB; | |
| 127 if (kNone_PMConversion == pmConv) { | |
| 128 swapRB = true; | |
| 129 } else { | |
| 130 swapRB = random->nextBool(); | |
| 131 } | |
| 132 AutoEffectUnref effect(SkNEW_ARGS(GrConfigConversionEffect, | |
| 133 (textures[GrEffectUnitTest::kSkiaPMTextureIdx], | |
| 134 swapRB, | |
| 135 pmConv, | |
| 136 GrEffectUnitTest::TestMatrix(random)))); | |
| 137 return CreateEffectRef(effect); | |
| 138 } | |
| 139 | |
| 140 /////////////////////////////////////////////////////////////////////////////// | |
| 141 void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context, | |
| 142 PMConversion* pmToUPMRule, | |
| 143 PMConversion* upmToPMRule) { | |
| 144 *pmToUPMRule = kNone_PMConversion; | |
| 145 *upmToPMRule = kNone_PMConversion; | |
| 146 SkAutoTMalloc<uint32_t> data(256 * 256 * 3); | |
| 147 uint32_t* srcData = data.get(); | |
| 148 uint32_t* firstRead = data.get() + 256 * 256; | |
| 149 uint32_t* secondRead = data.get() + 2 * 256 * 256; | |
| 150 | |
| 151 // Fill with every possible premultiplied A, color channel value. There will be 256-y duplicate | |
| 152 // values in row y. We set r,g, and b to the same value since they are handled identically. | |
| 153 for (int y = 0; y < 256; ++y) { | |
| 154 for (int x = 0; x < 256; ++x) { | |
| 155 uint8_t* color = reinterpret_cast<uint8_t*>(&srcData[256*y + x]); | |
| 156 color[3] = y; | |
| 157 color[2] = GrMin(x, y); | |
| 158 color[1] = GrMin(x, y); | |
| 159 color[0] = GrMin(x, y); | |
| 160 } | |
| 161 } | |
| 162 | |
| 163 GrTextureDesc desc; | |
| 164 desc.fFlags = kRenderTarget_GrTextureFlagBit | | |
| 165 kNoStencil_GrTextureFlagBit; | |
| 166 desc.fWidth = 256; | |
| 167 desc.fHeight = 256; | |
| 168 desc.fConfig = kRGBA_8888_GrPixelConfig; | |
| 169 | |
| 170 SkAutoTUnref<GrTexture> readTex(context->createUncachedTexture(desc, NULL, 0)); | |
| 171 if (!readTex.get()) { | |
| 172 return; | |
| 173 } | |
| 174 SkAutoTUnref<GrTexture> tempTex(context->createUncachedTexture(desc, NULL, 0)); | |
| 175 if (!tempTex.get()) { | |
| 176 return; | |
| 177 } | |
| 178 desc.fFlags = kNone_GrTextureFlags; | |
| 179 SkAutoTUnref<GrTexture> dataTex(context->createUncachedTexture(desc, data, 0)); | |
| 180 if (!dataTex.get()) { | |
| 181 return; | |
| 182 } | |
| 183 | |
| 184 static const PMConversion kConversionRules[][2] = { | |
| 185 {kDivByAlpha_RoundDown_PMConversion, kMulByAlpha_RoundUp_PMConversion}, | |
| 186 {kDivByAlpha_RoundUp_PMConversion, kMulByAlpha_RoundDown_PMConversion}, | |
| 187 }; | |
| 188 | |
| 189 GrContext::AutoWideOpenIdentityDraw awoid(context, NULL); | |
| 190 | |
| 191 bool failed = true; | |
| 192 | |
| 193 for (size_t i = 0; i < GR_ARRAY_COUNT(kConversionRules) && failed; ++i) { | |
| 194 *pmToUPMRule = kConversionRules[i][0]; | |
| 195 *upmToPMRule = kConversionRules[i][1]; | |
| 196 | |
| 197 static const SkRect kDstRect = SkRect::MakeWH(SkIntToScalar(256), SkIntToScalar(256)); | |
| 198 static const SkRect kSrcRect = SkRect::MakeWH(SK_Scalar1, SK_Scalar1); | |
| 199 // We do a PM->UPM draw from dataTex to readTex and read the data. Then we do a UPM->PM draw | |
| 200 // from readTex to tempTex followed by a PM->UPM draw to readTex and finally read the data. | |
| 201 // We then verify that two reads produced the same values. | |
| 202 | |
| 203 AutoEffectUnref pmToUPM1(SkNEW_ARGS(GrConfigConversionEffect, (dataTex, | |
| 204 false, | |
| 205 *pmToUPMRule, | |
| 206 SkMatrix::I()))); | |
| 207 AutoEffectUnref upmToPM(SkNEW_ARGS(GrConfigConversionEffect, (readTex, | |
| 208 false, | |
| 209 *upmToPMRule, | |
| 210 SkMatrix::I()))); | |
| 211 AutoEffectUnref pmToUPM2(SkNEW_ARGS(GrConfigConversionEffect, (tempTex, | |
| 212 false, | |
| 213 *pmToUPMRule, | |
| 214 SkMatrix::I()))); | |
| 215 | |
| 216 SkAutoTUnref<GrEffectRef> pmToUPMEffect1(CreateEffectRef(pmToUPM1)); | |
| 217 SkAutoTUnref<GrEffectRef> upmToPMEffect(CreateEffectRef(upmToPM)); | |
| 218 SkAutoTUnref<GrEffectRef> pmToUPMEffect2(CreateEffectRef(pmToUPM2)); | |
| 219 | |
| 220 context->setRenderTarget(readTex->asRenderTarget()); | |
| 221 GrPaint paint1; | |
| 222 paint1.addColorEffect(pmToUPMEffect1); | |
| 223 context->drawRectToRect(paint1, kDstRect, kSrcRect); | |
| 224 | |
| 225 readTex->readPixels(0, 0, 256, 256, kRGBA_8888_GrPixelConfig, firstRead); | |
| 226 | |
| 227 context->setRenderTarget(tempTex->asRenderTarget()); | |
| 228 GrPaint paint2; | |
| 229 paint2.addColorEffect(upmToPMEffect); | |
| 230 context->drawRectToRect(paint2, kDstRect, kSrcRect); | |
| 231 context->setRenderTarget(readTex->asRenderTarget()); | |
| 232 | |
| 233 GrPaint paint3; | |
| 234 paint3.addColorEffect(pmToUPMEffect2); | |
| 235 context->drawRectToRect(paint3, kDstRect, kSrcRect); | |
| 236 | |
| 237 readTex->readPixels(0, 0, 256, 256, kRGBA_8888_GrPixelConfig, secondRead); | |
| 238 | |
| 239 failed = false; | |
| 240 for (int y = 0; y < 256 && !failed; ++y) { | |
| 241 for (int x = 0; x <= y; ++x) { | |
| 242 if (firstRead[256 * y + x] != secondRead[256 * y + x]) { | |
| 243 failed = true; | |
| 244 break; | |
| 245 } | |
| 246 } | |
| 247 } | |
| 248 } | |
| 249 if (failed) { | |
| 250 *pmToUPMRule = kNone_PMConversion; | |
| 251 *upmToPMRule = kNone_PMConversion; | |
| 252 } | |
| 253 } | |
| 254 | |
| 255 const GrEffectRef* GrConfigConversionEffect::Create(GrTexture* texture, | |
| 256 bool swapRedAndBlue, | |
| 257 PMConversion pmConversion, | |
| 258 const SkMatrix& matrix) { | |
| 259 if (!swapRedAndBlue && kNone_PMConversion == pmConversion) { | |
| 260 // If we returned a GrConfigConversionEffect that was equivalent to a GrSimpleTextureEffect | |
| 261 // then we may pollute our texture cache with redundant shaders. So in the case that no | |
| 262 // conversions were requested we instead return a GrSimpleTextureEffect. | |
| 263 return GrSimpleTextureEffect::Create(texture, matrix); | |
| 264 } else { | |
| 265 if (kRGBA_8888_GrPixelConfig != texture->config() && | |
| 266 kBGRA_8888_GrPixelConfig != texture->config() && | |
| 267 kNone_PMConversion != pmConversion) { | |
| 268 // The PM conversions assume colors are 0..255 | |
| 269 return NULL; | |
| 270 } | |
| 271 AutoEffectUnref effect(SkNEW_ARGS(GrConfigConversionEffect, (texture, | |
| 272 swapRedAndBlue, | |
| 273 pmConversion, | |
| 274 matrix))); | |
| 275 return CreateEffectRef(effect); | |
| 276 } | |
| 277 } |
