SkPictureData.cpp 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536
  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. */
  7. #include "src/core/SkPictureData.h"
  8. #include "include/core/SkImageGenerator.h"
  9. #include "include/core/SkTypeface.h"
  10. #include "include/private/SkTo.h"
  11. #include "src/core/SkAutoMalloc.h"
  12. #include "src/core/SkMakeUnique.h"
  13. #include "src/core/SkPicturePriv.h"
  14. #include "src/core/SkPictureRecord.h"
  15. #include "src/core/SkReadBuffer.h"
  16. #include "src/core/SkTextBlobPriv.h"
  17. #include "src/core/SkWriteBuffer.h"
  18. #include <new>
  19. #if SK_SUPPORT_GPU
  20. #include "include/gpu/GrContext.h"
  21. #endif
  22. template <typename T> int SafeCount(const T* obj) {
  23. return obj ? obj->count() : 0;
  24. }
  25. SkPictureData::SkPictureData(const SkPictInfo& info)
  26. : fInfo(info) {}
  27. void SkPictureData::initForPlayback() const {
  28. // ensure that the paths bounds are pre-computed
  29. for (int i = 0; i < fPaths.count(); i++) {
  30. fPaths[i].updateBoundsCache();
  31. }
  32. }
  33. SkPictureData::SkPictureData(const SkPictureRecord& record,
  34. const SkPictInfo& info)
  35. : fPictures(record.getPictures())
  36. , fDrawables(record.getDrawables())
  37. , fTextBlobs(record.getTextBlobs())
  38. , fVertices(record.getVertices())
  39. , fImages(record.getImages())
  40. , fInfo(info) {
  41. fOpData = record.opData();
  42. fPaints = record.fPaints;
  43. fPaths.reset(record.fPaths.count());
  44. record.fPaths.foreach([this](const SkPath& path, int n) {
  45. // These indices are logically 1-based, but we need to serialize them
  46. // 0-based to keep the deserializing SkPictureData::getPath() working.
  47. fPaths[n-1] = path;
  48. });
  49. this->initForPlayback();
  50. }
  51. ///////////////////////////////////////////////////////////////////////////////
  52. ///////////////////////////////////////////////////////////////////////////////
  53. #include "include/core/SkStream.h"
  54. static size_t compute_chunk_size(SkFlattenable::Factory* array, int count) {
  55. size_t size = 4; // for 'count'
  56. for (int i = 0; i < count; i++) {
  57. const char* name = SkFlattenable::FactoryToName(array[i]);
  58. if (nullptr == name || 0 == *name) {
  59. size += SkWStream::SizeOfPackedUInt(0);
  60. } else {
  61. size_t len = strlen(name);
  62. size += SkWStream::SizeOfPackedUInt(len);
  63. size += len;
  64. }
  65. }
  66. return size;
  67. }
  68. static void write_tag_size(SkWriteBuffer& buffer, uint32_t tag, size_t size) {
  69. buffer.writeUInt(tag);
  70. buffer.writeUInt(SkToU32(size));
  71. }
  72. static void write_tag_size(SkWStream* stream, uint32_t tag, size_t size) {
  73. stream->write32(tag);
  74. stream->write32(SkToU32(size));
  75. }
  76. void SkPictureData::WriteFactories(SkWStream* stream, const SkFactorySet& rec) {
  77. int count = rec.count();
  78. SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count);
  79. SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get();
  80. rec.copyToArray(array);
  81. size_t size = compute_chunk_size(array, count);
  82. // TODO: write_tag_size should really take a size_t
  83. write_tag_size(stream, SK_PICT_FACTORY_TAG, (uint32_t) size);
  84. SkDEBUGCODE(size_t start = stream->bytesWritten());
  85. stream->write32(count);
  86. for (int i = 0; i < count; i++) {
  87. const char* name = SkFlattenable::FactoryToName(array[i]);
  88. if (nullptr == name || 0 == *name) {
  89. stream->writePackedUInt(0);
  90. } else {
  91. size_t len = strlen(name);
  92. stream->writePackedUInt(len);
  93. stream->write(name, len);
  94. }
  95. }
  96. SkASSERT(size == (stream->bytesWritten() - start));
  97. }
  98. void SkPictureData::WriteTypefaces(SkWStream* stream, const SkRefCntSet& rec,
  99. const SkSerialProcs& procs) {
  100. int count = rec.count();
  101. write_tag_size(stream, SK_PICT_TYPEFACE_TAG, count);
  102. SkAutoSTMalloc<16, SkTypeface*> storage(count);
  103. SkTypeface** array = (SkTypeface**)storage.get();
  104. rec.copyToArray((SkRefCnt**)array);
  105. for (int i = 0; i < count; i++) {
  106. SkTypeface* tf = array[i];
  107. if (procs.fTypefaceProc) {
  108. auto data = procs.fTypefaceProc(tf, procs.fTypefaceCtx);
  109. if (data) {
  110. stream->write(data->data(), data->size());
  111. continue;
  112. }
  113. }
  114. array[i]->serialize(stream);
  115. }
  116. }
  117. void SkPictureData::flattenToBuffer(SkWriteBuffer& buffer, bool textBlobsOnly) const {
  118. int i, n;
  119. if (!textBlobsOnly) {
  120. if ((n = fPaints.count()) > 0) {
  121. write_tag_size(buffer, SK_PICT_PAINT_BUFFER_TAG, n);
  122. for (i = 0; i < n; i++) {
  123. buffer.writePaint(fPaints[i]);
  124. }
  125. }
  126. if ((n = fPaths.count()) > 0) {
  127. write_tag_size(buffer, SK_PICT_PATH_BUFFER_TAG, n);
  128. buffer.writeInt(n);
  129. for (int i = 0; i < n; i++) {
  130. buffer.writePath(fPaths[i]);
  131. }
  132. }
  133. }
  134. if (!fTextBlobs.empty()) {
  135. write_tag_size(buffer, SK_PICT_TEXTBLOB_BUFFER_TAG, fTextBlobs.count());
  136. for (const auto& blob : fTextBlobs) {
  137. SkTextBlobPriv::Flatten(*blob, buffer);
  138. }
  139. }
  140. if (!textBlobsOnly) {
  141. if (!fVertices.empty()) {
  142. write_tag_size(buffer, SK_PICT_VERTICES_BUFFER_TAG, fVertices.count());
  143. for (const auto& vert : fVertices) {
  144. buffer.writeDataAsByteArray(vert->encode().get());
  145. }
  146. }
  147. if (!fImages.empty()) {
  148. write_tag_size(buffer, SK_PICT_IMAGE_BUFFER_TAG, fImages.count());
  149. for (const auto& img : fImages) {
  150. buffer.writeImage(img.get());
  151. }
  152. }
  153. }
  154. }
  155. // SkPictureData::serialize() will write out paints, and then write out an array of typefaces
  156. // (unique set). However, paint's serializer will respect SerialProcs, which can cause us to
  157. // call that custom typefaceproc on *every* typeface, not just on the unique ones. To avoid this,
  158. // we ignore the custom proc (here) when we serialize the paints, and then do respect it when
  159. // we serialize the typefaces.
  160. static SkSerialProcs skip_typeface_proc(const SkSerialProcs& procs) {
  161. SkSerialProcs newProcs = procs;
  162. newProcs.fTypefaceProc = nullptr;
  163. newProcs.fTypefaceCtx = nullptr;
  164. return newProcs;
  165. }
  166. // topLevelTypeFaceSet is null only on the top level call.
  167. // This method is called recursively on every subpicture in two passes.
  168. // textBlobsOnly serves to indicate that we are on the first pass and skip as much work as
  169. // possible that is not relevant to collecting text blobs in topLevelTypeFaceSet
  170. // TODO(nifong): dedupe typefaces and all other shared resources in a faster and more readable way.
  171. void SkPictureData::serialize(SkWStream* stream, const SkSerialProcs& procs,
  172. SkRefCntSet* topLevelTypeFaceSet, bool textBlobsOnly) const {
  173. // This can happen at pretty much any time, so might as well do it first.
  174. write_tag_size(stream, SK_PICT_READER_TAG, fOpData->size());
  175. stream->write(fOpData->bytes(), fOpData->size());
  176. // We serialize all typefaces into the typeface section of the top-level picture.
  177. SkRefCntSet localTypefaceSet;
  178. SkRefCntSet* typefaceSet = topLevelTypeFaceSet ? topLevelTypeFaceSet : &localTypefaceSet;
  179. // We delay serializing the bulk of our data until after we've serialized
  180. // factories and typefaces by first serializing to an in-memory write buffer.
  181. SkFactorySet factSet; // buffer refs factSet, so factSet must come first.
  182. SkBinaryWriteBuffer buffer;
  183. buffer.setFactoryRecorder(sk_ref_sp(&factSet));
  184. buffer.setSerialProcs(skip_typeface_proc(procs));
  185. buffer.setTypefaceRecorder(sk_ref_sp(typefaceSet));
  186. this->flattenToBuffer(buffer, textBlobsOnly);
  187. // Dummy serialize our sub-pictures for the side effect of filling typefaceSet
  188. // with typefaces from sub-pictures.
  189. struct DevNull: public SkWStream {
  190. DevNull() : fBytesWritten(0) {}
  191. size_t fBytesWritten;
  192. bool write(const void*, size_t size) override { fBytesWritten += size; return true; }
  193. size_t bytesWritten() const override { return fBytesWritten; }
  194. } devnull;
  195. for (const auto& pic : fPictures) {
  196. pic->serialize(&devnull, nullptr, typefaceSet, /*textBlobsOnly=*/ true);
  197. }
  198. if (textBlobsOnly) { return; } // return early from dummy serialize
  199. // We need to write factories before we write the buffer.
  200. // We need to write typefaces before we write the buffer or any sub-picture.
  201. WriteFactories(stream, factSet);
  202. // Pass the original typefaceproc (if any) now that we're ready to actually serialize the
  203. // typefaces. We skipped this proc before, when we were serializing paints, so that the
  204. // paints would just write indices into our typeface set.
  205. WriteTypefaces(stream, *typefaceSet, procs);
  206. // Write the buffer.
  207. write_tag_size(stream, SK_PICT_BUFFER_SIZE_TAG, buffer.bytesWritten());
  208. buffer.writeToStream(stream);
  209. // Write sub-pictures by calling serialize again.
  210. if (!fPictures.empty()) {
  211. write_tag_size(stream, SK_PICT_PICTURE_TAG, fPictures.count());
  212. for (const auto& pic : fPictures) {
  213. pic->serialize(stream, &procs, typefaceSet, /*textBlobsOnly=*/ false);
  214. }
  215. }
  216. stream->write32(SK_PICT_EOF_TAG);
  217. }
  218. void SkPictureData::flatten(SkWriteBuffer& buffer) const {
  219. write_tag_size(buffer, SK_PICT_READER_TAG, fOpData->size());
  220. buffer.writeByteArray(fOpData->bytes(), fOpData->size());
  221. if (!fPictures.empty()) {
  222. write_tag_size(buffer, SK_PICT_PICTURE_TAG, fPictures.count());
  223. for (const auto& pic : fPictures) {
  224. SkPicturePriv::Flatten(pic, buffer);
  225. }
  226. }
  227. if (!fDrawables.empty()) {
  228. write_tag_size(buffer, SK_PICT_DRAWABLE_TAG, fDrawables.count());
  229. for (const auto& draw : fDrawables) {
  230. buffer.writeFlattenable(draw.get());
  231. }
  232. }
  233. // Write this picture playback's data into a writebuffer
  234. this->flattenToBuffer(buffer, false);
  235. buffer.write32(SK_PICT_EOF_TAG);
  236. }
  237. ///////////////////////////////////////////////////////////////////////////////
  238. bool SkPictureData::parseStreamTag(SkStream* stream,
  239. uint32_t tag,
  240. uint32_t size,
  241. const SkDeserialProcs& procs,
  242. SkTypefacePlayback* topLevelTFPlayback) {
  243. switch (tag) {
  244. case SK_PICT_READER_TAG:
  245. SkASSERT(nullptr == fOpData);
  246. fOpData = SkData::MakeFromStream(stream, size);
  247. if (!fOpData) {
  248. return false;
  249. }
  250. break;
  251. case SK_PICT_FACTORY_TAG: {
  252. if (!stream->readU32(&size)) { return false; }
  253. fFactoryPlayback = skstd::make_unique<SkFactoryPlayback>(size);
  254. for (size_t i = 0; i < size; i++) {
  255. SkString str;
  256. size_t len;
  257. if (!stream->readPackedUInt(&len)) { return false; }
  258. str.resize(len);
  259. if (stream->read(str.writable_str(), len) != len) {
  260. return false;
  261. }
  262. fFactoryPlayback->base()[i] = SkFlattenable::NameToFactory(str.c_str());
  263. }
  264. } break;
  265. case SK_PICT_TYPEFACE_TAG: {
  266. fTFPlayback.setCount(size);
  267. for (uint32_t i = 0; i < size; ++i) {
  268. sk_sp<SkTypeface> tf(SkTypeface::MakeDeserialize(stream));
  269. if (!tf.get()) { // failed to deserialize
  270. // fTFPlayback asserts it never has a null, so we plop in
  271. // the default here.
  272. tf = SkTypeface::MakeDefault();
  273. }
  274. fTFPlayback[i] = std::move(tf);
  275. }
  276. } break;
  277. case SK_PICT_PICTURE_TAG: {
  278. SkASSERT(fPictures.empty());
  279. fPictures.reserve(SkToInt(size));
  280. for (uint32_t i = 0; i < size; i++) {
  281. auto pic = SkPicture::MakeFromStream(stream, &procs, topLevelTFPlayback);
  282. if (!pic) {
  283. return false;
  284. }
  285. fPictures.push_back(std::move(pic));
  286. }
  287. } break;
  288. case SK_PICT_BUFFER_SIZE_TAG: {
  289. SkAutoMalloc storage(size);
  290. if (stream->read(storage.get(), size) != size) {
  291. return false;
  292. }
  293. SkReadBuffer buffer(storage.get(), size);
  294. buffer.setVersion(fInfo.getVersion());
  295. if (!fFactoryPlayback) {
  296. return false;
  297. }
  298. fFactoryPlayback->setupBuffer(buffer);
  299. buffer.setDeserialProcs(procs);
  300. if (fTFPlayback.count() > 0) {
  301. // .skp files <= v43 have typefaces serialized with each sub picture.
  302. fTFPlayback.setupBuffer(buffer);
  303. } else {
  304. // Newer .skp files serialize all typefaces with the top picture.
  305. topLevelTFPlayback->setupBuffer(buffer);
  306. }
  307. while (!buffer.eof() && buffer.isValid()) {
  308. tag = buffer.readUInt();
  309. size = buffer.readUInt();
  310. this->parseBufferTag(buffer, tag, size);
  311. }
  312. if (!buffer.isValid()) {
  313. return false;
  314. }
  315. } break;
  316. }
  317. return true; // success
  318. }
  319. static sk_sp<SkImage> create_image_from_buffer(SkReadBuffer& buffer) {
  320. return buffer.readImage();
  321. }
  322. static sk_sp<SkVertices> create_vertices_from_buffer(SkReadBuffer& buffer) {
  323. auto data = buffer.readByteArrayAsData();
  324. return data ? SkVertices::Decode(data->data(), data->size()) : nullptr;
  325. }
  326. static sk_sp<SkDrawable> create_drawable_from_buffer(SkReadBuffer& buffer) {
  327. return sk_sp<SkDrawable>((SkDrawable*)buffer.readFlattenable(SkFlattenable::kSkDrawable_Type));
  328. }
  329. // We need two types 'cause SkDrawable is const-variant.
  330. template <typename T, typename U>
  331. bool new_array_from_buffer(SkReadBuffer& buffer, uint32_t inCount,
  332. SkTArray<sk_sp<T>>& array, sk_sp<U> (*factory)(SkReadBuffer&)) {
  333. if (!buffer.validate(array.empty() && SkTFitsIn<int>(inCount))) {
  334. return false;
  335. }
  336. if (0 == inCount) {
  337. return true;
  338. }
  339. for (uint32_t i = 0; i < inCount; ++i) {
  340. auto obj = factory(buffer);
  341. if (!buffer.validate(obj != nullptr)) {
  342. array.reset();
  343. return false;
  344. }
  345. array.push_back(std::move(obj));
  346. }
  347. return true;
  348. }
  349. void SkPictureData::parseBufferTag(SkReadBuffer& buffer, uint32_t tag, uint32_t size) {
  350. switch (tag) {
  351. case SK_PICT_PAINT_BUFFER_TAG: {
  352. if (!buffer.validate(SkTFitsIn<int>(size))) {
  353. return;
  354. }
  355. const int count = SkToInt(size);
  356. for (int i = 0; i < count; ++i) {
  357. // Do we need to keep an array of fFonts for legacy draws?
  358. if (!buffer.readPaint(&fPaints.push_back(), nullptr)) {
  359. return;
  360. }
  361. }
  362. } break;
  363. case SK_PICT_PATH_BUFFER_TAG:
  364. if (size > 0) {
  365. const int count = buffer.readInt();
  366. if (!buffer.validate(count >= 0)) {
  367. return;
  368. }
  369. for (int i = 0; i < count; i++) {
  370. buffer.readPath(&fPaths.push_back());
  371. if (!buffer.isValid()) {
  372. return;
  373. }
  374. }
  375. } break;
  376. case SK_PICT_TEXTBLOB_BUFFER_TAG:
  377. new_array_from_buffer(buffer, size, fTextBlobs, SkTextBlobPriv::MakeFromBuffer);
  378. break;
  379. case SK_PICT_VERTICES_BUFFER_TAG:
  380. new_array_from_buffer(buffer, size, fVertices, create_vertices_from_buffer);
  381. break;
  382. case SK_PICT_IMAGE_BUFFER_TAG:
  383. new_array_from_buffer(buffer, size, fImages, create_image_from_buffer);
  384. break;
  385. case SK_PICT_READER_TAG: {
  386. // Preflight check that we can initialize all data from the buffer
  387. // before allocating it.
  388. if (!buffer.validateCanReadN<uint8_t>(size)) {
  389. return;
  390. }
  391. auto data(SkData::MakeUninitialized(size));
  392. if (!buffer.readByteArray(data->writable_data(), size) ||
  393. !buffer.validate(nullptr == fOpData)) {
  394. return;
  395. }
  396. SkASSERT(nullptr == fOpData);
  397. fOpData = std::move(data);
  398. } break;
  399. case SK_PICT_PICTURE_TAG:
  400. new_array_from_buffer(buffer, size, fPictures, SkPicturePriv::MakeFromBuffer);
  401. break;
  402. case SK_PICT_DRAWABLE_TAG:
  403. new_array_from_buffer(buffer, size, fDrawables, create_drawable_from_buffer);
  404. break;
  405. default:
  406. buffer.validate(false); // The tag was invalid.
  407. break;
  408. }
  409. }
  410. SkPictureData* SkPictureData::CreateFromStream(SkStream* stream,
  411. const SkPictInfo& info,
  412. const SkDeserialProcs& procs,
  413. SkTypefacePlayback* topLevelTFPlayback) {
  414. std::unique_ptr<SkPictureData> data(new SkPictureData(info));
  415. if (!topLevelTFPlayback) {
  416. topLevelTFPlayback = &data->fTFPlayback;
  417. }
  418. if (!data->parseStream(stream, procs, topLevelTFPlayback)) {
  419. return nullptr;
  420. }
  421. return data.release();
  422. }
  423. SkPictureData* SkPictureData::CreateFromBuffer(SkReadBuffer& buffer,
  424. const SkPictInfo& info) {
  425. std::unique_ptr<SkPictureData> data(new SkPictureData(info));
  426. buffer.setVersion(info.getVersion());
  427. if (!data->parseBuffer(buffer)) {
  428. return nullptr;
  429. }
  430. return data.release();
  431. }
  432. bool SkPictureData::parseStream(SkStream* stream,
  433. const SkDeserialProcs& procs,
  434. SkTypefacePlayback* topLevelTFPlayback) {
  435. for (;;) {
  436. uint32_t tag;
  437. if (!stream->readU32(&tag)) { return false; }
  438. if (SK_PICT_EOF_TAG == tag) {
  439. break;
  440. }
  441. uint32_t size;
  442. if (!stream->readU32(&size)) { return false; }
  443. if (!this->parseStreamTag(stream, tag, size, procs, topLevelTFPlayback)) {
  444. return false; // we're invalid
  445. }
  446. }
  447. return true;
  448. }
  449. bool SkPictureData::parseBuffer(SkReadBuffer& buffer) {
  450. while (buffer.isValid()) {
  451. uint32_t tag = buffer.readUInt();
  452. if (SK_PICT_EOF_TAG == tag) {
  453. break;
  454. }
  455. this->parseBufferTag(buffer, tag, buffer.readUInt());
  456. }
  457. // Check that we encountered required tags
  458. if (!buffer.validate(this->opData() != nullptr)) {
  459. // If we didn't build any opData, we are invalid. Even an EmptyPicture allocates the
  460. // SkData for the ops (though its length may be zero).
  461. return false;
  462. }
  463. return true;
  464. }