add pipecanvas

src/pipe/SkPipeCanvas.cpp

Index: src/pipe/SkPipeCanvas.cpp
diff --git a/src/pipe/SkPipeCanvas.cpp b/src/pipe/SkPipeCanvas.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..097f5a238efaabcd730d50c7b0bf600e813eb370
--- /dev/null
+++ b/src/pipe/SkPipeCanvas.cpp
@@ -0,0 +1,488 @@
+/*
+ * 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 "SkPipeCanvas.h"
+#include "SkPipeFormat.h"
+
+#include "SkPathEffect.h"
+#include "SkShader.h"
+#include "SkColorFilter.h"
+#include "SkImageFilter.h"
+#include "SkMaskFilter.h"
+#include "SkRasterizer.h"
+#include "SkStream.h"
+
+template <typename T> void write_rrect(T* writer, const SkRRect& rrect) {
+    char tmp[SkRRect::kSizeInMemory];
+    rrect.writeToMemory(tmp);
+    writer->write(tmp, SkRRect::kSizeInMemory);
+}
+
+template <typename T> void write_pad(T* writer, const void* buffer, size_t len) {
+    writer->write(buffer, len & ~3);
+    if (len & 3) {
+        const char* src = (const char*)buffer + (len & ~3);
+        len &= 3;
+        
+        char tmp[4];

[mtklein, 2016/08/04 12:50:37]

Or,

uint32_t tmp = 0;
memcpy(&tmp, src, len);
writer->write(&tmp, 4);

[reed1, 2016/08/04 13:18:41]

Nice. Considered that, but got temporarily confused about endianness (which
doesn't matter)

+        for (size_t i = 0; i < len; ++i) {
+            tmp[i] = src[i];
+        }
+        for (size_t i = len; i < 4; ++i) {
+            tmp[i] = 0;
+        }
+        writer->write(tmp, 4);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+class ScopedWriter : public SkBinaryWriteBuffer {
+public:
+    ScopedWriter(SkPipeCanvas*) : SkBinaryWriteBuffer(0) {}

[mtklein, 2016/08/04 12:50:37]

This probably doesn't need to inherit from SkBinaryWriteBuffer?  Is that just so
we don't have to retype the write() methods, or are we passing it somewhere that
needs to be an SkWriteBuffer?

I take it the idea is that at some point we'll call setDedupers() and in the
destructor we'll flush to fStream?

[reed1, 2016/08/04 13:18:41]

Correct, just wanted a quickie so that syntactically it would build.

+};
+
+static uint16_t compute_nondef(const SkPaint& paint, PaintUsage usage) {
+    const SkScalar kTextSize_Default    = 12;
+    const SkScalar kTextScaleX_Default  = 1;
+    const SkScalar kTextSkewX_Default   = 0;
+    const SkScalar kStrokeWidth_Default = 0;
+    const SkScalar kStrokeMiter_Default = 4;
+    const SkColor  kColor_Default       = SK_ColorBLACK;
+
+    unsigned bits = (paint.getColor() != kColor_Default) ? kColor_NonDef : 0;
+
+    if (kText_PaintUsage == usage) {
+        bits |= (paint.getTextSize() != kTextSize_Default       ? kTextSize_NonDef : 0);
+        bits |= (paint.getTextScaleX() != kTextScaleX_Default   ? kTextSize_NonDef : 0);

[mtklein, 2016/08/04 12:50:37]

I bet scale and skew stay default with a non-default size pretty often.

[reed1, 2016/08/04 13:18:41]

That's a typo, fixed.

+        bits |= (paint.getTextSkewX() != kTextSkewX_Default     ? kTextSize_NonDef : 0);
+        bits |= (paint.getTypeface()                            ? kTypeface_NonDef : 0);
+    }
+
+    if (usage & (kText_PaintUsage | kGeometry_PaintUsage)) {
+        bits |= (paint.getPathEffect()  ? kPathEffect_NonDef : 0);
+        bits |= (paint.getShader()      ? kShader_NonDef : 0);
+        bits |= (paint.getRasterizer()  ? kRasterizer_NonDef : 0);
+
+        if (paint.getStyle() != SkPaint::kFill_Style) {
+            bits |= (paint.getStrokeWidth() != kStrokeWidth_Default ? kStrokeWidth_NonDef : 0);
+            bits |= (paint.getStrokeMiter() != kStrokeMiter_Default ? kStrokeMiter_NonDef : 0);
+        }
+    }
+
+    bits |= (paint.getXfermode()    ? kXfermode_NonDef : 0);
+    bits |= (paint.getMaskFilter()  ? kMaskFilter_NonDef : 0);
+    bits |= (paint.getColorFilter() ? kColorFilter_NonDef : 0);
+    bits |= (paint.getImageFilter() ? kImageFilter_NonDef : 0);
+
+    return SkToU16(bits);
+}
+
+static uint32_t pack_paint_flags(unsigned flags, unsigned hint, unsigned align,
+                                 unsigned filter, unsigned caps, unsigned joins) {
+    SkASSERT(kFlags_BPF + kHint_BPF + kAlign_BPF + kFilter_BPF <= 32);
+
+    ASSERT_FITS_IN(flags, kFlags_BPF);
+    ASSERT_FITS_IN(hint, kHint_BPF);
+    ASSERT_FITS_IN(align, kAlign_BPF);
+    ASSERT_FITS_IN(filter, kFilter_BPF);
+    ASSERT_FITS_IN(caps, kCaps_BPF);
+    ASSERT_FITS_IN(joins, kJoins_BPF);
+
+    // left-align the fields of "known" size, and right-align the last (flatFlags) so it can easly
+    // add more bits in the future.
+
+    uint32_t packed = 0;
+    int shift = 32;
+
+    shift -= kFlags_BPF;    packed |= (flags << shift);
+    shift -= kHint_BPF;     packed |= (hint << shift);
+    shift -= kAlign_BPF;    packed |= (align << shift);
+    shift -= kFilter_BPF;   packed |= (filter << shift);
+    shift -= kCaps_BPF;     packed |= (caps << shift);
+    shift -= kJoins_BPF;    packed |= (joins << shift);
+
+    return packed;
+}
+
+#define CHECK_WRITE_SCALAR(bit, code)   \

[mtklein, 2016/08/04 12:50:37]

Might help readability to pass nondef in too.

[reed1, 2016/08/04 13:18:41]

... and writer? I was sort of modeling other macro helpers that have implicit
parameters, but I'll add those explicitly

[mtklein, 2016/08/04 15:13:23]

The rule of thumb I try to stick to is that implicit parameters must outlive the
macro in textual scope, so it's always clear what those params are.  I might not
have done so well...

+    do { if (nondef & (bit)) { writer.writeScalar(code); } } while (0)
+
+#define CHECK_WRITE_FLATTENABLE(bit, code)  \
+    do { if (nondef & (bit)) {              \
+        SkFlattenable* f = code;            \
+        SkASSERT(f != nullptr);             \
+        writer.writeFlattenable(f);         \
+    } } while (0)
+
+/*
+ *  Header:
+ *      paint flags     : 32
+ *      non_def bits    : 16
+ *      xfermode enum   : 8
+ *      pad zeros       : 8
+ */
+static void write_paint(SkWriteBuffer& writer, const SkPaint& paint, PaintUsage usage) {
+    uint32_t packedFlags = pack_paint_flags(paint.getFlags(), paint.getHinting(),
+                                            paint.getTextAlign(), paint.getFilterQuality(),
+                                            paint.getStrokeCap(), paint.getStrokeJoin());
+    writer.write32(packedFlags);
+
+    unsigned nondef = compute_nondef(paint, usage);
+    SkXfermode::Mode mode;
+    if (SkXfermode::AsMode(paint.getXfermode(), &mode)) {
+        nondef &= ~kXfermode_NonDef;    // don't need to store a pointer since we have an enum
+    } else {
+        SkASSERT(nondef & kXfermode_NonDef);
+        mode = (SkXfermode::Mode)0;
+    }
+    const uint8_t pad = 0;
+    writer.write32((nondef << 16) | ((unsigned)mode << 8) | pad);
+
+    CHECK_WRITE_SCALAR(kTextSize_NonDef,    paint.getTextSize());
+    CHECK_WRITE_SCALAR(kTextScaleX_NonDef,  paint.getTextScaleX());
+    CHECK_WRITE_SCALAR(kTextSkewX_NonDef,   paint.getTextSkewX());
+    CHECK_WRITE_SCALAR(kStrokeWidth_NonDef, paint.getStrokeWidth());
+    CHECK_WRITE_SCALAR(kStrokeMiter_NonDef, paint.getStrokeMiter());
+
+    if (nondef & kColor_NonDef) {
+        writer.write32(paint.getColor());
+    }
+    if (nondef & kTypeface_NonDef) {
+    }
+
+    CHECK_WRITE_FLATTENABLE(kPathEffect_NonDef,     paint.getPathEffect());
+    CHECK_WRITE_FLATTENABLE(kShader_NonDef,         paint.getShader());
+    CHECK_WRITE_FLATTENABLE(kXfermode_NonDef,       paint.getXfermode());
+    CHECK_WRITE_FLATTENABLE(kMaskFilter_NonDef,     paint.getMaskFilter());
+    CHECK_WRITE_FLATTENABLE(kColorFilter_NonDef,    paint.getColorFilter());
+    CHECK_WRITE_FLATTENABLE(kRasterizer_NonDef,     paint.getRasterizer());
+    CHECK_WRITE_FLATTENABLE(kImageFilter_NonDef,    paint.getImageFilter());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+SkPipeCanvas::SkPipeCanvas(int width, int height, SkWStream* stream)
+    : INHERITED(width, height)
+    , fStream(stream)
+{}
+
+SkPipeCanvas::~SkPipeCanvas() {}
+
+void SkPipeCanvas::willSave() {
+    this->writeVerb(kSave_Verb);

[mtklein, 2016/08/04 12:50:37]

We should probably funnel all verbs through the same way? 
write32(pack_verb(...)) seems fine to me... where is writeVerb() anyway?

[reed1, 2016/08/04 13:18:41]

Done

+
+    this->INHERITED::willSave();
+}
+
+SkCanvas::SaveLayerStrategy SkPipeCanvas::getSaveLayerStrategy(const SaveLayerRec& rec) {
+    this->INHERITED::getSaveLayerStrategy(rec);
+
+    return kNoLayer_SaveLayerStrategy;
+}
+
+void SkPipeCanvas::willRestore() {
+    this->writeVerb(kRestore_Verb);
+
+    this->INHERITED::willRestore();
+}
+
+void SkPipeCanvas::didConcat(const SkMatrix& matrix) {
+    SkMatrix::TypeMask tm = matrix.getType();
+    SkASSERT(tm != SkMatrix::kIdentity_Mask);
+    fStream->write32(pack_verb(kConcat_Verb, tm));
+
+    SkScalar tmp[9];
+    if (tm & SkMatrix::kPerspective_Mask) {
+        matrix.get9(tmp);
+        fStream->write(tmp, 9 * sizeof(SkScalar));
+    } else if (tm & SkMatrix::kAffine_Mask) {
+        tmp[0] = matrix[SkMatrix::kMScaleX];
+        tmp[1] = matrix[SkMatrix::kMSkewX];
+        tmp[2] = matrix[SkMatrix::kMTransX];
+        tmp[3] = matrix[SkMatrix::kMScaleY];
+        tmp[4] = matrix[SkMatrix::kMSkewY];
+        tmp[5] = matrix[SkMatrix::kMTransY];
+        fStream->write(tmp, 6 * sizeof(SkScalar));
+    } else if (tm & SkMatrix::kScale_Mask) {
+        tmp[0] = matrix[SkMatrix::kMScaleX];
+        tmp[1] = matrix[SkMatrix::kMTransX];
+        tmp[2] = matrix[SkMatrix::kMScaleY];
+        tmp[3] = matrix[SkMatrix::kMTransY];
+        fStream->write(tmp, 4 * sizeof(SkScalar));
+    } else if (tm & SkMatrix::kTranslate_Mask) {
+        tmp[0] = matrix[SkMatrix::kMTransX];
+        tmp[1] = matrix[SkMatrix::kMTransY];
+        fStream->write(tmp, 2 * sizeof(SkScalar));
+    }
+
+    this->INHERITED::didConcat(matrix);
+}
+
+void SkPipeCanvas::didSetMatrix(const SkMatrix& matrix) {
+    // Can we eliminate this?
+    this->INHERITED::didSetMatrix(matrix);
+}
+
+void SkPipeCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+    fStream->write32(pack_verb(kClipRect_Verb, ((unsigned)op << 1) | edgeStyle));

[mtklein, 2016/08/04 12:50:37]

static inline pack_clip(SkRegion::Op, ClipEdgeStyle = kHard)  ?

[reed1, 2016/08/04 13:18:41]

Yea, there are lots of helpers like this I will write (e.g. clip, text, image)
that have custom "extra" packings.

+    fStream->write(&rect, 4 * sizeof(SkScalar));
+
+    this->INHERITED::onClipRect(rect, op, edgeStyle);
+}
+
+void SkPipeCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+    fStream->write32(pack_verb(kClipRRect_Verb, ((unsigned)op << 1) | edgeStyle));
+    write_rrect(fStream, rrect);
+
+    this->INHERITED::onClipRRect(rrect, op, edgeStyle);
+}
+
+void SkPipeCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kClipPath_Verb, ((unsigned)op << 1) | edgeStyle));
+    writer.writePath(path);
+
+    this->INHERITED::onClipPath(path, op, edgeStyle);
+}
+
+void SkPipeCanvas::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kClipRegion_Verb, (unsigned)op << 1));
+    writer.writeRegion(deviceRgn);
+
+    this->INHERITED::onClipRegion(deviceRgn, op);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+void SkPipeCanvas::onDrawPaint(const SkPaint& paint) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawPaint_Verb));
+    write_paint(writer, paint, kDrawPaint_PaintUsage);
+}
+
+void SkPipeCanvas::onDrawPoints(PointMode mode, size_t count, const SkPoint pts[],
+                                const SkPaint& paint) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawPoints_Verb, mode));
+    writer.write32(SkToU32(count));
+    writer.write(pts, count * sizeof(SkPoint));
+    write_paint(writer, paint, kGeometry_PaintUsage);
+}
+
+void SkPipeCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawRect_Verb));
+    writer.write(&rect, sizeof(SkRect));
+    write_paint(writer, paint, kGeometry_PaintUsage);
+}
+
+void SkPipeCanvas::onDrawOval(const SkRect& rect, const SkPaint& paint) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawOval_Verb));
+    writer.write(&rect, sizeof(SkRect));
+    write_paint(writer, paint, kGeometry_PaintUsage);
+}
+
+void SkPipeCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawRRect_Verb));
+    write_rrect(&writer, rrect);
+    write_paint(writer, paint, kGeometry_PaintUsage);
+}
+
+void SkPipeCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawDRRect_Verb));
+    write_rrect(&writer, outer);
+    write_rrect(&writer, inner);
+    write_paint(writer, paint, kGeometry_PaintUsage);
+}
+
+void SkPipeCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawPath_Verb));
+    writer.writePath(path);
+    write_paint(writer, paint, kGeometry_PaintUsage);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+static sk_sp<SkImage> make_from_bitmap(const SkBitmap& bitmap) {
+    // If we just "make" an image, it will force a CPU copy (if its mutable), only to have
+    // us then either find it in our cache, or compress and send it.
+    //
+    // Better could be to look it up in our cache first, and only create/compress it if we have to.
+    //
+    // But for now, just do the dumb thing...
+    return SkImage::MakeFromBitmap(bitmap);
+}
+
+void SkPipeCanvas::onDrawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
+                                const SkPaint* paint) {
+    sk_sp<SkImage> image = make_from_bitmap(bitmap);
+    if (image) {
+        this->onDrawImage(image.get(), x, y, paint);
+    }
+}
+
+void SkPipeCanvas::onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst,
+                                    const SkPaint* paint, SrcRectConstraint constraint) {
+    sk_sp<SkImage> image = make_from_bitmap(bitmap);
+    if (image) {
+        this->onDrawImageRect(image.get(), src, dst, paint, constraint);
+    }
+}
+
+void SkPipeCanvas::onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
+                                    const SkRect& dst, const SkPaint* paint) {
+    sk_sp<SkImage> image = make_from_bitmap(bitmap);
+    if (image) {
+        this->onDrawImageNine(image.get(), center, dst, paint);
+    }
+}
+
+void SkPipeCanvas::onDrawImage(const SkImage* image, SkScalar left, SkScalar top,
+                               const SkPaint* paint) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawImage_Verb, paint != nullptr));
+    writer.writeImage(image);
+    writer.writeScalar(left);
+    writer.writeScalar(top);
+    if (paint) {
+        write_paint(writer, *paint, kImage_PaintUsage);
+    }
+}
+
+void SkPipeCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
+                                   const SkPaint* paint, SrcRectConstraint constraint) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawImageRect_Verb, ((src != nullptr) << 1) | (paint != nullptr)));
+    writer.writeImage(image);
+    if (src) {
+        writer.write(src, sizeof(*src));
+    }
+    writer.write(&dst, sizeof(dst));
+    if (paint) {
+        write_paint(writer, *paint, kImage_PaintUsage);
+    }
+}
+
+void SkPipeCanvas::onDrawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst,
+                                   const SkPaint* paint) {
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawImageNine_Verb, paint != nullptr));
+    writer.writeImage(image);
+    writer.write(&center, sizeof(center));
+    writer.write(&dst, sizeof(dst));
+    if (paint) {
+        write_paint(writer, *paint, kImage_PaintUsage);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+void SkPipeCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
+                              const SkPaint& paint) {
+    SkASSERT(byteLength);
+
+    bool compact = fits_in(byteLength, 24);
+
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawText_Verb, compact ? (unsigned)byteLength : 0));
+    if (!compact) {
+        writer.write32(SkToU32(byteLength));
+    }
+    write_pad(&writer, text, byteLength);
+    writer.writeScalar(x);
+    writer.writeScalar(y);
+    write_paint(writer, paint, kText_PaintUsage);
+}
+
+void SkPipeCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
+                                 const SkPaint& paint) {
+    SkASSERT(byteLength);
+    
+    bool compact = fits_in(byteLength, 24);
+    
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawText_Verb, compact ? (unsigned)byteLength : 0));
+    if (!compact) {
+        writer.write32(SkToU32(byteLength));
+    }
+    write_pad(&writer, text, byteLength);
+    writer.writePointArray(pos, paint.countText(text, byteLength));
+    write_paint(writer, paint, kText_PaintUsage);
+}
+
+void SkPipeCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
+                                  SkScalar constY, const SkPaint& paint) {
+    SkASSERT(byteLength);
+    
+    bool compact = fits_in(byteLength, 24);
+    
+    ScopedWriter writer(this);
+    writer.write32(pack_verb(kDrawText_Verb, compact ? (unsigned)byteLength : 0));
+    if (!compact) {
+        writer.write32(SkToU32(byteLength));
+    }
+    write_pad(&writer, text, byteLength);
+    writer.writeScalarArray(xpos, paint.countText(text, byteLength));
+    writer.writeScalar(constY);
+    write_paint(writer, paint, kText_PaintUsage);
+}
+
+void SkPipeCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
+                                    const SkMatrix* matrix, const SkPaint& paint) {
+    sk_throw();
+}
+
+void SkPipeCanvas::onDrawTextRSXform(const void* text, size_t byteLength, const SkRSXform xform[],
+                                     const SkRect* cull, const SkPaint& paint) {
+    sk_throw();
+}
+
+void SkPipeCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
+                                  const SkPaint &paint) {
+    sk_throw();
+}
+
+void SkPipeCanvas::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix,
+                                 const SkPaint* paint) {
+    sk_throw();
+}
+
+void SkPipeCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
+                                  const SkPoint vertices[], const SkPoint texs[],
+                                  const SkColor colors[], SkXfermode* xmode,
+                                  const uint16_t indices[], int indexCount,
+                                  const SkPaint& paint) {
+    sk_throw();
+}
+
+void SkPipeCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
+                               const SkPoint texCoords[4], SkXfermode* xmode,
+                               const SkPaint& paint) {
+    sk_throw();
+}
+
+void SkPipeCanvas::onDrawAnnotation(const SkRect& rect, const char key[], SkData* data) {
+    const size_t len = strlen(key);
+    bool compact = fits_in(len, 24);
+    fStream->write32(pack_verb(kDrawAnnotation_Verb, compact ? (unsigned)len : 0));
+    if (!compact) {
+        fStream->write32(SkToU32(len));
+    }
+    write_pad(fStream, key, len);
+    if (data) {
+        fStream->write32(SkToU32(data->size()));
+        write_pad(fStream, data->data(), data->size());
+    } else {
+        fStream->write32(0);
+    }
+}