epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2011 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 | */ |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 7 | #include <new> |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 8 | #include "SkPictureData.h" |
commit-bot@chromium.org | 8016f79 | 2014-03-07 15:53:01 +0000 | [diff] [blame] | 9 | #include "SkPictureRecord.h" |
commit-bot@chromium.org | 8016f79 | 2014-03-07 15:53:01 +0000 | [diff] [blame] | 10 | #include "SkReadBuffer.h" |
fmalita | b742517 | 2014-08-26 07:56:44 -0700 | [diff] [blame] | 11 | #include "SkTextBlob.h" |
commit-bot@chromium.org | 8016f79 | 2014-03-07 15:53:01 +0000 | [diff] [blame] | 12 | #include "SkTypeface.h" |
commit-bot@chromium.org | 8016f79 | 2014-03-07 15:53:01 +0000 | [diff] [blame] | 13 | #include "SkWriteBuffer.h" |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 14 | |
egdaniel | 12c2198 | 2014-06-18 07:34:39 -0700 | [diff] [blame] | 15 | #if SK_SUPPORT_GPU |
| 16 | #include "GrContext.h" |
| 17 | #endif |
| 18 | |
reed@google.com | f4cc187 | 2012-07-23 15:04:45 +0000 | [diff] [blame] | 19 | template <typename T> int SafeCount(const T* obj) { |
| 20 | return obj ? obj->count() : 0; |
| 21 | } |
| 22 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 23 | SkPictureData::SkPictureData(const SkPictInfo& info) |
robertphillips | e26e65e | 2014-06-12 05:51:22 -0700 | [diff] [blame] | 24 | : fInfo(info) { |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 25 | this->init(); |
| 26 | } |
| 27 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 28 | void SkPictureData::initForPlayback() const { |
robertphillips | e26e65e | 2014-06-12 05:51:22 -0700 | [diff] [blame] | 29 | // ensure that the paths bounds are pre-computed |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 30 | for (int i = 0; i < fPaths.count(); i++) { |
| 31 | fPaths[i].updateBoundsCache(); |
robertphillips | e26e65e | 2014-06-12 05:51:22 -0700 | [diff] [blame] | 32 | } |
| 33 | } |
| 34 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 35 | SkPictureData::SkPictureData(const SkPictureRecord& record, |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 36 | const SkPictInfo& info, |
| 37 | bool deepCopyOps) |
robertphillips | e26e65e | 2014-06-12 05:51:22 -0700 | [diff] [blame] | 38 | : fInfo(info) { |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 39 | |
commit-bot@chromium.org | 70512af | 2014-03-18 17:45:32 +0000 | [diff] [blame] | 40 | this->init(); |
robertphillips | 0bdbea7 | 2014-06-11 11:37:55 -0700 | [diff] [blame] | 41 | |
| 42 | fOpData = record.opData(deepCopyOps); |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 43 | |
robertphillips | 0bdbea7 | 2014-06-11 11:37:55 -0700 | [diff] [blame] | 44 | fContentInfo.set(record.fContentInfo); |
rileya@google.com | 8515e79 | 2012-09-13 21:41:51 +0000 | [diff] [blame] | 45 | |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 46 | fBitmaps = record.fBitmaps; |
| 47 | fPaints = record.fPaints; |
| 48 | fPaths = record.fPaths; |
djsollen@google.com | c9ab987 | 2012-08-29 18:52:07 +0000 | [diff] [blame] | 49 | |
robertphillips | e26e65e | 2014-06-12 05:51:22 -0700 | [diff] [blame] | 50 | this->initForPlayback(); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 51 | |
robertphillips | 9b14f26 | 2014-06-04 05:40:44 -0700 | [diff] [blame] | 52 | const SkTDArray<const SkPicture* >& pictures = record.getPictureRefs(); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 53 | fPictureCount = pictures.count(); |
| 54 | if (fPictureCount > 0) { |
robertphillips | 9b14f26 | 2014-06-04 05:40:44 -0700 | [diff] [blame] | 55 | fPictureRefs = SkNEW_ARRAY(const SkPicture*, fPictureCount); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 56 | for (int i = 0; i < fPictureCount; i++) { |
robertphillips | 6de2712 | 2014-06-10 09:23:06 -0700 | [diff] [blame] | 57 | fPictureRefs[i] = pictures[i]; |
| 58 | fPictureRefs[i]->ref(); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 59 | } |
| 60 | } |
fmalita | b742517 | 2014-08-26 07:56:44 -0700 | [diff] [blame] | 61 | |
| 62 | // templatize to consolidate with similar picture logic? |
| 63 | const SkTDArray<const SkTextBlob*>& blobs = record.getTextBlobRefs(); |
| 64 | fTextBlobCount = blobs.count(); |
| 65 | if (fTextBlobCount > 0) { |
| 66 | fTextBlobRefs = SkNEW_ARRAY(const SkTextBlob*, fTextBlobCount); |
| 67 | for (int i = 0; i < fTextBlobCount; ++i) { |
| 68 | fTextBlobRefs[i] = SkRef(blobs[i]); |
| 69 | } |
| 70 | } |
reed | 871872f | 2015-06-22 12:48:26 -0700 | [diff] [blame] | 71 | |
| 72 | const SkTDArray<const SkImage*>& imgs = record.getImageRefs(); |
| 73 | fImageCount = imgs.count(); |
| 74 | if (fImageCount > 0) { |
| 75 | fImageRefs = SkNEW_ARRAY(const SkImage*, fImageCount); |
| 76 | for (int i = 0; i < fImageCount; ++i) { |
| 77 | fImageRefs[i] = SkRef(imgs[i]); |
| 78 | } |
| 79 | } |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 80 | } |
| 81 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 82 | void SkPictureData::init() { |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 83 | fPictureRefs = NULL; |
reed@google.com | f4cc187 | 2012-07-23 15:04:45 +0000 | [diff] [blame] | 84 | fPictureCount = 0; |
fmalita | b742517 | 2014-08-26 07:56:44 -0700 | [diff] [blame] | 85 | fTextBlobRefs = NULL; |
| 86 | fTextBlobCount = 0; |
reed | 871872f | 2015-06-22 12:48:26 -0700 | [diff] [blame] | 87 | fImageRefs = NULL; |
| 88 | fImageCount = 0; |
reed@google.com | ddf98a8 | 2012-07-21 20:31:09 +0000 | [diff] [blame] | 89 | fOpData = NULL; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 90 | fFactoryPlayback = NULL; |
| 91 | } |
| 92 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 93 | SkPictureData::~SkPictureData() { |
commit-bot@chromium.org | 9e5f85e | 2014-03-12 14:46:41 +0000 | [diff] [blame] | 94 | SkSafeUnref(fOpData); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 95 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 96 | for (int i = 0; i < fPictureCount; i++) { |
| 97 | fPictureRefs[i]->unref(); |
| 98 | } |
| 99 | SkDELETE_ARRAY(fPictureRefs); |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 100 | |
fmalita | b742517 | 2014-08-26 07:56:44 -0700 | [diff] [blame] | 101 | for (int i = 0; i < fTextBlobCount; i++) { |
| 102 | fTextBlobRefs[i]->unref(); |
| 103 | } |
| 104 | SkDELETE_ARRAY(fTextBlobRefs); |
reed | 871872f | 2015-06-22 12:48:26 -0700 | [diff] [blame] | 105 | |
| 106 | for (int i = 0; i < fImageCount; i++) { |
| 107 | fImageRefs[i]->unref(); |
| 108 | } |
| 109 | SkDELETE_ARRAY(fImageRefs); |
| 110 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 111 | SkDELETE(fFactoryPlayback); |
| 112 | } |
| 113 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 114 | bool SkPictureData::containsBitmaps() const { |
reed | 871872f | 2015-06-22 12:48:26 -0700 | [diff] [blame] | 115 | if (fBitmaps.count() > 0 || fImageCount > 0) { |
tomhudson@google.com | 381010e | 2013-10-24 11:12:47 +0000 | [diff] [blame] | 116 | return true; |
| 117 | } |
| 118 | for (int i = 0; i < fPictureCount; ++i) { |
| 119 | if (fPictureRefs[i]->willPlayBackBitmaps()) { |
| 120 | return true; |
| 121 | } |
| 122 | } |
| 123 | return false; |
| 124 | } |
| 125 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 126 | /////////////////////////////////////////////////////////////////////////////// |
| 127 | /////////////////////////////////////////////////////////////////////////////// |
| 128 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 129 | #include "SkStream.h" |
| 130 | |
commit-bot@chromium.org | dcb8e54 | 2014-03-05 18:25:20 +0000 | [diff] [blame] | 131 | static size_t compute_chunk_size(SkFlattenable::Factory* array, int count) { |
| 132 | size_t size = 4; // for 'count' |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 133 | |
commit-bot@chromium.org | dcb8e54 | 2014-03-05 18:25:20 +0000 | [diff] [blame] | 134 | for (int i = 0; i < count; i++) { |
| 135 | const char* name = SkFlattenable::FactoryToName(array[i]); |
| 136 | if (NULL == name || 0 == *name) { |
| 137 | size += SkWStream::SizeOfPackedUInt(0); |
| 138 | } else { |
| 139 | size_t len = strlen(name); |
| 140 | size += SkWStream::SizeOfPackedUInt(len); |
| 141 | size += len; |
| 142 | } |
| 143 | } |
| 144 | |
| 145 | return size; |
| 146 | } |
| 147 | |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 148 | static void write_tag_size(SkWriteBuffer& buffer, uint32_t tag, size_t size) { |
| 149 | buffer.writeUInt(tag); |
| 150 | buffer.writeUInt(SkToU32(size)); |
| 151 | } |
| 152 | |
| 153 | static void write_tag_size(SkWStream* stream, uint32_t tag, size_t size) { |
| 154 | stream->write32(tag); |
| 155 | stream->write32(SkToU32(size)); |
| 156 | } |
| 157 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 158 | void SkPictureData::WriteFactories(SkWStream* stream, const SkFactorySet& rec) { |
commit-bot@chromium.org | dcb8e54 | 2014-03-05 18:25:20 +0000 | [diff] [blame] | 159 | int count = rec.count(); |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 160 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 161 | SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count); |
| 162 | SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get(); |
mike@reedtribe.org | e9e08cc | 2011-04-29 01:44:52 +0000 | [diff] [blame] | 163 | rec.copyToArray(array); |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 164 | |
commit-bot@chromium.org | dcb8e54 | 2014-03-05 18:25:20 +0000 | [diff] [blame] | 165 | size_t size = compute_chunk_size(array, count); |
| 166 | |
| 167 | // TODO: write_tag_size should really take a size_t |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 168 | write_tag_size(stream, SK_PICT_FACTORY_TAG, (uint32_t) size); |
commit-bot@chromium.org | 06e9752 | 2014-03-06 20:53:44 +0000 | [diff] [blame] | 169 | SkDEBUGCODE(size_t start = stream->bytesWritten()); |
commit-bot@chromium.org | dcb8e54 | 2014-03-05 18:25:20 +0000 | [diff] [blame] | 170 | stream->write32(count); |
| 171 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 172 | for (int i = 0; i < count; i++) { |
| 173 | const char* name = SkFlattenable::FactoryToName(array[i]); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 174 | if (NULL == name || 0 == *name) { |
| 175 | stream->writePackedUInt(0); |
| 176 | } else { |
commit-bot@chromium.org | 2cfa320 | 2014-04-19 22:00:40 +0000 | [diff] [blame] | 177 | size_t len = strlen(name); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 178 | stream->writePackedUInt(len); |
| 179 | stream->write(name, len); |
| 180 | } |
| 181 | } |
commit-bot@chromium.org | dcb8e54 | 2014-03-05 18:25:20 +0000 | [diff] [blame] | 182 | |
commit-bot@chromium.org | 06e9752 | 2014-03-06 20:53:44 +0000 | [diff] [blame] | 183 | SkASSERT(size == (stream->bytesWritten() - start)); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 184 | } |
| 185 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 186 | void SkPictureData::WriteTypefaces(SkWStream* stream, const SkRefCntSet& rec) { |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 187 | int count = rec.count(); |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 188 | |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 189 | write_tag_size(stream, SK_PICT_TYPEFACE_TAG, count); |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 190 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 191 | SkAutoSTMalloc<16, SkTypeface*> storage(count); |
| 192 | SkTypeface** array = (SkTypeface**)storage.get(); |
mike@reedtribe.org | e9e08cc | 2011-04-29 01:44:52 +0000 | [diff] [blame] | 193 | rec.copyToArray((SkRefCnt**)array); |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 194 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 195 | for (int i = 0; i < count; i++) { |
mtklein | d9591bb | 2015-02-10 11:48:55 -0800 | [diff] [blame] | 196 | #ifdef SK_PICTURE_FORCE_FONT_EMBEDDING |
mtklein | 1a4900e | 2014-12-11 11:06:00 -0800 | [diff] [blame] | 197 | array[i]->serializeForcingEmbedding(stream); |
| 198 | #else |
mtklein | d9591bb | 2015-02-10 11:48:55 -0800 | [diff] [blame] | 199 | // TODO: if (embedFonts) { array[i]->serializeForcingEmbedding(stream) } else |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 200 | array[i]->serialize(stream); |
mtklein | 1a4900e | 2014-12-11 11:06:00 -0800 | [diff] [blame] | 201 | #endif |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 202 | } |
| 203 | } |
| 204 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 205 | void SkPictureData::flattenToBuffer(SkWriteBuffer& buffer) const { |
reed@google.com | f4cc187 | 2012-07-23 15:04:45 +0000 | [diff] [blame] | 206 | int i, n; |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 207 | |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 208 | if ((n = fBitmaps.count()) > 0) { |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 209 | write_tag_size(buffer, SK_PICT_BITMAP_BUFFER_TAG, n); |
reed@google.com | f4cc187 | 2012-07-23 15:04:45 +0000 | [diff] [blame] | 210 | for (i = 0; i < n; i++) { |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 211 | buffer.writeBitmap(fBitmaps[i]); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 212 | } |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 213 | } |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 214 | |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 215 | if ((n = fPaints.count()) > 0) { |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 216 | write_tag_size(buffer, SK_PICT_PAINT_BUFFER_TAG, n); |
reed@google.com | f4cc187 | 2012-07-23 15:04:45 +0000 | [diff] [blame] | 217 | for (i = 0; i < n; i++) { |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 218 | buffer.writePaint(fPaints[i]); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 219 | } |
| 220 | } |
skia.committer@gmail.com | a27096b | 2012-08-30 14:38:00 +0000 | [diff] [blame] | 221 | |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 222 | if ((n = fPaths.count()) > 0) { |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 223 | write_tag_size(buffer, SK_PICT_PATH_BUFFER_TAG, n); |
mtklein | 71a2363 | 2014-11-12 10:24:55 -0800 | [diff] [blame] | 224 | buffer.writeInt(n); |
| 225 | for (int i = 0; i < n; i++) { |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 226 | buffer.writePath(fPaths[i]); |
mtklein | 71a2363 | 2014-11-12 10:24:55 -0800 | [diff] [blame] | 227 | } |
robertphillips | e26e65e | 2014-06-12 05:51:22 -0700 | [diff] [blame] | 228 | } |
fmalita | b742517 | 2014-08-26 07:56:44 -0700 | [diff] [blame] | 229 | |
| 230 | if (fTextBlobCount > 0) { |
| 231 | write_tag_size(buffer, SK_PICT_TEXTBLOB_BUFFER_TAG, fTextBlobCount); |
| 232 | for (i = 0; i < fTextBlobCount; ++i) { |
| 233 | fTextBlobRefs[i]->flatten(buffer); |
| 234 | } |
| 235 | } |
reed | 871872f | 2015-06-22 12:48:26 -0700 | [diff] [blame] | 236 | |
| 237 | if (fImageCount > 0) { |
| 238 | write_tag_size(buffer, SK_PICT_IMAGE_BUFFER_TAG, fImageCount); |
| 239 | for (i = 0; i < fImageCount; ++i) { |
| 240 | buffer.writeImage(fImageRefs[i]); |
| 241 | } |
| 242 | } |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 243 | } |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 244 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 245 | void SkPictureData::serialize(SkWStream* stream, |
scroggo | 895c43b | 2014-12-11 10:53:58 -0800 | [diff] [blame] | 246 | SkPixelSerializer* pixelSerializer) const { |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 247 | write_tag_size(stream, SK_PICT_READER_TAG, fOpData->size()); |
reed@google.com | ddf98a8 | 2012-07-21 20:31:09 +0000 | [diff] [blame] | 248 | stream->write(fOpData->bytes(), fOpData->size()); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 249 | |
| 250 | if (fPictureCount > 0) { |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 251 | write_tag_size(stream, SK_PICT_PICTURE_TAG, fPictureCount); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 252 | for (int i = 0; i < fPictureCount; i++) { |
scroggo | 895c43b | 2014-12-11 10:53:58 -0800 | [diff] [blame] | 253 | fPictureRefs[i]->serialize(stream, pixelSerializer); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 254 | } |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 255 | } |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 256 | |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 257 | // Write some of our data into a writebuffer, and then serialize that |
| 258 | // into our stream |
| 259 | { |
| 260 | SkRefCntSet typefaceSet; |
| 261 | SkFactorySet factSet; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 262 | |
commit-bot@chromium.org | a2bd2d1 | 2014-01-30 22:16:32 +0000 | [diff] [blame] | 263 | SkWriteBuffer buffer(SkWriteBuffer::kCrossProcess_Flag); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 264 | buffer.setTypefaceRecorder(&typefaceSet); |
| 265 | buffer.setFactoryRecorder(&factSet); |
scroggo | 895c43b | 2014-12-11 10:53:58 -0800 | [diff] [blame] | 266 | buffer.setPixelSerializer(pixelSerializer); |
reed@google.com | 34342f6 | 2012-06-25 14:36:28 +0000 | [diff] [blame] | 267 | |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 268 | this->flattenToBuffer(buffer); |
| 269 | |
commit-bot@chromium.org | dcb8e54 | 2014-03-05 18:25:20 +0000 | [diff] [blame] | 270 | // We have to write these two sets into the stream *before* we write |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 271 | // the buffer, since parsing that buffer will require that we already |
| 272 | // have these sets available to use. |
commit-bot@chromium.org | 8f831f2 | 2014-04-23 22:35:42 +0000 | [diff] [blame] | 273 | WriteFactories(stream, factSet); |
| 274 | WriteTypefaces(stream, typefaceSet); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 275 | |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 276 | write_tag_size(stream, SK_PICT_BUFFER_SIZE_TAG, buffer.bytesWritten()); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 277 | buffer.writeToStream(stream); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 278 | } |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 279 | |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 280 | stream->write32(SK_PICT_EOF_TAG); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 281 | } |
| 282 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 283 | void SkPictureData::flatten(SkWriteBuffer& buffer) const { |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 284 | write_tag_size(buffer, SK_PICT_READER_TAG, fOpData->size()); |
commit-bot@chromium.org | 5e0995e | 2014-02-07 12:20:04 +0000 | [diff] [blame] | 285 | buffer.writeByteArray(fOpData->bytes(), fOpData->size()); |
| 286 | |
| 287 | if (fPictureCount > 0) { |
robertphillips | 6142609 | 2014-07-10 09:35:12 -0700 | [diff] [blame] | 288 | write_tag_size(buffer, SK_PICT_PICTURE_TAG, fPictureCount); |
commit-bot@chromium.org | 5e0995e | 2014-02-07 12:20:04 +0000 | [diff] [blame] | 289 | for (int i = 0; i < fPictureCount; i++) { |
| 290 | fPictureRefs[i]->flatten(buffer); |
| 291 | } |
| 292 | } |
| 293 | |
| 294 | // Write this picture playback's data into a writebuffer |
| 295 | this->flattenToBuffer(buffer); |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 296 | buffer.write32(SK_PICT_EOF_TAG); |
commit-bot@chromium.org | 5e0995e | 2014-02-07 12:20:04 +0000 | [diff] [blame] | 297 | } |
| 298 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 299 | /////////////////////////////////////////////////////////////////////////////// |
| 300 | |
reed@google.com | 34342f6 | 2012-06-25 14:36:28 +0000 | [diff] [blame] | 301 | /** |
commit-bot@chromium.org | 8b0e8ac | 2014-01-30 18:58:24 +0000 | [diff] [blame] | 302 | * Return the corresponding SkReadBuffer flags, given a set of |
reed@google.com | 34342f6 | 2012-06-25 14:36:28 +0000 | [diff] [blame] | 303 | * SkPictInfo flags. |
| 304 | */ |
| 305 | static uint32_t pictInfoFlagsToReadBufferFlags(uint32_t pictInfoFlags) { |
| 306 | static const struct { |
| 307 | uint32_t fSrc; |
| 308 | uint32_t fDst; |
| 309 | } gSD[] = { |
commit-bot@chromium.org | 8b0e8ac | 2014-01-30 18:58:24 +0000 | [diff] [blame] | 310 | { SkPictInfo::kCrossProcess_Flag, SkReadBuffer::kCrossProcess_Flag }, |
| 311 | { SkPictInfo::kScalarIsFloat_Flag, SkReadBuffer::kScalarIsFloat_Flag }, |
| 312 | { SkPictInfo::kPtrIs64Bit_Flag, SkReadBuffer::kPtrIs64Bit_Flag }, |
reed@google.com | 34342f6 | 2012-06-25 14:36:28 +0000 | [diff] [blame] | 313 | }; |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 314 | |
reed@google.com | 34342f6 | 2012-06-25 14:36:28 +0000 | [diff] [blame] | 315 | uint32_t rbMask = 0; |
| 316 | for (size_t i = 0; i < SK_ARRAY_COUNT(gSD); ++i) { |
| 317 | if (pictInfoFlags & gSD[i].fSrc) { |
| 318 | rbMask |= gSD[i].fDst; |
| 319 | } |
| 320 | } |
| 321 | return rbMask; |
| 322 | } |
| 323 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 324 | bool SkPictureData::parseStreamTag(SkStream* stream, |
robertphillips | ce4dd3d | 2014-07-07 13:46:35 -0700 | [diff] [blame] | 325 | uint32_t tag, |
| 326 | uint32_t size, |
| 327 | SkPicture::InstallPixelRefProc proc) { |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 328 | /* |
| 329 | * By the time we encounter BUFFER_SIZE_TAG, we need to have already seen |
| 330 | * its dependents: FACTORY_TAG and TYPEFACE_TAG. These two are not required |
| 331 | * but if they are present, they need to have been seen before the buffer. |
| 332 | * |
| 333 | * We assert that if/when we see either of these, that we have not yet seen |
| 334 | * the buffer tag, because if we have, then its too-late to deal with the |
| 335 | * factories or typefaces. |
| 336 | */ |
scroggo@google.com | c4dc831 | 2013-02-22 15:46:44 +0000 | [diff] [blame] | 337 | SkDEBUGCODE(bool haveBuffer = false;) |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 338 | |
| 339 | switch (tag) { |
reed | 9594da1 | 2014-09-12 12:12:27 -0700 | [diff] [blame] | 340 | case SK_PICT_READER_TAG: |
| 341 | SkASSERT(NULL == fOpData); |
| 342 | fOpData = SkData::NewFromStream(stream, size); |
| 343 | if (!fOpData) { |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 344 | return false; |
| 345 | } |
reed | 9594da1 | 2014-09-12 12:12:27 -0700 | [diff] [blame] | 346 | break; |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 347 | case SK_PICT_FACTORY_TAG: { |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 348 | SkASSERT(!haveBuffer); |
mtklein | 88fd0fb | 2014-12-01 06:56:38 -0800 | [diff] [blame] | 349 | size = stream->readU32(); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 350 | fFactoryPlayback = SkNEW_ARGS(SkFactoryPlayback, (size)); |
| 351 | for (size_t i = 0; i < size; i++) { |
| 352 | SkString str; |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 353 | const size_t len = stream->readPackedUInt(); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 354 | str.resize(len); |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 355 | if (stream->read(str.writable_str(), len) != len) { |
| 356 | return false; |
| 357 | } |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 358 | fFactoryPlayback->base()[i] = SkFlattenable::NameToFactory(str.c_str()); |
| 359 | } |
| 360 | } break; |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 361 | case SK_PICT_TYPEFACE_TAG: { |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 362 | SkASSERT(!haveBuffer); |
commit-bot@chromium.org | dcecb16 | 2014-04-22 17:54:29 +0000 | [diff] [blame] | 363 | const int count = SkToInt(size); |
| 364 | fTFPlayback.setCount(count); |
| 365 | for (int i = 0; i < count; i++) { |
reed@google.com | 73c0abc | 2013-04-22 13:47:40 +0000 | [diff] [blame] | 366 | SkAutoTUnref<SkTypeface> tf(SkTypeface::Deserialize(stream)); |
| 367 | if (!tf.get()) { // failed to deserialize |
| 368 | // fTFPlayback asserts it never has a null, so we plop in |
| 369 | // the default here. |
| 370 | tf.reset(SkTypeface::RefDefault()); |
| 371 | } |
| 372 | fTFPlayback.set(i, tf); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 373 | } |
| 374 | } break; |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 375 | case SK_PICT_PICTURE_TAG: { |
fmalita | 5479d3b | 2015-07-29 14:40:06 -0700 | [diff] [blame^] | 376 | fPictureCount = 0; |
| 377 | fPictureRefs = SkNEW_ARRAY(const SkPicture*, size); |
| 378 | for (uint32_t i = 0; i < size; i++) { |
scroggo@google.com | f1754ec | 2013-06-28 21:32:00 +0000 | [diff] [blame] | 379 | fPictureRefs[i] = SkPicture::CreateFromStream(stream, proc); |
fmalita | 5479d3b | 2015-07-29 14:40:06 -0700 | [diff] [blame^] | 380 | if (!fPictureRefs[i]) { |
| 381 | return false; |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 382 | } |
fmalita | 5479d3b | 2015-07-29 14:40:06 -0700 | [diff] [blame^] | 383 | fPictureCount++; |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 384 | } |
| 385 | } break; |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 386 | case SK_PICT_BUFFER_SIZE_TAG: { |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 387 | SkAutoMalloc storage(size); |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 388 | if (stream->read(storage.get(), size) != size) { |
| 389 | return false; |
| 390 | } |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 391 | |
reed | ac6a2f9 | 2014-11-12 09:25:25 -0800 | [diff] [blame] | 392 | /* Should we use SkValidatingReadBuffer instead? */ |
commit-bot@chromium.org | 8b0e8ac | 2014-01-30 18:58:24 +0000 | [diff] [blame] | 393 | SkReadBuffer buffer(storage.get(), size); |
commit-bot@chromium.org | 0943f5f | 2014-03-28 18:05:47 +0000 | [diff] [blame] | 394 | buffer.setFlags(pictInfoFlagsToReadBufferFlags(fInfo.fFlags)); |
commit-bot@chromium.org | 7ed173b | 2014-05-20 17:31:08 +0000 | [diff] [blame] | 395 | buffer.setVersion(fInfo.fVersion); |
reed@google.com | 34342f6 | 2012-06-25 14:36:28 +0000 | [diff] [blame] | 396 | |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 397 | fFactoryPlayback->setupBuffer(buffer); |
| 398 | fTFPlayback.setupBuffer(buffer); |
scroggo@google.com | f8d7d27 | 2013-02-22 21:38:35 +0000 | [diff] [blame] | 399 | buffer.setBitmapDecoder(proc); |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 400 | |
reed | ac6a2f9 | 2014-11-12 09:25:25 -0800 | [diff] [blame] | 401 | while (!buffer.eof() && buffer.isValid()) { |
djsollen@google.com | c73dd5c | 2012-08-07 15:54:32 +0000 | [diff] [blame] | 402 | tag = buffer.readUInt(); |
| 403 | size = buffer.readUInt(); |
robertphillips | e26e65e | 2014-06-12 05:51:22 -0700 | [diff] [blame] | 404 | if (!this->parseBufferTag(buffer, tag, size)) { |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 405 | return false; |
| 406 | } |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 407 | } |
reed | ac6a2f9 | 2014-11-12 09:25:25 -0800 | [diff] [blame] | 408 | if (!buffer.isValid()) { |
| 409 | return false; |
| 410 | } |
scroggo@google.com | c4dc831 | 2013-02-22 15:46:44 +0000 | [diff] [blame] | 411 | SkDEBUGCODE(haveBuffer = true;) |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 412 | } break; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 413 | } |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 414 | return true; // success |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 415 | } |
| 416 | |
reed | 871872f | 2015-06-22 12:48:26 -0700 | [diff] [blame] | 417 | static const SkImage* create_image_from_buffer(SkReadBuffer& buffer) { |
| 418 | int width = buffer.read32(); |
| 419 | int height = buffer.read32(); |
| 420 | if (width <= 0 || height <= 0) { // SkImage never has a zero dimension |
| 421 | buffer.validate(false); |
| 422 | return NULL; |
| 423 | } |
| 424 | |
| 425 | SkAutoTUnref<SkData> encoded(buffer.readByteArrayAsData()); |
| 426 | int originX = buffer.read32(); |
| 427 | int originY = buffer.read32(); |
| 428 | if (0 == encoded->size() || originX < 0 || originY < 0) { |
| 429 | buffer.validate(false); |
| 430 | return NULL; |
| 431 | } |
| 432 | |
| 433 | const SkIRect subset = SkIRect::MakeXYWH(originX, originY, width, height); |
| 434 | return SkImage::NewFromEncoded(encoded, &subset); |
| 435 | } |
| 436 | |
| 437 | // Need a shallow wrapper to return const SkPicture* to match the other factories, |
| 438 | // as SkPicture::CreateFromBuffer() returns SkPicture* |
| 439 | static const SkPicture* create_picture_from_buffer(SkReadBuffer& buffer) { |
| 440 | return SkPicture::CreateFromBuffer(buffer); |
| 441 | } |
| 442 | |
| 443 | template <typename T> |
| 444 | bool new_array_from_buffer(SkReadBuffer& buffer, uint32_t inCount, |
| 445 | const T*** array, int* outCount, const T* (*factory)(SkReadBuffer&)) { |
| 446 | if (!buffer.validate((0 == *outCount) && (NULL == *array))) { |
| 447 | return false; |
| 448 | } |
| 449 | if (0 == inCount) { |
| 450 | return true; |
| 451 | } |
| 452 | *outCount = inCount; |
| 453 | *array = SkNEW_ARRAY(const T*, *outCount); |
| 454 | bool success = true; |
| 455 | int i = 0; |
| 456 | for (; i < *outCount; i++) { |
| 457 | (*array)[i] = factory(buffer); |
| 458 | if (NULL == (*array)[i]) { |
| 459 | success = false; |
| 460 | break; |
| 461 | } |
| 462 | } |
| 463 | if (!success) { |
| 464 | // Delete all of the blobs that were already created (up to but excluding i): |
| 465 | for (int j = 0; j < i; j++) { |
| 466 | (*array)[j]->unref(); |
| 467 | } |
| 468 | // Delete the array |
| 469 | SkDELETE_ARRAY(*array); |
| 470 | *array = NULL; |
| 471 | *outCount = 0; |
| 472 | return false; |
| 473 | } |
| 474 | return true; |
| 475 | } |
| 476 | |
| 477 | bool SkPictureData::parseBufferTag(SkReadBuffer& buffer, uint32_t tag, uint32_t size) { |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 478 | switch (tag) { |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 479 | case SK_PICT_BITMAP_BUFFER_TAG: { |
commit-bot@chromium.org | dcecb16 | 2014-04-22 17:54:29 +0000 | [diff] [blame] | 480 | const int count = SkToInt(size); |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 481 | fBitmaps.reset(count); |
commit-bot@chromium.org | dcecb16 | 2014-04-22 17:54:29 +0000 | [diff] [blame] | 482 | for (int i = 0; i < count; ++i) { |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 483 | SkBitmap* bm = &fBitmaps[i]; |
reed | ac6a2f9 | 2014-11-12 09:25:25 -0800 | [diff] [blame] | 484 | if (buffer.readBitmap(bm)) { |
| 485 | bm->setImmutable(); |
| 486 | } else { |
| 487 | return false; |
| 488 | } |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 489 | } |
| 490 | } break; |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 491 | case SK_PICT_PAINT_BUFFER_TAG: { |
commit-bot@chromium.org | dcecb16 | 2014-04-22 17:54:29 +0000 | [diff] [blame] | 492 | const int count = SkToInt(size); |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 493 | fPaints.reset(count); |
commit-bot@chromium.org | dcecb16 | 2014-04-22 17:54:29 +0000 | [diff] [blame] | 494 | for (int i = 0; i < count; ++i) { |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 495 | buffer.readPaint(&fPaints[i]); |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 496 | } |
| 497 | } break; |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 498 | case SK_PICT_PATH_BUFFER_TAG: |
robertphillips | e26e65e | 2014-06-12 05:51:22 -0700 | [diff] [blame] | 499 | if (size > 0) { |
mtklein | 71a2363 | 2014-11-12 10:24:55 -0800 | [diff] [blame] | 500 | const int count = buffer.readInt(); |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 501 | fPaths.reset(count); |
mtklein | 71a2363 | 2014-11-12 10:24:55 -0800 | [diff] [blame] | 502 | for (int i = 0; i < count; i++) { |
mtklein | 703d3c7 | 2014-11-12 11:08:20 -0800 | [diff] [blame] | 503 | buffer.readPath(&fPaths[i]); |
mtklein | 71a2363 | 2014-11-12 10:24:55 -0800 | [diff] [blame] | 504 | } |
| 505 | } break; |
reed | 871872f | 2015-06-22 12:48:26 -0700 | [diff] [blame] | 506 | case SK_PICT_TEXTBLOB_BUFFER_TAG: |
| 507 | if (!new_array_from_buffer(buffer, size, &fTextBlobRefs, &fTextBlobCount, |
| 508 | SkTextBlob::CreateFromBuffer)) { |
fmalita | b742517 | 2014-08-26 07:56:44 -0700 | [diff] [blame] | 509 | return false; |
| 510 | } |
reed | 871872f | 2015-06-22 12:48:26 -0700 | [diff] [blame] | 511 | break; |
| 512 | case SK_PICT_IMAGE_BUFFER_TAG: |
| 513 | if (!new_array_from_buffer(buffer, size, &fImageRefs, &fImageCount, |
| 514 | create_image_from_buffer)) { |
fmalita | b742517 | 2014-08-26 07:56:44 -0700 | [diff] [blame] | 515 | return false; |
| 516 | } |
reed | 871872f | 2015-06-22 12:48:26 -0700 | [diff] [blame] | 517 | break; |
commit-bot@chromium.org | 9e5f85e | 2014-03-12 14:46:41 +0000 | [diff] [blame] | 518 | case SK_PICT_READER_TAG: { |
reed | 9594da1 | 2014-09-12 12:12:27 -0700 | [diff] [blame] | 519 | SkAutoDataUnref data(SkData::NewUninitialized(size)); |
| 520 | if (!buffer.readByteArray(data->writable_data(), size) || |
commit-bot@chromium.org | 9e5f85e | 2014-03-12 14:46:41 +0000 | [diff] [blame] | 521 | !buffer.validate(NULL == fOpData)) { |
| 522 | return false; |
| 523 | } |
| 524 | SkASSERT(NULL == fOpData); |
reed | 9594da1 | 2014-09-12 12:12:27 -0700 | [diff] [blame] | 525 | fOpData = data.detach(); |
commit-bot@chromium.org | 9e5f85e | 2014-03-12 14:46:41 +0000 | [diff] [blame] | 526 | } break; |
reed | 871872f | 2015-06-22 12:48:26 -0700 | [diff] [blame] | 527 | case SK_PICT_PICTURE_TAG: |
| 528 | if (!new_array_from_buffer(buffer, size, &fPictureRefs, &fPictureCount, |
| 529 | create_picture_from_buffer)) { |
commit-bot@chromium.org | 9e5f85e | 2014-03-12 14:46:41 +0000 | [diff] [blame] | 530 | return false; |
| 531 | } |
reed | c210035 | 2015-06-22 17:03:10 -0700 | [diff] [blame] | 532 | break; |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 533 | default: |
| 534 | // The tag was invalid. |
| 535 | return false; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 536 | } |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 537 | return true; // success |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 538 | } |
| 539 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 540 | SkPictureData* SkPictureData::CreateFromStream(SkStream* stream, |
| 541 | const SkPictInfo& info, |
| 542 | SkPicture::InstallPixelRefProc proc) { |
| 543 | SkAutoTDelete<SkPictureData> data(SkNEW_ARGS(SkPictureData, (info))); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 544 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 545 | if (!data->parseStream(stream, proc)) { |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 546 | return NULL; |
| 547 | } |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 548 | return data.detach(); |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 549 | } |
| 550 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 551 | SkPictureData* SkPictureData::CreateFromBuffer(SkReadBuffer& buffer, |
| 552 | const SkPictInfo& info) { |
| 553 | SkAutoTDelete<SkPictureData> data(SkNEW_ARGS(SkPictureData, (info))); |
commit-bot@chromium.org | 7ed173b | 2014-05-20 17:31:08 +0000 | [diff] [blame] | 554 | buffer.setVersion(info.fVersion); |
commit-bot@chromium.org | 5e0995e | 2014-02-07 12:20:04 +0000 | [diff] [blame] | 555 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 556 | if (!data->parseBuffer(buffer)) { |
commit-bot@chromium.org | 5e0995e | 2014-02-07 12:20:04 +0000 | [diff] [blame] | 557 | return NULL; |
| 558 | } |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 559 | return data.detach(); |
commit-bot@chromium.org | 5e0995e | 2014-02-07 12:20:04 +0000 | [diff] [blame] | 560 | } |
| 561 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 562 | bool SkPictureData::parseStream(SkStream* stream, |
| 563 | SkPicture::InstallPixelRefProc proc) { |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 564 | for (;;) { |
| 565 | uint32_t tag = stream->readU32(); |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 566 | if (SK_PICT_EOF_TAG == tag) { |
reed@google.com | 6756209 | 2012-06-22 15:38:39 +0000 | [diff] [blame] | 567 | break; |
| 568 | } |
reed@google.com | 82065d6 | 2011-02-07 15:30:46 +0000 | [diff] [blame] | 569 | |
reed@google.com | ed38495 | 2012-06-22 13:12:17 +0000 | [diff] [blame] | 570 | uint32_t size = stream->readU32(); |
robertphillips | e26e65e | 2014-06-12 05:51:22 -0700 | [diff] [blame] | 571 | if (!this->parseStreamTag(stream, tag, size, proc)) { |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 572 | return false; // we're invalid |
| 573 | } |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 574 | } |
scroggo@google.com | 1270532 | 2013-10-01 15:30:46 +0000 | [diff] [blame] | 575 | return true; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 576 | } |
| 577 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 578 | bool SkPictureData::parseBuffer(SkReadBuffer& buffer) { |
commit-bot@chromium.org | 5e0995e | 2014-02-07 12:20:04 +0000 | [diff] [blame] | 579 | for (;;) { |
| 580 | uint32_t tag = buffer.readUInt(); |
commit-bot@chromium.org | 6f4fb0f | 2014-03-03 19:18:39 +0000 | [diff] [blame] | 581 | if (SK_PICT_EOF_TAG == tag) { |
commit-bot@chromium.org | 5e0995e | 2014-02-07 12:20:04 +0000 | [diff] [blame] | 582 | break; |
| 583 | } |
| 584 | |
| 585 | uint32_t size = buffer.readUInt(); |
robertphillips | e26e65e | 2014-06-12 05:51:22 -0700 | [diff] [blame] | 586 | if (!this->parseBufferTag(buffer, tag, size)) { |
commit-bot@chromium.org | 5e0995e | 2014-02-07 12:20:04 +0000 | [diff] [blame] | 587 | return false; // we're invalid |
| 588 | } |
| 589 | } |
| 590 | return true; |
| 591 | } |
| 592 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 593 | /////////////////////////////////////////////////////////////////////////////// |
| 594 | /////////////////////////////////////////////////////////////////////////////// |
| 595 | |
robertphillips | 0bdbea7 | 2014-06-11 11:37:55 -0700 | [diff] [blame] | 596 | #if SK_SUPPORT_GPU |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 597 | bool SkPictureData::suitableForGpuRasterization(GrContext* context, const char **reason, |
hendrikw | afdada2 | 2014-08-08 10:44:33 -0700 | [diff] [blame] | 598 | int sampleCount) const { |
| 599 | return fContentInfo.suitableForGpuRasterization(context, reason, sampleCount); |
robertphillips | 0bdbea7 | 2014-06-11 11:37:55 -0700 | [diff] [blame] | 600 | } |
egdaniel | 12c2198 | 2014-06-18 07:34:39 -0700 | [diff] [blame] | 601 | |
robertphillips | db53990 | 2014-07-01 08:47:04 -0700 | [diff] [blame] | 602 | bool SkPictureData::suitableForGpuRasterization(GrContext* context, const char **reason, |
| 603 | GrPixelConfig config, SkScalar dpi) const { |
egdaniel | 12c2198 | 2014-06-18 07:34:39 -0700 | [diff] [blame] | 604 | |
| 605 | if (context != NULL) { |
| 606 | return this->suitableForGpuRasterization(context, reason, |
| 607 | context->getRecommendedSampleCount(config, dpi)); |
| 608 | } else { |
| 609 | return this->suitableForGpuRasterization(NULL, reason); |
| 610 | } |
| 611 | } |
| 612 | |
robertphillips | c019ec4 | 2014-08-12 05:35:58 -0700 | [diff] [blame] | 613 | bool SkPictureData::suitableForLayerOptimization() const { |
| 614 | return fContentInfo.numLayers() > 0; |
| 615 | } |
robertphillips | 0bdbea7 | 2014-06-11 11:37:55 -0700 | [diff] [blame] | 616 | #endif |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 617 | /////////////////////////////////////////////////////////////////////////////// |
| 618 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 619 | |