Move SkColorMatrixFilter implementation to core.

src/core/SkColorMatrixFilterRowMajor255.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#include "SkColorMatrixFilter.h"
-#include "SkColorMatrix.h"
+#include "SkColorMatrixFilterRowMajor255.h"
 #include "SkColorPriv.h"
 #include "SkNx.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkUnPreMultiply.h"
 #include "SkString.h"
 
 #define SK_PMORDER_INDEX_A  (SK_A32_SHIFT / 8)
 #define SK_PMORDER_INDEX_R  (SK_R32_SHIFT / 8)
 #define SK_PMORDER_INDEX_G  (SK_G32_SHIFT / 8)
 #define SK_PMORDER_INDEX_B  (SK_B32_SHIFT / 8)
 
 static void transpose_to_pmorder(float dst[20], const float src[20]) {
     const float* srcR = src + 0;
     const float* srcG = src + 5;
     const float* srcB = src + 10;
     const float* srcA = src + 15;
 
     for (int i = 0; i < 20; i += 4) {
         dst[i + SK_PMORDER_INDEX_A] = *srcA++;
         dst[i + SK_PMORDER_INDEX_R] = *srcR++;
         dst[i + SK_PMORDER_INDEX_G] = *srcG++;
         dst[i + SK_PMORDER_INDEX_B] = *srcB++;
     }
 }
 
 // src is [20] but some compilers won't accept __restrict__ on anything
 // but an raw pointer or reference
