39#define HEAP_BLOCK_SIZE 4096
70 size_t initialOffset = this->addDraw(
SAVE, &size);
93 size_t size =
sizeof(
kUInt32Size) +
sizeof(uint32_t);
97 size +=
sizeof(*subset);
100 size_t initialOffset = this->addDraw(
SAVE_BEHIND, &size);
103 this->addRect(*subset);
106 this->
validate(initialOffset, size);
113 uint32_t flatFlags = 0;
122 size +=
sizeof(uint32_t);
126 size +=
sizeof(uint32_t);
130 size +=
sizeof(uint32_t);
138 size +=
sizeof(uint32_t);
139 size +=
sizeof(uint32_t) * filterCount;
143 this->addInt(flatFlags);
148 this->addPaintPtr(rec.
fPaint);
154 this->addPaint(
paint);
163 this->addInt(filterCount);
164 for (uint32_t i = 0; i < filterCount; ++i) {
168 this->addPaint(
paint);
171 this->
validate(initialOffset, size);
193 SkASSERT(fRestoreOffsetStack.count() > 1);
197 if (fRestoreOffsetStack.
empty()) {
210 this->fillRestoreOffsetPlaceholdersForCurrentStackLevel((uint32_t)fWriter.
bytesWritten());
213 size_t initialOffset = this->addDraw(
RESTORE, &size);
214 this->
validate(initialOffset, size);
222 size_t initialOffset = this->addDraw(
TRANSLATE, &size);
223 this->addScalar(m.getTranslateX());
224 this->addScalar(m.getTranslateY());
225 this->
validate(initialOffset, size);
233 size_t initialOffset = this->addDraw(
SCALE, &size);
234 this->addScalar(m.getScaleX());
235 this->addScalar(m.getScaleY());
236 this->
validate(initialOffset, size);
243 size_t initialOffset = this->addDraw(
CONCAT44, &size);
245 this->
validate(initialOffset, size);
254 size_t initialOffset = this->addDraw(
SET_M44, &size);
256 this->
validate(initialOffset, size);
272 size_t initialOffset = this->addDraw(
CONCAT, &size);
273 this->addMatrix(matrix);
274 this->
validate(initialOffset, size);
277void SkPictureRecord::fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset) {
300 fInitialSaveCount = this->
save();
308size_t SkPictureRecord::recordRestoreOffsetPlaceholder() {
309 if (fRestoreOffsetStack.
empty()) {
318 int32_t prevOffset = fRestoreOffsetStack.
back();
321 this->addInt(prevOffset);
335 if (!fRestoreOffsetStack.
empty()) {
339 size_t initialOffset = this->addDraw(
CLIP_RECT, &size);
342 size_t offset = this->recordRestoreOffsetPlaceholder();
344 this->
validate(initialOffset, size);
357 if (!fRestoreOffsetStack.
empty()) {
361 size_t initialOffset = this->addDraw(
CLIP_RRECT, &size);
362 this->addRRect(rrect);
364 size_t offset = recordRestoreOffsetPlaceholder();
365 this->
validate(initialOffset, size);
379 if (!fRestoreOffsetStack.
empty()) {
383 size_t initialOffset = this->addDraw(
CLIP_PATH, &size);
384 this->addInt(pathID);
386 size_t offset = recordRestoreOffsetPlaceholder();
387 this->
validate(initialOffset, size);
400 this->addPaint(
paint);
401 this->addInt((
int)op);
402 this->
validate(initialOffset, size);
416 if (!fRestoreOffsetStack.
empty()) {
420 size_t initialOffset = this->addDraw(
CLIP_REGION, &size);
421 this->addRegion(region);
423 size_t offset = this->recordRestoreOffsetPlaceholder();
425 this->
validate(initialOffset, size);
430 if (!fRestoreOffsetStack.
empty()) {
434 this->fillRestoreOffsetPlaceholdersForCurrentStackLevel(0);
437 size_t initialOffset = this->addDraw(
RESET_CLIP, &size);
438 this->
validate(initialOffset, size);
445 size_t initialOffset = this->addDraw(
DRAW_PAINT, &size);
446 this->addPaint(
paint);
447 this->
validate(initialOffset, size);
455 this->addPaint(
paint);
456 this->
validate(initialOffset, size);
463 size_t initialOffset = this->addDraw(
DRAW_POINTS, &size);
464 this->addPaint(
paint);
469 this->
validate(initialOffset, size);
475 size_t initialOffset = this->addDraw(
DRAW_OVAL, &size);
476 this->addPaint(
paint);
478 this->
validate(initialOffset, size);
484 size_t size = 2 *
kUInt32Size +
sizeof(oval) +
sizeof(startAngle) +
sizeof(sweepAngle) +
486 size_t initialOffset = this->addDraw(
DRAW_ARC, &size);
487 this->addPaint(
paint);
489 this->addScalar(startAngle);
490 this->addScalar(sweepAngle);
491 this->addInt(useCenter);
492 this->
validate(initialOffset, size);
498 size_t initialOffset = this->addDraw(
DRAW_RECT, &size);
499 this->addPaint(
paint);
501 this->
validate(initialOffset, size);
508 size_t initialOffset = this->addDraw(
DRAW_REGION, &size);
509 this->addPaint(
paint);
511 this->
validate(initialOffset, size);
517 size_t initialOffset = this->addDraw(
DRAW_RRECT, &size);
518 this->addPaint(
paint);
519 this->addRRect(rrect);
520 this->
validate(initialOffset, size);
527 size_t initialOffset = this->addDraw(
DRAW_DRRECT, &size);
528 this->addPaint(
paint);
529 this->addRRect(outer);
530 this->addRRect(inner);
531 this->
validate(initialOffset, size);
537 size_t initialOffset = this->addDraw(
DRAW_PATH, &size);
538 this->addPaint(
paint);
540 this->
validate(initialOffset, size);
547 size_t initialOffset = this->addDraw(
DRAW_IMAGE2, &size);
548 this->addPaintPtr(
paint);
549 this->addImage(
image);
552 this->addSampling(sampling);
553 this->
validate(initialOffset, size);
564 this->addPaintPtr(
paint);
565 this->addImage(
image);
568 this->addSampling(sampling);
569 this->addInt(constraint);
570 this->
validate(initialOffset, size);
578 size_t size = 3 *
kUInt32Size + latticeSize +
sizeof(dst) +
sizeof(uint32_t);
580 this->addPaintPtr(
paint);
581 this->addImage(
image);
584 this->addInt(
static_cast<uint32_t
>(filter));
585 this->
validate(initialOffset, size);
595 this->addPaint(
paint);
596 this->addTextBlob(blob);
600 this->
validate(initialOffset, size);
606 size_t initialOffset = this->addDraw(
DRAW_SLUG, &size);
608 this->addPaint(
paint);
610 this->
validate(initialOffset, size);
617 size_t initialOffset;
619 if (
nullptr == matrix &&
nullptr ==
paint) {
621 this->addPicture(picture);
626 this->addPaintPtr(
paint);
628 this->addPicture(picture);
630 this->
validate(initialOffset, size);
636 size_t initialOffset;
638 if (
nullptr == matrix) {
640 this->addDrawable(drawable);
644 this->addMatrix(*matrix);
645 this->addDrawable(drawable);
647 this->
validate(initialOffset, size);
656 this->addPaint(
paint);
657 this->addVertices(vertices);
659 this->addInt(
static_cast<uint32_t
>(mode));
661 this->
validate(initialOffset, size);
683 size_t initialOffset = this->addDraw(
DRAW_PATCH, &size);
684 this->addPaint(
paint);
685 this->addPatch(cubics);
696 this->addInt((
int)bmode);
698 this->
validate(initialOffset, size);
712 size +=
sizeof(uint32_t);
720 size_t initialOffset = this->addDraw(
DRAW_ATLAS, &size);
721 this->addPaintPtr(
paint);
722 this->addImage(atlas);
731 this->addInt((
int)mode);
736 this->addSampling(sampling);
737 this->
validate(initialOffset, size);
754 this->
validate(initialOffset, size);
760 size_t size = 4 +
sizeof(
SkRect) + keyLen + valueLen;
766 this->
validate(initialOffset, size);
778 this->addInt((
int) aa);
780 this->addInt((
int) mode);
781 this->addInt(
clip !=
nullptr);
783 this->addPoints(
clip, 4);
785 this->
validate(initialOffset, size);
794 static constexpr size_t kMatrixSize = 9 *
sizeof(
SkScalar);
797 int totalDstClipCount, totalMatrixCount;
801 kMatrixSize * totalMatrixCount +
806 this->addPaintPtr(
paint);
807 this->addSampling(sampling);
808 this->addInt((
int) constraint);
809 for (
int i = 0; i <
count; ++i) {
810 this->addImage(set[i].fImage.get());
811 this->addRect(set[i].fSrcRect);
812 this->addRect(set[i].fDstRect);
813 this->addInt(set[i].fMatrixIndex);
814 this->addScalar(set[i].fAlpha);
815 this->addInt((
int)set[i].fAAFlags);
816 this->addInt(set[i].fHasClip);
818 this->addInt(totalDstClipCount);
819 this->addPoints(dstClips, totalDstClipCount);
820 this->addInt(totalMatrixCount);
821 for (
int i = 0; i < totalMatrixCount; ++i) {
822 this->addMatrix(preViewMatrices[i]);
824 this->
validate(initialOffset, size);
832static bool equals(T*
a, T*
b) {
return a->uniqueID() ==
b->uniqueID(); }
842 for (
int i = 0; i < array.size(); i++) {
843 if (
equals(array[i].get(), obj)) {
850 return array.size() - 1;
862void SkPictureRecord::addMatrix(
const SkMatrix& matrix) {
866void SkPictureRecord::addPaintPtr(
const SkPaint*
paint) {
869 this->addInt(fPaints.
size());
876 if (
int* n = fPaths.
find(path)) {
879 int n = fPaths.
count() + 1;
884void SkPictureRecord::addPath(
const SkPath& path) {
888void SkPictureRecord::addPatch(
const SkPoint cubics[12]) {
892void SkPictureRecord::addPicture(
const SkPicture* picture) {
897void SkPictureRecord::addDrawable(
SkDrawable* drawable) {
902void SkPictureRecord::addPoint(
const SkPoint& point) {
906void SkPictureRecord::addPoints(
const SkPoint pts[],
int count) {
912 this->addDraw(
NOOP, &size);
915void SkPictureRecord::addRect(
const SkRect& rect) {
919void SkPictureRecord::addRectPtr(
const SkRect* rect) {
920 if (fWriter.
writeBool(rect !=
nullptr)) {
925void SkPictureRecord::addIRect(
const SkIRect& rect) {
926 fWriter.
write(&rect,
sizeof(rect));
929void SkPictureRecord::addIRectPtr(
const SkIRect* rect) {
930 if (fWriter.
writeBool(rect !=
nullptr)) {
935void SkPictureRecord::addRRect(
const SkRRect& rrect) {
939void SkPictureRecord::addRegion(
const SkRegion& region) {
947void SkPictureRecord::addText(
const void*
text,
size_t byteLength) {
952void SkPictureRecord::addTextBlob(
const SkTextBlob* blob) {
962void SkPictureRecord::addVertices(
const SkVertices* vertices) {
static void info(const char *fmt,...) SK_PRINTF_LIKE(1
static SkPath clip(const SkPath &path, const SkHalfPlane &plane)
@ DRAW_PICTURE_MATRIX_PAINT
@ SAVE_LAYER_SAVELAYERREC
static uint32_t ClipParams_pack(SkClipOp op, bool doAA)
@ SAVELAYERREC_HAS_BACKDROP_SCALE
@ SAVELAYERREC_HAS_MULTIPLE_FILTERS
@ SAVELAYERREC_HAS_BACKDROP
@ SAVELAYERREC_HAS_BOUNDS
@ DRAW_VERTICES_HAS_COLORS
@ DRAW_ATLAS_HAS_SAMPLING
static int find_or_append(TArray< sk_sp< T > > &array, T *obj)
static int const kUInt32Size
static bool equals(T *a, T *b)
#define UNPACK_8_24(combined, small, large)
sk_sp< T > sk_ref_sp(T *obj)
constexpr int SkToInt(S x)
constexpr uint32_t SkToU32(S x)
static void WriteLattice(SkWriteBuffer &, const SkCanvas::Lattice &)
static SkScalar GetBackdropScaleFactor(const SkCanvas::SaveLayerRec &rec)
static void GetDstClipAndMatrixCounts(const SkCanvas::ImageSetEntry set[], int count, int *totalDstClipCount, int *totalMatrixCount)
@ kNoLayer_SaveLayerStrategy
void restoreToCount(int saveCount)
friend class SkPictureRecord
static SkM44 Translate(SkScalar x, SkScalar y, SkScalar z=0)
static SkM44 Scale(SkScalar x, SkScalar y, SkScalar z=1)
static size_t WriteToMemory(const SkMatrix &matrix, void *buffer)
static const SkScalar * M44ColMajor(const SkM44 &m)
static const SkMatrix & I()
@ kTranslate_Mask
translation SkMatrix
@ kScale_Mask
scale SkMatrix
void onDrawTextBlob(const SkTextBlob *blob, SkScalar x, SkScalar y, const SkPaint &paint) override
void onDrawImage2(const SkImage *, SkScalar, SkScalar, const SkSamplingOptions &, const SkPaint *) override
void onDrawSlug(const sktext::gpu::Slug *slug, const SkPaint &paint) override
void onDrawDrawable(SkDrawable *, const SkMatrix *) override
void onDrawRect(const SkRect &, const SkPaint &) override
void onDrawArc(const SkRect &, SkScalar, SkScalar, bool, const SkPaint &) override
void onDrawBehind(const SkPaint &) override
void onClipRect(const SkRect &, SkClipOp, ClipEdgeStyle) override
void validate(size_t initialOffset, size_t size) const
void onClipRRect(const SkRRect &, SkClipOp, ClipEdgeStyle) override
void recordSaveLayer(const SaveLayerRec &)
void recordScale(const SkMatrix &matrix)
size_t recordClipRRect(const SkRRect &rrect, SkClipOp op, bool doAA)
int addPathToHeap(const SkPath &path)
void onDrawPaint(const SkPaint &) override
void onDrawPicture(const SkPicture *, const SkMatrix *, const SkPaint *) override
void recordRestore(bool fillInSkips=true)
void willRestore() override
void onDrawOval(const SkRect &, const SkPaint &) override
void onDrawAnnotation(const SkRect &, const char[], SkData *) override
void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint &) override
void onDrawEdgeAAQuad(const SkRect &, const SkPoint[4], QuadAAFlags, const SkColor4f &, SkBlendMode) override
SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec &) override
void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode, const SkPaint &paint) override
void didScale(SkScalar, SkScalar) override
void onDrawAtlas2(const SkImage *, const SkRSXform[], const SkRect[], const SkColor[], int, SkBlendMode, const SkSamplingOptions &, const SkRect *, const SkPaint *) override
bool onDoSaveBehind(const SkRect *) override
void onDrawVerticesObject(const SkVertices *, SkBlendMode, const SkPaint &) override
void onDrawRegion(const SkRegion &, const SkPaint &) override
void recordTranslate(const SkMatrix &matrix)
void onClipRegion(const SkRegion &, SkClipOp) override
void recordConcat(const SkMatrix &matrix)
void onDrawShadowRec(const SkPath &, const SkDrawShadowRec &) override
size_t recordClipPath(int pathID, SkClipOp op, bool doAA)
void onDrawPath(const SkPath &, const SkPaint &) override
void didConcat44(const SkM44 &) override
size_t recordClipRect(const SkRect &rect, SkClipOp op, bool doAA)
void onDrawRRect(const SkRRect &, const SkPaint &) override
void onResetClip() override
void onClipPath(const SkPath &, SkClipOp, ClipEdgeStyle) override
size_t recordClipRegion(const SkRegion ®ion, SkClipOp op)
void onDrawEdgeAAImageSet2(const ImageSetEntry[], int count, const SkPoint[], const SkMatrix[], const SkSamplingOptions &, const SkPaint *, SrcRectConstraint) override
void onDrawDRRect(const SkRRect &, const SkRRect &, const SkPaint &) override
void onDrawImageRect2(const SkImage *, const SkRect &, const SkRect &, const SkSamplingOptions &, const SkPaint *, SrcRectConstraint) override
void onClipShader(sk_sp< SkShader >, SkClipOp) override
void didTranslate(SkScalar, SkScalar) override
sk_sp< SkSurface > onNewSurface(const SkImageInfo &, const SkSurfaceProps &) override
void didSetM44(const SkM44 &) override
void onDrawImageLattice2(const SkImage *, const Lattice &, const SkRect &, SkFilterMode, const SkPaint *) override
static constexpr size_t kSizeInMemory
size_t writeToMemory(void *buffer) const
static size_t FlatSize(const SkSamplingOptions &options)
constexpr size_t size() const
void push_back(const T &v)
void overwriteTAt(size_t offset, const T &value)
static size_t WriteDataSize(const SkData *data)
void write32(int32_t value)
void write(const void *values, size_t size)
void writeRRect(const SkRRect &rrect)
void writeSampling(const SkSamplingOptions &sampling)
uint32_t * reservePad(size_t size)
void writeRect(const SkRect &rect)
void writeScalar(SkScalar value)
void writeMatrix(const SkMatrix &matrix)
uint32_t * reserve(size_t size)
void writePoint(const SkPoint &pt)
void writeMul4(const void *values, size_t size)
void writePad(const void *src, size_t size)
void writeData(const SkData *data)
void writePoint3(const SkPoint3 &pt)
static size_t WriteStringSize(const char *str, size_t len=(size_t) -1)
bool writeBool(bool value)
const T & readTAt(size_t offset) const
void writeRegion(const SkRegion &rgn)
void writeString(const char *str, size_t len=(size_t) -1)
size_t bytesWritten() const
V * find(const K &key) const
FlutterSemanticsFlag flag
FlutterSemanticsFlag flags
const SkImageFilter * fBackdrop
SaveLayerFlags fSaveLayerFlags
SkISize dimensions() const