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

Unified Diff: src/core/SkPicturePlayback.cpp

Issue 377623002: Split SkPicturePlayback out of SkPictureData (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Add virtual dtor for SkPicturePlayback Created 6 years, 5 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
« no previous file with comments | « src/core/SkPicturePlayback.h ('k') | src/gpu/GrPictureUtils.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/core/SkPicturePlayback.cpp
diff --git a/src/core/SkPicturePlayback.cpp b/src/core/SkPicturePlayback.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eccd1ae0c850d757bdd00686aa9f10998f784c3b
--- /dev/null
+++ b/src/core/SkPicturePlayback.cpp
@@ -0,0 +1,648 @@
+/*
+ * 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 "SkCanvas.h"
+#include "SkPictureData.h"
+#include "SkPicturePlayback.h"
+#include "SkPictureRecord.h"
+#include "SkPictureStateTree.h"
+#include "SkReader32.h"
+#include "SkTDArray.h"
+#include "SkTypes.h"
+
+SkPicturePlayback::PlaybackReplacements::ReplacementInfo*
+SkPicturePlayback::PlaybackReplacements::push() {
+ SkDEBUGCODE(this->validate());
+ return fReplacements.push();
+}
+
+void SkPicturePlayback::PlaybackReplacements::freeAll() {
+ for (int i = 0; i < fReplacements.count(); ++i) {
+ SkDELETE(fReplacements[i].fBM);
+ }
+ fReplacements.reset();
+}
+
+#ifdef SK_DEBUG
+void SkPicturePlayback::PlaybackReplacements::validate() const {
+ // Check that the ranges are monotonically increasing and non-overlapping
+ if (fReplacements.count() > 0) {
+ SkASSERT(fReplacements[0].fStart < fReplacements[0].fStop);
+
+ for (int i = 1; i < fReplacements.count(); ++i) {
+ SkASSERT(fReplacements[i].fStart < fReplacements[i].fStop);
+ SkASSERT(fReplacements[i - 1].fStop < fReplacements[i].fStart);
+ }
+ }
+}
+#endif
+
+// TODO: Replace with hash or pass in "lastLookedUp" hint
+SkPicturePlayback::PlaybackReplacements::ReplacementInfo*
+SkPicturePlayback::PlaybackReplacements::lookupByStart(size_t start) {
+ SkDEBUGCODE(this->validate());
+ for (int i = 0; i < fReplacements.count(); ++i) {
+ if (start == fReplacements[i].fStart) {
+ return &fReplacements[i];
+ } else if (start < fReplacements[i].fStart) {
+ return NULL; // the ranges are monotonically increasing and non-overlapping
+ }
+ }
+
+ return NULL;
+}
+
+
+class SkAutoResetOpID {
+public:
+ SkAutoResetOpID(SkPicturePlayback* playback) : fPlayback(playback) { }
+ ~SkAutoResetOpID() {
+ if (NULL != fPlayback) {
+ fPlayback->resetOpID();
+ }
+ }
+
+private:
+ SkPicturePlayback* fPlayback;
+};
+
+/*
+* Read the next op code and chunk size from 'reader'. The returned size
+* is the entire size of the chunk (including the opcode). Thus, the
+* offset just prior to calling read_op_and_size + 'size' is the offset
+* to the next chunk's op code. This also means that the size of a chunk
+* with no arguments (just an opcode) will be 4.
+*/
+static DrawType read_op_and_size(SkReader32* reader, uint32_t* size) {
+ uint32_t temp = reader->readInt();
+ uint32_t op;
+ if (((uint8_t)temp) == temp) {
+ // old skp file - no size information
+ op = temp;
+ *size = 0;
+ } else {
+ UNPACK_8_24(temp, op, *size);
+ if (MASK_24 == *size) {
+ *size = reader->readInt();
+ }
+ }
+ return (DrawType)op;
+}
+
+
+static const SkRect* get_rect_ptr(SkReader32& reader) {
+ if (reader.readBool()) {
+ return &reader.skipT<SkRect>();
+ } else {
+ return NULL;
+ }
+}
+
+class TextContainer {
+public:
+ size_t length() { return fByteLength; }
+ const void* text() { return (const void*)fText; }
+ size_t fByteLength;
+ const char* fText;
+};
+
+void get_text(SkReader32* reader, TextContainer* text) {
+ size_t length = text->fByteLength = reader->readInt();
+ text->fText = (const char*)reader->skip(length);
+}
+
+void SkPicturePlayback::draw(SkCanvas* canvas, SkDrawPictureCallback* callback) {
+ SkAutoResetOpID aroi(this);
+ SkASSERT(0 == fCurOffset);
+
+#ifdef ENABLE_TIME_DRAW
+ SkAutoTime at("SkPicture::draw", 50);
+#endif
+
+#ifdef SPEW_CLIP_SKIPPING
+ SkipClipRec skipRect, skipRRect, skipRegion, skipPath, skipCull;
+ int opCount = 0;
+#endif
+
+ // kDrawComplete will be the signal that we have reached the end of
+ // the command stream
+ static const uint32_t kDrawComplete = SK_MaxU32;
+
+ SkReader32 reader(fPictureData->fOpData->bytes(), fPictureData->fOpData->size());
+ TextContainer text;
+ SkAutoTDelete<const SkPicture::OperationList> activeOpsList;
+ const SkTDArray<void*>* activeOps = NULL;
+
+ // When draw limits are enabled (i.e., 0 != fStart || 0 != fStop) the state
+ // tree isn't used to pick and choose the draw operations
+ if (0 == fStart && 0 == fStop) {
+ if (fUseBBH && NULL != fPictureData->fStateTree && NULL != fPictureData->fBoundingHierarchy) {
+ SkRect clipBounds;
+ if (canvas->getClipBounds(&clipBounds)) {
+ SkIRect query;
+ clipBounds.roundOut(&query);
+
+ activeOpsList.reset(fPictureData->getActiveOps(query));
+ if (NULL != activeOpsList.get()) {
+ if (0 == activeOpsList->numOps()) {
+ return; // nothing to draw
+ }
+
+ // Since the opList is valid we know it is our derived class
+ activeOps = &((const SkPictureData::OperationList*)activeOpsList.get())->fOps;
+ }
+ }
+ }
+ }
+
+ SkPictureStateTree::Iterator it = (NULL == activeOps) ?
+ SkPictureStateTree::Iterator() :
+ fPictureData->fStateTree->getIterator(*activeOps, canvas);
+
+ if (0 != fStart || 0 != fStop) {
+ reader.setOffset(fStart);
+ uint32_t size;
+ SkDEBUGCODE(DrawType op = ) read_op_and_size(&reader, &size);
+ SkASSERT(SAVE_LAYER == op);
+ reader.setOffset(fStart + size);
+ }
+
+ if (it.isValid()) {
+ uint32_t skipTo = it.nextDraw();
+ if (kDrawComplete == skipTo) {
+ return;
+ }
+ reader.setOffset(skipTo);
+ }
+
+ // Record this, so we can concat w/ it if we encounter a setMatrix()
+ SkMatrix initialMatrix = canvas->getTotalMatrix();
+
+ SkAutoCanvasRestore acr(canvas, false);
+
+#ifdef SK_DEVELOPER
+ int opIndex = -1;
+#endif
+
+ while (!reader.eof()) {
+ if (callback && callback->abortDrawing()) {
+ return;
+ }
+
+ if (0 != fStart || 0 != fStop) {
+ size_t offset = reader.offset();
+ if (offset >= fStop) {
+ uint32_t size;
+ SkDEBUGCODE(DrawType op = ) read_op_and_size(&reader, &size);
+ SkASSERT(RESTORE == op);
+ return;
+ }
+ }
+
+ if (NULL != fReplacements) {
+ // Potentially replace a block of operations with a single drawBitmap call
+ SkPicturePlayback::PlaybackReplacements::ReplacementInfo* temp =
+ fReplacements->lookupByStart(reader.offset());
+ if (NULL != temp) {
+ SkASSERT(NULL != temp->fBM);
+ SkASSERT(NULL != temp->fPaint);
+ canvas->save();
+ canvas->setMatrix(initialMatrix);
+ SkRect src = SkRect::Make(temp->fSrcRect);
+ SkRect dst = SkRect::MakeXYWH(temp->fPos.fX, temp->fPos.fY,
+ temp->fSrcRect.width(),
+ temp->fSrcRect.height());
+ canvas->drawBitmapRectToRect(*temp->fBM, &src, dst, temp->fPaint);
+ canvas->restore();
+
+ if (it.isValid()) {
+ // This save is needed since the BBH will automatically issue
+ // a restore to balanced the saveLayer we're skipping
+ canvas->save();
+
+ // At this point we know that the PictureStateTree was aiming
+ // for some draw op within temp's saveLayer (although potentially
+ // in a separate saveLayer nested inside it).
+ // We need to skip all the operations inside temp's range
+ // along with all the associated state changes but update
+ // the state tree to the first operation outside temp's range.
+
+ uint32_t skipTo;
+ do {
+ skipTo = it.nextDraw();
+ if (kDrawComplete == skipTo) {
+ break;
+ }
+
+ if (skipTo <= temp->fStop) {
+ reader.setOffset(skipTo);
+ uint32_t size;
+ DrawType op = read_op_and_size(&reader, &size);
+ // Since we are relying on the normal SkPictureStateTree
+ // playback we need to convert any nested saveLayer calls
+ // it may issue into saves (so that all its internal
+ // restores will be balanced).
+ if (SAVE_LAYER == op) {
+ canvas->save();
+ }
+ }
+ } while (skipTo <= temp->fStop);
+
+ if (kDrawComplete == skipTo) {
+ break;
+ }
+
+ reader.setOffset(skipTo);
+ } else {
+ reader.setOffset(temp->fStop);
+ uint32_t size;
+ SkDEBUGCODE(DrawType op = ) read_op_and_size(&reader, &size);
+ SkASSERT(RESTORE == op);
+ }
+ continue;
+ }
+ }
+
+#ifdef SPEW_CLIP_SKIPPING
+ opCount++;
+#endif
+
+ fCurOffset = reader.offset();
+ uint32_t size;
+ DrawType op = read_op_and_size(&reader, &size);
+ size_t skipTo = 0;
+ if (NOOP == op) {
+ // NOOPs are to be ignored - do not propagate them any further
+ skipTo = fCurOffset + size;
+#ifdef SK_DEVELOPER
+ } else {
+ opIndex++;
+ if (this->preDraw(opIndex, op)) {
+ skipTo = fCurOffset + size;
+ }
+#endif
+ }
+
+ if (0 != skipTo) {
+ if (it.isValid()) {
+ // If using a bounding box hierarchy, advance the state tree
+ // iterator until at or after skipTo
+ uint32_t adjustedSkipTo;
+ do {
+ adjustedSkipTo = it.nextDraw();
+ } while (adjustedSkipTo < skipTo);
+ skipTo = adjustedSkipTo;
+ }
+ if (kDrawComplete == skipTo) {
+ break;
+ }
+ reader.setOffset(skipTo);
+ continue;
+ }
+
+ switch (op) {
+ case CLIP_PATH: {
+ const SkPath& path = fPictureData->getPath(reader);
+ uint32_t packed = reader.readInt();
+ SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
+ bool doAA = ClipParams_unpackDoAA(packed);
+ size_t offsetToRestore = reader.readInt();
+ SkASSERT(!offsetToRestore || offsetToRestore >= reader.offset());
+ canvas->clipPath(path, regionOp, doAA);
+ if (canvas->isClipEmpty() && offsetToRestore) {
+#ifdef SPEW_CLIP_SKIPPING
+ skipPath.recordSkip(offsetToRestore - reader.offset());
+#endif
+ reader.setOffset(offsetToRestore);
+ }
+ } break;
+ case CLIP_REGION: {
+ SkRegion region;
+ reader.readRegion(&region);
+ uint32_t packed = reader.readInt();
+ SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
+ size_t offsetToRestore = reader.readInt();
+ SkASSERT(!offsetToRestore || offsetToRestore >= reader.offset());
+ canvas->clipRegion(region, regionOp);
+ if (canvas->isClipEmpty() && offsetToRestore) {
+#ifdef SPEW_CLIP_SKIPPING
+ skipRegion.recordSkip(offsetToRestore - reader.offset());
+#endif
+ reader.setOffset(offsetToRestore);
+ }
+ } break;
+ case CLIP_RECT: {
+ const SkRect& rect = reader.skipT<SkRect>();
+ uint32_t packed = reader.readInt();
+ SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
+ bool doAA = ClipParams_unpackDoAA(packed);
+ size_t offsetToRestore = reader.readInt();
+ SkASSERT(!offsetToRestore || offsetToRestore >= reader.offset());
+ canvas->clipRect(rect, regionOp, doAA);
+ if (canvas->isClipEmpty() && offsetToRestore) {
+#ifdef SPEW_CLIP_SKIPPING
+ skipRect.recordSkip(offsetToRestore - reader.offset());
+#endif
+ reader.setOffset(offsetToRestore);
+ }
+ } break;
+ case CLIP_RRECT: {
+ SkRRect rrect;
+ reader.readRRect(&rrect);
+ uint32_t packed = reader.readInt();
+ SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
+ bool doAA = ClipParams_unpackDoAA(packed);
+ size_t offsetToRestore = reader.readInt();
+ SkASSERT(!offsetToRestore || offsetToRestore >= reader.offset());
+ canvas->clipRRect(rrect, regionOp, doAA);
+ if (canvas->isClipEmpty() && offsetToRestore) {
+#ifdef SPEW_CLIP_SKIPPING
+ skipRRect.recordSkip(offsetToRestore - reader.offset());
+#endif
+ reader.setOffset(offsetToRestore);
+ }
+ } break;
+ case PUSH_CULL: {
+ const SkRect& cullRect = reader.skipT<SkRect>();
+ size_t offsetToRestore = reader.readInt();
+ if (offsetToRestore && canvas->quickReject(cullRect)) {
+#ifdef SPEW_CLIP_SKIPPING
+ skipCull.recordSkip(offsetToRestore - reader.offset());
+#endif
+ reader.setOffset(offsetToRestore);
+ } else {
+ canvas->pushCull(cullRect);
+ }
+ } break;
+ case POP_CULL:
+ canvas->popCull();
+ break;
+ case CONCAT: {
+ SkMatrix matrix;
+ reader.readMatrix(&matrix);
+ canvas->concat(matrix);
+ break;
+ }
+ case DRAW_BITMAP: {
+ const SkPaint* paint = fPictureData->getPaint(reader);
+ const SkBitmap& bitmap = fPictureData->getBitmap(reader);
+ const SkPoint& loc = reader.skipT<SkPoint>();
+ canvas->drawBitmap(bitmap, loc.fX, loc.fY, paint);
+ } break;
+ case DRAW_BITMAP_RECT_TO_RECT: {
+ const SkPaint* paint = fPictureData->getPaint(reader);
+ const SkBitmap& bitmap = fPictureData->getBitmap(reader);
+ const SkRect* src = get_rect_ptr(reader); // may be null
+ const SkRect& dst = reader.skipT<SkRect>(); // required
+ SkCanvas::DrawBitmapRectFlags flags;
+ flags = (SkCanvas::DrawBitmapRectFlags) reader.readInt();
+ canvas->drawBitmapRectToRect(bitmap, src, dst, paint, flags);
+ } break;
+ case DRAW_BITMAP_MATRIX: {
+ const SkPaint* paint = fPictureData->getPaint(reader);
+ const SkBitmap& bitmap = fPictureData->getBitmap(reader);
+ SkMatrix matrix;
+ reader.readMatrix(&matrix);
+ canvas->drawBitmapMatrix(bitmap, matrix, paint);
+ } break;
+ case DRAW_BITMAP_NINE: {
+ const SkPaint* paint = fPictureData->getPaint(reader);
+ const SkBitmap& bitmap = fPictureData->getBitmap(reader);
+ const SkIRect& src = reader.skipT<SkIRect>();
+ const SkRect& dst = reader.skipT<SkRect>();
+ canvas->drawBitmapNine(bitmap, src, dst, paint);
+ } break;
+ case DRAW_CLEAR:
+ canvas->clear(reader.readInt());
+ break;
+ case DRAW_DATA: {
+ size_t length = reader.readInt();
+ canvas->drawData(reader.skip(length), length);
+ // skip handles padding the read out to a multiple of 4
+ } break;
+ case DRAW_DRRECT: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ SkRRect outer, inner;
+ reader.readRRect(&outer);
+ reader.readRRect(&inner);
+ canvas->drawDRRect(outer, inner, paint);
+ } break;
+ case BEGIN_COMMENT_GROUP: {
+ const char* desc = reader.readString();
+ canvas->beginCommentGroup(desc);
+ } break;
+ case COMMENT: {
+ const char* kywd = reader.readString();
+ const char* value = reader.readString();
+ canvas->addComment(kywd, value);
+ } break;
+ case END_COMMENT_GROUP: {
+ canvas->endCommentGroup();
+ } break;
+ case DRAW_OVAL: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ canvas->drawOval(reader.skipT<SkRect>(), paint);
+ } break;
+ case DRAW_PAINT:
+ canvas->drawPaint(*fPictureData->getPaint(reader));
+ break;
+ case DRAW_PATH: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ canvas->drawPath(fPictureData->getPath(reader), paint);
+ } break;
+ case DRAW_PICTURE:
+ canvas->drawPicture(fPictureData->getPicture(reader));
+ break;
+ case DRAW_POINTS: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ SkCanvas::PointMode mode = (SkCanvas::PointMode)reader.readInt();
+ size_t count = reader.readInt();
+ const SkPoint* pts = (const SkPoint*)reader.skip(sizeof(SkPoint)* count);
+ canvas->drawPoints(mode, count, pts, paint);
+ } break;
+ case DRAW_POS_TEXT: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ get_text(&reader, &text);
+ size_t points = reader.readInt();
+ const SkPoint* pos = (const SkPoint*)reader.skip(points * sizeof(SkPoint));
+ canvas->drawPosText(text.text(), text.length(), pos, paint);
+ } break;
+ case DRAW_POS_TEXT_TOP_BOTTOM: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ get_text(&reader, &text);
+ size_t points = reader.readInt();
+ const SkPoint* pos = (const SkPoint*)reader.skip(points * sizeof(SkPoint));
+ const SkScalar top = reader.readScalar();
+ const SkScalar bottom = reader.readScalar();
+ if (!canvas->quickRejectY(top, bottom)) {
+ canvas->drawPosText(text.text(), text.length(), pos, paint);
+ }
+ } break;
+ case DRAW_POS_TEXT_H: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ get_text(&reader, &text);
+ size_t xCount = reader.readInt();
+ const SkScalar constY = reader.readScalar();
+ const SkScalar* xpos = (const SkScalar*)reader.skip(xCount * sizeof(SkScalar));
+ canvas->drawPosTextH(text.text(), text.length(), xpos, constY, paint);
+ } break;
+ case DRAW_POS_TEXT_H_TOP_BOTTOM: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ get_text(&reader, &text);
+ size_t xCount = reader.readInt();
+ const SkScalar* xpos = (const SkScalar*)reader.skip((3 + xCount) * sizeof(SkScalar));
+ const SkScalar top = *xpos++;
+ const SkScalar bottom = *xpos++;
+ const SkScalar constY = *xpos++;
+ if (!canvas->quickRejectY(top, bottom)) {
+ canvas->drawPosTextH(text.text(), text.length(), xpos, constY, paint);
+ }
+ } break;
+ case DRAW_RECT: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ canvas->drawRect(reader.skipT<SkRect>(), paint);
+ } break;
+ case DRAW_RRECT: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ SkRRect rrect;
+ reader.readRRect(&rrect);
+ canvas->drawRRect(rrect, paint);
+ } break;
+ case DRAW_SPRITE: {
+ const SkPaint* paint = fPictureData->getPaint(reader);
+ const SkBitmap& bitmap = fPictureData->getBitmap(reader);
+ int left = reader.readInt();
+ int top = reader.readInt();
+ canvas->drawSprite(bitmap, left, top, paint);
+ } break;
+ case DRAW_TEXT: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ get_text(&reader, &text);
+ SkScalar x = reader.readScalar();
+ SkScalar y = reader.readScalar();
+ canvas->drawText(text.text(), text.length(), x, y, paint);
+ } break;
+ case DRAW_TEXT_TOP_BOTTOM: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ get_text(&reader, &text);
+ const SkScalar* ptr = (const SkScalar*)reader.skip(4 * sizeof(SkScalar));
+ // ptr[0] == x
+ // ptr[1] == y
+ // ptr[2] == top
+ // ptr[3] == bottom
+ if (!canvas->quickRejectY(ptr[2], ptr[3])) {
+ canvas->drawText(text.text(), text.length(), ptr[0], ptr[1], paint);
+ }
+ } break;
+ case DRAW_TEXT_ON_PATH: {
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ get_text(&reader, &text);
+ const SkPath& path = fPictureData->getPath(reader);
+ SkMatrix matrix;
+ reader.readMatrix(&matrix);
+ canvas->drawTextOnPath(text.text(), text.length(), path, &matrix, paint);
+ } break;
+ case DRAW_VERTICES: {
+ SkAutoTUnref<SkXfermode> xfer;
+ const SkPaint& paint = *fPictureData->getPaint(reader);
+ DrawVertexFlags flags = (DrawVertexFlags)reader.readInt();
+ SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader.readInt();
+ int vCount = reader.readInt();
+ const SkPoint* verts = (const SkPoint*)reader.skip(vCount * sizeof(SkPoint));
+ const SkPoint* texs = NULL;
+ const SkColor* colors = NULL;
+ const uint16_t* indices = NULL;
+ int iCount = 0;
+ if (flags & DRAW_VERTICES_HAS_TEXS) {
+ texs = (const SkPoint*)reader.skip(vCount * sizeof(SkPoint));
+ }
+ if (flags & DRAW_VERTICES_HAS_COLORS) {
+ colors = (const SkColor*)reader.skip(vCount * sizeof(SkColor));
+ }
+ if (flags & DRAW_VERTICES_HAS_INDICES) {
+ iCount = reader.readInt();
+ indices = (const uint16_t*)reader.skip(iCount * sizeof(uint16_t));
+ }
+ if (flags & DRAW_VERTICES_HAS_XFER) {
+ int mode = reader.readInt();
+ if (mode < 0 || mode > SkXfermode::kLastMode) {
+ mode = SkXfermode::kModulate_Mode;
+ }
+ xfer.reset(SkXfermode::Create((SkXfermode::Mode)mode));
+ }
+ canvas->drawVertices(vmode, vCount, verts, texs, colors, xfer, indices, iCount, paint);
+ } break;
+ case RESTORE:
+ canvas->restore();
+ break;
+ case ROTATE:
+ canvas->rotate(reader.readScalar());
+ break;
+ case SAVE:
+ // SKPs with version < 29 also store a SaveFlags param.
+ if (size > 4) {
+ SkASSERT(8 == size);
+ reader.readInt();
+ }
+ canvas->save();
+ break;
+ case SAVE_LAYER: {
+ const SkRect* boundsPtr = get_rect_ptr(reader);
+ const SkPaint* paint = fPictureData->getPaint(reader);
+ canvas->saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) reader.readInt());
+ } break;
+ case SCALE: {
+ SkScalar sx = reader.readScalar();
+ SkScalar sy = reader.readScalar();
+ canvas->scale(sx, sy);
+ } break;
+ case SET_MATRIX: {
+ SkMatrix matrix;
+ reader.readMatrix(&matrix);
+ matrix.postConcat(initialMatrix);
+ canvas->setMatrix(matrix);
+ } break;
+ case SKEW: {
+ SkScalar sx = reader.readScalar();
+ SkScalar sy = reader.readScalar();
+ canvas->skew(sx, sy);
+ } break;
+ case TRANSLATE: {
+ SkScalar dx = reader.readScalar();
+ SkScalar dy = reader.readScalar();
+ canvas->translate(dx, dy);
+ } break;
+ default:
+ SkASSERT(0);
+ }
+
+#ifdef SK_DEVELOPER
+ this->postDraw(opIndex);
+#endif
+
+ if (it.isValid()) {
+ uint32_t skipTo = it.nextDraw();
+ if (kDrawComplete == skipTo) {
+ break;
+ }
+ reader.setOffset(skipTo);
+ }
+ }
+
+#ifdef SPEW_CLIP_SKIPPING
+ {
+ size_t size = skipRect.fSize + skipRRect.fSize + skipPath.fSize + skipRegion.fSize +
+ skipCull.fSize;
+ SkDebugf("--- Clip skips %d%% rect:%d rrect:%d path:%d rgn:%d cull:%d\n",
+ size * 100 / reader.offset(), skipRect.fCount, skipRRect.fCount,
+ skipPath.fCount, skipRegion.fCount, skipCull.fCount);
+ SkDebugf("--- Total ops: %d\n", opCount);
+ }
+#endif
+ // this->dumpSize();
+}
+
« no previous file with comments | « src/core/SkPicturePlayback.h ('k') | src/gpu/GrPictureUtils.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698