/* * 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 "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/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()); // 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(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(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 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(reader->read32()); SkColor4f color; reader->readColor4f(&color); SkBlendMode blend = static_cast(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 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(expectedClips <= dstClipCount)) { // Entries request more dstClip points than are provided in the buffer 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((maxMatrixIndex + 1) <= matrixCount) || !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 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(); 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(); 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_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 MARK_CTM: { SkString name; reader->readString(&name); BREAK_ON_READ_ERROR(reader); canvas->markCTM(name.c_str()); } 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 }