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