Add NV12 texture conversion support.

src/gpu/effects/GrYUVEffect.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 "GrYUVEffect.h"
 
 #include "GrCoordTransform.h"
@@ skipping 46 matching lines @@
      0.182663f,  0.614473f, 0.061971f, 0.0625f,
     -0.100672f, -0.338658f, 0.43933f,  0.5f,
      0.439142f, -0.39891f, -0.040231f, 0.5f,
      0.f,        0.f,       0.f,       1.
 };
 
 class YUVtoRGBEffect : public GrFragmentProcessor {
 public:
     static sk_sp<GrFragmentProcessor> Make(GrTexture* yTexture, GrTexture* uTexture,
                                            GrTexture* vTexture, const SkISize sizes[3],
-                                           SkYUVColorSpace colorSpace) {
+                                           SkYUVColorSpace colorSpace, bool nv12) {
         SkScalar w[3], h[3];
         w[0] = SkIntToScalar(sizes[0].fWidth)  / SkIntToScalar(yTexture->width());
         h[0] = SkIntToScalar(sizes[0].fHeight) / SkIntToScalar(yTexture->height());
         w[1] = SkIntToScalar(sizes[1].fWidth)  / SkIntToScalar(uTexture->width());
         h[1] = SkIntToScalar(sizes[1].fHeight) / SkIntToScalar(uTexture->height());
         w[2] = SkIntToScalar(sizes[2].fWidth)  / SkIntToScalar(vTexture->width());
         h[2] = SkIntToScalar(sizes[2].fHeight) / SkIntToScalar(vTexture->height());
         SkMatrix yuvMatrix[3];
         yuvMatrix[0] = GrCoordTransform::MakeDivByTextureWHMatrix(yTexture);
         yuvMatrix[1] = yuvMatrix[0];
         yuvMatrix[1].preScale(w[1] / w[0], h[1] / h[0]);
         yuvMatrix[2] = yuvMatrix[0];
         yuvMatrix[2].preScale(w[2] / w[0], h[2] / h[0]);
         GrTextureParams::FilterMode uvFilterMode =
             ((sizes[1].fWidth  != sizes[0].fWidth) ||
              (sizes[1].fHeight != sizes[0].fHeight) ||
              (sizes[2].fWidth  != sizes[0].fWidth) ||
              (sizes[2].fHeight != sizes[0].fHeight)) ?
             GrTextureParams::kBilerp_FilterMode :
             GrTextureParams::kNone_FilterMode;
-        return sk_sp<GrFragmentProcessor>(
-            new YUVtoRGBEffect(yTexture, uTexture, vTexture, yuvMatrix, uvFilterMode, colorSpace));
+        return sk_sp<GrFragmentProcessor>(new YUVtoRGBEffect(
+            yTexture, uTexture, vTexture, yuvMatrix, uvFilterMode, colorSpace, nv12));
     }
 
     const char* name() const override { return "YUV to RGB"; }
 
     SkYUVColorSpace getColorSpace() const { return fColorSpace; }
 
+    bool isNV12() const {
+        return fNV12;
+    }
+
     class GLSLProcessor : public GrGLSLFragmentProcessor {
     public:
-        // this class always generates the same code.
-        static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) {}
-
         void emitCode(EmitArgs& args) override {
             GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+            const YUVtoRGBEffect& effect = args.fFp.cast<YUVtoRGBEffect>();
 
             const char* colorSpaceMatrix = nullptr;
             fMatrixUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
                                                           kMat44f_GrSLType, kDefault_GrSLPrecision,
                                                           "ColorSpaceMatrix", &colorSpaceMatrix);
             fragBuilder->codeAppendf("%s = vec4(", args.fOutputColor);
             fragBuilder->appendTextureLookup(args.fTexSamplers[0], args.fCoords[0].c_str(),
                                              args.fCoords[0].getType());
             fragBuilder->codeAppend(".r,");
             fragBuilder->appendTextureLookup(args.fTexSamplers[1], args.fCoords[1].c_str(),
                                              args.fCoords[1].getType());
-            fragBuilder->codeAppend(".r,");
-            fragBuilder->appendTextureLookup(args.fTexSamplers[2], args.fCoords[2].c_str(),
-                                             args.fCoords[2].getType());
-            fragBuilder->codeAppendf(".r, 1.0) * %s;", colorSpaceMatrix);
+            if (effect.fNV12) {
+                fragBuilder->codeAppendf(".rg,");
+            } else {
+                fragBuilder->codeAppend(".r,");
+                fragBuilder->appendTextureLookup(args.fTexSamplers[2], args.fCoords[2].c_str(),
+                                                 args.fCoords[2].getType());
+                fragBuilder->codeAppendf(".g,");
+            }
+            fragBuilder->codeAppendf("1.0) * %s;", colorSpaceMatrix);
         }
 
     protected:
         void onSetData(const GrGLSLProgramDataManager& pdman,
                        const GrProcessor& processor) override {
             const YUVtoRGBEffect& yuvEffect = processor.cast<YUVtoRGBEffect>();
             switch (yuvEffect.getColorSpace()) {
                 case kJPEG_SkYUVColorSpace:
                     pdman.setMatrix4f(fMatrixUni, kJPEGConversionMatrix);
                     break;
                 case kRec601_SkYUVColorSpace:
                     pdman.setMatrix4f(fMatrixUni, kRec601ConversionMatrix);
                     break;
                 case kRec709_SkYUVColorSpace:
                     pdman.setMatrix4f(fMatrixUni, kRec709ConversionMatrix);
                     break;
             }
         }
 
     private:
         GrGLSLProgramDataManager::UniformHandle fMatrixUni;
 
         typedef GrGLSLFragmentProcessor INHERITED;
     };
 
 private:
     YUVtoRGBEffect(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
                    const SkMatrix yuvMatrix[3], GrTextureParams::FilterMode uvFilterMode,
-                   SkYUVColorSpace colorSpace)
-    : fYTransform(kLocal_GrCoordSet, yuvMatrix[0], yTexture, GrTextureParams::kNone_FilterMode)
-    , fYAccess(yTexture)
-    , fUTransform(kLocal_GrCoordSet, yuvMatrix[1], uTexture, uvFilterMode)
-    , fUAccess(uTexture, uvFilterMode)
-    , fVTransform(kLocal_GrCoordSet, yuvMatrix[2], vTexture, uvFilterMode)
-    , fVAccess(vTexture, uvFilterMode)
-    , fColorSpace(colorSpace) {
+                   SkYUVColorSpace colorSpace, bool nv12)
+        : fYTransform(kLocal_GrCoordSet, yuvMatrix[0], yTexture, GrTextureParams::kNone_FilterMode)
+        , fYAccess(yTexture)
+        , fUTransform(kLocal_GrCoordSet, yuvMatrix[1], uTexture, uvFilterMode)
+        , fUAccess(uTexture, uvFilterMode)
+        , fVAccess(vTexture, uvFilterMode)
+        , fColorSpace(colorSpace)
+        , fNV12(nv12) {
         this->initClassID<YUVtoRGBEffect>();
         this->addCoordTransform(&fYTransform);
         this->addTextureAccess(&fYAccess);
         this->addCoordTransform(&fUTransform);
         this->addTextureAccess(&fUAccess);
-        this->addCoordTransform(&fVTransform);
-        this->addTextureAccess(&fVAccess);
+        if (!fNV12) {
+            fVTransform = GrCoordTransform(kLocal_GrCoordSet, yuvMatrix[2], vTexture, uvFilterMode);
+            this->addCoordTransform(&fVTransform);
+            this->addTextureAccess(&fVAccess);
+        }
     }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
         return new GLSLProcessor;
     }
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
-        GLSLProcessor::GenKey(*this, caps, b);
+        b->add32(fNV12);
     }
 
     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
         const YUVtoRGBEffect& s = sBase.cast<YUVtoRGBEffect>();
