New names for SkPMFloat methods.

src/core/SkXfermode.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkXfermode.h"
 #include "SkXfermode_opts_SSE2.h"
@@ skipping 798 matching lines @@
             return true;
         default:
             return false;
     }
 }
 
 bool SkProcCoeffXfermode::isOpaque(SkXfermode::SrcColorOpacity opacityType) const {
     if (CANNOT_USE_COEFF == fSrcCoeff) {
         return false;
     }
-   
+
     if (SkXfermode::kDA_Coeff == fSrcCoeff || SkXfermode::kDC_Coeff == fSrcCoeff ||
         SkXfermode::kIDA_Coeff == fSrcCoeff || SkXfermode::kIDC_Coeff == fSrcCoeff) {
         return false;
     }
-        
+
     switch (fDstCoeff) {
         case SkXfermode::kZero_Coeff:
             return true;
         case SkXfermode::kISA_Coeff:
             return SkXfermode::kOpaque_SrcColorOpacity == opacityType;
         case SkXfermode::kSA_Coeff:
             return SkXfermode::kTransparentBlack_SrcColorOpacity == opacityType ||
                    SkXfermode::kTransparentAlpha_SrcColorOpacity == opacityType;
         case SkXfermode::kSC_Coeff:
             return SkXfermode::kTransparentBlack_SrcColorOpacity == opacityType;
@@ skipping 374 matching lines @@
  *
  *  If we know we're going to write-out the values as bytes, we can relax these somewhat,
  *  since we only really need to enforce that the bytes are valid premul...
  *
  *  To that end, this method asserts that the resulting pmcolor will be valid, but does not call
  *  SkPMFloat::isValid(), as that would fire sometimes, but not result in a bad pixel.
  */
 static inline SkPMFloat check_as_pmfloat(const Sk4f& value) {
     SkPMFloat pm = value;
 #ifdef SK_DEBUG
-    (void)pm.get();
+    (void)pm.round();
 #endif
     return pm;
 }
 
 //  kSrcATop_Mode,  //!< [Da, Sc * Da + (1 - Sa) * Dc]
 struct SrcATop4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
         Sk4f s4 = src;
         Sk4f d4 = dst;
@@ skipping 61 matching lines @@
     static const bool kFoldCoverageIntoSrcAlpha = true;
     static const SkXfermode::Mode kMode = SkXfermode::kScreen_Mode;
 };
 
 template <typename ProcType>
 class SkT4fXfermode : public SkProcCoeffXfermode {
 public:
     static SkXfermode* Create(const ProcCoeff& rec) {
         return SkNEW_ARGS(SkT4fXfermode, (rec));
     }
-    
+
     void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[]) const override {
         if (NULL == aa) {
             while (n & 3) {
-                *dst = ProcType::Xfer(SkPMFloat(*src++), SkPMFloat(*dst)).get();
+                *dst = ProcType::Xfer(SkPMFloat(*src++), SkPMFloat(*dst)).round();
                 dst++;
                 n -= 1;
             }
             n >>= 2;
             for (int i = 0; i < n; ++i) {
                 SkPMFloat s0, s1, s2, s3;
                 SkPMFloat::From4PMColors(src, &s0, &s1, &s2, &s3);
                 SkPMFloat d0, d1, d2, d3;
                 SkPMFloat::From4PMColors(dst, &d0, &d1, &d2, &d3);
-                SkPMFloat::To4PMColors(ProcType::Xfer(s0, d0), ProcType::Xfer(s1, d1),
-                                       ProcType::Xfer(s2, d2), ProcType::Xfer(s3, d3), dst);
+                SkPMFloat::RoundTo4PMColors(ProcType::Xfer(s0, d0), ProcType::Xfer(s1, d1),
+                                            ProcType::Xfer(s2, d2), ProcType::Xfer(s3, d3), dst);
                 src += 4;
                 dst += 4;
             }
         } else {
             for (int i = 0; i < n; ++i) {
                 const Sk4f aa4 = Sk4f(aa[i] * gInv255);
                 SkPMFloat dstF(dst[i]);
                 SkPMFloat srcF(src[i]);
                 Sk4f res;
                 if (ProcType::kFoldCoverageIntoSrcAlpha) {
                     Sk4f src4 = srcF;
                     res = ProcType::Xfer(src4 * aa4, dstF);
                 } else {
                     res = ramp(dstF, ProcType::Xfer(srcF, dstF), aa4);
                 }
-                dst[i] = SkPMFloat(res).get();
+                dst[i] = SkPMFloat(res).round();
             }
         }
     }
-    
+
 private:
     SkT4fXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, ProcType::kMode) {}
-    
+
     typedef SkProcCoeffXfermode INHERITED;
 };
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkDstOutXfermode : public SkProcCoeffXfermode {
 public:
     static SkDstOutXfermode* Create(const ProcCoeff& rec) {
         return SkNEW_ARGS(SkDstOutXfermode, (rec));
@@ skipping 372 matching lines @@
         } else {
             proc16 = rec.fProc16_General;
         }
     }
     return proc16;
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END