Support Float32 output from SkColorSpaceXform

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkGr.h"
 #include "SkGrPriv.h"
 
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrGpuResourcePriv.h"
 #include "GrImageIDTextureAdjuster.h"
 #include "GrTextureParamsAdjuster.h"
 #include "GrTexturePriv.h"
 #include "GrTypes.h"
 #include "GrXferProcessor.h"
 #include "GrYUVProvider.h"
 
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkCanvas.h"
+#include "SkColorSpaceXform.h"
 #include "SkData.h"
 #include "SkErrorInternals.h"
 #include "SkMessageBus.h"
 #include "SkMipMap.h"
 #include "SkPixelRef.h"
 #include "SkPM4fPriv.h"
 #include "SkResourceCache.h"
 #include "SkTemplates.h"
 #include "SkYUVPlanesCache.h"
 #include "effects/GrBicubicEffect.h"
@@ skipping 486 matching lines @@
                                            GrDrawContext* dc,
                                            const SkPaint& skPaint,
                                            const SkMatrix& viewM,
                                            sk_sp<GrFragmentProcessor>* shaderProcessor,
                                            SkXfermode::Mode* primColorMode,
                                            bool primitiveIsSrc,
                                            GrPaint* grPaint) {
     grPaint->setAntiAlias(skPaint.isAntiAlias());
     grPaint->setAllowSRGBInputs(dc->isGammaCorrect());
 
-    // Raw translation of the SkPaint color to our 4f format:
-    GrColor4f origColor = GrColor4f::FromGrColor(SkColorToUnpremulGrColor(skPaint.getColor()));
+    GrColor4f origColor;
 
     // Linearize, if the color is meant to be in sRGB gamma:
     if (dc->isGammaCorrect()) {
-        origColor.fRGBA[0] = exact_srgb_to_linear(origColor.fRGBA[0]);
-        origColor.fRGBA[1] = exact_srgb_to_linear(origColor.fRGBA[1]);
-        origColor.fRGBA[2] = exact_srgb_to_linear(origColor.fRGBA[2]);
+        SkColorSpaceXform* xform = dc->getColorXformFromSRGB();
+        SkASSERT(xform);
 
-        if (dc->getColorXformFromSRGB()) {
-            origColor = dc->getColorXformFromSRGB()->apply(origColor);
-        }
+        // FIXME (msarett): Support BGRA inputs to SkColorSpaceXform?
+        uint32_t rgba = SkSwizzle_RB(skPaint.getColor());
+        xform->apply(&origColor, &rgba, 1, SkColorSpaceXform::kRGBA_F32_ColorFormat,
+                     kUnpremul_SkAlphaType);
+    } else {
+        // Raw translation of the SkPaint color to our 4f format:
+        origColor = GrColor4f::FromGrColor(SkColorToUnpremulGrColor(skPaint.getColor()));
     }
 
     // Setup the initial color considering the shader, the SkPaint color, and the presence or not
     // of per-vertex colors.
     sk_sp<GrFragmentProcessor> shaderFP;
     if (!primColorMode || blend_requires_shader(*primColorMode, primitiveIsSrc)) {
         if (shaderProcessor) {
             shaderFP = *shaderProcessor;
         } else if (const SkShader* shader = skPaint.getShader()) {
             shaderFP = shader->asFragmentProcessor(SkShader::AsFPArgs(context, &viewM, nullptr,
@@ skipping 220 matching lines @@
             SkErrorInternals::SetError( kInvalidPaint_SkError,
                                         "Sorry, I don't understand the filtering "
                                         "mode you asked for.  Falling back to "
                                         "MIPMaps.");
             textureFilterMode = GrTextureParams::kMipMap_FilterMode;
             break;
 
     }
     return textureFilterMode;
 }