-        return fColorSpace == s.getColorSpace();
+        return (fColorSpace == s.getColorSpace()) && (fNV12 == s.isNV12());
     }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         // YUV is opaque
         inout->setToOther(kA_GrColorComponentFlag, 0xFF << GrColor_SHIFT_A,
                           GrInvariantOutput::kWillNot_ReadInput);
     }
 
     GrCoordTransform fYTransform;
     GrTextureAccess fYAccess;
     GrCoordTransform fUTransform;
     GrTextureAccess fUAccess;
     GrCoordTransform fVTransform;
     GrTextureAccess fVAccess;
     SkYUVColorSpace fColorSpace;
+    bool fNV12;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 
 class RGBToYUVEffect : public GrFragmentProcessor {
 public:
     enum OutputChannels {
         // output color r = y, g = u, b = v, a = a
         kYUV_OutputChannels,
@@ skipping 144 matching lines @@
     SkYUVColorSpace     fColorSpace;
     OutputChannels      fOutputChannels;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-sk_sp<GrFragmentProcessor>
-GrYUVEffect::MakeYUVToRGB(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
-                            const SkISize sizes[3], SkYUVColorSpace colorSpace) {
+sk_sp<GrFragmentProcessor> GrYUVEffect::MakeYUVToRGB(GrTexture* yTexture, GrTexture* uTexture,
+                                                     GrTexture* vTexture, const SkISize sizes[3],
+                                                     SkYUVColorSpace colorSpace, bool nv12) {
     SkASSERT(yTexture && uTexture && vTexture && sizes);
-    return YUVtoRGBEffect::Make(yTexture, uTexture, vTexture, sizes, colorSpace);
+    return YUVtoRGBEffect::Make(yTexture, uTexture, vTexture, sizes, colorSpace, nv12);
 }
 
 sk_sp<GrFragmentProcessor>
 GrYUVEffect::MakeRGBToYUV(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
     SkASSERT(rgbFP);
     return sk_sp<GrFragmentProcessor>(
         new RGBToYUVEffect(std::move(rgbFP), colorSpace, RGBToYUVEffect::kYUV_OutputChannels));
 }
 
 sk_sp<GrFragmentProcessor>
@@ skipping 16 matching lines @@
     return sk_sp<GrFragmentProcessor>(
         new RGBToYUVEffect(std::move(rgbFP), colorSpace, RGBToYUVEffect::kU_OutputChannels));
 }
 
 sk_sp<GrFragmentProcessor>
 GrYUVEffect::MakeRGBToV(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
     SkASSERT(rgbFP);
     return sk_sp<GrFragmentProcessor>(
         new RGBToYUVEffect(std::move(rgbFP), colorSpace, RGBToYUVEffect::kV_OutputChannels));
 }