djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 1 | |
| 2 | /* |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 3 | * Copyright 2012 Google Inc. |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 4 | * |
| 5 | * Use of this source code is governed by a BSD-style license that can be |
| 6 | * found in the LICENSE file. |
| 7 | */ |
| 8 | |
| 9 | #include "SkOrderedWriteBuffer.h" |
junov@chromium.org | ce65f38 | 2012-10-17 19:36:09 +0000 | [diff] [blame] | 10 | #include "SkBitmap.h" |
mike@reedtribe.org | 227b516 | 2012-08-12 19:25:08 +0000 | [diff] [blame] | 11 | #include "SkPtrRecorder.h" |
scroggo@google.com | 5a7c6be | 2012-10-04 21:46:08 +0000 | [diff] [blame] | 12 | #include "SkStream.h" |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 13 | #include "SkTypeface.h" |
| 14 | |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 15 | SkOrderedWriteBuffer::SkOrderedWriteBuffer(size_t minSize) |
| 16 | : INHERITED() |
| 17 | , fFactorySet(NULL) |
| 18 | , fNamedFactorySet(NULL) |
| 19 | , fWriter(minSize) |
djsollen@google.com | 21830d9 | 2012-08-07 19:49:41 +0000 | [diff] [blame] | 20 | , fBitmapHeap(NULL) |
scroggo@google.com | 5a7c6be | 2012-10-04 21:46:08 +0000 | [diff] [blame] | 21 | , fTFSet(NULL) |
| 22 | , fBitmapEncoder(NULL) { |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 23 | } |
| 24 | |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 25 | SkOrderedWriteBuffer::SkOrderedWriteBuffer(size_t minSize, void* storage, size_t storageSize) |
| 26 | : INHERITED() |
| 27 | , fFactorySet(NULL) |
| 28 | , fNamedFactorySet(NULL) |
| 29 | , fWriter(minSize, storage, storageSize) |
djsollen@google.com | 21830d9 | 2012-08-07 19:49:41 +0000 | [diff] [blame] | 30 | , fBitmapHeap(NULL) |
scroggo@google.com | 5a7c6be | 2012-10-04 21:46:08 +0000 | [diff] [blame] | 31 | , fTFSet(NULL) |
| 32 | , fBitmapEncoder(NULL) { |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 33 | } |
| 34 | |
| 35 | SkOrderedWriteBuffer::~SkOrderedWriteBuffer() { |
| 36 | SkSafeUnref(fFactorySet); |
| 37 | SkSafeUnref(fNamedFactorySet); |
djsollen@google.com | 21830d9 | 2012-08-07 19:49:41 +0000 | [diff] [blame] | 38 | SkSafeUnref(fBitmapHeap); |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 39 | SkSafeUnref(fTFSet); |
| 40 | } |
| 41 | |
| 42 | void SkOrderedWriteBuffer::writeByteArray(const void* data, size_t size) { |
| 43 | fWriter.write32(size); |
| 44 | fWriter.writePad(data, size); |
| 45 | } |
| 46 | |
| 47 | void SkOrderedWriteBuffer::writeBool(bool value) { |
| 48 | fWriter.writeBool(value); |
| 49 | } |
| 50 | |
| 51 | void SkOrderedWriteBuffer::writeFixed(SkFixed value) { |
| 52 | fWriter.write32(value); |
| 53 | } |
| 54 | |
| 55 | void SkOrderedWriteBuffer::writeScalar(SkScalar value) { |
| 56 | fWriter.writeScalar(value); |
| 57 | } |
| 58 | |
| 59 | void SkOrderedWriteBuffer::writeScalarArray(const SkScalar* value, uint32_t count) { |
| 60 | fWriter.write32(count); |
| 61 | fWriter.write(value, count * sizeof(SkScalar)); |
| 62 | } |
| 63 | |
| 64 | void SkOrderedWriteBuffer::writeInt(int32_t value) { |
| 65 | fWriter.write32(value); |
| 66 | } |
| 67 | |
| 68 | void SkOrderedWriteBuffer::writeIntArray(const int32_t* value, uint32_t count) { |
| 69 | fWriter.write32(count); |
| 70 | fWriter.write(value, count * sizeof(int32_t)); |
| 71 | } |
| 72 | |
| 73 | void SkOrderedWriteBuffer::writeUInt(uint32_t value) { |
| 74 | fWriter.write32(value); |
| 75 | } |
| 76 | |
| 77 | void SkOrderedWriteBuffer::write32(int32_t value) { |
| 78 | fWriter.write32(value); |
| 79 | } |
| 80 | |
| 81 | void SkOrderedWriteBuffer::writeString(const char* value) { |
| 82 | fWriter.writeString(value); |
| 83 | } |
| 84 | |
| 85 | void SkOrderedWriteBuffer::writeEncodedString(const void* value, size_t byteLength, |
| 86 | SkPaint::TextEncoding encoding) { |
| 87 | fWriter.writeInt(encoding); |
| 88 | fWriter.writeInt(byteLength); |
| 89 | fWriter.write(value, byteLength); |
| 90 | } |
| 91 | |
| 92 | |
| 93 | void SkOrderedWriteBuffer::writeColor(const SkColor& color) { |
| 94 | fWriter.write32(color); |
| 95 | } |
| 96 | |
| 97 | void SkOrderedWriteBuffer::writeColorArray(const SkColor* color, uint32_t count) { |
| 98 | fWriter.write32(count); |
| 99 | fWriter.write(color, count * sizeof(SkColor)); |
| 100 | } |
| 101 | |
| 102 | void SkOrderedWriteBuffer::writePoint(const SkPoint& point) { |
| 103 | fWriter.writeScalar(point.fX); |
| 104 | fWriter.writeScalar(point.fY); |
| 105 | } |
| 106 | |
| 107 | void SkOrderedWriteBuffer::writePointArray(const SkPoint* point, uint32_t count) { |
| 108 | fWriter.write32(count); |
| 109 | fWriter.write(point, count * sizeof(SkPoint)); |
| 110 | } |
| 111 | |
| 112 | void SkOrderedWriteBuffer::writeMatrix(const SkMatrix& matrix) { |
| 113 | fWriter.writeMatrix(matrix); |
| 114 | } |
| 115 | |
| 116 | void SkOrderedWriteBuffer::writeIRect(const SkIRect& rect) { |
| 117 | fWriter.write(&rect, sizeof(SkIRect)); |
| 118 | } |
| 119 | |
| 120 | void SkOrderedWriteBuffer::writeRect(const SkRect& rect) { |
| 121 | fWriter.writeRect(rect); |
| 122 | } |
| 123 | |
| 124 | void SkOrderedWriteBuffer::writeRegion(const SkRegion& region) { |
| 125 | fWriter.writeRegion(region); |
| 126 | } |
| 127 | |
| 128 | void SkOrderedWriteBuffer::writePath(const SkPath& path) { |
| 129 | fWriter.writePath(path); |
| 130 | } |
| 131 | |
| 132 | size_t SkOrderedWriteBuffer::writeStream(SkStream* stream, size_t length) { |
| 133 | return fWriter.readFromStream(stream, length); |
| 134 | } |
| 135 | |
| 136 | bool SkOrderedWriteBuffer::writeToStream(SkWStream* stream) { |
| 137 | return fWriter.writeToStream(stream); |
| 138 | } |
| 139 | |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 140 | void SkOrderedWriteBuffer::writeBitmap(const SkBitmap& bitmap) { |
scroggo@google.com | 5a7c6be | 2012-10-04 21:46:08 +0000 | [diff] [blame] | 141 | bool encoded = false; |
| 142 | if (fBitmapEncoder != NULL) { |
| 143 | SkDynamicMemoryWStream pngStream; |
| 144 | if (fBitmapEncoder(&pngStream, bitmap)) { |
| 145 | encoded = true; |
| 146 | if (encoded) { |
| 147 | uint32_t offset = fWriter.bytesWritten(); |
| 148 | // Write the length to indicate that the bitmap was encoded successfully. |
| 149 | size_t length = pngStream.getOffset(); |
| 150 | this->writeUInt(length); |
| 151 | // Now write the stream. |
| 152 | if (pngStream.read(fWriter.reservePad(length), 0, length)) { |
| 153 | // Write the width and height in case the reader does not have a decoder. |
| 154 | this->writeInt(bitmap.width()); |
| 155 | this->writeInt(bitmap.height()); |
| 156 | } else { |
| 157 | // Writing the stream failed, so go back to original state to store another way. |
| 158 | fWriter.rewindToOffset(offset); |
| 159 | encoded = false; |
| 160 | } |
| 161 | } |
| 162 | } |
| 163 | } |
| 164 | if (!encoded) { |
| 165 | // Bitmap was not encoded. Record a zero, implying that the reader need not decode. |
| 166 | this->writeUInt(0); |
| 167 | if (fBitmapHeap) { |
junov@chromium.org | ce65f38 | 2012-10-17 19:36:09 +0000 | [diff] [blame] | 168 | int32_t slot = fBitmapHeap->insert(bitmap); |
| 169 | fWriter.write32(slot); |
| 170 | // crbug.com/155875 |
| 171 | // The generation ID is not required information. We write it to prevent collisions |
| 172 | // in SkFlatDictionary. It is possible to get a collision when a previously |
| 173 | // unflattened (i.e. stale) instance of a similar flattenable is in the dictionary |
| 174 | // and the instance currently being written is re-using the same slot from the |
| 175 | // bitmap heap. |
| 176 | fWriter.write32(bitmap.getGenerationID()); |
scroggo@google.com | 5a7c6be | 2012-10-04 21:46:08 +0000 | [diff] [blame] | 177 | } else { |
| 178 | bitmap.flatten(*this); |
| 179 | } |
djsollen@google.com | 21830d9 | 2012-08-07 19:49:41 +0000 | [diff] [blame] | 180 | } |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 181 | } |
| 182 | |
| 183 | void SkOrderedWriteBuffer::writeTypeface(SkTypeface* obj) { |
| 184 | if (NULL == obj || NULL == fTFSet) { |
| 185 | fWriter.write32(0); |
| 186 | } else { |
| 187 | fWriter.write32(fTFSet->add(obj)); |
| 188 | } |
| 189 | } |
| 190 | |
| 191 | SkFactorySet* SkOrderedWriteBuffer::setFactoryRecorder(SkFactorySet* rec) { |
| 192 | SkRefCnt_SafeAssign(fFactorySet, rec); |
| 193 | if (fNamedFactorySet != NULL) { |
| 194 | fNamedFactorySet->unref(); |
| 195 | fNamedFactorySet = NULL; |
| 196 | } |
| 197 | return rec; |
| 198 | } |
| 199 | |
| 200 | SkNamedFactorySet* SkOrderedWriteBuffer::setNamedFactoryRecorder(SkNamedFactorySet* rec) { |
| 201 | SkRefCnt_SafeAssign(fNamedFactorySet, rec); |
| 202 | if (fFactorySet != NULL) { |
| 203 | fFactorySet->unref(); |
| 204 | fFactorySet = NULL; |
| 205 | } |
| 206 | return rec; |
| 207 | } |
| 208 | |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 209 | SkRefCntSet* SkOrderedWriteBuffer::setTypefaceRecorder(SkRefCntSet* rec) { |
| 210 | SkRefCnt_SafeAssign(fTFSet, rec); |
| 211 | return rec; |
reed@google.com | e49aca9 | 2012-04-24 21:12:39 +0000 | [diff] [blame] | 212 | } |
| 213 | |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 214 | void SkOrderedWriteBuffer::writeFlattenable(SkFlattenable* flattenable) { |
| 215 | /* |
| 216 | * If we have a factoryset, then the first 32bits tell us... |
| 217 | * 0: failure to write the flattenable |
scroggo@google.com | 0c3e5fe | 2012-08-01 19:34:20 +0000 | [diff] [blame] | 218 | * >0: (1-based) index into the SkFactorySet or SkNamedFactorySet |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 219 | * If we don't have a factoryset, then the first "ptr" is either the |
| 220 | * factory, or null for failure. |
| 221 | * |
| 222 | * The distinction is important, since 0-index is 32bits (always), but a |
| 223 | * 0-functionptr might be 32 or 64 bits. |
| 224 | */ |
| 225 | |
| 226 | SkFlattenable::Factory factory = NULL; |
| 227 | if (flattenable) { |
| 228 | factory = flattenable->getFactory(); |
| 229 | } |
| 230 | if (NULL == factory) { |
scroggo@google.com | 0c3e5fe | 2012-08-01 19:34:20 +0000 | [diff] [blame] | 231 | if (fFactorySet != NULL || fNamedFactorySet != NULL) { |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 232 | this->write32(0); |
| 233 | } else { |
| 234 | this->writeFunctionPtr(NULL); |
| 235 | } |
| 236 | return; |
| 237 | } |
| 238 | |
| 239 | /* |
| 240 | * We can write 1 of 3 versions of the flattenable: |
| 241 | * 1. function-ptr : this is the fastest for the reader, but assumes that |
| 242 | * the writer and reader are in the same process. |
| 243 | * 2. index into fFactorySet : This is assumes the writer will later |
| 244 | * resolve the function-ptrs into strings for its reader. SkPicture |
| 245 | * does exactly this, by writing a table of names (matching the indices) |
| 246 | * up front in its serialized form. |
scroggo@google.com | 0c3e5fe | 2012-08-01 19:34:20 +0000 | [diff] [blame] | 247 | * 3. index into fNamedFactorySet. fNamedFactorySet will also store the |
| 248 | * name. SkGPipe uses this technique so it can write the name to its |
| 249 | * stream before writing the flattenable. |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 250 | */ |
| 251 | if (fFactorySet) { |
scroggo@google.com | 0c3e5fe | 2012-08-01 19:34:20 +0000 | [diff] [blame] | 252 | this->write32(fFactorySet->add(factory)); |
| 253 | } else if (fNamedFactorySet) { |
| 254 | int32_t index = fNamedFactorySet->find(factory); |
| 255 | this->write32(index); |
| 256 | if (0 == index) { |
| 257 | return; |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 258 | } |
| 259 | } else { |
| 260 | this->writeFunctionPtr((void*)factory); |
| 261 | } |
| 262 | |
scroggo@google.com | d8a6cc8 | 2012-09-12 18:53:49 +0000 | [diff] [blame] | 263 | // make room for the size of the flattened object |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 264 | (void)fWriter.reserve(sizeof(uint32_t)); |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 265 | // record the current size, so we can subtract after the object writes. |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 266 | uint32_t offset = fWriter.size(); |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 267 | // now flatten the object |
| 268 | flattenObject(flattenable, *this); |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 269 | uint32_t objSize = fWriter.size() - offset; |
djsollen@google.com | 2b2ede3 | 2012-04-12 13:24:04 +0000 | [diff] [blame] | 270 | // record the obj's size |
| 271 | *fWriter.peek32(offset - sizeof(uint32_t)) = objSize; |
| 272 | } |