Add SkRasterPipeline blitter.

src/core/SkRasterPipelineBlitter.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 "SkBlitter.h"
+#include "SkColor.h"
+#include "SkColorFilter.h"
+#include "SkPM4f.h"
+#include "SkRasterPipeline.h"
+#include "SkShader.h"
+#include "SkSRGB.h"
+#include "SkXfermode.h"
+
+
+struct SkRasterPipelineBlitter : public SkBlitter {

[reed1, 2016/07/20 13:09:59]

class?

[mtklein, 2016/07/20 13:29:03]

Done.

+    SkRasterPipelineBlitter(SkPixmap dst,
+                            SkRasterPipeline shader,
+                            SkRasterPipeline colorFilter,
+                            SkRasterPipeline xfermode,
+                            SkPM4f paintColor)
+        : fDst(dst)
+        , fShader(shader)
+        , fColorFilter(colorFilter)
+        , fXfermode(xfermode)
+        , fPaintColor(paintColor)
+    {}
+
+    void blitH    (int x, int y, int w)                            override;
+    void blitAntiH(int x, int y, const SkAlpha[], const int16_t[]) override;
+    void blitMask (const SkMask&, const SkIRect& clip)             override;
+
+    // TODO: The default implementations of the other blits look fine,
+    // but some of them like blitV could probably benefit from custom
+    // blits using something like a SkRasterPipeline::runFew() method.
+
+    SkPixmap         fDst;
+    SkRasterPipeline fShader, fColorFilter, fXfermode;
+    SkPM4f           fPaintColor;
+
+    typedef SkBlitter INHERITED;
+};
+
+
+
+// The default shader produces a constant color (from the SkPaint).
+static void SK_VECTORCALL constant_color(SkRasterPipeline::Stage* st, size_t x,
+                                         Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                         Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto color = st->ctx<const SkPM4f*>();
+    r = color->r();
+    g = color->g();
+    b = color->b();
+    a = color->a();
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+// The default transfer mode is srcover, s' = s + d*(1-sa).
+static void SK_VECTORCALL srcover(SkRasterPipeline::Stage* st, size_t x,
+                                  Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                  Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto A = 1.0f - a;
+    r += dr*A;
+    g += dg*A;
+    b += db*A;
+    a += da*A;
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+// s' = d(1-c) + sc, for a constant c.
+static void SK_VECTORCALL lerp_constant_float(SkRasterPipeline::Stage* st, size_t x,
+                                              Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                              Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    Sk4f c = *st->ctx<const float*>();
+
+    Sk4f C = 1.0f - c;
+    r = r*c + dr*C;
+    g = g*c + dg*C;
+    b = b*c + db*C;
+    a = a*c + da*C;
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+// s' = d(1-c) + sc, 4 pixels at a time for 8-bit coverage.
+static void SK_VECTORCALL lerp_a8(SkRasterPipeline::Stage* st, size_t x,
+                                  Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                  Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto ptr = st->ctx<const uint8_t*>() + x;
+    Sk4f c = SkNx_cast<float>(Sk4b::Load(ptr)) * (1/255.0f);
+
+    Sk4f C = 1.0f - c;
+    r = r*c + dr*C;
+    g = g*c + dg*C;
+    b = b*c + db*C;
+    a = a*c + da*C;
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+// Tail variant of lerp_a8() handling 1 pixel at a time.
+static void SK_VECTORCALL lerp_a8_1(SkRasterPipeline::Stage* st, size_t x,
+                                    Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                    Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto ptr = st->ctx<const uint8_t*>() + x;
+    Sk4f c = *ptr * (1/255.0f);
+
+    Sk4f C = 1.0f - c;
+    r = r*c + dr*C;
+    g = g*c + dg*C;
+    b = b*c + db*C;
+    a = a*c + da*C;
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+static void upscale_lcd16(const Sk4h& lcd16, Sk4f* r, Sk4f* g, Sk4f* b) {
+    Sk4i _32_bit = SkNx_cast<int>(lcd16);
+
+    *r = SkNx_cast<float>(_32_bit & SK_R16_MASK_IN_PLACE) * (1.0f / SK_R16_MASK_IN_PLACE);
+    *g = SkNx_cast<float>(_32_bit & SK_G16_MASK_IN_PLACE) * (1.0f / SK_G16_MASK_IN_PLACE);
+    *b = SkNx_cast<float>(_32_bit & SK_B16_MASK_IN_PLACE) * (1.0f / SK_B16_MASK_IN_PLACE);
+}
+
+// s' = d(1-c) + sc, 4 pixels at a time for 565 coverage.
+static void SK_VECTORCALL lerp_lcd16(SkRasterPipeline::Stage* st, size_t x,
+                                     Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                     Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto ptr = st->ctx<const uint16_t*>() + x;
+    Sk4f cr, cg, cb;
+    upscale_lcd16(Sk4h::Load(ptr), &cr, &cg, &cb);
+
+    r = r*cr + dr*(1.0f - cr);
+    g = g*cg + dg*(1.0f - cg);
+    b = b*cb + db*(1.0f - cb);
+    a = 1.0f;
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+// Tail variant of lerp_lcd16() handling 1 pixel at a time.
+static void SK_VECTORCALL lerp_lcd16_1(SkRasterPipeline::Stage* st, size_t x,
+                                       Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                       Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto ptr = st->ctx<const uint16_t*>() + x;
+    Sk4f cr, cg, cb;
+    upscale_lcd16({*ptr,0,0,0}, &cr, &cg, &cb);
+
+    r = r*cr + dr*(1.0f - cr);
+    g = g*cg + dg*(1.0f - cg);
+    b = b*cb + db*(1.0f - cb);
+    a = 1.0f;
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+// Load 4 8-bit sRGB pixels from SkPMColor order to RGBA.
+static void SK_VECTORCALL load_d_srgb(SkRasterPipeline::Stage* st, size_t x,
+                                      Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                      Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto ptr = st->ctx<const uint32_t*>() + x;
+
+    dr = { sk_linear_from_srgb[(ptr[0] >> SK_R32_SHIFT) & 0xff],
+           sk_linear_from_srgb[(ptr[1] >> SK_R32_SHIFT) & 0xff],
+           sk_linear_from_srgb[(ptr[2] >> SK_R32_SHIFT) & 0xff],
+           sk_linear_from_srgb[(ptr[3] >> SK_R32_SHIFT) & 0xff] };
+
+    dg = { sk_linear_from_srgb[(ptr[0] >> SK_G32_SHIFT) & 0xff],
+           sk_linear_from_srgb[(ptr[1] >> SK_G32_SHIFT) & 0xff],
+           sk_linear_from_srgb[(ptr[2] >> SK_G32_SHIFT) & 0xff],
+           sk_linear_from_srgb[(ptr[3] >> SK_G32_SHIFT) & 0xff] };
+
+    db = { sk_linear_from_srgb[(ptr[0] >> SK_B32_SHIFT) & 0xff],
+           sk_linear_from_srgb[(ptr[1] >> SK_B32_SHIFT) & 0xff],
+           sk_linear_from_srgb[(ptr[2] >> SK_B32_SHIFT) & 0xff],
+           sk_linear_from_srgb[(ptr[3] >> SK_B32_SHIFT) & 0xff] };
+
+    // TODO: this >> doesn't really need mask if we make it logical instead of arithmetic.
+    da = SkNx_cast<float>((Sk4i::Load(ptr) >> SK_A32_SHIFT) & 0xff) * (1/255.0f);
+
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+// Tail variant of load_d_srgb() handling 1 pixel at a time.
+static void SK_VECTORCALL load_d_srgb_1(SkRasterPipeline::Stage* st, size_t x,
+                                        Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                        Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto ptr = st->ctx<const uint32_t*>() + x;
+
+    dr = { sk_linear_from_srgb[(*ptr >> SK_R32_SHIFT) & 0xff], 0,0,0 };
+    dg = { sk_linear_from_srgb[(*ptr >> SK_G32_SHIFT) & 0xff], 0,0,0 };
+    db = { sk_linear_from_srgb[(*ptr >> SK_B32_SHIFT) & 0xff], 0,0,0 };
+    da = {        (1/255.0f) * (*ptr >> SK_A32_SHIFT)        , 0,0,0 };
+
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+static Sk4f clamp_0_255(const Sk4f& x) {
+    // This Max() argument order clamps NaN to 0.
+    return Sk4f::Min(Sk4f::Max(x, 0.0f), 255.0f);
+}
+
+// Write out 4 pixels as 8-bit SkPMColor-order sRGB.
+static void SK_VECTORCALL store_srgb(SkRasterPipeline::Stage* st, size_t x,
+                                     Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                     Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    r = clamp_0_255(sk_linear_to_srgb(r));
+    g = clamp_0_255(sk_linear_to_srgb(g));
+    b = clamp_0_255(sk_linear_to_srgb(b));
+    a = clamp_0_255(         255.0f * a );
+
+    auto dst = st->ctx<uint32_t*>() + x;
+    ( Sk4f_round(r) << SK_R32_SHIFT
+    | Sk4f_round(g) << SK_G32_SHIFT
+    | Sk4f_round(b) << SK_B32_SHIFT
+    | Sk4f_round(a) << SK_A32_SHIFT).store(dst);
+}
+
+// Tail variant of store_srgb() handling 1 pixel at a time.
+static void SK_VECTORCALL store_srgb_1(SkRasterPipeline::Stage* st, size_t x,
+                                       Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                       Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto rgba = sk_linear_to_srgb({r[0], g[0], b[0], 0}),
+           pm = clamp_0_255({rgba[SK_R_INDEX], rgba[SK_G_INDEX], rgba[SK_B_INDEX], 255.0f*a[0]});
+
+    auto dst = st->ctx<uint32_t*>() + x;
+    SkNx_cast<uint8_t>(Sk4f_round(pm)).store(dst);
+}
+
+
+template <typename Effect>
+static bool append_effect_stages(const Effect* effect, SkRasterPipeline* pipeline) {
+    return !effect || effect->appendStages(pipeline);
+}
+
+std::unique_ptr<SkBlitter> SkCreateRasterPipelineBlitter(const SkPixmap& dst,
+                                                         const SkPaint& paint) {
+    if (!dst.info().gammaCloseToSRGB()) {
+        return nullptr;  // TODO: f16, etc.
+    }
+    if (paint.getShader()) {
+        return nullptr;  // TODO: need to work out how shaders and their contexts work
+    }
+
+    SkRasterPipeline shader, colorFilter, xfermode;
+    if (!append_effect_stages(paint.getColorFilter(), &colorFilter) ||
+        !append_effect_stages(paint.getXfermode(),    &xfermode   )) {
+        return nullptr;
+    }
+
+    // TODO: SkPM4f paintColor = SkColor4f::FromColor(paint.getColor()).premul();
+    // once FromColor() is correct sRGB -> linear.
+    SkPM4f paintColor = SkColor4f{
+        sk_linear_from_srgb[SkColorGetR(paint.getColor())],
+        sk_linear_from_srgb[SkColorGetG(paint.getColor())],
+        sk_linear_from_srgb[SkColorGetB(paint.getColor())],
+              (1/255.0f) *  SkColorGetA(paint.getColor()) ,
+    }.premul();
+
+    std::unique_ptr<SkRasterPipelineBlitter> blitter(new SkRasterPipelineBlitter{
+        dst,
+        shader, colorFilter, xfermode,
+        paintColor,
+    });
+
+    if (!paint.getShader()) {

[reed1, 2016/07/20 13:09:59]

didn't we already check on line 238?

[mtklein, 2016/07/20 13:29:03]

Yep.  This check will stay long-term, the one on 238 is temporary until I get
shaders an appendStages().

[reed1, 2016/07/20 13:32:39]

That's what I figured. sgtm

+        blitter->fShader.append(constant_color, &blitter->fPaintColor);
+    }
+    if (!paint.getXfermode()) {
+        blitter->fXfermode.append(srcover);
+    }
+
+    return std::move(blitter);
+}
+
+void SkRasterPipelineBlitter::blitH(int x, int y, int w) {
+    auto dst = fDst.writable_addr(0,y);
+
+    SkRasterPipeline p;
+    p.extend(fShader);
+    p.extend(fColorFilter);
+    p.append(load_d_srgb, load_d_srgb_1, dst);
+    p.extend(fXfermode);
+    p.append(store_srgb, store_srgb_1, dst);
+
+    p.run(x, w);
+}
+
+void SkRasterPipelineBlitter::blitAntiH(int x, int y, const SkAlpha aa[], const int16_t runs[]) {
+    auto dst = fDst.writable_addr(0,y);
+    float coverage;
+
+    SkRasterPipeline p;
+    p.extend(fShader);
+    p.extend(fColorFilter);
+    p.append(load_d_srgb, load_d_srgb_1, dst);
+    p.extend(fXfermode);
+    p.append(lerp_constant_float, &coverage);
+    p.append(store_srgb, store_srgb_1, dst);
+
+    for (int16_t run = *runs; run > 0; run = *runs) {
+        coverage = *aa * (1/255.0f);
+        p.run(x, run);
+
+        x    += run;
+        runs += run;
+        aa   += run;
+    }
+}
+
+void SkRasterPipelineBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {
+    if (mask.fFormat == SkMask::kBW_Format) {
+        // TODO: native BW masks?
+        return INHERITED::blitMask(mask, clip);
+    }
+
+    for (int y = clip.top(); y < clip.bottom(); y++) {
+        auto dst = fDst.writable_addr(0,y);
+
+        SkRasterPipeline p;
+        p.extend(fShader);
+        p.extend(fColorFilter);
+        p.append(load_d_srgb, load_d_srgb_1, dst);
+        p.extend(fXfermode);
+        switch (mask.fFormat) {
+            case SkMask::kA8_Format:
+                p.append(lerp_a8, lerp_a8_1, mask.getAddr8(0,y));
+                break;
+            case SkMask::kLCD16_Format:
+                p.append(lerp_lcd16, lerp_lcd16_1, mask.getAddrLCD16(0,y));
+                break;
+            default: break;
+        }
+        p.append(store_srgb, store_srgb_1, dst);
+
+        p.run(clip.left(), clip.width());
+    }
+}