Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1082)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/pipe/SkPipeReader.cpp

Issue 2201323003: add pipecanvas (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: drawVertices and drawTextOnPath Created 4 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« src/pipe/SkPipeFormat.h ('K') | « src/pipe/SkPipeFormat.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/pipe/SkPipeReader.cpp
diff --git a/src/pipe/SkPipeReader.cpp b/src/pipe/SkPipeReader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b30904ea4bd6c450546176336b25a67e2ea12d60
--- /dev/null
+++ b/src/pipe/SkPipeReader.cpp
@@ -0,0 +1,733 @@
+/*
+ * 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 "SkCanvas.h"
+#include "SkDeduper.h"
+#include "SkPicture.h"
+#include "SkPictureRecorder.h"
+#include "SkPipe.h"
+#include "SkPipeFormat.h"
+#include "SkReadBuffer.h"
+#include "SkRefSet.h"
+#include "SkRSXform.h"
+#include "SkTextBlob.h"
+#include "SkTypeface.h"
+
+class SkPipeReader;
+
+static bool do_playback(SkPipeReader& reader, SkCanvas* canvas);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+class SkPipeInflator : public SkInflator {
+public:
+ SkPipeInflator(SkRefSet<SkImage>* images, SkRefSet<SkPicture>* pictures,
+ SkRefSet<SkTypeface>* typefaces, SkTDArray<SkFlattenable::Factory>* factories)
+ : fImages(images)
+ , fPictures(pictures)
+ , fTypefaces(typefaces)
+ , fFactories(factories)
+ {}
+
+ SkImage* getImage(int index) override {
+ return index ? fImages->get(index - 1) : nullptr;
+ }
+ SkPicture* getPicture(int index) override {
+ return index ? fPictures->get(index - 1) : nullptr;
+ }
+ SkTypeface* getTypeface(int index) override { return fTypefaces->get(index); }
+ SkFlattenable::Factory getFactory(int index) override {
+ return index ? fFactories->getAt(index - 1) : nullptr;
+ }
+
+ bool setImage(int index, SkImage* img) {
+ return fImages->set(index - 1, img);
+ }
+ bool setPicture(int index, SkPicture* pic) {
+ return fPictures->set(index - 1, pic);
+ }
+ bool setTypeface(int index, SkTypeface* face) {
+ return fTypefaces->set(index - 1, face);
+ }
+ bool setFactory(int index, SkFlattenable::Factory factory) {
+ SkASSERT(index > 0);
+ SkASSERT(factory);
+ index -= 1;
+ if ((unsigned)index < (unsigned)fFactories->count()) {
+ (*fFactories)[index] = factory;
+ return true;
+ }
+ if (fFactories->count() == index) {
+ *fFactories->append() = factory;
+ return true;
+ }
+ SkDebugf("setFactory: index [%d] out of range %d\n", index, fFactories->count());
+ return false;
+ }
+
+private:
+ SkRefSet<SkImage>* fImages;
+ SkRefSet<SkPicture>* fPictures;
+ SkRefSet<SkTypeface>* fTypefaces;
+ SkTDArray<SkFlattenable::Factory>* fFactories;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename T> const T* skip(SkReadBuffer& reader, int count = 1) {
+ return (const T*)reader.skip(count * sizeof(T));
+}
+
+static SkRRect read_rrect(SkReadBuffer& reader) {
+ SkRRect rrect;
+ rrect.readFromMemory(reader.skip(SkRRect::kSizeInMemory), SkRRect::kSizeInMemory);
+ return rrect;
+}
+
+static SkMatrix read_sparse_matrix(SkReadBuffer& reader, SkMatrix::TypeMask tm) {
+ SkMatrix matrix;
+ matrix.reset();
+
+ if (tm & SkMatrix::kPerspective_Mask) {
+ matrix.set9(skip<SkScalar>(reader, 9));
+ } else if (tm & SkMatrix::kAffine_Mask) {
+ const SkScalar* tmp = skip<SkScalar>(reader, 6);
+ matrix[SkMatrix::kMScaleX] = tmp[0];
+ matrix[SkMatrix::kMSkewX] = tmp[1];
+ matrix[SkMatrix::kMTransX] = tmp[2];
+ matrix[SkMatrix::kMScaleY] = tmp[3];
+ matrix[SkMatrix::kMSkewY] = tmp[4];
+ matrix[SkMatrix::kMTransY] = tmp[5];
+ } else if (tm & SkMatrix::kScale_Mask) {
+ const SkScalar* tmp = skip<SkScalar>(reader, 4);
+ matrix[SkMatrix::kMScaleX] = tmp[0];
+ matrix[SkMatrix::kMTransX] = tmp[1];
+ matrix[SkMatrix::kMScaleY] = tmp[2];
+ matrix[SkMatrix::kMTransY] = tmp[3];
+ } else if (tm & SkMatrix::kTranslate_Mask) {
+ const SkScalar* tmp = skip<SkScalar>(reader, 2);
+ matrix[SkMatrix::kMTransX] = tmp[0];
+ matrix[SkMatrix::kMTransY] = tmp[1];
+ }
+ // else read nothing for Identity
+ return matrix;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define CHECK_SET_SCALAR(Field) \
+ do { if (nondef & k##Field##_NonDef) { \
+ paint.set##Field(reader.readScalar()); \
+ }} while (0)
+
+#define CHECK_SET_FLATTENABLE(Field) \
+ do { if (nondef & k##Field##_NonDef) { \
+ paint.set##Field(reader.read##Field()); \
+ }} while (0)
+
+/*
+ * Header:
+ * paint flags : 32
+ * non_def bits : 16
+ * xfermode enum : 8
+ * pad zeros : 8
+ */
+static SkPaint read_paint(SkReadBuffer& reader) {
+ uint32_t packedFlags = reader.read32();
+ uint32_t extra = reader.read32();
+ unsigned nondef = extra >> 16;
+ SkXfermode::Mode mode = (SkXfermode::Mode)((extra >> 8) & 0xFF);
+ SkASSERT((extra & 0xFF) == 0);
+
+ SkPaint paint;
+
+ packedFlags >>= 2;
+ paint.setTextEncoding((SkPaint::TextEncoding)(packedFlags & 3)); packedFlags >>= 2;
+ paint.setTextAlign((SkPaint::Align)(packedFlags & 3)); packedFlags >>= 2;
+ paint.setHinting((SkPaint::Hinting)(packedFlags & 2)); packedFlags >>= 2;
+ paint.setStrokeJoin((SkPaint::Join)(packedFlags & 3)); packedFlags >>= 2;
+ paint.setStrokeCap((SkPaint::Cap)(packedFlags & 3)); packedFlags >>= 2;
+ paint.setStyle((SkPaint::Style)(packedFlags & 3)); packedFlags >>= 2;
+ paint.setFilterQuality((SkFilterQuality)(packedFlags & 3)); packedFlags >>= 2;
+ paint.setFlags(packedFlags);
+
+ CHECK_SET_SCALAR(TextSize);
+ CHECK_SET_SCALAR(TextScaleX);
+ CHECK_SET_SCALAR(TextSkewX);
+ CHECK_SET_SCALAR(StrokeWidth);
+ CHECK_SET_SCALAR(StrokeMiter);
+
+ if (nondef & kColor_NonDef) {
+ paint.setColor(reader.read32());
+ }
+ if (nondef & kTypeface_NonDef) {
mtklein 2016/08/26 18:43:23 :|
+ }
+
+ CHECK_SET_FLATTENABLE(PathEffect);
+ CHECK_SET_FLATTENABLE(Shader);
+ CHECK_SET_FLATTENABLE(Xfermode);
+ CHECK_SET_FLATTENABLE(MaskFilter);
+ CHECK_SET_FLATTENABLE(ColorFilter);
+ CHECK_SET_FLATTENABLE(Rasterizer);
+ CHECK_SET_FLATTENABLE(ImageFilter);
+
+ if (!(nondef & kXfermode_NonDef)) {
+ paint.setXfermodeMode(mode);
+ }
+
+ return paint;
+}
+
+class SkPipeReader : public SkReadBuffer {
+public:
+ SkPipeReader(SkPipeDeserializer* sink, const void* data, size_t size)
+ : SkReadBuffer(data, size)
+ , fSink(sink)
+ {}
+
+ SkPipeDeserializer* fSink;
+
+ SkFlattenable::Factory findFactory(const char name[]) {
+ SkFlattenable::Factory factory;
+ // Check if a custom Factory has been specified for this flattenable.
+ if (!(factory = this->getCustomFactory(SkString(name)))) {
+ // If there is no custom Factory, check for a default.
+ factory = SkFlattenable::NameToFactory(name);
+ }
+ return factory;
+ }
+
+ void readPaint(SkPaint* paint) override {
+ *paint = read_paint(*this);
+ }
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+typedef void (*SkPipeHandler)(SkPipeReader&, uint32_t packedVerb, SkCanvas*);
+
+static void save_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kSave == unpack_verb(packedVerb));
+ canvas->save();
+}
+
+static void saveLayer_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kSaveLayer == unpack_verb(packedVerb));
+ unsigned extra = unpack_verb_extra(packedVerb);
+ const SkRect* bounds = (extra & kHasBounds_SaveLayerMask) ? skip<SkRect>(reader) : nullptr;
+ SkPaint paintStorage, *paint = nullptr;
+ if (extra & kHasPaint_SaveLayerMask) {
+ paintStorage = read_paint(reader);
+ paint = &paintStorage;
+ }
+ sk_sp<SkImageFilter> backdrop;
+ if (extra & kHasBackdrop_SaveLayerMask) {
+ backdrop = reader.readImageFilter();
+ }
+ SkCanvas::SaveLayerFlags flags = (SkCanvas::SaveLayerFlags)(extra & kFlags_SaveLayerMask);
+ canvas->saveLayer(SkCanvas::SaveLayerRec(bounds, paint, backdrop.get(), flags));
+}
+
+static void restore_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kRestore == unpack_verb(packedVerb));
+ canvas->restore();
+}
+
+static void concat_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kConcat == unpack_verb(packedVerb));
+ SkMatrix::TypeMask tm = (SkMatrix::TypeMask)unpack_verb_extra(packedVerb);
+ canvas->concat(read_sparse_matrix(reader, tm));
+}
+
+static void clipRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kClipRect == unpack_verb(packedVerb));
+ SkRegion::Op op = (SkRegion::Op)(unpack_verb_extra(packedVerb) >> 1);
+ bool isAA = unpack_verb_extra(packedVerb) & 1;
+ canvas->clipRect(*skip<SkRect>(reader), op, isAA);
+}
+
+static void clipRRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kClipRRect == unpack_verb(packedVerb));
+ SkRegion::Op op = (SkRegion::Op)(unpack_verb_extra(packedVerb) >> 1);
+ bool isAA = unpack_verb_extra(packedVerb) & 1;
+ canvas->clipRRect(read_rrect(reader), op, isAA);
+}
+
+static void clipPath_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kClipPath == unpack_verb(packedVerb));
+ SkRegion::Op op = (SkRegion::Op)(unpack_verb_extra(packedVerb) >> 1);
+ bool isAA = unpack_verb_extra(packedVerb) & 1;
+ SkPath path;
+ reader.readPath(&path);
+ canvas->clipPath(path, op, isAA);
+}
+
+static void clipRegion_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kClipRegion == unpack_verb(packedVerb));
+ SkRegion::Op op = (SkRegion::Op)(unpack_verb_extra(packedVerb) >> 1);
+ SkRegion region;
+ reader.readRegion(&region);
+ canvas->clipRegion(region, op);
+}
+
+static void drawDRRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawDRRect == unpack_verb(packedVerb));
+ const SkRRect outer = read_rrect(reader);
+ const SkRRect inner = read_rrect(reader);
+ canvas->drawDRRect(outer, inner, read_paint(reader));
+}
+
+static void drawText_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawText == unpack_verb(packedVerb));
+ uint32_t len = unpack_verb_extra(packedVerb);
+ if (0 == len) {
+ len = reader.read32();
+ }
+ const void* text = reader.skip(SkAlign4(len));
+ SkScalar x = reader.readScalar();
+ SkScalar y = reader.readScalar();
+ canvas->drawText(text, len, x, y, read_paint(reader));
+}
+
+static void drawPosText_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawPosText == unpack_verb(packedVerb));
+ uint32_t len = unpack_verb_extra(packedVerb);
+ if (0 == len) {
+ len = reader.read32();
+ }
+ const void* text = reader.skip(SkAlign4(len));
+ int count = reader.read32();
+ const SkPoint* pos = skip<SkPoint>(reader, count);
+ SkPaint paint = read_paint(reader);
+ SkASSERT(paint.countText(text, len) == count);
+ canvas->drawPosText(text, len, pos, paint);
+}
+
+static void drawPosTextH_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawPosTextH == unpack_verb(packedVerb));
+ uint32_t len = unpack_verb_extra(packedVerb);
+ if (0 == len) {
+ len = reader.read32();
+ }
+ const void* text = reader.skip(SkAlign4(len));
+ int count = reader.read32();
+ const SkScalar* xpos = skip<SkScalar>(reader, count);
+ SkScalar constY = reader.readScalar();
+ SkPaint paint = read_paint(reader);
+ SkASSERT(paint.countText(text, len) == count);
+ canvas->drawPosTextH(text, len, xpos, constY, paint);
+}
+
+static void drawTextOnPath_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawTextOnPath == unpack_verb(packedVerb));
+ uint32_t byteLength = packedVerb & kTextLength_DrawTextOnPathMask;
+ SkMatrix::TypeMask tm = (SkMatrix::TypeMask)
+ ((packedVerb & kMatrixType_DrawTextOnPathMask) >> kMatrixType_DrawTextOnPathShift);
+
+ if (0 == byteLength) {
+ byteLength = reader.read32();
+ }
+ const void* text = reader.skip(SkAlign4(byteLength));
+ SkPath path;
+ reader.readPath(&path);
+ const SkMatrix* matrix = nullptr;
+ SkMatrix matrixStorage;
+ if (tm != SkMatrix::kIdentity_Mask) {
+ matrixStorage = read_sparse_matrix(reader, tm);
+ matrix = &matrixStorage;
+ }
+ canvas->drawTextOnPath(text, byteLength, path, matrix, read_paint(reader));
+}
+
+static void drawTextBlob_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ sk_sp<SkTextBlob> tb = SkTextBlob::MakeFromBuffer(reader);
+ SkScalar x = reader.readScalar();
+ SkScalar y = reader.readScalar();
+ canvas->drawTextBlob(tb, x, y, read_paint(reader));
+}
+
+static void drawTextRSXform_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawTextRSXform == unpack_verb(packedVerb));
+ uint32_t len = unpack_verb_extra(packedVerb) >> 1;
+ if (0 == len) {
+ len = reader.read32();
+ }
+ const void* text = reader.skip(SkAlign4(len));
+ int count = reader.read32();
+ const SkRSXform* xform = skip<SkRSXform>(reader, count);
+ const SkRect* cull = (packedVerb & 1) ? skip<SkRect>(reader) : nullptr;
+ SkPaint paint = read_paint(reader);
+ SkASSERT(paint.countText(text, len) == count);
+ canvas->drawTextRSXform(text, len, xform, cull, paint);
+}
+
+static void drawPatch_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawPatch == unpack_verb(packedVerb));
+ const SkColor* colors = nullptr;
+ const SkPoint* tex = nullptr;
+ const SkPoint* cubics = skip<SkPoint>(reader, 12);
+ if (packedVerb & kHasColors_DrawPatchExtraMask) {
+ colors = skip<SkColor>(reader, 4);
+ }
+ if (packedVerb & kHasTexture_DrawPatchExtraMask) {
+ tex = skip<SkPoint>(reader, 4);
+ }
+ sk_sp<SkXfermode> xfer;
+ unsigned mode = packedVerb & kModeEnum_DrawPatchExtraMask;
+ if (kExplicitXfer_DrawPatchExtraValue == mode) {
+ xfer = reader.readXfermode();
+ } else {
+ if (mode != SkXfermode::kSrcOver_Mode) {
+ xfer = SkXfermode::Make((SkXfermode::Mode)mode);
+ }
+ }
+ canvas->drawPatch(cubics, colors, tex, xfer.get(), read_paint(reader));
+}
+
+static void drawPaint_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawPaint == unpack_verb(packedVerb));
+ canvas->drawPaint(read_paint(reader));
+}
+
+static void drawRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawRect == unpack_verb(packedVerb));
+ const SkRect* rect = skip<SkRect>(reader);
+ canvas->drawRect(*rect, read_paint(reader));
+}
+
+static void drawOval_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawOval == unpack_verb(packedVerb));
+ const SkRect* rect = skip<SkRect>(reader);
+ canvas->drawOval(*rect, read_paint(reader));
+}
+
+static void drawRRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawRRect == unpack_verb(packedVerb));
+ SkRRect rrect = read_rrect(reader);
+ canvas->drawRRect(rrect, read_paint(reader));
+}
+
+static void drawPath_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawPath == unpack_verb(packedVerb));
+ SkPath path;
+ reader.readPath(&path);
+ canvas->drawPath(path, read_paint(reader));
+}
+
+static void drawPoints_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawPoints == unpack_verb(packedVerb));
+ SkCanvas::PointMode mode = (SkCanvas::PointMode)unpack_verb_extra(packedVerb);
+ int count = reader.read32();
+ const SkPoint* points = skip<SkPoint>(reader, count);
+ canvas->drawPoints(mode, count, points, read_paint(reader));
+}
+
+static void drawImage_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawImage == unpack_verb(packedVerb));
+ sk_sp<SkImage> image(reader.readImage());
+ SkScalar x = reader.readScalar();
+ SkScalar y = reader.readScalar();
+ SkPaint paintStorage, *paint = nullptr;
+ if (packedVerb & 1) {
+ paintStorage = read_paint(reader);
+ paint = &paintStorage;
+ }
+ canvas->drawImage(image, x, y, paint);
+}
+
+static void drawImageRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawImageRect == unpack_verb(packedVerb));
+ sk_sp<SkImage> image(reader.readImage());
+ const SkRect* src = (packedVerb & 2) ? skip<SkRect>(reader) : nullptr;
+ const SkRect* dst = skip<SkRect>(reader);
+ SkPaint paintStorage, *paint = nullptr;
+ if (packedVerb & 1) {
+ paintStorage = read_paint(reader);
+ paint = &paintStorage;
+ }
+ if (src) {
+ canvas->drawImageRect(image, *src, *dst, paint);
+ } else {
+ canvas->drawImageRect(image, *dst, paint);
+ }
+}
+
+static void drawImageNine_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawImageNine == unpack_verb(packedVerb));
+ sk_sp<SkImage> image(reader.readImage());
+ const SkIRect* center = skip<SkIRect>(reader);
+ const SkRect* dst = skip<SkRect>(reader);
+ SkPaint paintStorage, *paint = nullptr;
+ if (packedVerb & 1) {
+ paintStorage = read_paint(reader);
+ paint = &paintStorage;
+ }
+ canvas->drawImageNine(image, *center, *dst, paint);
+}
+
+static void drawVertices_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawVertices == unpack_verb(packedVerb));
+ SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)
+ ((packedVerb & kVMode_DrawVerticesMask) >> kVMode_DrawVerticesShift);
+ int vertexCount = packedVerb & kVCount_DrawVerticesMask;
+ if (0 == vertexCount) {
+ vertexCount = reader.read32();
+ }
+ sk_sp<SkXfermode> xfer;
+ unsigned xmode = (packedVerb & kVMode_DrawVerticesMask) >> kVMode_DrawVerticesShift;
+ if (0xFF == xmode) {
+ xfer = reader.readXfermode();
+ } else {
+ xfer = SkXfermode::Make((SkXfermode::Mode)xmode);
+ }
+ const SkPoint* vertices = skip<SkPoint>(reader, vertexCount);
+ const SkPoint* texs = nullptr;
+ if (packedVerb & kHasTex_DrawVerticesMask) {
+ texs = skip<SkPoint>(reader, vertexCount);
+ }
+ const SkColor* colors = nullptr;
+ if (packedVerb & kHasColors_DrawVerticesMask) {
+ colors = skip<SkColor>(reader, vertexCount);
+ }
+ int indexCount = 0;
+ const uint16_t* indices = nullptr;
+ if (packedVerb & kHasIndices_DrawVerticesMask) {
+ indexCount = reader.read32();
+ indices = skip<uint16_t>(reader, indexCount);
+ }
+
+ canvas->drawVertices(vmode, vertexCount, vertices, texs, colors, xfer.get(),
+ indices, indexCount, read_paint(reader));
+}
+
+static void drawPicture_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawPicture == unpack_verb(packedVerb));
+ unsigned extra = unpack_verb_extra(packedVerb);
+ int index = extra & kIndex_DefineObjectMask;
+ SkPicture* pic = reader.getInflator()->getPicture(index);
+ SkMatrix matrixStorage, *matrix = nullptr;
+ SkPaint paintStorage, *paint = nullptr;
+ if (extra & kHasMatrix_DrawPictureExtra) {
+ reader.readMatrix(&matrixStorage);
+ matrix = &matrixStorage;
+ }
+ if (extra & kHasPaint_DrawPictureExtra) {
+ paintStorage = read_paint(reader);
+ paint = &paintStorage;
+ }
+ canvas->drawPicture(pic, matrix, paint);
+}
+
+static void drawAnnotation_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDrawAnnotation == unpack_verb(packedVerb));
+ const SkRect* rect = skip<SkRect>(reader);
+
+ // len includes the key's trailing 0
+ uint32_t len = unpack_verb_extra(packedVerb) >> 1;
+ if (0 == len) {
+ len = reader.read32();
+ }
+ const char* key = skip<char>(reader, len);
+ sk_sp<SkData> data;
+ if (packedVerb & 1) {
+ uint32_t size = reader.read32();
+ data = SkData::MakeWithCopy(reader.skip(SkAlign4(size)), size);
+ }
+ canvas->drawAnnotation(*rect, key, data);
+}
+
+static void defineImage_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDefineImage == unpack_verb(packedVerb));
+ SkPipeInflator* inflator = (SkPipeInflator*)reader.getInflator();
+ uint32_t extra = unpack_verb_extra(packedVerb);
+ int index = extra & kIndex_DefineObjectMask;
+
+ if (extra & kForget_DefineObjectMask) {
+ // zero-index means we are "forgetting" that cache entry
+ inflator->setImage(index, nullptr);
+ } else {
+ // we are defining a new image
+ sk_sp<SkData> data = reader.readByteArrayAsData();
+ sk_sp<SkImage> image = SkImage::MakeFromEncoded(data);
+ inflator->setImage(index, image.get());
+ }
+}
+
+static void definePicture_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDefinePicture == unpack_verb(packedVerb));
+ uint32_t extra = unpack_verb_extra(packedVerb);
+ // we expect our caller to notice the "kEnd" and not call us
+ SkASSERT(0 == (extra & kEnd_DefinePictureMask));
+
+ SkPipeInflator* inflator = (SkPipeInflator*)reader.getInflator();
+ int index = extra & kIndex_DefineObjectMask;
+
+ if (extra & kForget_DefineObjectMask) {
+ // zero-index means we are "forgetting" that cache entry
+ inflator->setPicture(index, nullptr);
+ } else {
+ SkPictureRecorder recorder;
+ do_playback(reader, recorder.beginRecording(9999, 9999));
+ sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
+ inflator->setPicture(index, picture.get());
+ }
+}
+
+static void defineTypeface_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDefineTypeface == unpack_verb(packedVerb));
+}
+
+static void defineFactory_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
+ SkASSERT(SkPipeVerb::kDefineFactory == unpack_verb(packedVerb));
+ SkPipeInflator* inflator = (SkPipeInflator*)reader.getInflator();
+ uint32_t extra = unpack_verb_extra(packedVerb);
+ int index = extra >> kNameLength_DefineFactoryExtraBits;
+ size_t len = extra & kNameLength_DefineFactoryExtraMask;
+
+ const char* name = (const char*)reader.skip(SkAlign4(len));
+ SkFlattenable::Factory factory = reader.findFactory(name);
+ if (factory) {
+ inflator->setFactory(index, factory);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct HandlerRec {
+ SkPipeHandler fProc;
+ const char* fName;
+};
+
+#define HANDLER(name) { name##_handler, #name }
+const HandlerRec gPipeHandlers[] = {
+ HANDLER(save),
+ HANDLER(saveLayer),
+ HANDLER(restore),
+ HANDLER(concat),
+
+ HANDLER(clipRect),
+ HANDLER(clipRRect),
+ HANDLER(clipPath),
+ HANDLER(clipRegion),
+
+ HANDLER(drawDRRect),
+ HANDLER(drawText),
+ HANDLER(drawPosText),
+ HANDLER(drawPosTextH),
+ HANDLER(drawTextOnPath),
+ HANDLER(drawTextBlob),
+ HANDLER(drawTextRSXform),
+ HANDLER(drawPatch),
+ HANDLER(drawPaint),
+ HANDLER(drawPoints),
+ HANDLER(drawRect),
+ HANDLER(drawPath),
+ HANDLER(drawOval),
+ HANDLER(drawRRect),
+
+ HANDLER(drawImage),
+ HANDLER(drawImageRect),
+ HANDLER(drawImageNine),
+
+ HANDLER(drawVertices),
+
+ HANDLER(drawPicture),
+ HANDLER(drawAnnotation),
+
+ HANDLER(defineImage),
+ HANDLER(definePicture),
+ HANDLER(defineTypeface),
+ HANDLER(defineFactory),
+};
+#undef HANDLER
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+class SkPipeDeserializer::Impl {
+public:
+ SkRefSet<SkImage> fImages;
+ SkRefSet<SkPicture> fPictures;
+ SkRefSet<SkTypeface> fTypefaces;
+ SkTDArray<SkFlattenable::Factory> fFactories;
+};
+
+SkPipeDeserializer::SkPipeDeserializer() : fImpl(new Impl) {}
+SkPipeDeserializer::~SkPipeDeserializer() { delete fImpl; }
+
+sk_sp<SkPicture> SkPipeDeserializer::readPicture(const void* data, size_t size) {
+ if (size < sizeof(uint32_t) + sizeof(SkRect)) {
+ return nullptr;
+ }
+
+ uint32_t header;
+ memcpy(&header, data, 4); size -= 4; data = (const char*)data + 4;
+ if (kDefinePicture_ExtPipeVerb != header) {
+ return nullptr;
+ }
+ SkRect cull;
+ memcpy(&cull, data, sizeof(SkRect));
+ size -= sizeof(SkRect); data = (const char*)data + sizeof(SkRect);
+
+ SkPictureRecorder recorder;
+ this->playback(data, size, recorder.beginRecording(cull));
+ return recorder.finishRecordingAsPicture();
+}
+
+sk_sp<SkImage> SkPipeDeserializer::readImage(const void* data, size_t size) {
+ if (size < sizeof(uint32_t)) {
+ return nullptr;
+ }
+
+ uint32_t header;
+ memcpy(&header, data, 4); size -= 4; data = (const char*)data + 4;
+ if (kDefineImage_ExtPipeVerb != header) {
+ return nullptr;
+ }
+
+ SkPipeInflator inflator(&fImpl->fImages, &fImpl->fPictures,
+ &fImpl->fTypefaces, &fImpl->fFactories);
+ SkPipeReader reader(this, data, size);
+ reader.setInflator(&inflator);
+ return sk_sp<SkImage>(reader.readImage());
+}
+
+static bool do_playback(SkPipeReader& reader, SkCanvas* canvas) {
+ const bool showEachVerb = true;
+ int counter = 0;
+ while (!reader.eof()) {
+ uint32_t prevOffset = reader.offset();
+ uint32_t packedVerb = reader.read32();
+ SkPipeVerb verb = unpack_verb(packedVerb);
+ if ((unsigned)verb >= SK_ARRAY_COUNT(gPipeHandlers)) {
+ SkDebugf("------- bad verb %d\n", verb);
+ return false;
+ }
+
+ if (SkPipeVerb::kDefinePicture == verb && (packedVerb & kEnd_DefinePictureMask)) {
+ return true;
+ }
+ HandlerRec rec = gPipeHandlers[(unsigned)verb];
+ rec.fProc(reader, packedVerb, canvas);
+ if (showEachVerb) {
+ SkDebugf("[%d] %s %d\n", counter++, rec.fName, reader.offset() - prevOffset);
+ }
+ if (!reader.isValid()) {
+ SkDebugf("-------- bad reader\n");
+ return false;
+ }
+ }
+ return true;
+}
+
+bool SkPipeDeserializer::playback(const void* data, size_t size, SkCanvas* canvas) {
+ SkPipeInflator inflator(&fImpl->fImages, &fImpl->fPictures,
+ &fImpl->fTypefaces, &fImpl->fFactories);
+ SkPipeReader reader(this, data, size);
+ reader.setInflator(&inflator);
+ return do_playback(reader, canvas);
+}
+
« src/pipe/SkPipeFormat.h ('K') | « src/pipe/SkPipeFormat.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698