| |
| /* |
| * Copyright 2008 The Android Open Source Project |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| |
| #ifndef SkWriter32_DEFINED |
| #define SkWriter32_DEFINED |
| |
| #include "../private/SkTemplates.h" |
| #include "SkData.h" |
| #include "SkMatrix.h" |
| #include "SkPath.h" |
| #include "SkPoint.h" |
| #include "SkPoint3.h" |
| #include "SkRRect.h" |
| #include "SkRect.h" |
| #include "SkRegion.h" |
| #include "SkScalar.h" |
| #include "SkStream.h" |
| #include "SkTypes.h" |
| |
| class SK_API SkWriter32 : SkNoncopyable { |
| public: |
| /** |
| * The caller can specify an initial block of storage, which the caller manages. |
| * |
| * SkWriter32 will try to back reserve and write calls with this external storage until the |
| * first time an allocation doesn't fit. From then it will use dynamically allocated storage. |
| * This used to be optional behavior, but pipe now relies on it. |
| */ |
| SkWriter32(void* external = nullptr, size_t externalBytes = 0) { |
| this->reset(external, externalBytes); |
| } |
| |
| // return the current offset (will always be a multiple of 4) |
| size_t bytesWritten() const { return fUsed; } |
| |
| SK_ATTR_DEPRECATED("use bytesWritten") |
| size_t size() const { return this->bytesWritten(); } |
| |
| void reset(void* external = nullptr, size_t externalBytes = 0) { |
| SkASSERT(SkIsAlign4((uintptr_t)external)); |
| SkASSERT(SkIsAlign4(externalBytes)); |
| |
| fData = (uint8_t*)external; |
| fCapacity = externalBytes; |
| fUsed = 0; |
| fExternal = external; |
| } |
| |
| // size MUST be multiple of 4 |
| uint32_t* reserve(size_t size) { |
| SkASSERT(SkAlign4(size) == size); |
| size_t offset = fUsed; |
| size_t totalRequired = fUsed + size; |
| if (totalRequired > fCapacity) { |
| this->growToAtLeast(totalRequired); |
| } |
| fUsed = totalRequired; |
| return (uint32_t*)(fData + offset); |
| } |
| |
| /** |
| * Read a T record at offset, which must be a multiple of 4. Only legal if the record |
| * was written atomically using the write methods below. |
| */ |
| template<typename T> |
| const T& readTAt(size_t offset) const { |
| SkASSERT(SkAlign4(offset) == offset); |
| SkASSERT(offset < fUsed); |
| return *(T*)(fData + offset); |
| } |
| |
| /** |
| * Overwrite a T record at offset, which must be a multiple of 4. Only legal if the record |
| * was written atomically using the write methods below. |
| */ |
| template<typename T> |
| void overwriteTAt(size_t offset, const T& value) { |
| SkASSERT(SkAlign4(offset) == offset); |
| SkASSERT(offset < fUsed); |
| *(T*)(fData + offset) = value; |
| } |
| |
| bool writeBool(bool value) { |
| this->write32(value); |
| return value; |
| } |
| |
| void writeInt(int32_t value) { |
| this->write32(value); |
| } |
| |
| void write8(int32_t value) { |
| *(int32_t*)this->reserve(sizeof(value)) = value & 0xFF; |
| } |
| |
| void write16(int32_t value) { |
| *(int32_t*)this->reserve(sizeof(value)) = value & 0xFFFF; |
| } |
| |
| void write32(int32_t value) { |
| *(int32_t*)this->reserve(sizeof(value)) = value; |
| } |
| |
| void writePtr(void* value) { |
| *(void**)this->reserve(sizeof(value)) = value; |
| } |
| |
| void writeScalar(SkScalar value) { |
| *(SkScalar*)this->reserve(sizeof(value)) = value; |
| } |
| |
| void writePoint(const SkPoint& pt) { |
| *(SkPoint*)this->reserve(sizeof(pt)) = pt; |
| } |
| |
| void writePoint3(const SkPoint3& pt) { |
| *(SkPoint3*)this->reserve(sizeof(pt)) = pt; |
| } |
| |
| void writeRect(const SkRect& rect) { |
| *(SkRect*)this->reserve(sizeof(rect)) = rect; |
| } |
| |
| void writeIRect(const SkIRect& rect) { |
| *(SkIRect*)this->reserve(sizeof(rect)) = rect; |
| } |
| |
| void writeRRect(const SkRRect& rrect) { |
| rrect.writeToMemory(this->reserve(SkRRect::kSizeInMemory)); |
| } |
| |
| void writePath(const SkPath& path) { |
| size_t size = path.writeToMemory(nullptr); |
| SkASSERT(SkAlign4(size) == size); |
| path.writeToMemory(this->reserve(size)); |
| } |
| |
| void writeMatrix(const SkMatrix& matrix); |
| |
| void writeRegion(const SkRegion& rgn) { |
| size_t size = rgn.writeToMemory(nullptr); |
| SkASSERT(SkAlign4(size) == size); |
| rgn.writeToMemory(this->reserve(size)); |
| } |
| |
| // write count bytes (must be a multiple of 4) |
| void writeMul4(const void* values, size_t size) { |
| this->write(values, size); |
| } |
| |
| /** |
| * Write size bytes from values. size must be a multiple of 4, though |
| * values need not be 4-byte aligned. |
| */ |
| void write(const void* values, size_t size) { |
| SkASSERT(SkAlign4(size) == size); |
| sk_careful_memcpy(this->reserve(size), values, size); |
| } |
| |
| /** |
| * Reserve size bytes. Does not need to be 4 byte aligned. The remaining space (if any) will be |
| * filled in with zeroes. |
| */ |
| uint32_t* reservePad(size_t size) { |
| size_t alignedSize = SkAlign4(size); |
| uint32_t* p = this->reserve(alignedSize); |
| if (alignedSize != size) { |
| SkASSERT(alignedSize >= 4); |
| p[alignedSize / 4 - 1] = 0; |
| } |
| return p; |
| } |
| |
| /** |
| * Write size bytes from src, and pad to 4 byte alignment with zeroes. |
| */ |
| void writePad(const void* src, size_t size) { |
| sk_careful_memcpy(this->reservePad(size), src, size); |
| } |
| |
| /** |
| * Writes a string to the writer, which can be retrieved with |
| * SkReader32::readString(). |
| * The length can be specified, or if -1 is passed, it will be computed by |
| * calling strlen(). The length must be < max size_t. |
| * |
| * If you write NULL, it will be read as "". |
| */ |
| void writeString(const char* str, size_t len = (size_t)-1); |
| |
| /** |
| * Computes the size (aligned to multiple of 4) need to write the string |
| * in a call to writeString(). If the length is not specified, it will be |
| * computed by calling strlen(). |
| */ |
| static size_t WriteStringSize(const char* str, size_t len = (size_t)-1); |
| |
| void writeData(const SkData* data) { |
| uint32_t len = data ? SkToU32(data->size()) : 0; |
| this->write32(len); |
| if (data) { |
| this->writePad(data->data(), len); |
| } |
| } |
| |
| static size_t WriteDataSize(const SkData* data) { |
| return 4 + SkAlign4(data ? data->size() : 0); |
| } |
| |
| /** |
| * Move the cursor back to offset bytes from the beginning. |
| * offset must be a multiple of 4 no greater than size(). |
| */ |
| void rewindToOffset(size_t offset) { |
| SkASSERT(SkAlign4(offset) == offset); |
| SkASSERT(offset <= bytesWritten()); |
| fUsed = offset; |
| } |
| |
| // copy into a single buffer (allocated by caller). Must be at least size() |
| void flatten(void* dst) const { |
| memcpy(dst, fData, fUsed); |
| } |
| |
| bool writeToStream(SkWStream* stream) const { |
| return stream->write(fData, fUsed); |
| } |
| |
| // read from the stream, and write up to length bytes. Return the actual |
| // number of bytes written. |
| size_t readFromStream(SkStream* stream, size_t length) { |
| return stream->read(this->reservePad(length), length); |
| } |
| |
| /** |
| * Captures a snapshot of the data as it is right now, and return it. |
| */ |
| sk_sp<SkData> snapshotAsData() const; |
| private: |
| void growToAtLeast(size_t size); |
| |
| uint8_t* fData; // Points to either fInternal or fExternal. |
| size_t fCapacity; // Number of bytes we can write to fData. |
| size_t fUsed; // Number of bytes written. |
| void* fExternal; // Unmanaged memory block. |
| SkAutoTMalloc<uint8_t> fInternal; // Managed memory block. |
| }; |
| |
| /** |
| * Helper class to allocated SIZE bytes as part of the writer, and to provide |
| * that storage to the constructor as its initial storage buffer. |
| * |
| * This wrapper ensures proper alignment rules are met for the storage. |
| */ |
| template <size_t SIZE> class SkSWriter32 : public SkWriter32 { |
| public: |
| SkSWriter32() { this->reset(); } |
| |
| void reset() {this->INHERITED::reset(fData.fStorage, SIZE); } |
| |
| private: |
| union { |
| void* fPtrAlignment; |
| double fDoubleAlignment; |
| char fStorage[SIZE]; |
| } fData; |
| |
| typedef SkWriter32 INHERITED; |
| }; |
| |
| #endif |