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(®ion); |
+ 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(); |
+} |
+ |