extend gm to test aa[] parameter on xfer4f procs

src/core/SkXfermode4f.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPM4fPriv.h"
 #include "SkUtils.h"
 #include "SkXfermode.h"
@@ skipping 21 matching lines @@
 }
 
 static Sk4f srgb_4b_to_linear_unit(SkPMColor dstC) {
     return Sk4f_fromS32(dstC);
 }
 
 template <DstType D> uint32_t store_dst(const Sk4f& x4) {
     return (D == kSRGB_Dst) ? Sk4f_toS32(x4) : Sk4f_toL32(x4);
 }
 
-static uint32_t linear_unit_to_srgb_32(const Sk4f& l4) {
-    return Sk4f_toL32(l4);
-}
-
 static Sk4f linear_unit_to_srgb_255f(const Sk4f& l4) {
     return linear_to_srgb(l4) * Sk4f(255) + Sk4f(0.5f);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static Sk4f scale_255_round(const SkPM4f& pm4) {
     return Sk4f::Load(pm4.fVec) * Sk4f(255) + Sk4f(0.5f);
 }
 
@@ skipping 217 matching lines @@
     
     if (aa) {
         for (int i = 0; i < count; ++i) {
             unsigned a = aa[i];
             if (0 == a) {
                 continue;
             }
             Sk4f d4 = Sk4f_fromL32(dst[i]);
             Sk4f r4;
             if (a != 0xFF) {
-                s4 = scale_by_coverage(s4, a);
-                r4 = s4 + d4 * Sk4f(1 - get_alpha(s4));
+                Sk4f s4_aa = scale_by_coverage(s4, a);

[mtklein, 2016/02/03 01:32:55]

Ah!  Let's make s4 and dst_scale const?

I guarantee the compiler will allocate registers as well as we can manually if
you just always give each new value a new name.  All the good ones give each new
value a new name internally anyway (this is "SSA" form, single static
assignment).

[reed1, 2016/02/03 03:19:49]

ok

+                r4 = s4_aa + d4 * Sk4f(1 - get_alpha(s4_aa));
             } else {
                 r4 = s4 + d4 * dst_scale;
             }
             dst[i] = Sk4f_toL32(r4);
         }
     } else {
         s4 = s4 * Sk4f(255) + Sk4f(0.5f);   // +0.5 to pre-bias for rounding
         while (count >= 4) {
             Sk4f d0 = to_4f(dst[0]);
             Sk4f d1 = to_4f(dst[1]);
@@ skipping 21 matching lines @@
 
     if (aa) {
         for (int i = 0; i < count; ++i) {
             unsigned a = aa[i];
             if (0 == a) {
                 continue;
             }
             Sk4f d4 = srgb_4b_to_linear_unit(dst[i]);
             Sk4f r4;
             if (a != 0xFF) {
-                s4 = scale_by_coverage(s4, a);
-                r4 = s4 + d4 * Sk4f(1 - get_alpha(s4));
+                Sk4f s4_aa = scale_by_coverage(s4, a);
+                r4 = s4_aa + d4 * Sk4f(1 - get_alpha(s4_aa));
             } else {
                 r4 = s4 + d4 * dst_scale;
             }
-            dst[i] = linear_unit_to_srgb_32(r4);
+            dst[i] = to_4b(linear_unit_to_srgb_255f(r4));
         }
     } else {
         while (count >= 4) {
             Sk4f d0 = srgb_4b_to_linear_unit(dst[0]);
             Sk4f d1 = srgb_4b_to_linear_unit(dst[1]);
             Sk4f d2 = srgb_4b_to_linear_unit(dst[2]);
             Sk4f d3 = srgb_4b_to_linear_unit(dst[3]);
             Sk4f_ToBytes((uint8_t*)dst,
                          linear_unit_to_srgb_255f(s4 + d0 * dst_scale),
                          linear_unit_to_srgb_255f(s4 + d1 * dst_scale),
@@ skipping 43 matching lines @@
 
 SkXfermode::PM4fProc1 SkXfermode::getPM4fProc1(uint32_t flags) const {
     Mode mode;
     return this->asMode(&mode) ? GetPM4fProc1(mode, flags) : xfer_pm4_proc_1;
 }
 
 SkXfermode::PM4fProcN SkXfermode::getPM4fProcN(uint32_t flags) const {
     Mode mode;
     return this->asMode(&mode) ? GetPM4fProcN(mode, flags) : xfer_pm4_proc_n;
 }