Add support for the Rec601 YUV color space to GrYUVtoRGBEffect.

src/gpu/effects/GrYUVtoRGBEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/builders/GrGLProgramBuilder.h"
 #include "GrYUVtoRGBEffect.h"
 
 #include "GrCoordTransform.h"
 #include "GrEffect.h"
 #include "gl/GrGLEffect.h"
 #include "GrTBackendEffectFactory.h"
 
 namespace {
 
 class YUVtoRGBEffect : public GrEffect {
 public:
-    static GrEffect* Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture) {
-        return SkNEW_ARGS(YUVtoRGBEffect, (yTexture, uTexture, vTexture));
+    static GrEffect* Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
+                            SkPixelRef::YUVColorSpace colorSpace) {
+        return SkNEW_ARGS(YUVtoRGBEffect, (yTexture, uTexture, vTexture, colorSpace));
     }
 
     static const char* Name() { return "YUV to RGB"; }
 
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
         return GrTBackendEffectFactory<YUVtoRGBEffect>::getInstance();
     }
 
     virtual void getConstantColorComponents(GrColor* color,
                                             uint32_t* validFlags) const SK_OVERRIDE {
         // YUV is opaque
         *color = 0xFF;
         *validFlags = kA_GrColorComponentFlag;
     }
 
+    SkPixelRef::YUVColorSpace getColorSpace() const {
+        return fColorSpace;
+    }
+
     class GLEffect : public GrGLEffect {
     public:
+        static const GrGLfloat kJPEGConversionMatrix[16];
+        static const GrGLfloat kRec601ConversionMatrix[16];
+
         // this class always generates the same code.
         static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
 
         GLEffect(const GrBackendEffectFactory& factory,
                  const GrDrawEffect&)
         : INHERITED(factory) {
         }
 
         virtual void emitCode(GrGLProgramBuilder* builder,
-                              const GrDrawEffect&,
+                              const GrDrawEffect& drawEffect,
                               const GrEffectKey&,
                               const char* outputColor,
                               const char* inputColor,
                               const TransformedCoordsArray& coords,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
             GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
-            const char* yuvMatrix   = "yuvMatrix";
-            fsBuilder->codeAppendf("\tconst mat4 %s = mat4(1.0,  0.0,    1.402, -0.701,\n\t\t\t"
-                                                          "1.0, -0.344, -0.714,  0.529,\n\t\t\t"
-                                                          "1.0,  1.772,  0.0,   -0.886,\n\t\t\t"
-                                                          "0.0,  0.0,    0.0,    1.0);\n",
-                                   yuvMatrix);
+
+            const char* yuvMatrix   = NULL;
+            fMatrixUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,

[sugoi1, 2014/09/11 17:57:23]

Hi, sorry for the late comment:

Instead of adding a uniform, couldn't we add a key and produce 2 shaders with
hardcoded matrices inside them, since we already know what the matrices are. I
doubt we'd have more than 255 color spaces any time soon. Otherwise, this shader
would just become a variant of SkColorMatrixFilter, with 3 inputs, no?

+                                             kMat44f_GrSLType, "YUVMatrix",
+                                             &yuvMatrix);
             fsBuilder->codeAppendf("\t%s = vec4(\n\t\t", outputColor);
             fsBuilder->appendTextureLookup(samplers[0], coords[0].c_str(), coords[0].type());
             fsBuilder->codeAppend(".r,\n\t\t");
             fsBuilder->appendTextureLookup(samplers[1], coords[0].c_str(), coords[0].type());
             fsBuilder->codeAppend(".r,\n\t\t");
             fsBuilder->appendTextureLookup(samplers[2], coords[0].c_str(), coords[0].type());
             fsBuilder->codeAppendf(".r,\n\t\t1.0) * %s;\n", yuvMatrix);
         }
 
+        virtual void setData(const GrGLProgramDataManager& pdman,
+                             const GrDrawEffect& drawEffect) SK_OVERRIDE {
+            const YUVtoRGBEffect& yuvEffect = drawEffect.castEffect<YUVtoRGBEffect>();
+            switch (yuvEffect.getColorSpace()) {
+                case SkPixelRef::kJPEG_YUVColorSpace:
+                    pdman.setMatrix4f(fMatrixUni, kJPEGConversionMatrix);
+                    break;
+                case SkPixelRef::kRec601_YUVColorSpace:
+                    pdman.setMatrix4f(fMatrixUni, kRec601ConversionMatrix);
+                    break;
+            }
+        }
+
+    private:
+        GrGLProgramDataManager::UniformHandle fMatrixUni;
+
         typedef GrGLEffect INHERITED;
     };
 
 private:
-    YUVtoRGBEffect(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture)
-    : fCoordTransform(kLocal_GrCoordSet, GrCoordTransform::MakeDivByTextureWHMatrix(yTexture),
-                      yTexture)
+    YUVtoRGBEffect(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
+                   SkPixelRef::YUVColorSpace colorSpace)
+     : fCoordTransform(kLocal_GrCoordSet, GrCoordTransform::MakeDivByTextureWHMatrix(yTexture),
+                       yTexture)
     , fYAccess(yTexture)
     , fUAccess(uTexture)
-    , fVAccess(vTexture) {
+    , fVAccess(vTexture)
+    , fColorSpace(colorSpace) {
         this->addCoordTransform(&fCoordTransform);
         this->addTextureAccess(&fYAccess);
         this->addTextureAccess(&fUAccess);
         this->addTextureAccess(&fVAccess);
         this->setWillNotUseInputColor();
     }
 
     virtual bool onIsEqual(const GrEffect& sBase) const {
         const YUVtoRGBEffect& s = CastEffect<YUVtoRGBEffect>(sBase);
         return fYAccess.getTexture() == s.fYAccess.getTexture() &&
                fUAccess.getTexture() == s.fUAccess.getTexture() &&
-               fVAccess.getTexture() == s.fVAccess.getTexture();
+               fVAccess.getTexture() == s.fVAccess.getTexture() &&
+               fColorSpace == s.getColorSpace();
     }
 
     GrCoordTransform fCoordTransform;
     GrTextureAccess fYAccess;
     GrTextureAccess fUAccess;
     GrTextureAccess fVAccess;
+    SkPixelRef::YUVColorSpace fColorSpace;
 
     typedef GrEffect INHERITED;
 };
 
+const GrGLfloat YUVtoRGBEffect::GLEffect::kJPEGConversionMatrix[16] = {
+    1.0,  0.0,     1.402,    -0.701,
+    1.0, -0.34414, -0.71414,  0.529,
+    1.0,  1.772,   0.0,      -0.886,
+    0.0,  0.0,     0.0,       1.0};
+const GrGLfloat YUVtoRGBEffect::GLEffect::kRec601ConversionMatrix[16] = {
+    1.164,  0.0,    1.596, -1.08175,
+    1.164, -0.391, -0.813,  0.529,
+    1.164,  2.018,  0.0,   -1.08175,
+    0.0,    0.0,    0.0,    1.0};
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrEffect* GrYUVtoRGBEffect::Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture) {
-    return YUVtoRGBEffect::Create(yTexture, uTexture, vTexture);
+GrEffect* GrYUVtoRGBEffect::Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
+                                   SkPixelRef::YUVColorSpace colorSpace) {
+    return YUVtoRGBEffect::Create(yTexture, uTexture, vTexture, colorSpace);
 }