Add constant color GrFP.

include/gpu/GrInvariantOutput.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrInvariantOutput_DEFINED
 #define GrInvariantOutput_DEFINED
 
@@ skipping 98 matching lines @@
     void mulByKnownSingleComponent(uint8_t alpha) {
         if (this->hasZeroAlpha() || 0 == alpha) {
             this->internalSetToTransparentBlack();
         } else {
             if (alpha != 255) {
                 // Multiply color by alpha
                 fColor = GrColorPackRGBA(SkMulDiv255Round(GrColorUnpackR(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackG(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackB(fColor), alpha),
                                          SkMulDiv255Round(GrColorUnpackA(fColor), alpha));
+                // We don't need to change fIsSingleComponent in this case
             }
         }
     }
 
+    void mulByKnownFourComponents(GrColor color) {
+        GrColor a = GrColorUnpackA(color);
+        if (a == GrColorUnpackR(color) &&
+            a == GrColorUnpackG(color) &&
+            a == GrColorUnpackB(color)) {
+            this->mulByKnownSingleComponent(a);
+        } else {
+            if (color != 0xffffffff) {
+                fColor = GrColorPackRGBA(
+                    SkMulDiv255Round(GrColorUnpackR(fColor), GrColorUnpackR(color)),
+                    SkMulDiv255Round(GrColorUnpackG(fColor), GrColorUnpackG(color)),
+                    SkMulDiv255Round(GrColorUnpackB(fColor), GrColorUnpackB(color)),
+                    SkMulDiv255Round(GrColorUnpackA(fColor), GrColorUnpackA(color)));
+                    if (kRGBA_GrColorComponentFlags == fValidFlags) {
+                        GrColor a = GrColorUnpackA(fColor);
+                        fIsSingleComponent = a == GrColorUnpackR(fColor) &&
+                                             a == GrColorUnpackG(fColor) &&
+                                             a == GrColorUnpackB(fColor);
+                    }
+            }
+        }
+    }
+
+    // Ignores the incoming color's RGB and muls its alpha by color.
+    void mulAlphaByKnownFourComponents(GrColor color) {
+        GrColor a = GrColorUnpackA(color);
+        if (a == GrColorUnpackR(color) &&
+            a == GrColorUnpackG(color) &&
+            a == GrColorUnpackB(color)) {
+            this->mulAlphaByKnownSingleComponent(a);
+        } else if (fValidFlags & kA_GrColorComponentFlag) {
+            GrColor alpha = GrColorUnpackA(fColor);
+            if (0 == alpha) {
+                this->internalSetToTransparentBlack();
+            } else {
+                fColor = GrColorPackRGBA(
+                    SkMulDiv255Round(alpha, GrColorUnpackR(color)),
+                    SkMulDiv255Round(alpha, GrColorUnpackG(color)),
+                    SkMulDiv255Round(alpha, GrColorUnpackB(color)),
+                    SkMulDiv255Round(alpha, GrColorUnpackA(color)));
+                fValidFlags = kRGBA_GrColorComponentFlags;
+            }
+        } else {
+            fValidFlags = 0;
+        }
+    }
+
+    // Ignores the incoming color's RGB and muls its alpha by the alpha param and sets all channels
+    // equal to that value.
+    void mulAlphaByKnownSingleComponent(uint8_t alpha) {
+        if (0 == alpha || 0 == this->hasZeroAlpha()) {
+            this->internalSetToTransparentBlack();
+        } else {
+            if (fValidFlags & kA_GrColorComponentFlag) {
+                GrColor a = GrColorUnpackA(fColor);
+                a = SkMulDiv255Round(alpha, a);
+                fColor = GrColorPackRGBA(a, a, a, a);
+                fValidFlags = kRGBA_GrColorComponentFlags;
+            } else {
+                fValidFlags = 0;
+            }
+            fIsSingleComponent = true;
+        }
+    }
+
     void invalidateComponents(uint8_t invalidateFlags, ReadInput readsInput) {
         fValidFlags &= ~invalidateFlags;
         fIsSingleComponent = false;
         fNonMulStageFound = true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
     }
 
     void setToOther(uint8_t validFlags, GrColor color, ReadInput readsInput) {
         fValidFlags = validFlags;
         fColor = color;
         fIsSingleComponent = false;
         fNonMulStageFound = true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
+        if (kRGBA_GrColorComponentFlags == fValidFlags) {
+            GrColor a = GrColorUnpackA(fColor);

[egdaniel, 2015/03/31 21:02:54]

Maybe we should create some shared helper that can also used by
colorComponentsAllEqual() below

[bsalomon, 2015/04/01 19:54:27]

Done.

+            if (GrColorUnpackR(fColor) == a &&
+                GrColorUnpackG(fColor) == a &&
+                GrColorUnpackB(fColor) == a) {
+                fIsSingleComponent = true;
+            }
+        } else if (kA_GrColorComponentFlag & fValidFlags) {
+            // Assuming fColor is premul means if a is 0 the color
+            // must be all 0s.
+            if (!GrColorUnpackA(fColor)) {
+                SkASSERT(!(kR_GrColorComponentFlag & fValidFlags) || !GrColorUnpackR(fColor));

[egdaniel, 2015/03/31 21:02:54]

are there asserts really needed? seems like we are do the checkout of premul for
some client. But even if it is in an invalid premul state we would just be
forcing it to the correct one anyways.

Or we could make a shared helper with validPremulColor() below.

[bsalomon, 2015/04/01 19:54:26]

I think if we're going to assume that we're always in premul state, then we
should assert. I added lots of 'em.

+                SkASSERT(!(kG_GrColorComponentFlag & fValidFlags) || !GrColorUnpackG(fColor));
+                SkASSERT(!(kB_GrColorComponentFlag & fValidFlags) || !GrColorUnpackB(fColor));
+                fColor = 0;

[egdaniel, 2015/03/31 21:02:54]

just call internalSetToTransparentBlacK()?

+                fIsSingleComponent = true;
+                fValidFlags = kRGBA_GrColorComponentFlags;
+            }
+        }
     }
 
     void setToUnknown(ReadInput readsInput) {
         this->internalSetToUnknown();
         fNonMulStageFound= true;
         if (kWillNot_ReadInput == readsInput) {
             fWillUseInputColor = false;
         }
     }
 
@@ skipping 75 matching lines @@
     uint32_t fValidFlags;
     bool fIsSingleComponent;
     bool fNonMulStageFound;
     bool fWillUseInputColor;
     bool fIsLCDCoverage; // Temorary data member until texture pixel configs are updated
 
 };
 
 #endif