blob: d8c5efe54e6971eaffacc9906bc7f7c44c5c1a2b [file] [log] [blame]
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkRecord_DEFINED
#define SkRecord_DEFINED
#include "include/private/base/SkTLogic.h"
#include "include/private/base/SkTemplates.h"
#include "src/base/SkArenaAlloc.h"
#include "src/core/SkRecords.h"
// SkRecord represents a sequence of SkCanvas calls, saved for future use.
// These future uses may include: replay, optimization, serialization, or combinations of those.
//
// Though an enterprising user may find calling alloc(), append(), visit(), and mutate() enough to
// work with SkRecord, you probably want to look at SkRecorder which presents an SkCanvas interface
// for creating an SkRecord, and SkRecordDraw which plays an SkRecord back into another SkCanvas.
//
// SkRecord often looks like it's compatible with any type T, but really it's compatible with any
// type T which has a static const SkRecords::Type kType. That is to say, SkRecord is compatible
// only with SkRecords::* structs defined in SkRecords.h. Your compiler will helpfully yell if you
// get this wrong.
class SkRecord : public SkRefCnt {
public:
SkRecord() = default;
~SkRecord() override;
// Returns the number of canvas commands in this SkRecord.
int count() const { return fCount; }
// Visit the i-th canvas command with a functor matching this interface:
// template <typename T>
// R operator()(const T& record) { ... }
// This operator() must be defined for at least all SkRecords::*.
template <typename F>
auto visit(int i, F&& f) const -> decltype(f(SkRecords::NoOp())) {
return fRecords[i].visit(f);
}
// Mutate the i-th canvas command with a functor matching this interface:
// template <typename T>
// R operator()(T* record) { ... }
// This operator() must be defined for at least all SkRecords::*.
template <typename F>
auto mutate(int i, F&& f) -> decltype(f((SkRecords::NoOp*)nullptr)) {
return fRecords[i].mutate(f);
}
// Allocate contiguous space for count Ts, to be freed when the SkRecord is destroyed.
// Here T can be any class, not just those from SkRecords. Throws on failure.
template <typename T>
T* alloc(size_t count = 1) {
struct RawBytes {
alignas(T) char data[sizeof(T)];
};
fApproxBytesAllocated += count * sizeof(T) + alignof(T);
return (T*)fAlloc.makeArrayDefault<RawBytes>(count);
}
// Add a new command of type T to the end of this SkRecord.
// You are expected to placement new an object of type T onto this pointer.
template <typename T>
T* append() {
if (fCount == fReserved) {
this->grow();
}
return fRecords[fCount++].set(this->allocCommand<T>());
}
// Replace the i-th command with a new command of type T.
// You are expected to placement new an object of type T onto this pointer.
// References to the original command are invalidated.
template <typename T>
T* replace(int i) {
SkASSERT(i < this->count());
Destroyer destroyer;
this->mutate(i, destroyer);
return fRecords[i].set(this->allocCommand<T>());
}
// Does not return the bytes in any pointers embedded in the Records; callers
// need to iterate with a visitor to measure those they care for.
size_t bytesUsed() const;
// Rearrange and resize this record to eliminate any NoOps.
// May change count() and the indices of ops, but preserves their order.
void defrag();
private:
// An SkRecord is structured as an array of pointers into a big chunk of memory where
// records representing each canvas draw call are stored:
//
// fRecords: [*][*][*]...
// | | |
// | | |
// | | +---------------------------------------+
// | +-----------------+ |
// | | |
// v v v
// fAlloc: [SkRecords::DrawRect][SkRecords::DrawPosTextH][SkRecords::DrawRect]...
//
// We store the types of each of the pointers alongside the pointer.
// The cost to append a T to this structure is 8 + sizeof(T) bytes.
// A mutator that can be used with replace to destroy canvas commands.
struct Destroyer {
template <typename T>
void operator()(T* record) { record->~T(); }
};
template <typename T>
std::enable_if_t<std::is_empty<T>::value, T*> allocCommand() {
static T singleton = {};
return &singleton;
}
template <typename T>
std::enable_if_t<!std::is_empty<T>::value, T*> allocCommand() { return this->alloc<T>(); }
void grow();
// A typed pointer to some bytes in fAlloc. visit() and mutate() allow polymorphic dispatch.
struct Record {
SkRecords::Type fType;
void* fPtr;
// Point this record to its data in fAlloc. Returns ptr for convenience.
template <typename T>
T* set(T* ptr) {
fType = T::kType;
fPtr = ptr;
SkASSERT(this->ptr() == ptr && this->type() == T::kType);
return ptr;
}
SkRecords::Type type() const { return fType; }
void* ptr() const { return fPtr; }
// Visit this record with functor F (see public API above).
template <typename F>
auto visit(F&& f) const -> decltype(f(SkRecords::NoOp())) {
#define CASE(T) case SkRecords::T##_Type: return f(*(const SkRecords::T*)this->ptr());
switch(this->type()) { SK_RECORD_TYPES(CASE) }
#undef CASE
SkDEBUGFAIL("Unreachable");
static const SkRecords::NoOp noop{};
return f(noop);
}
// Mutate this record with functor F (see public API above).
template <typename F>
auto mutate(F&& f) -> decltype(f((SkRecords::NoOp*)nullptr)) {
#define CASE(T) case SkRecords::T##_Type: return f((SkRecords::T*)this->ptr());
switch(this->type()) { SK_RECORD_TYPES(CASE) }
#undef CASE
SkDEBUGFAIL("Unreachable");
static const SkRecords::NoOp noop{};
return f(const_cast<SkRecords::NoOp*>(&noop));
}
};
// fRecords needs to be a data structure that can append fixed length data, and need to
// support efficient random access and forward iteration. (It doesn't need to be contiguous.)
int fCount{0},
fReserved{0};
skia_private::AutoTMalloc<Record> fRecords;
// fAlloc needs to be a data structure which can append variable length data in contiguous
// chunks, returning a stable handle to that data for later retrieval.
SkArenaAlloc fAlloc{256};
size_t fApproxBytesAllocated{0};
};
#endif//SkRecord_DEFINED