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,
+                            GrYUVtoRGBEffect::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;
     }
 
+    GrYUVtoRGBEffect::YUVColorSpace getYUVColorSpace() const {
+        return fColorSpace;
+    }
+
     class GLEffect : public GrGLEffect {
     public:
-        // this class always generates the same code.
-        static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
+        static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
+                           GrEffectKeyBuilder* builder) {
+            const YUVtoRGBEffect& yuvEffect = drawEffect.castEffect<YUVtoRGBEffect>();
+            builder->add32(yuvEffect.getYUVColorSpace());
+        }
 
         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 YUVtoRGBEffect& yuvEffect = drawEffect.castEffect<YUVtoRGBEffect>();
+
+            switch (yuvEffect.getYUVColorSpace()) {
+                case GrYUVtoRGBEffect::kJPEG:
+                    fsBuilder->codeAppendf("\tconst mat4 %s = "
+                                           "mat4(1.0,  0.0,     1.402,    -0.701,\n\t\t\t"

[Stephen White, 2014/08/28 15:11:06]

Not new to this patch, but I wonder if it's worth using a uniform mat4 here,
instead of a constant. It would make for one fewer shader permutation, at the
cost of a matrix upload.

[rileya (GONE FROM CHROMIUM), 2014/08/28 21:05:57]

I'll need to refresh on how exactly uniforms get plumbed around in Gr, but I'll
take a look.

+                                                "1.0, -0.34414, -0.71414,  0.529,\n\t\t\t"

[rileya (GONE FROM CHROMIUM), 2014/08/28 01:03:27]

I added a couple decimal points to the original JPEG version so that it matches
the YUV conversion implementation in chromium's compositor:

https://code.google.com/p/chromium/codesearch#chromium/src/cc/output/gl_rende...

which is based on libjpeg itself's numbers:

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/libjpe...

+                                                "1.0,  1.772,   0.0,      -0.886,\n\t\t\t"
+                                                "0.0,  0.0,     0.0,       1.0);\n",
+                                           yuvMatrix);
+                    break;
+                case GrYUVtoRGBEffect::kRec601:
+                    fsBuilder->codeAppendf("\tconst mat4 %s = "
+                                           "mat4(1.164,  0.0,    1.596, -1.08175,\n\t\t\t"
+                                                "1.164, -0.391, -0.813,  0.529,\n\t\t\t"
+                                                "1.164,  2.018,  0.0,   -1.08175,\n\t\t\t"
+                                                "0.0,    0.0,    0.0,    1.0);\n",
+                                           yuvMatrix);
+                    break;
+            }
             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);
         }
 
         typedef GrGLEffect INHERITED;
     };
 
 private:
-    YUVtoRGBEffect(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture)
+    YUVtoRGBEffect(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
+                   GrYUVtoRGBEffect::YUVColorSpace colorSpace)
     : fCoordTransform(kLocal_GrCoordSet, 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();
     }
 
     GrCoordTransform fCoordTransform;
     GrTextureAccess fYAccess;
     GrTextureAccess fUAccess;
     GrTextureAccess fVAccess;
+    GrYUVtoRGBEffect::YUVColorSpace fColorSpace;
 
     typedef GrEffect INHERITED;
 };
 
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrEffect* GrYUVtoRGBEffect::Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture) {
-    return YUVtoRGBEffect::Create(yTexture, uTexture, vTexture);
+GrEffect* GrYUVtoRGBEffect::Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
+                                   GrYUVtoRGBEffect::YUVColorSpace colorSpace) {
+    return YUVtoRGBEffect::Create(yTexture, uTexture, vTexture, colorSpace);
 }