| /* |
| * 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 "include/core/SkCanvas.h" |
| #include "include/core/SkRSXform.h" |
| #include "include/core/SkTextBlob.h" |
| #include "include/core/SkTypes.h" |
| #include "include/private/SkTDArray.h" |
| #include "include/private/chromium/Slug.h" |
| #include "src/core/SkCanvasPriv.h" |
| #include "src/core/SkDrawShadowInfo.h" |
| #include "src/core/SkFontPriv.h" |
| #include "src/core/SkPaintPriv.h" |
| #include "src/core/SkPictureData.h" |
| #include "src/core/SkPictureFlat.h" |
| #include "src/core/SkPicturePlayback.h" |
| #include "src/core/SkPictureRecord.h" |
| #include "src/core/SkReadBuffer.h" |
| #include "src/core/SkSafeMath.h" |
| #include "src/core/SkSamplingPriv.h" |
| #include "src/core/SkVerticesPriv.h" |
| #include "src/utils/SkPatchUtils.h" |
| |
| static const SkRect* get_rect_ptr(SkReadBuffer* reader, SkRect* storage) { |
| if (reader->readBool()) { |
| reader->readRect(storage); |
| return storage; |
| } else { |
| return nullptr; |
| } |
| } |
| |
| void SkPicturePlayback::draw(SkCanvas* canvas, |
| SkPicture::AbortCallback* callback, |
| SkReadBuffer* buffer) { |
| AutoResetOpID aroi(this); |
| SkASSERT(0 == fCurOffset); |
| |
| SkReadBuffer reader(fPictureData->opData()->bytes(), |
| fPictureData->opData()->size()); |
| reader.setVersion(fPictureData->info().getVersion()); |
| |
| // Record this, so we can concat w/ it if we encounter a setMatrix() |
| SkM44 initialMatrix = canvas->getLocalToDevice(); |
| |
| SkAutoCanvasRestore acr(canvas, false); |
| |
| while (!reader.eof() && reader.isValid()) { |
| if (callback && callback->abort()) { |
| return; |
| } |
| |
| fCurOffset = reader.offset(); |
| |
| uint32_t bits = reader.readInt(); |
| uint32_t op = bits >> 24, |
| size = bits & 0xffffff; |
| if (size == 0xffffff) { |
| size = reader.readInt(); |
| } |
| |
| if (!reader.validate(size > 0 && op > UNUSED && op <= LAST_DRAWTYPE_ENUM)) { |
| return; |
| } |
| |
| this->handleOp(&reader, (DrawType)op, size, canvas, initialMatrix); |
| } |
| |
| // need to propagate invalid state to the parent reader |
| if (buffer) { |
| buffer->validate(reader.isValid()); |
| } |
| } |
| |
| static void validate_offsetToRestore(SkReadBuffer* reader, size_t offsetToRestore) { |
| if (offsetToRestore) { |
| reader->validate(SkIsAlign4(offsetToRestore) && offsetToRestore >= reader->offset()); |
| } |
| } |
| |
| static bool do_clip_op(SkReadBuffer* reader, SkCanvas* canvas, SkRegion::Op op, |
| SkClipOp* clipOpToUse) { |
| switch(op) { |
| case SkRegion::kDifference_Op: |
| case SkRegion::kIntersect_Op: |
| // Fully supported, identity mapping between SkClipOp and Region::Op |
| *clipOpToUse = static_cast<SkClipOp>(op); |
| return true; |
| case SkRegion::kReplace_Op: |
| // Emulate the replace by resetting first and following it up with an intersect |
| SkASSERT(reader->isVersionLT(SkPicturePriv::kNoExpandingClipOps)); |
| SkCanvasPriv::ResetClip(canvas); |
| *clipOpToUse = SkClipOp::kIntersect; |
| return true; |
| default: |
| // An expanding clip op, which if encountered on an old SKP, we just silently ignore |
| SkASSERT(reader->isVersionLT(SkPicturePriv::kNoExpandingClipOps)); |
| return false; |
| } |
| } |
| |
| void SkPicturePlayback::handleOp(SkReadBuffer* reader, |
| DrawType op, |
| uint32_t size, |
| SkCanvas* canvas, |
| const SkM44& initialMatrix) { |
| #define BREAK_ON_READ_ERROR(r) if (!r->isValid()) break |
| |
| switch (op) { |
| case NOOP: { |
| SkASSERT(size >= 4); |
| reader->skip(size - 4); |
| } break; |
| case FLUSH: |
| canvas->flush(); |
| break; |
| case CLIP_PATH: { |
| const SkPath& path = fPictureData->getPath(reader); |
| uint32_t packed = reader->readInt(); |
| SkRegion::Op rgnOp = ClipParams_unpackRegionOp(reader, packed); |
| bool doAA = ClipParams_unpackDoAA(packed); |
| size_t offsetToRestore = reader->readInt(); |
| validate_offsetToRestore(reader, offsetToRestore); |
| BREAK_ON_READ_ERROR(reader); |
| |
| SkClipOp clipOp; |
| if (do_clip_op(reader, canvas, rgnOp, &clipOp)) { |
| canvas->clipPath(path, clipOp, doAA); |
| } |
| if (canvas->isClipEmpty() && offsetToRestore) { |
| reader->skip(offsetToRestore - reader->offset()); |
| } |
| } break; |
| case CLIP_REGION: { |
| SkRegion region; |
| reader->readRegion(®ion); |
| uint32_t packed = reader->readInt(); |
| SkRegion::Op rgnOp = ClipParams_unpackRegionOp(reader, packed); |
| size_t offsetToRestore = reader->readInt(); |
| validate_offsetToRestore(reader, offsetToRestore); |
| BREAK_ON_READ_ERROR(reader); |
| |
| SkClipOp clipOp; |
| if (do_clip_op(reader, canvas, rgnOp, &clipOp)) { |
| canvas->clipRegion(region, clipOp); |
| } |
| if (canvas->isClipEmpty() && offsetToRestore) { |
| reader->skip(offsetToRestore - reader->offset()); |
| } |
| } break; |
| case CLIP_RECT: { |
| SkRect rect; |
| reader->readRect(&rect); |
| uint32_t packed = reader->readInt(); |
| SkRegion::Op rgnOp = ClipParams_unpackRegionOp(reader, packed); |
| bool doAA = ClipParams_unpackDoAA(packed); |
| size_t offsetToRestore = reader->readInt(); |
| validate_offsetToRestore(reader, offsetToRestore); |
| BREAK_ON_READ_ERROR(reader); |
| |
| SkClipOp clipOp; |
| if (do_clip_op(reader, canvas, rgnOp, &clipOp)) { |
| canvas->clipRect(rect, clipOp, doAA); |
| } |
| if (canvas->isClipEmpty() && offsetToRestore) { |
| reader->skip(offsetToRestore - reader->offset()); |
| } |
| } break; |
| case CLIP_RRECT: { |
| SkRRect rrect; |
| reader->readRRect(&rrect); |
| uint32_t packed = reader->readInt(); |
| SkRegion::Op rgnOp = ClipParams_unpackRegionOp(reader, packed); |
| bool doAA = ClipParams_unpackDoAA(packed); |
| size_t offsetToRestore = reader->readInt(); |
| validate_offsetToRestore(reader, offsetToRestore); |
| BREAK_ON_READ_ERROR(reader); |
| |
| SkClipOp clipOp; |
| if (do_clip_op(reader, canvas, rgnOp, &clipOp)) { |
| canvas->clipRRect(rrect, clipOp, doAA); |
| } |
| if (canvas->isClipEmpty() && offsetToRestore) { |
| reader->skip(offsetToRestore - reader->offset()); |
| } |
| } break; |
| case CLIP_SHADER_IN_PAINT: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| // clipShader() was never used in conjunction with deprecated, expanding clip ops, so |
| // it requires the op to just be intersect or difference. |
| SkClipOp clipOp = reader->checkRange(SkClipOp::kDifference, SkClipOp::kIntersect); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->clipShader(paint.refShader(), clipOp); |
| } break; |
| case RESET_CLIP: |
| // For Android, an emulated "replace" clip op appears as a manual reset followed by |
| // an intersect operation (equivalent to the above handling of replace ops encountered |
| // in old serialized pictures). |
| SkCanvasPriv::ResetClip(canvas); |
| break; |
| case PUSH_CULL: break; // Deprecated, safe to ignore both push and pop. |
| case POP_CULL: break; |
| case CONCAT: { |
| SkMatrix matrix; |
| reader->readMatrix(&matrix); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->concat(matrix); |
| break; |
| } |
| case CONCAT44: { |
| const SkScalar* colMaj = reader->skipT<SkScalar>(16); |
| BREAK_ON_READ_ERROR(reader); |
| canvas->concat(SkM44::ColMajor(colMaj)); |
| break; |
| } |
| case DRAW_ANNOTATION: { |
| SkRect rect; |
| reader->readRect(&rect); |
| SkString key; |
| reader->readString(&key); |
| sk_sp<SkData> data = reader->readByteArrayAsData(); |
| BREAK_ON_READ_ERROR(reader); |
| SkASSERT(data); |
| |
| canvas->drawAnnotation(rect, key.c_str(), data.get()); |
| } break; |
| case DRAW_ARC: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| SkRect rect; |
| reader->readRect(&rect); |
| SkScalar startAngle = reader->readScalar(); |
| SkScalar sweepAngle = reader->readScalar(); |
| int useCenter = reader->readInt(); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawArc(rect, startAngle, sweepAngle, SkToBool(useCenter), paint); |
| } break; |
| case DRAW_ATLAS: { |
| const SkPaint* paint = fPictureData->optionalPaint(reader); |
| const SkImage* atlas = fPictureData->getImage(reader); |
| const uint32_t flags = reader->readUInt(); |
| const int count = reader->readUInt(); |
| const SkRSXform* xform = (const SkRSXform*)reader->skip(count, sizeof(SkRSXform)); |
| const SkRect* tex = (const SkRect*)reader->skip(count, sizeof(SkRect)); |
| const SkColor* colors = nullptr; |
| SkBlendMode mode = SkBlendMode::kDst; |
| if (flags & DRAW_ATLAS_HAS_COLORS) { |
| colors = (const SkColor*)reader->skip(count, sizeof(SkColor)); |
| mode = (SkBlendMode)reader->readUInt(); |
| } |
| const SkRect* cull = nullptr; |
| if (flags & DRAW_ATLAS_HAS_CULL) { |
| cull = (const SkRect*)reader->skip(sizeof(SkRect)); |
| } |
| BREAK_ON_READ_ERROR(reader); |
| |
| SkSamplingOptions sampling; |
| if (flags & DRAW_ATLAS_HAS_SAMPLING) { |
| sampling = reader->readSampling(); |
| BREAK_ON_READ_ERROR(reader); |
| } |
| canvas->drawAtlas(atlas, xform, tex, colors, count, mode, sampling, cull, paint); |
| } break; |
| case DRAW_CLEAR: { |
| auto c = reader->readInt(); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->clear(c); |
| } break; |
| case DRAW_DATA: { |
| // This opcode is now dead, just need to skip it for backwards compatibility |
| size_t length = reader->readInt(); |
| (void)reader->skip(length); |
| // skip handles padding the read out to a multiple of 4 |
| } break; |
| case DRAW_DRAWABLE: { |
| auto* d = fPictureData->getDrawable(reader); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawDrawable(d); |
| } break; |
| case DRAW_DRAWABLE_MATRIX: { |
| SkMatrix matrix; |
| reader->readMatrix(&matrix); |
| SkDrawable* drawable = fPictureData->getDrawable(reader); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawDrawable(drawable, &matrix); |
| } break; |
| case DRAW_DRRECT: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| SkRRect outer, inner; |
| reader->readRRect(&outer); |
| reader->readRRect(&inner); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawDRRect(outer, inner, paint); |
| } break; |
| case DRAW_EDGEAA_QUAD: { |
| SkRect rect; |
| reader->readRect(&rect); |
| SkCanvas::QuadAAFlags aaFlags = static_cast<SkCanvas::QuadAAFlags>(reader->read32()); |
| SkColor4f color; |
| reader->readColor4f(&color); |
| SkBlendMode blend = static_cast<SkBlendMode>(reader->read32()); |
| bool hasClip = reader->readInt(); |
| SkPoint* clip = nullptr; |
| if (hasClip) { |
| clip = (SkPoint*) reader->skip(4, sizeof(SkPoint)); |
| } |
| BREAK_ON_READ_ERROR(reader); |
| canvas->experimental_DrawEdgeAAQuad(rect, clip, aaFlags, color, blend); |
| } break; |
| case DRAW_EDGEAA_IMAGE_SET: |
| case DRAW_EDGEAA_IMAGE_SET2: { |
| static const size_t kEntryReadSize = |
| 4 * sizeof(uint32_t) + 2 * sizeof(SkRect) + sizeof(SkScalar); |
| static const size_t kMatrixSize = 9 * sizeof(SkScalar); // != sizeof(SkMatrix) |
| |
| int cnt = reader->readInt(); |
| if (!reader->validate(cnt >= 0)) { |
| break; |
| } |
| const SkPaint* paint = fPictureData->optionalPaint(reader); |
| |
| SkSamplingOptions sampling; |
| if (op == DRAW_EDGEAA_IMAGE_SET2) { |
| sampling = reader->readSampling(); |
| } else { |
| sampling = SkSamplingOptions(SkFilterMode::kNearest); |
| } |
| |
| SkCanvas::SrcRectConstraint constraint = |
| reader->checkRange(SkCanvas::kStrict_SrcRectConstraint, |
| SkCanvas::kFast_SrcRectConstraint); |
| |
| if (!reader->validate(SkSafeMath::Mul(cnt, kEntryReadSize) <= reader->available())) { |
| break; |
| } |
| |
| // Track minimum necessary clip points and matrices that must be provided to satisfy |
| // the entries. |
| int expectedClips = 0; |
| int maxMatrixIndex = -1; |
| SkAutoTArray<SkCanvas::ImageSetEntry> set(cnt); |
| for (int i = 0; i < cnt && reader->isValid(); ++i) { |
| set[i].fImage = sk_ref_sp(fPictureData->getImage(reader)); |
| reader->readRect(&set[i].fSrcRect); |
| reader->readRect(&set[i].fDstRect); |
| set[i].fMatrixIndex = reader->readInt(); |
| set[i].fAlpha = reader->readScalar(); |
| set[i].fAAFlags = reader->readUInt(); |
| set[i].fHasClip = reader->readInt(); |
| |
| expectedClips += set[i].fHasClip ? 1 : 0; |
| if (set[i].fMatrixIndex > maxMatrixIndex) { |
| maxMatrixIndex = set[i].fMatrixIndex; |
| } |
| } |
| |
| int dstClipCount = reader->readInt(); |
| SkPoint* dstClips = nullptr; |
| if (!reader->validate(dstClipCount >= 0) || |
| !reader->validate(expectedClips <= dstClipCount)) { |
| // A bad dstClipCount (either negative, or not enough to satisfy entries). |
| break; |
| } else if (dstClipCount > 0) { |
| dstClips = (SkPoint*) reader->skip(dstClipCount, sizeof(SkPoint)); |
| if (dstClips == nullptr) { |
| // Not enough bytes remaining so the reader has been invalidated |
| break; |
| } |
| } |
| int matrixCount = reader->readInt(); |
| if (!reader->validate(matrixCount >= 0) || |
| !reader->validate(maxMatrixIndex <= (matrixCount - 1)) || |
| !reader->validate( |
| SkSafeMath::Mul(matrixCount, kMatrixSize) <= reader->available())) { |
| // Entries access out-of-bound matrix indices, given provided matrices or |
| // there aren't enough bytes to provide that many matrices |
| break; |
| } |
| SkTArray<SkMatrix> matrices(matrixCount); |
| for (int i = 0; i < matrixCount && reader->isValid(); ++i) { |
| reader->readMatrix(&matrices.push_back()); |
| } |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->experimental_DrawEdgeAAImageSet(set.get(), cnt, dstClips, matrices.begin(), |
| sampling, paint, constraint); |
| } break; |
| case DRAW_IMAGE: { |
| const SkPaint* paint = fPictureData->optionalPaint(reader); |
| const SkImage* image = fPictureData->getImage(reader); |
| SkPoint loc; |
| reader->readPoint(&loc); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawImage(image, loc.fX, loc.fY, |
| SkSamplingOptions(SkFilterMode::kNearest), |
| paint); |
| } break; |
| case DRAW_IMAGE2: { |
| const SkPaint* paint = fPictureData->optionalPaint(reader); |
| const SkImage* image = fPictureData->getImage(reader); |
| SkPoint loc; |
| reader->readPoint(&loc); |
| SkSamplingOptions sampling = reader->readSampling(); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawImage(image, loc.fX, loc.fY, sampling, paint); |
| } break; |
| case DRAW_IMAGE_LATTICE: { |
| const SkPaint* paint = fPictureData->optionalPaint(reader); |
| const SkImage* image = fPictureData->getImage(reader); |
| SkCanvas::Lattice lattice; |
| (void)SkCanvasPriv::ReadLattice(*reader, &lattice); |
| const SkRect* dst = reader->skipT<SkRect>(); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawImageLattice(image, lattice, *dst, SkFilterMode::kNearest, paint); |
| } break; |
| case DRAW_IMAGE_LATTICE2: { |
| const SkPaint* paint = fPictureData->optionalPaint(reader); |
| const SkImage* image = fPictureData->getImage(reader); |
| SkCanvas::Lattice lattice; |
| (void)SkCanvasPriv::ReadLattice(*reader, &lattice); |
| const SkRect* dst = reader->skipT<SkRect>(); |
| SkFilterMode filter = reader->read32LE(SkFilterMode::kLinear); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawImageLattice(image, lattice, *dst, filter, paint); |
| } break; |
| case DRAW_IMAGE_NINE: { |
| const SkPaint* paint = fPictureData->optionalPaint(reader); |
| const SkImage* image = fPictureData->getImage(reader); |
| SkIRect center; |
| reader->readIRect(¢er); |
| SkRect dst; |
| reader->readRect(&dst); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawImageNine(image, center, dst, SkFilterMode::kNearest, paint); |
| } break; |
| case DRAW_IMAGE_RECT: { |
| const SkPaint* paint = fPictureData->optionalPaint(reader); |
| const SkImage* image = fPictureData->getImage(reader); |
| SkRect storage; |
| const SkRect* src = get_rect_ptr(reader, &storage); // may be null |
| SkRect dst; |
| reader->readRect(&dst); // required |
| // DRAW_IMAGE_RECT_STRICT assumes this constraint, and doesn't store it |
| SkCanvas::SrcRectConstraint constraint = SkCanvas::kStrict_SrcRectConstraint; |
| if (DRAW_IMAGE_RECT == op) { |
| // newer op-code stores the constraint explicitly |
| constraint = reader->checkRange(SkCanvas::kStrict_SrcRectConstraint, |
| SkCanvas::kFast_SrcRectConstraint); |
| } |
| BREAK_ON_READ_ERROR(reader); |
| |
| auto sampling = SkSamplingOptions(SkFilterMode::kNearest); |
| if (src) { |
| canvas->drawImageRect(image, *src, dst, sampling, paint, constraint); |
| } else { |
| canvas->drawImageRect(image, dst, sampling, paint); |
| } |
| } break; |
| case DRAW_IMAGE_RECT2: { |
| const SkPaint* paint = fPictureData->optionalPaint(reader); |
| const SkImage* image = fPictureData->getImage(reader); |
| SkRect src = reader->readRect(); |
| SkRect dst = reader->readRect(); |
| SkSamplingOptions sampling = reader->readSampling(); |
| auto constraint = reader->read32LE(SkCanvas::kFast_SrcRectConstraint); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawImageRect(image, src, dst, sampling, paint, constraint); |
| } break; |
| case DRAW_OVAL: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| SkRect rect; |
| reader->readRect(&rect); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawOval(rect, paint); |
| } break; |
| case DRAW_PAINT: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawPaint(paint); |
| } break; |
| case DRAW_BEHIND_PAINT: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| BREAK_ON_READ_ERROR(reader); |
| |
| SkCanvasPriv::DrawBehind(canvas, paint); |
| } break; |
| case DRAW_PATCH: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| |
| const SkPoint* cubics = (const SkPoint*)reader->skip(SkPatchUtils::kNumCtrlPts, |
| sizeof(SkPoint)); |
| uint32_t flag = reader->readInt(); |
| const SkColor* colors = nullptr; |
| if (flag & DRAW_VERTICES_HAS_COLORS) { |
| colors = (const SkColor*)reader->skip(SkPatchUtils::kNumCorners, sizeof(SkColor)); |
| } |
| const SkPoint* texCoords = nullptr; |
| if (flag & DRAW_VERTICES_HAS_TEXS) { |
| texCoords = (const SkPoint*)reader->skip(SkPatchUtils::kNumCorners, |
| sizeof(SkPoint)); |
| } |
| SkBlendMode bmode = SkBlendMode::kModulate; |
| if (flag & DRAW_VERTICES_HAS_XFER) { |
| unsigned mode = reader->readInt(); |
| if (mode <= (unsigned)SkBlendMode::kLastMode) { |
| bmode = (SkBlendMode)mode; |
| } |
| } |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawPatch(cubics, colors, texCoords, bmode, paint); |
| } break; |
| case DRAW_PATH: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| const auto& path = fPictureData->getPath(reader); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawPath(path, paint); |
| } break; |
| case DRAW_PICTURE: { |
| const auto* pic = fPictureData->getPicture(reader); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawPicture(pic); |
| } break; |
| case DRAW_PICTURE_MATRIX_PAINT: { |
| const SkPaint* paint = fPictureData->optionalPaint(reader); |
| SkMatrix matrix; |
| reader->readMatrix(&matrix); |
| const SkPicture* pic = fPictureData->getPicture(reader); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawPicture(pic, &matrix, paint); |
| } break; |
| case DRAW_POINTS: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| SkCanvas::PointMode mode = reader->checkRange(SkCanvas::kPoints_PointMode, |
| SkCanvas::kPolygon_PointMode); |
| size_t count = reader->readInt(); |
| const SkPoint* pts = (const SkPoint*)reader->skip(count, sizeof(SkPoint)); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawPoints(mode, count, pts, paint); |
| } break; |
| case DRAW_RECT: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| SkRect rect; |
| reader->readRect(&rect); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawRect(rect, paint); |
| } break; |
| case DRAW_REGION: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| SkRegion region; |
| reader->readRegion(®ion); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawRegion(region, paint); |
| } break; |
| case DRAW_RRECT: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| SkRRect rrect; |
| reader->readRRect(&rrect); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawRRect(rrect, paint); |
| } break; |
| case DRAW_SHADOW_REC: { |
| const auto& path = fPictureData->getPath(reader); |
| SkDrawShadowRec rec; |
| reader->readPoint3(&rec.fZPlaneParams); |
| reader->readPoint3(&rec.fLightPos); |
| rec.fLightRadius = reader->readScalar(); |
| rec.fAmbientColor = reader->read32(); |
| rec.fSpotColor = reader->read32(); |
| rec.fFlags = reader->read32(); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->private_draw_shadow_rec(path, rec); |
| } break; |
| case DRAW_TEXT_BLOB: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| const SkTextBlob* blob = fPictureData->getTextBlob(reader); |
| SkScalar x = reader->readScalar(); |
| SkScalar y = reader->readScalar(); |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->drawTextBlob(blob, x, y, paint); |
| } break; |
| case DRAW_SLUG: { |
| #if SK_SUPPORT_GPU |
| const sktext::gpu::Slug* slug = fPictureData->getSlug(reader); |
| BREAK_ON_READ_ERROR(reader); |
| |
| slug->draw(canvas); |
| #endif |
| } break; |
| case DRAW_VERTICES_OBJECT: { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| const SkVertices* vertices = fPictureData->getVertices(reader); |
| const int boneCount = reader->readInt(); |
| (void)reader->skip(boneCount, sizeof(SkVertices_DeprecatedBone)); |
| SkBlendMode bmode = reader->read32LE(SkBlendMode::kLastMode); |
| BREAK_ON_READ_ERROR(reader); |
| |
| if (vertices) { // TODO: read error if vertices == null? |
| canvas->drawVertices(vertices, bmode, paint); |
| } |
| } break; |
| case RESTORE: |
| canvas->restore(); |
| break; |
| case ROTATE: { |
| auto deg = reader->readScalar(); |
| canvas->rotate(deg); |
| } break; |
| case SAVE: |
| canvas->save(); |
| break; |
| case SAVE_BEHIND: { |
| uint32_t flags = reader->readInt(); |
| const SkRect* subset = nullptr; |
| SkRect storage; |
| if (flags & SAVEBEHIND_HAS_SUBSET) { |
| reader->readRect(&storage); |
| subset = &storage; |
| } |
| SkCanvasPriv::SaveBehind(canvas, subset); |
| } break; |
| case SAVE_LAYER_SAVELAYERREC: { |
| SkCanvas::SaveLayerRec rec(nullptr, nullptr, nullptr, 0); |
| const uint32_t flatFlags = reader->readInt(); |
| SkRect bounds; |
| if (flatFlags & SAVELAYERREC_HAS_BOUNDS) { |
| reader->readRect(&bounds); |
| rec.fBounds = &bounds; |
| } |
| if (flatFlags & SAVELAYERREC_HAS_PAINT) { |
| rec.fPaint = &fPictureData->requiredPaint(reader); |
| } |
| if (flatFlags & SAVELAYERREC_HAS_BACKDROP) { |
| const SkPaint& paint = fPictureData->requiredPaint(reader); |
| rec.fBackdrop = paint.getImageFilter(); |
| } |
| if (flatFlags & SAVELAYERREC_HAS_FLAGS) { |
| rec.fSaveLayerFlags = reader->readInt(); |
| } |
| if (flatFlags & SAVELAYERREC_HAS_CLIPMASK_OBSOLETE) { |
| (void)fPictureData->getImage(reader); |
| } |
| if (flatFlags & SAVELAYERREC_HAS_CLIPMATRIX_OBSOLETE) { |
| SkMatrix clipMatrix_ignored; |
| reader->readMatrix(&clipMatrix_ignored); |
| } |
| if (!reader->isVersionLT(SkPicturePriv::Version::kBackdropScaleFactor) && |
| (flatFlags & SAVELAYERREC_HAS_BACKDROP_SCALE)) { |
| SkCanvasPriv::SetBackdropScaleFactor(&rec, reader->readScalar()); |
| } |
| BREAK_ON_READ_ERROR(reader); |
| |
| canvas->saveLayer(rec); |
| } break; |
| case SCALE: { |
| SkScalar sx = reader->readScalar(); |
| SkScalar sy = reader->readScalar(); |
| canvas->scale(sx, sy); |
| } break; |
| case SET_M44: { |
| SkM44 m; |
| reader->read(&m); |
| canvas->setMatrix(initialMatrix * m); |
| } break; |
| case SET_MATRIX: { |
| SkMatrix matrix; |
| reader->readMatrix(&matrix); |
| canvas->setMatrix(initialMatrix * SkM44(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: |
| reader->validate(false); // unknown op |
| break; |
| } |
| |
| #undef BREAK_ON_READ_ERROR |
| } |
