Adding 3D lut color filter

gm/colorprofile.cpp

Index: gm/colorprofile.cpp
diff --git a/gm/colorprofile.cpp b/gm/colorprofile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..11c863f446a4f9b5d66d3de96723172465ae7508
--- /dev/null
+++ b/gm/colorprofile.cpp
@@ -0,0 +1,150 @@
+/*
+ * Copyright 2014 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 "SkColorProfileFilter.h"
+#include "SkBitmapSource.h"
+#include "SkData.h"
+#include "SkGradientShader.h"
+
+namespace skiagm {
+
+static SkShader* MakeLinear() {
+    static const SkPoint pts[2] = {
+            { 0, 0 },
+            { SkIntToScalar(80), SkIntToScalar(80) }
+        };
+    static const SkColor colors[] = { SK_ColorYELLOW, SK_ColorBLUE };
+    return SkGradientShader::CreateLinear(
+        pts, colors, NULL, 2, SkShader::kRepeat_TileMode, 0, &SkMatrix::I());
+}
+
+class ColorProfileGM : public GM {
+public:
+    ColorProfileGM()
+    : fInitialized(false)
+    , f3DLut4(NULL)
+    , f3DLut8(NULL)
+    , f3DLut16(NULL)
+    , f3DLut32(NULL)
+    , f3DLut64(NULL)
+    {
+        this->setBGColor(0xFF000000);
+    }
+
+    ~ColorProfileGM() {
+        SkSafeUnref(f3DLut4);
+        SkSafeUnref(f3DLut8);
+        SkSafeUnref(f3DLut16);
+        SkSafeUnref(f3DLut32);
+        SkSafeUnref(f3DLut64);
+    }
+
+protected:
+    virtual SkString onShortName() {
+        return SkString("colorprofile");
+    }
+
+    void make_3Dluts() {
+        make_3Dlut(&f3DLut4, 4, true, false, false);
+        make_3Dlut(&f3DLut8, 8, false, true, false);
+        make_3Dlut(&f3DLut16, 16, false, true, true);
+        make_3Dlut(&f3DLut32, 32, true, true, false);
+        make_3Dlut(&f3DLut64, 64, true, false, true);
+    }
+
+    void make_bitmap() {
+        fBitmap.allocN32Pixels(80, 80);
+        SkCanvas canvas(fBitmap);
+        canvas.clear(0x00000000);
+        SkPaint paint;
+        paint.setAntiAlias(true);
+        SkShader* shader = MakeLinear();
+        paint.setShader(shader);
+        SkRect r = { 0, 0, SkIntToScalar(80), SkIntToScalar(80) };
+        canvas.drawRect(r, paint);
+        shader->unref();
+    }
+
+    void make_3Dlut(SkData** data, int size, bool invR, bool invG, bool invB) {
+        *data = SkData::NewUninitialized(sizeof(SkColor) * size * size * size);
+        SkColor* pixels = (SkColor*)((*data)->writable_data());
+        SkAutoMalloc lutMemory(size);
+        SkAutoMalloc invLutMemory(size);
+        uint8_t* lut = (uint8_t*)lutMemory.get();
+        uint8_t* invLut = (uint8_t*)invLutMemory.get();
+        const int maxIndex = size - 1;
+        for (int i = 0; i < size; i++) {
+            lut[i] = (i * 255) / maxIndex;
+            invLut[i] = ((maxIndex - i) * 255) / maxIndex;
+        }
+        for (int r = 0; r < size; ++r) {
+            for (int g = 0; g < size; ++g) {
+                for (int b = 0; b < size; ++b) {
+                    pixels[(size * ((size * b) + g)) + r] = SkColorSetARGB(0xFF,
+                            invR ? invLut[r] : lut[r],
+                            invG ? invLut[g] : lut[g],
+                            invB ? invLut[b] : lut[b]);
+                }
+            }
+        }
+    }
+
+    virtual SkISize onISize() {
+        return SkISize::Make(500, 100);
+    }
+
+    void drawClippedBitmap(SkCanvas* canvas, int x, int y, const SkPaint& paint) {
+        canvas->save();
+        canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
+        canvas->clipRect(SkRect::MakeWH(SkIntToScalar(fBitmap.width()),
+                                        SkIntToScalar(fBitmap.height())));
+        canvas->drawBitmap(fBitmap, 0, 0, &paint);
+        canvas->restore();
+    }
+
+    virtual void onDraw(SkCanvas* canvas) {
+        if (!fInitialized) {
+            this->make_bitmap();
+            this->make_3Dluts();
+            fInitialized = true;
+        }
+        canvas->clear(0x00000000);
+        SkPaint paint;
+        paint.setColorFilter(SkColorProfileFilter::Create(f3DLut4, 4))->unref();
+        drawClippedBitmap(canvas, 10, 10, paint);

[Stephen White, 2014/10/06 16:40:40]

Not sure if drawClippedBitmap() is necessary here either, but if it isn't,
consider removing it.

[sugoi1, 2014/10/06 17:18:41]

Done.

+
+        paint.setColorFilter(SkColorProfileFilter::Create(f3DLut8, 8))->unref();
+        drawClippedBitmap(canvas, 110, 10, paint);
+
+        paint.setColorFilter(SkColorProfileFilter::Create(f3DLut16, 16))->unref();
+        drawClippedBitmap(canvas, 210, 10, paint);
+
+        paint.setColorFilter(SkColorProfileFilter::Create(f3DLut32, 32))->unref();
+        drawClippedBitmap(canvas, 310, 10, paint);
+
+        paint.setColorFilter(SkColorProfileFilter::Create(f3DLut64, 64))->unref();
+        drawClippedBitmap(canvas, 410, 10, paint);
+    }
+
+private:
+    typedef GM INHERITED;
+    bool fInitialized;
+    SkBitmap fBitmap;
+    SkData* f3DLut4;
+    SkData* f3DLut8;
+    SkData* f3DLut16;
+    SkData* f3DLut32;
+    SkData* f3DLut64;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static GM* MyFactory(void*) { return new ColorProfileGM; }
+static GMRegistry reg(MyFactory);
+
+}