1/*
2 * Copyright 2014 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef SkRecord_DEFINED
9#define SkRecord_DEFINED
10
11#include "include/private/SkTLogic.h"
12#include "include/private/SkTemplates.h"
13#include "src/core/SkArenaAlloc.h"
14#include "src/core/SkRecords.h"
15
16// SkRecord represents a sequence of SkCanvas calls, saved for future use.
17// These future uses may include: replay, optimization, serialization, or combinations of those.
18//
19// Though an enterprising user may find calling alloc(), append(), visit(), and mutate() enough to
20// work with SkRecord, you probably want to look at SkRecorder which presents an SkCanvas interface
21// for creating an SkRecord, and SkRecordDraw which plays an SkRecord back into another SkCanvas.
22//
23// SkRecord often looks like it's compatible with any type T, but really it's compatible with any
24// type T which has a static const SkRecords::Type kType. That is to say, SkRecord is compatible
25// only with SkRecords::* structs defined in SkRecords.h. Your compiler will helpfully yell if you
26// get this wrong.
27
28class SkRecord : public SkRefCnt {
29public:
30 SkRecord() = default;
31 ~SkRecord() override;
32
33 // Returns the number of canvas commands in this SkRecord.
34 int count() const { return fCount; }
35
36 // Visit the i-th canvas command with a functor matching this interface:
37 // template <typename T>
38 // R operator()(const T& record) { ... }
39 // This operator() must be defined for at least all SkRecords::*.
40 template <typename F>
41 auto visit(int i, F&& f) const -> decltype(f(SkRecords::NoOp())) {
42 return fRecords[i].visit(f);
43 }
44
45 // Mutate the i-th canvas command with a functor matching this interface:
46 // template <typename T>
47 // R operator()(T* record) { ... }
48 // This operator() must be defined for at least all SkRecords::*.
49 template <typename F>
50 auto mutate(int i, F&& f) -> decltype(f((SkRecords::NoOp*)nullptr)) {
51 return fRecords[i].mutate(f);
52 }
53
54 // Allocate contiguous space for count Ts, to be freed when the SkRecord is destroyed.
55 // Here T can be any class, not just those from SkRecords. Throws on failure.
56 template <typename T>
57 T* alloc(size_t count = 1) {
58 struct RawBytes {
59 alignas(T) char data[sizeof(T)];
60 };
61 fApproxBytesAllocated += count * sizeof(T) + alignof(T);
62 return (T*)fAlloc.makeArrayDefault<RawBytes>(count);
63 }
64
65 // Add a new command of type T to the end of this SkRecord.
66 // You are expected to placement new an object of type T onto this pointer.
67 template <typename T>
68 T* append() {
69 if (fCount == fReserved) {
70 this->grow();
71 }
72 return fRecords[fCount++].set(this->allocCommand<T>());
73 }
74
75 // Replace the i-th command with a new command of type T.
76 // You are expected to placement new an object of type T onto this pointer.
77 // References to the original command are invalidated.
78 template <typename T>
79 T* replace(int i) {
80 SkASSERT(i < this->count());
81
82 Destroyer destroyer;
83 this->mutate(i, destroyer);
84
85 return fRecords[i].set(this->allocCommand<T>());
86 }
87
88 // Does not return the bytes in any pointers embedded in the Records; callers
89 // need to iterate with a visitor to measure those they care for.
90 size_t bytesUsed() const;
91
92 // Rearrange and resize this record to eliminate any NoOps.
93 // May change count() and the indices of ops, but preserves their order.
94 void defrag();
95
96private:
97 // An SkRecord is structured as an array of pointers into a big chunk of memory where
98 // records representing each canvas draw call are stored:
99 //
100 // fRecords: [*][*][*]...
101 // | | |
102 // | | |
103 // | | +---------------------------------------+
104 // | +-----------------+ |
105 // | | |
106 // v v v
107 // fAlloc: [SkRecords::DrawRect][SkRecords::DrawPosTextH][SkRecords::DrawRect]...
108 //
109 // We store the types of each of the pointers alongside the pointer.
110 // The cost to append a T to this structure is 8 + sizeof(T) bytes.
111
112 // A mutator that can be used with replace to destroy canvas commands.
113 struct Destroyer {
114 template <typename T>
115 void operator()(T* record) { record->~T(); }
116 };
117
118 template <typename T>
119 std::enable_if_t<std::is_empty<T>::value, T*> allocCommand() {
120 static T singleton = {};
121 return &singleton;
122 }
123
124 template <typename T>
125 std::enable_if_t<!std::is_empty<T>::value, T*> allocCommand() { return this->alloc<T>(); }
126
127 void grow();
128
129 // A typed pointer to some bytes in fAlloc. visit() and mutate() allow polymorphic dispatch.
130 struct Record {
131 SkRecords::Type fType;
132 void* fPtr;
133
134 // Point this record to its data in fAlloc. Returns ptr for convenience.
135 template <typename T>
136 T* set(T* ptr) {
137 fType = T::kType;
138 fPtr = ptr;
139 SkASSERT(this->ptr() == ptr && this->type() == T::kType);
140 return ptr;
141 }
142
143 SkRecords::Type type() const { return fType; }
144 void* ptr() const { return fPtr; }
145
146 // Visit this record with functor F (see public API above).
147 template <typename F>
148 auto visit(F&& f) const -> decltype(f(SkRecords::NoOp())) {
149 #define CASE(T) case SkRecords::T##_Type: return f(*(const SkRecords::T*)this->ptr());
150 switch(this->type()) { SK_RECORD_TYPES(CASE) }
151 #undef CASE
152 SkDEBUGFAIL("Unreachable");
153 static const SkRecords::NoOp noop{};
154 return f(noop);
155 }
156
157 // Mutate this record with functor F (see public API above).
158 template <typename F>
159 auto mutate(F&& f) -> decltype(f((SkRecords::NoOp*)nullptr)) {
160 #define CASE(T) case SkRecords::T##_Type: return f((SkRecords::T*)this->ptr());
161 switch(this->type()) { SK_RECORD_TYPES(CASE) }
162 #undef CASE
163 SkDEBUGFAIL("Unreachable");
164 static const SkRecords::NoOp noop{};
165 return f(const_cast<SkRecords::NoOp*>(&noop));
166 }
167 };
168
169 // fRecords needs to be a data structure that can append fixed length data, and need to
170 // support efficient random access and forward iteration. (It doesn't need to be contiguous.)
171 int fCount{0},
172 fReserved{0};
173 SkAutoTMalloc<Record> fRecords;
174
175 // fAlloc needs to be a data structure which can append variable length data in contiguous
176 // chunks, returning a stable handle to that data for later retrieval.
177 SkArenaAlloc fAlloc{256};
178 size_t fApproxBytesAllocated{0};
179};
180
181#endif//SkRecord_DEFINED
182