src/gpu/effects/GrYUVtoRGBEffect.cpp

   1 /*
   2  * Copyright 2014 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 "GrYUVtoRGBEffect.h"
   9
  10 #include "GrCoordTransform.h"
  11 #include "GrInvariantOutput.h"
  12 #include "GrProcessor.h"
  13 #include "glsl/GrGLSLFragmentProcessor.h"
  14 #include "glsl/GrGLSLFragmentShaderBuilder.h"
  15 #include "glsl/GrGLSLProgramBuilder.h"
  16 #include "glsl/GrGLSLProgramDataManager.h"
  17
  18 namespace {
  19
  20 class YUVtoRGBEffect : public GrFragmentProcessor {
  21 public:
  22     static GrFragmentProcessor* Create(GrTexture* yTexture, GrTexture* uTexture,
  23                                        GrTexture* vTexture, const SkISize sizes[3],
  24                                        SkYUVColorSpace colorSpace) {
  25         SkScalar w[3], h[3];
  26         w[0] = SkIntToScalar(sizes[0].fWidth)  / SkIntToScalar(yTexture->width());
  27         h[0] = SkIntToScalar(sizes[0].fHeight) / SkIntToScalar(yTexture->height());
  28         w[1] = SkIntToScalar(sizes[1].fWidth)  / SkIntToScalar(uTexture->width());
  29         h[1] = SkIntToScalar(sizes[1].fHeight) / SkIntToScalar(uTexture->height());
  30         w[2] = SkIntToScalar(sizes[2].fWidth)  / SkIntToScalar(vTexture->width());
  31         h[2] = SkIntToScalar(sizes[2].fHeight) / SkIntToScalar(vTexture->height());
  32         SkMatrix yuvMatrix[3];
  33         yuvMatrix[0] = GrCoordTransform::MakeDivByTextureWHMatrix(yTexture);
  34         yuvMatrix[1] = yuvMatrix[0];
  35         yuvMatrix[1].preScale(w[1] / w[0], h[1] / h[0]);
  36         yuvMatrix[2] = yuvMatrix[0];
  37         yuvMatrix[2].preScale(w[2] / w[0], h[2] / h[0]);
  38         GrTextureParams::FilterMode uvFilterMode =
  39             ((sizes[1].fWidth  != sizes[0].fWidth) ||
  40              (sizes[1].fHeight != sizes[0].fHeight) ||
  41              (sizes[2].fWidth  != sizes[0].fWidth) ||
  42              (sizes[2].fHeight != sizes[0].fHeight)) ?
  43             GrTextureParams::kBilerp_FilterMode :
  44             GrTextureParams::kNone_FilterMode;
  45         return new YUVtoRGBEffect(yTexture, uTexture, vTexture, yuvMatrix, uvFilterMode,
  46                                   colorSpace);
  47     }
  48
  49     const char* name() const override { return "YUV to RGB"; }
  50
  51     SkYUVColorSpace getColorSpace() const {
  52         return fColorSpace;
  53     }
  54
  55     class GLSLProcessor : public GrGLSLFragmentProcessor {
  56     public:
  57         static const float kJPEGConversionMatrix[16];
  58         static const float kRec601ConversionMatrix[16];
  59         static const float kRec709ConversionMatrix[16];
  60
  61         // this class always generates the same code.
  62         static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) {}
  63
  64         GLSLProcessor(const GrProcessor&) {}
  65
  66         virtual void emitCode(EmitArgs& args) override {
  67             GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
  68
  69             const char* yuvMatrix   = nullptr;
  70             fMatrixUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
  71                                                    kMat44f_GrSLType, kDefault_GrSLPrecision,
  72                                                    "YUVMatrix", &yuvMatrix);
  73             fragBuilder->codeAppendf("\t%s = vec4(\n\t\t", args.fOutputColor);
  74             fragBuilder->appendTextureLookup(args.fSamplers[0], args.fCoords[0].c_str(),
  75                                              args.fCoords[0].getType());
  76             fragBuilder->codeAppend(".r,\n\t\t");
  77             fragBuilder->appendTextureLookup(args.fSamplers[1], args.fCoords[1].c_str(),
  78                                              args.fCoords[1].getType());
  79             fragBuilder->codeAppend(".r,\n\t\t");
  80             fragBuilder->appendTextureLookup(args.fSamplers[2], args.fCoords[2].c_str(),
  81                                              args.fCoords[2].getType());
  82             fragBuilder->codeAppendf(".r,\n\t\t1.0) * %s;\n", yuvMatrix);
  83         }
  84
  85     protected:
  86         virtual void onSetData(const GrGLSLProgramDataManager& pdman,
  87                                const GrProcessor& processor) override {
  88             const YUVtoRGBEffect& yuvEffect = processor.cast<YUVtoRGBEffect>();
  89             switch (yuvEffect.getColorSpace()) {
  90                 case kJPEG_SkYUVColorSpace:
  91                     pdman.setMatrix4f(fMatrixUni, kJPEGConversionMatrix);
  92                     break;
  93                 case kRec601_SkYUVColorSpace:
  94                     pdman.setMatrix4f(fMatrixUni, kRec601ConversionMatrix);
  95                     break;
  96                 case kRec709_SkYUVColorSpace:
  97                     pdman.setMatrix4f(fMatrixUni, kRec709ConversionMatrix);
  98                     break;
  99             }
 100         }
 101
 102     private:
 103         GrGLSLProgramDataManager::UniformHandle fMatrixUni;
 104
 105         typedef GrGLSLFragmentProcessor INHERITED;
 106     };
 107
 108 private:
 109     YUVtoRGBEffect(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
 110                    const SkMatrix yuvMatrix[3], GrTextureParams::FilterMode uvFilterMode,
 111                    SkYUVColorSpace colorSpace)
 112     : fYTransform(kLocal_GrCoordSet, yuvMatrix[0], yTexture, GrTextureParams::kNone_FilterMode)
 113     , fYAccess(yTexture)
 114     , fUTransform(kLocal_GrCoordSet, yuvMatrix[1], uTexture, uvFilterMode)
 115     , fUAccess(uTexture, uvFilterMode)
 116     , fVTransform(kLocal_GrCoordSet, yuvMatrix[2], vTexture, uvFilterMode)
 117     , fVAccess(vTexture, uvFilterMode)
 118     , fColorSpace(colorSpace) {
 119         this->initClassID<YUVtoRGBEffect>();
 120         this->addCoordTransform(&fYTransform);
 121         this->addTextureAccess(&fYAccess);
 122         this->addCoordTransform(&fUTransform);
 123         this->addTextureAccess(&fUAccess);
 124         this->addCoordTransform(&fVTransform);
 125         this->addTextureAccess(&fVAccess);
 126     }
 127
 128     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
 129         return new GLSLProcessor(*this);
 130     }
 131
 132     virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
 133                                        GrProcessorKeyBuilder* b) const override {
 134         GLSLProcessor::GenKey(*this, caps, b);
 135     }
 136
 137     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
 138         const YUVtoRGBEffect& s = sBase.cast<YUVtoRGBEffect>();
 139         return fColorSpace == s.getColorSpace();
 140     }
 141
 142     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
 143         // YUV is opaque
 144         inout->setToOther(kA_GrColorComponentFlag, 0xFF << GrColor_SHIFT_A,
 145                           GrInvariantOutput::kWillNot_ReadInput);
 146     }
 147
 148     GrCoordTransform fYTransform;
 149     GrTextureAccess fYAccess;
 150     GrCoordTransform fUTransform;
 151     GrTextureAccess fUAccess;
 152     GrCoordTransform fVTransform;
 153     GrTextureAccess fVAccess;
 154     SkYUVColorSpace fColorSpace;
 155
 156     typedef GrFragmentProcessor INHERITED;
 157 };
 158
 159 const float YUVtoRGBEffect::GLSLProcessor::kJPEGConversionMatrix[16] = {
 160     1.0f,  0.0f,      1.402f,  -0.701f,
 161     1.0f, -0.34414f, -0.71414f, 0.529f,
 162     1.0f,  1.772f,    0.0f,    -0.886f,
 163     0.0f,  0.0f,      0.0f,     1.0};
 164 const float YUVtoRGBEffect::GLSLProcessor::kRec601ConversionMatrix[16] = {
 165     1.164f,  0.0f,    1.596f, -0.87075f,
 166     1.164f, -0.391f, -0.813f,  0.52925f,
 167     1.164f,  2.018f,  0.0f,   -1.08175f,
 168     0.0f,    0.0f,    0.0f,    1.0};
 169 const float YUVtoRGBEffect::GLSLProcessor::kRec709ConversionMatrix[16] = {
 170     1.164f,  0.0f,    1.793f, -0.96925f,
 171     1.164f, -0.213f, -0.533f,  0.30025f,
 172     1.164f,  2.112f,  0.0f,   -1.12875f,
 173     0.0f,    0.0f,    0.0f,    1.0f};
 174 }
 175
 176 //////////////////////////////////////////////////////////////////////////////
 177
 178 GrFragmentProcessor*
 179 GrYUVtoRGBEffect::Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
 180                          const SkISize sizes[3], SkYUVColorSpace colorSpace) {
 181     SkASSERT(yTexture && uTexture && vTexture && sizes);
 182     return YUVtoRGBEffect::Create(yTexture, uTexture, vTexture, sizes, colorSpace);
 183 }