Simplified linear pipeline.

gm/SkLinearBitmapPipelineGM.cpp

Index: gm/SkLinearBitmapPipelineGM.cpp
diff --git a/gm/SkLinearBitmapPipelineGM.cpp b/gm/SkLinearBitmapPipelineGM.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd6a42392d3ba64eb4f3fcafbee842fa41e57b2a
--- /dev/null
+++ b/gm/SkLinearBitmapPipelineGM.cpp
@@ -0,0 +1,192 @@
+/*
+ * 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 "gm.h"
+#include "SkCanvas.h"
+#include "SkColor.h"
+#include "SkImage.h"
+#include "SkImageInfo.h"
+#include "SkLinearBitmapPipeline.h"
+#include "SkXfermode.h"
+#include "SkPM4fPriv.h"
+#include "SkShader.h"
+
+static void fill_in_bits(SkBitmap& bm, SkIRect ir, SkColor c, bool premul) {
+    bm.allocN32Pixels(ir.width(), ir.height());
+    SkPixmap pm;
+    bm.peekPixels(&pm);
+
+    SkPMColor b = SkColorSetARGBMacro(255, 0, 0, 0);
+    SkPMColor w;
+    if (premul) {
+        w = SkPreMultiplyColor(c);
+    } else {
+        w = SkPackARGB32NoCheck(SkColorGetA(c), SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));
+    }
+
+    for (int y = 0; y < ir.height(); y++) {
+        for (int x = 0; x < ir.width(); x++) {
+            if ((x ^ y)  & 16) {
+                *pm.writable_addr32(x, y) = b;
+            } else {
+                *pm.writable_addr32(x, y) = w;
+            }
+        }
+    }
+}
+
+static void draw_rect_orig(SkCanvas* canvas, const SkRect& r, SkColor c, const SkMatrix* mat, bool useBilerp) {
+    const SkIRect ir = r.round();
+
+    SkBitmap bmsrc;
+    fill_in_bits(bmsrc, ir, c, true);
+
+    SkPixmap pmsrc;
+    bmsrc.peekPixels(&pmsrc);
+
+    SkBitmap bmdst;
+    bmdst.allocN32Pixels(ir.width(), ir.height());
+    bmdst.eraseColor(0xFFFFFFFF);
+    SkPixmap pmdst;
+    bmdst.peekPixels(&pmdst);
+
+    SkImageInfo info = SkImageInfo::MakeN32Premul(ir.width(), ir.height(), kLinear_SkColorProfileType);
+
+    SkAutoTUnref<SkImage> image{SkImage::NewRasterCopy(
+        info, pmsrc.addr32(), pmsrc.rowBytes())};
+    SkPaint paint;
+    int32_t storage[200];
+    SkShader* shader = image->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    if (useBilerp) {
+        paint.setFilterQuality(SkFilterQuality::kLow_SkFilterQuality);
+    } else {
+        paint.setFilterQuality(SkFilterQuality::kNone_SkFilterQuality);
+    }
+    paint.setShader(shader)->unref();
+    SkASSERT(paint.getShader()->contextSize() <= sizeof(storage));
+
+    SkShader::Context* ctx = paint.getShader()->createContext(
+        {paint, *mat, nullptr},
+        storage);
+
+    for (int y = 0; y < ir.height(); y++) {
+        ctx->shadeSpan(0, y, pmdst.writable_addr32(0, y), ir.width());
+    }
+
+    canvas->drawBitmap(bmdst, r.left(), r.top(), nullptr);
+
+    ctx->~Context();
+
+}
+
+static void draw_rect_fp(SkCanvas* canvas, const SkRect& r, SkColor c, const SkMatrix* mat, bool useBilerp) {
+    const SkIRect ir = r.round();
+
+    SkBitmap bmsrc;
+    fill_in_bits(bmsrc, ir, c, true);
+    SkPixmap pmsrc;
+    bmsrc.peekPixels(&pmsrc);
+
+    SkBitmap bmdst;
+    bmdst.allocN32Pixels(ir.width(), ir.height());
+    bmdst.eraseColor(0xFFFFFFFF);
+    SkPixmap pmdst;
+    bmdst.peekPixels(&pmdst);
+
+    SkPM4f* dstBits = new SkPM4f[ir.width()];
+    SkImageInfo info = SkImageInfo::MakeN32(ir.width(), ir.height(), kPremul_SkAlphaType);
+
+    SkMatrix inv;
+    bool trash = mat->invert(&inv);
+    sk_ignore_unused_variable(trash);
+
+
+    uint32_t flags = 0;
+    //if (kSRGB_SkColorProfileType == profile) {
+        //flags |= SkXfermode::kDstIsSRGB_PM4fFlag;
+    //}
+    const SkXfermode::PM4fState state { nullptr, flags };
+    auto procN = SkXfermode::GetPM4fProcN(SkXfermode::kSrcOver_Mode, flags);
+
+    SkLinearBitmapPipeline pipeline{
+            inv, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, info, pmsrc.addr32()};
+
+
+    for (int y = 0; y < ir.height(); y++) {
+        pipeline.shadeSpan4f(0, y, dstBits, ir.width());
+        procN(state, pmdst.writable_addr32(0, y), dstBits, ir.width(), nullptr);
+    }
+
+    delete [] dstBits;
+
+    canvas->drawBitmap(bmdst, r.left(), r.top(), nullptr);
+}
+
+static void draw_rect_none(SkCanvas* canvas, const SkRect& r, SkColor c) {
+    const SkIRect ir = r.round();
+
+    SkBitmap bm;
+    fill_in_bits(bm, ir, c, true);
+
+    canvas->drawBitmap(bm, r.left(), r.top(), nullptr);
+}
+
+/*
+ *  Test SkXfer4fProcs directly for src-over, comparing them to current SkColor blits.
+ */
+DEF_SIMPLE_GM(linear_pipeline, canvas, 580, 1400) {
+    const int IW = 50;
+    const SkScalar W = IW;
+    const SkScalar H = 100;
+
+    const SkColor colors[] = {
+        0x880000FF, 0x8800FF00, 0x88FF0000, 0x88000000,
+        SK_ColorBLUE, SK_ColorGREEN, SK_ColorRED, SK_ColorBLACK,
+    };
+
+    canvas->translate(20, 20);
+
+    SkMatrix mi = SkMatrix::I();
+    SkMatrix mt;
+    mt.setTranslate(8, 8);
+    SkMatrix ms;
+    ms.setScale(2.7f, 2.7f);
+    SkMatrix mr;
+    mr.setRotate(10);
+
+    const SkMatrix* mats[] = {nullptr, &mi, &mt, &ms, &mr};
+
+    const SkRect r = SkRect::MakeWH(W, H);
+    bool useBilerp = false;
+    while (true) {
+        canvas->save();
+        for (auto mat : mats) {
+            canvas->save();
+            for (SkColor c : colors) {
+                if (mat == nullptr) {
+                    SkPaint p;
+                    p.setColor(c);
+                    draw_rect_none(canvas, r, c);
+                    canvas->translate(W + 20, 0);
+                    draw_rect_none(canvas, r, c);
+
+                } else {
+                    draw_rect_orig(canvas, r, c, mat, useBilerp);
+                    canvas->translate(W + 20, 0);
+                    draw_rect_fp(canvas, r, c, mat, useBilerp);
+                }
+                canvas->translate(W + 20, 0);
+            }
+            canvas->restore();
+            canvas->translate(0, H + 20);
+        }
+        canvas->restore();
+        canvas->translate(0, (H + 20) * SK_ARRAY_COUNT(mats));
+        if (useBilerp) break;
+        useBilerp = true;
+    }
+}