lcd blits for sRGB

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 404 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;
 }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+#include "SkColorPriv.h"
+
+static Sk4f lcd16_to_unit_4f(uint16_t rgb) {
+    Sk4i rgbi = Sk4i(SkGetPackedR16(rgb), SkGetPackedG16(rgb)>>1, SkGetPackedB16(rgb), 0);

[mtklein, 2016/02/18 13:35:55]

Why throw away a green bit?

  Sk4i rgbi = Sk4i(SkGetPackedR16(rgb), SkGetPackedG16(rgb),
SkGetPackedB16(rgb), 0);
  return SkNx_cast<float>(rgbi) * Sk4f(1.0f/31, 1.0f/63, 1.0f/31, 0);

[reed1, 2016/02/18 15:11:35]

Was wondering if a single value for the scale was cheaper, and worth the lost
bit in green. We can try it both ways.

+    return SkNx_cast<float>(rgbi) * Sk4f(1.0f/31);
+}
+
+template <DstType D>
+void src_1_lcd(uint32_t dst[], const SkPM4f* src, int count, const uint16_t lcd[]) {
+    const Sk4f s4 = Sk4f::Load(src->fVec);
+    
+    if (D == kLinear_Dst) {
+        // operate in bias-255 space for src and dst
+        const Sk4f& s4bias = s4 * Sk4f(255);

[mtklein, 2016/02/18 13:35:55]

Seems odd (wrong?) to declare this as a const&.

[reed1, 2016/02/18 15:11:35]

Yes, copy/paste error.

+        for (int i = 0; i < count; ++i) {
+            const unsigned rgb = lcd[i];

[mtklein, 2016/02/18 13:35:55]

Somewhat weird to use unsigned here but pass it as uint16_t to lcd16_to_uint_4f.
 I'd go with uint16_t everywhere...

[reed1, 2016/02/18 15:11:35]

Done. old habit of not wanting the register to be smaller than natural

+            if (0 == rgb) {
+                continue;
+            }
+            Sk4f d4bias = to_4f(dst[i]);
+            dst[i] = to_4b(lerp(s4bias, d4bias, lcd16_to_unit_4f(rgb))) | (SK_A32_MASK << SK_A32_SHIFT);
+        }
+    } else {    // kSRGB
+        for (int i = 0; i < count; ++i) {
+            const unsigned rgb = lcd[i];

[mtklein, 2016/02/18 13:35:55]

(here too)

[reed1, 2016/02/18 15:11:35]

Done.

+            if (0 == rgb) {
+                continue;
+            }
+            Sk4f d4 = load_dst<D>(dst[i]);
+            dst[i] = store_dst<D>(lerp(s4, d4, lcd16_to_unit_4f(rgb))) | (SK_A32_MASK << SK_A32_SHIFT);
+        }
+    }
+}
+
+template <DstType D>
+void src_n_lcd(uint32_t dst[], const SkPM4f src[], int count, const uint16_t lcd[]) {
+    for (int i = 0; i < count; ++i) {
+        const unsigned rgb = lcd[i];

[mtklein, 2016/02/18 13:35:56]

No 0 check?

[reed1, 2016/02/18 15:11:35]

Done.

+        Sk4f s4 = Sk4f::Load(src[i].fVec);
+        Sk4f d4 = load_dst<D>(dst[i]);
+        dst[i] = store_dst<D>(lerp(s4, d4, lcd16_to_unit_4f(rgb))) | (SK_A32_MASK << SK_A32_SHIFT);
+    }
+}
+
+template <DstType D>
+void srcover_1_lcd(uint32_t dst[], const SkPM4f* src, int count, const uint16_t lcd[]) {
+    const Sk4f s4 = Sk4f::Load(src->fVec);
+    Sk4f dst_scale = Sk4f(1 - get_alpha(s4));
+
+    for (int i = 0; i < count; ++i) {
+        for (int i = 0; i < count; ++i) {

[mtklein, 2016/02/18 13:35:55]

Hmm...

Compilers _hate_ him!
One weird trick to speed up your loop by a sqrt!

[reed1, 2016/02/18 15:11:35]

CLEARLY I haven't tested the N case yet :)
fixed.

+            const unsigned rgb = lcd[i];
+            if (0 == rgb) {
+                continue;
+            }
+            Sk4f d4 = load_dst<D>(dst[i]);
+            Sk4f r4 = s4 + d4 * dst_scale;
+            if (0xFFFF != rgb) {
+                r4 = lerp(r4, d4, lcd16_to_unit_4f(rgb));
+            }
+            dst[i] = store_dst<D>(r4) | (SK_A32_MASK << SK_A32_SHIFT);
+        }
+    }
+}
+
+template <DstType D>
+void srcover_n_lcd(uint32_t dst[], const SkPM4f src[], int count, const uint16_t lcd[]) {
+    for (int i = 0; i < count; ++i) {
+        for (int i = 0; i < count; ++i) {

[mtklein, 2016/02/18 13:35:55]

(ditto)

[reed1, 2016/02/18 15:11:35]

Done.

+            const unsigned rgb = lcd[i];
+            if (0 == rgb) {
+                continue;
+            }
+            Sk4f s4 = Sk4f::Load(src[i].fVec);
+            Sk4f dst_scale = Sk4f(1 - get_alpha(s4));
+            Sk4f d4 = load_dst<D>(dst[i]);
+            Sk4f r4 = s4 + d4 * dst_scale;
+            if (0xFFFF != rgb) {
+                r4 = lerp(r4, d4, lcd16_to_unit_4f(rgb));
+            }
+            dst[i] = store_dst<D>(r4) | (SK_A32_MASK << SK_A32_SHIFT);
+        }
+    }
+}
+
+SkXfermode::LCD32Proc SkXfermode::GetLCD32Proc(uint32_t flags) {
+    SkASSERT((flags & ~7) == 0);
+    flags &= 7;
+
+    const LCD32Proc procs[] = {
+        srcover_n_lcd<kSRGB_Dst>,   src_n_lcd<kSRGB_Dst>,
+        srcover_1_lcd<kSRGB_Dst>,   src_1_lcd<kSRGB_Dst>,
+
+        srcover_n_lcd<kLinear_Dst>, src_n_lcd<kLinear_Dst>,
+        srcover_1_lcd<kLinear_Dst>, src_1_lcd<kLinear_Dst>,
+    };
+    return procs[flags];
+}