-void SkColorMatrixFilter::initState(const SkScalar* SK_RESTRICT src) {
+void SkColorMatrixFilterRowMajor255::initState(const SkScalar* SK_RESTRICT src) {
     transpose_to_pmorder(fTranspose, src);
 
-    const float* array = fMatrix.fMat;
+    const float* array = fMatrix;
 
     // check if we have to munge Alpha
     bool changesAlpha = (array[15] || array[16] || array[17] || (array[18] - 1) || array[19]);
     bool usesAlpha = (array[3] || array[8] || array[13]);
 
     if (changesAlpha || usesAlpha) {
         fFlags = changesAlpha ? 0 : kAlphaUnchanged_Flag;
     } else {
         fFlags = kAlphaUnchanged_Flag;
     }
     fFlags |= kSupports4f_Flag;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkColorMatrixFilter::SkColorMatrixFilter(const SkColorMatrix& cm) : fMatrix(cm) {
-    this->initState(cm.fMat);
-}
-
-SkColorMatrixFilter::SkColorMatrixFilter(const SkScalar array[20]) {
-    memcpy(fMatrix.fMat, array, 20 * sizeof(SkScalar));
+SkColorMatrixFilterRowMajor255::SkColorMatrixFilterRowMajor255(const SkScalar array[20]) {
+    memcpy(fMatrix, array, 20 * sizeof(SkScalar));
     this->initState(array);
 }
 
-uint32_t SkColorMatrixFilter::getFlags() const {
+uint32_t SkColorMatrixFilterRowMajor255::getFlags() const {
     return this->INHERITED::getFlags() | fFlags;
 }
 
 static Sk4f scale_rgb(float scale) {
     static_assert(SkPM4f::A == 3, "Alpha is lane 3");
     return Sk4f(scale, scale, scale, 1);
 }
 
 static Sk4f premul(const Sk4f& x) {
     return x * scale_rgb(x.kth<SkPM4f::A>());
@@ skipping 51 matching lines @@
 }
 
 struct SkPMColorAdaptor {
     static SkPMColor From4f(const Sk4f& c4) {
         return round(c4);
     }
     static Sk4f To4f(SkPMColor c) {
         return SkNx_cast<float>(Sk4b::Load(&c)) * Sk4f(1.0f/255);
     }
 };
-void SkColorMatrixFilter::filterSpan(const SkPMColor src[], int count, SkPMColor dst[]) const {
+void SkColorMatrixFilterRowMajor255::filterSpan(const SkPMColor src[], int count, SkPMColor dst[]) const {
     filter_span<SkPMColorAdaptor>(fTranspose, src, count, dst);
 }
 
 struct SkPM4fAdaptor {
     static SkPM4f From4f(const Sk4f& c4) {
         SkPM4f c;
         c4.store(&c);
         return c;
     }
     static Sk4f To4f(const SkPM4f& c) {
         return Sk4f::Load(&c);
     }
 };
-void SkColorMatrixFilter::filterSpan4f(const SkPM4f src[], int count, SkPM4f dst[]) const {
+void SkColorMatrixFilterRowMajor255::filterSpan4f(const SkPM4f src[], int count, SkPM4f dst[]) const {
     filter_span<SkPM4fAdaptor>(fTranspose, src, count, dst);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkColorMatrixFilter::flatten(SkWriteBuffer& buffer) const {
-    SkASSERT(sizeof(fMatrix.fMat)/sizeof(SkScalar) == 20);
-    buffer.writeScalarArray(fMatrix.fMat, 20);
+void SkColorMatrixFilterRowMajor255::flatten(SkWriteBuffer& buffer) const {
+    SkASSERT(sizeof(fMatrix)/sizeof(SkScalar) == 20);
+    buffer.writeScalarArray(fMatrix, 20);
 }
 
-SkFlattenable* SkColorMatrixFilter::CreateProc(SkReadBuffer& buffer) {
-    SkColorMatrix matrix;
-    if (buffer.readScalarArray(matrix.fMat, 20)) {
-        return Create(matrix);
+SkFlattenable* SkColorMatrixFilterRowMajor255::CreateProc(SkReadBuffer& buffer) {
+    SkScalar matrix[20];
+    if (buffer.readScalarArray(matrix, 20)) {
+        return new SkColorMatrixFilterRowMajor255(matrix);
     }
     return nullptr;
 }
 
-bool SkColorMatrixFilter::asColorMatrix(SkScalar matrix[20]) const {
+bool SkColorMatrixFilterRowMajor255::asColorMatrix(SkScalar matrix[20]) const {
     if (matrix) {
-        memcpy(matrix, fMatrix.fMat, 20 * sizeof(SkScalar));
+        memcpy(matrix, fMatrix, 20 * sizeof(SkScalar));
     }
     return true;
 }
 
-SkColorFilter* SkColorMatrixFilter::newComposed(const SkColorFilter* innerFilter) const {
+///////////////////////////////////////////////////////////////////////////////
+//  This code was duplicated from src/effects/SkColorMatrixc.cpp in order to be used in core.
+//////
+
+// To detect if we need to apply clamping after applying a matrix, we check if
+// any output component might go outside of [0, 255] for any combination of
+// input components in [0..255].
+// Each output component is an affine transformation of the input component, so
+// the minimum and maximum values are for any combination of minimum or maximum
+// values of input components (i.e. 0 or 255).
+// E.g. if R' = x*R + y*G + z*B + w*A + t
+// Then the maximum value will be for R=255 if x>0 or R=0 if x<0, and the
+// minimum value will be for R=0 if x>0 or R=255 if x<0.
+// Same goes for all components.
+static bool component_needs_clamping(const SkScalar row[5]) {
+    SkScalar maxValue = row[4] / 255;
+    SkScalar minValue = row[4] / 255;
+    for (int i = 0; i < 4; ++i) {
+        if (row[i] > 0)
+            maxValue += row[i];
+        else
+            minValue += row[i];
+    }
+    return (maxValue > 1) || (minValue < 0);
+}
+
+static bool needs_clamping(const SkScalar matrix[20]) {
+    return component_needs_clamping(matrix)
+        || component_needs_clamping(matrix+5)
+        || component_needs_clamping(matrix+10)
+        || component_needs_clamping(matrix+15);
+}
+
+static void set_concat(SkScalar result[20], const SkScalar outer[20], const SkScalar inner[20]) {
+    int index = 0;
+    for (int j = 0; j < 20; j += 5) {
+        for (int i = 0; i < 4; i++) {
+            result[index++] =   outer[j + 0] * inner[i + 0] +
+                                outer[j + 1] * inner[i + 5] +
+                                outer[j + 2] * inner[i + 10] +
+                                outer[j + 3] * inner[i + 15];
+        }
+        result[index++] =   outer[j + 0] * inner[4] +
+                            outer[j + 1] * inner[9] +
+                            outer[j + 2] * inner[14] +
+                            outer[j + 3] * inner[19] +
+                            outer[j + 4];
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  End duplication
+//////
+
+SkColorFilter* SkColorMatrixFilterRowMajor255::newComposed(const SkColorFilter* innerFilter) const {
     SkScalar innerMatrix[20];
-    if (innerFilter->asColorMatrix(innerMatrix) && !SkColorMatrix::NeedsClamping(innerMatrix)) {
+    if (innerFilter->asColorMatrix(innerMatrix) && !needs_clamping(innerMatrix)) {
         SkScalar concat[20];
-        SkColorMatrix::SetConcat(concat, fMatrix.fMat, innerMatrix);
-        return SkColorMatrixFilter::Create(concat);
+        set_concat(concat, fMatrix, innerMatrix);
+        return new SkColorMatrixFilterRowMajor255(concat);
     }
     return nullptr;
 }
 
 #if SK_SUPPORT_GPU
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLUniformHandler.h"
 
 class ColorMatrixEffect : public GrFragmentProcessor {
 public:
-    static const GrFragmentProcessor* Create(const SkColorMatrix& matrix) {
+    static const GrFragmentProcessor* Create(const SkScalar matrix[20]) {
         return new ColorMatrixEffect(matrix);
     }
 
     const char* name() const override { return "Color Matrix"; }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     class GLSLProcessor : public GrGLSLFragmentProcessor {
     public:
         // this class always generates the same code.
@@ skipping 26 matching lines @@
                                      uniformHandler->getUniformCStr(fVectorHandle));
             fragBuilder->codeAppendf("\t%s = clamp(%s, 0.0, 1.0);\n",
                                      args.fOutputColor, args.fOutputColor);
             fragBuilder->codeAppendf("\t%s.rgb *= %s.a;\n", args.fOutputColor, args.fOutputColor);
         }
 
     protected:
         virtual void onSetData(const GrGLSLProgramDataManager& uniManager,
                                const GrProcessor& proc) override {
             const ColorMatrixEffect& cme = proc.cast<ColorMatrixEffect>();
-            const float* m = cme.fMatrix.fMat;
+            const float* m = cme.fMatrix;
             // The GL matrix is transposed from SkColorMatrix.
             float mt[]  = {
                 m[0], m[5], m[10], m[15],
                 m[1], m[6], m[11], m[16],
                 m[2], m[7], m[12], m[17],
                 m[3], m[8], m[13], m[18],
             };
             static const float kScale = 1.0f / 255.0f;
             float vec[] = {
                 m[4] * kScale, m[9] * kScale, m[14] * kScale, m[19] * kScale,
             };
             uniManager.setMatrix4fv(fMatrixHandle, 1, mt);
             uniManager.set4fv(fVectorHandle, 1, vec);
         }
 
     private:
         GrGLSLProgramDataManager::UniformHandle fMatrixHandle;
         GrGLSLProgramDataManager::UniformHandle fVectorHandle;
 
         typedef GrGLSLFragmentProcessor INHERITED;
     };
 
 private:
-    ColorMatrixEffect(const SkColorMatrix& matrix) : fMatrix(matrix) {
+    ColorMatrixEffect(const SkScalar matrix[20]) {
+        memcpy(fMatrix, matrix, sizeof(SkScalar) * 20);
         this->initClassID<ColorMatrixEffect>();
     }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
         return new GLSLProcessor(*this);
     }
 
     virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                        GrProcessorKeyBuilder* b) const override {
         GLSLProcessor::GenKey(*this, caps, b);
     }
 
     bool onIsEqual(const GrFragmentProcessor& s) const override {
         const ColorMatrixEffect& cme = s.cast<ColorMatrixEffect>();
-        return cme.fMatrix == fMatrix;
+        return 0 == memcmp(fMatrix, cme.fMatrix, sizeof(fMatrix));
     }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         // We only bother to check whether the alpha channel will be constant. If SkColorMatrix had
         // type flags it might be worth checking the other components.
 
         // The matrix is defined such the 4th row determines the output alpha. The first four
         // columns of that row multiply the input r, g, b, and a, respectively, and the last column
         // is the "translation".
         static const uint32_t kRGBAFlags[] = {
             kR_GrColorComponentFlag,
             kG_GrColorComponentFlag,
             kB_GrColorComponentFlag,
             kA_GrColorComponentFlag
         };
         static const int kShifts[] = {
             GrColor_SHIFT_R, GrColor_SHIFT_G, GrColor_SHIFT_B, GrColor_SHIFT_A,
         };
         enum {
             kAlphaRowStartIdx = 15,
             kAlphaRowTranslateIdx = 19,
         };
 
         SkScalar outputA = 0;
         for (int i = 0; i < 4; ++i) {
             // If any relevant component of the color to be passed through the matrix is non-const
             // then we can't know the final result.
-            if (0 != fMatrix.fMat[kAlphaRowStartIdx + i]) {
+            if (0 != fMatrix[kAlphaRowStartIdx + i]) {
                 if (!(inout->validFlags() & kRGBAFlags[i])) {
                     inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
                     return;
                 } else {
                     uint32_t component = (inout->color() >> kShifts[i]) & 0xFF;
-                    outputA += fMatrix.fMat[kAlphaRowStartIdx + i] * component;
+                    outputA += fMatrix[kAlphaRowStartIdx + i] * component;
                 }
             }
         }
-        outputA += fMatrix.fMat[kAlphaRowTranslateIdx];
+        outputA += fMatrix[kAlphaRowTranslateIdx];
         // We pin the color to [0,1]. This would happen to the *final* color output from the frag
         // shader but currently the effect does not pin its own output. So in the case of over/
         // underflow this may deviate from the actual result. Maybe the effect should pin its
         // result if the matrix could over/underflow for any component?
         inout->setToOther(kA_GrColorComponentFlag,
                           static_cast<uint8_t>(SkScalarPin(outputA, 0, 255)) << GrColor_SHIFT_A,
                           GrInvariantOutput::kWill_ReadInput);
     }
 
-    SkColorMatrix fMatrix;
+    SkScalar fMatrix[20];
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ColorMatrixEffect);
 
 const GrFragmentProcessor* ColorMatrixEffect::TestCreate(GrProcessorTestData* d) {
-    SkColorMatrix colorMatrix;
-    for (size_t i = 0; i < SK_ARRAY_COUNT(colorMatrix.fMat); ++i) {
-        colorMatrix.fMat[i] = d->fRandom->nextSScalar1();
+    SkScalar colorMatrix[20];
+    for (size_t i = 0; i < SK_ARRAY_COUNT(colorMatrix); ++i) {
+        colorMatrix[i] = d->fRandom->nextSScalar1();
     }
     return ColorMatrixEffect::Create(colorMatrix);
 }
 
-const GrFragmentProcessor* SkColorMatrixFilter::asFragmentProcessor(GrContext*) const {
+const GrFragmentProcessor* SkColorMatrixFilterRowMajor255::asFragmentProcessor(GrContext*) const {
     return ColorMatrixEffect::Create(fMatrix);
 }
 
 #endif
 
 #ifndef SK_IGNORE_TO_STRING
-void SkColorMatrixFilter::toString(SkString* str) const {
-    str->append("SkColorMatrixFilter: ");
+void SkColorMatrixFilterRowMajor255::toString(SkString* str) const {
+    str->append("SkColorMatrixFilterRowMajor255: ");
 
     str->append("matrix: (");
     for (int i = 0; i < 20; ++i) {
-        str->appendScalar(fMatrix.fMat[i]);
+        str->appendScalar(fMatrix[i]);
         if (i < 19) {
             str->append(", ");
         }
     }
     str->append(")");
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkScalar byte_to_scale(U8CPU byte) {
-    if (0xFF == byte) {
-        // want to get this exact
-        return 1;
-    } else {
-        return byte * 0.00392156862745f;
-    }
+SkColorFilter* SkColorFilter::CreateMatrixFilterRowMajor255(const SkScalar array[20]) {
+    return new SkColorMatrixFilterRowMajor255(array);
 }
-
-SkColorFilter* SkColorMatrixFilter::CreateLightingFilter(SkColor mul, SkColor add) {
-    SkColorMatrix matrix;
-    matrix.setScale(byte_to_scale(SkColorGetR(mul)),
-                    byte_to_scale(SkColorGetG(mul)),
-                    byte_to_scale(SkColorGetB(mul)),
-                    1);
-    matrix.postTranslate(SkIntToScalar(SkColorGetR(add)),
-                         SkIntToScalar(SkColorGetG(add)),
-                         SkIntToScalar(SkColorGetB(add)),
-                         0);
-    return SkColorMatrixFilter::Create(matrix);
-}