reed@google.com | 99ac02b | 2013-06-07 20:30:16 +0000 | [diff] [blame] | 1 | /* |
halcanary | a43b415 | 2015-03-25 12:15:04 -0700 | [diff] [blame] | 2 | * Copyright 2011 Google Inc. |
reed@google.com | 99ac02b | 2013-06-07 20:30:16 +0000 | [diff] [blame] | 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 | |
Hal Canary | 7cbf5e3 | 2017-07-12 13:10:23 -0400 | [diff] [blame] | 8 | #include "SkPDFDocument.h" |
| 9 | |
| 10 | #include "SkCanvas.h" |
halcanary | 022c2bd | 2016-09-02 11:29:46 -0700 | [diff] [blame] | 11 | #include "SkMakeUnique.h" |
msarett | c213f0d | 2016-08-01 14:23:32 -0700 | [diff] [blame] | 12 | #include "SkPDFCanon.h" |
reed | 5867736 | 2014-10-09 05:30:10 -0700 | [diff] [blame] | 13 | #include "SkPDFDevice.h" |
halcanary | f12a167 | 2015-09-23 12:45:49 -0700 | [diff] [blame] | 14 | #include "SkPDFUtils.h" |
halcanary | a43b415 | 2015-03-25 12:15:04 -0700 | [diff] [blame] | 15 | #include "SkStream.h" |
halcanary | f12a167 | 2015-09-23 12:45:49 -0700 | [diff] [blame] | 16 | |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 17 | SkPDFObjectSerializer::SkPDFObjectSerializer() : fBaseOffset(0), fNextToBeSerialized(0) {} |
| 18 | |
| 19 | template <class T> static void renew(T* t) { t->~T(); new (t) T; } |
| 20 | |
halcanary | a50151d | 2016-03-25 11:57:49 -0700 | [diff] [blame] | 21 | SkPDFObjectSerializer::~SkPDFObjectSerializer() { |
| 22 | for (int i = 0; i < fObjNumMap.objects().count(); ++i) { |
| 23 | fObjNumMap.objects()[i]->drop(); |
| 24 | } |
| 25 | } |
| 26 | |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 27 | void SkPDFObjectSerializer::addObjectRecursively(const sk_sp<SkPDFObject>& object) { |
halcanary | 530032a | 2016-08-18 14:22:52 -0700 | [diff] [blame] | 28 | fObjNumMap.addObjectRecursively(object.get()); |
halcanary | a43b415 | 2015-03-25 12:15:04 -0700 | [diff] [blame] | 29 | } |
| 30 | |
halcanary | ad5dcd1 | 2016-03-31 06:59:00 -0700 | [diff] [blame] | 31 | #define SKPDF_MAGIC "\xD3\xEB\xE9\xE1" |
| 32 | #ifndef SK_BUILD_FOR_WIN32 |
| 33 | static_assert((SKPDF_MAGIC[0] & 0x7F) == "Skia"[0], ""); |
| 34 | static_assert((SKPDF_MAGIC[1] & 0x7F) == "Skia"[1], ""); |
| 35 | static_assert((SKPDF_MAGIC[2] & 0x7F) == "Skia"[2], ""); |
| 36 | static_assert((SKPDF_MAGIC[3] & 0x7F) == "Skia"[3], ""); |
| 37 | #endif |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 38 | void SkPDFObjectSerializer::serializeHeader(SkWStream* wStream, |
| 39 | const SkDocument::PDFMetadata& md) { |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 40 | fBaseOffset = wStream->bytesWritten(); |
halcanary | ad5dcd1 | 2016-03-31 06:59:00 -0700 | [diff] [blame] | 41 | static const char kHeader[] = "%PDF-1.4\n%" SKPDF_MAGIC "\n"; |
Hal Canary | c172f9b | 2017-05-27 20:29:44 -0400 | [diff] [blame] | 42 | wStream->writeText(kHeader); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 43 | // The PDF spec recommends including a comment with four |
| 44 | // bytes, all with their high bits set. "\xD3\xEB\xE9\xE1" is |
| 45 | // "Skia" with the high bits set. |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 46 | fInfoDict = SkPDFMetadata::MakeDocumentInformationDict(md); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 47 | this->addObjectRecursively(fInfoDict); |
| 48 | this->serializeObjects(wStream); |
| 49 | } |
halcanary | ad5dcd1 | 2016-03-31 06:59:00 -0700 | [diff] [blame] | 50 | #undef SKPDF_MAGIC |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 51 | |
| 52 | // Serialize all objects in the fObjNumMap that have not yet been serialized; |
| 53 | void SkPDFObjectSerializer::serializeObjects(SkWStream* wStream) { |
| 54 | const SkTArray<sk_sp<SkPDFObject>>& objects = fObjNumMap.objects(); |
| 55 | while (fNextToBeSerialized < objects.count()) { |
| 56 | SkPDFObject* object = objects[fNextToBeSerialized].get(); |
| 57 | int32_t index = fNextToBeSerialized + 1; // Skip object 0. |
| 58 | // "The first entry in the [XREF] table (object number 0) is |
| 59 | // always free and has a generation number of 65,535; it is |
| 60 | // the head of the linked list of free objects." |
| 61 | SkASSERT(fOffsets.count() == fNextToBeSerialized); |
| 62 | fOffsets.push(this->offset(wStream)); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 63 | wStream->writeDecAsText(index); |
| 64 | wStream->writeText(" 0 obj\n"); // Generation number is always 0. |
halcanary | 530032a | 2016-08-18 14:22:52 -0700 | [diff] [blame] | 65 | object->emitObject(wStream, fObjNumMap); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 66 | wStream->writeText("\nendobj\n"); |
| 67 | object->drop(); |
| 68 | ++fNextToBeSerialized; |
| 69 | } |
| 70 | } |
| 71 | |
| 72 | // Xref table and footer |
| 73 | void SkPDFObjectSerializer::serializeFooter(SkWStream* wStream, |
| 74 | const sk_sp<SkPDFObject> docCatalog, |
| 75 | sk_sp<SkPDFObject> id) { |
| 76 | this->serializeObjects(wStream); |
| 77 | int32_t xRefFileOffset = this->offset(wStream); |
| 78 | // Include the special zeroth object in the count. |
| 79 | int32_t objCount = SkToS32(fOffsets.count() + 1); |
| 80 | wStream->writeText("xref\n0 "); |
| 81 | wStream->writeDecAsText(objCount); |
| 82 | wStream->writeText("\n0000000000 65535 f \n"); |
| 83 | for (int i = 0; i < fOffsets.count(); i++) { |
| 84 | wStream->writeBigDecAsText(fOffsets[i], 10); |
| 85 | wStream->writeText(" 00000 n \n"); |
| 86 | } |
halcanary | a43b415 | 2015-03-25 12:15:04 -0700 | [diff] [blame] | 87 | SkPDFDict trailerDict; |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 88 | trailerDict.insertInt("Size", objCount); |
| 89 | SkASSERT(docCatalog); |
| 90 | trailerDict.insertObjRef("Root", docCatalog); |
| 91 | SkASSERT(fInfoDict); |
| 92 | trailerDict.insertObjRef("Info", std::move(fInfoDict)); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 93 | if (id) { |
halcanary | 8103a34 | 2016-03-08 15:10:16 -0800 | [diff] [blame] | 94 | trailerDict.insertObject("ID", std::move(id)); |
halcanary | 3442261 | 2015-10-12 10:11:18 -0700 | [diff] [blame] | 95 | } |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 96 | wStream->writeText("trailer\n"); |
halcanary | 530032a | 2016-08-18 14:22:52 -0700 | [diff] [blame] | 97 | trailerDict.emitObject(wStream, fObjNumMap); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 98 | wStream->writeText("\nstartxref\n"); |
| 99 | wStream->writeBigDecAsText(xRefFileOffset); |
| 100 | wStream->writeText("\n%%EOF"); |
| 101 | } |
| 102 | |
| 103 | int32_t SkPDFObjectSerializer::offset(SkWStream* wStream) { |
| 104 | size_t offset = wStream->bytesWritten(); |
| 105 | SkASSERT(offset > fBaseOffset); |
| 106 | return SkToS32(offset - fBaseOffset); |
halcanary | a43b415 | 2015-03-25 12:15:04 -0700 | [diff] [blame] | 107 | } |
| 108 | |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 109 | |
halcanary | 8103a34 | 2016-03-08 15:10:16 -0800 | [diff] [blame] | 110 | // return root node. |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 111 | static sk_sp<SkPDFDict> generate_page_tree(SkTArray<sk_sp<SkPDFDict>>* pages) { |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 112 | // PDF wants a tree describing all the pages in the document. We arbitrary |
| 113 | // choose 8 (kNodeSize) as the number of allowed children. The internal |
| 114 | // nodes have type "Pages" with an array of children, a parent pointer, and |
| 115 | // the number of leaves below the node as "Count." The leaves are passed |
| 116 | // into the method, have type "Page" and need a parent pointer. This method |
| 117 | // builds the tree bottom up, skipping internal nodes that would have only |
| 118 | // one child. |
| 119 | static const int kNodeSize = 8; |
| 120 | |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 121 | // curNodes takes a reference to its items, which it passes to pageTree. |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 122 | int totalPageCount = pages->count(); |
| 123 | SkTArray<sk_sp<SkPDFDict>> curNodes; |
| 124 | curNodes.swap(pages); |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 125 | |
| 126 | // nextRoundNodes passes its references to nodes on to curNodes. |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 127 | int treeCapacity = kNodeSize; |
| 128 | do { |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 129 | SkTArray<sk_sp<SkPDFDict>> nextRoundNodes; |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 130 | for (int i = 0; i < curNodes.count(); ) { |
| 131 | if (i > 0 && i + 1 == curNodes.count()) { |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 132 | SkASSERT(curNodes[i]); |
| 133 | nextRoundNodes.emplace_back(std::move(curNodes[i])); |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 134 | break; |
| 135 | } |
| 136 | |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 137 | auto newNode = sk_make_sp<SkPDFDict>("Pages"); |
| 138 | auto kids = sk_make_sp<SkPDFArray>(); |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 139 | kids->reserve(kNodeSize); |
| 140 | |
| 141 | int count = 0; |
| 142 | for (; i < curNodes.count() && count < kNodeSize; i++, count++) { |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 143 | SkASSERT(curNodes[i]); |
halcanary | 8103a34 | 2016-03-08 15:10:16 -0800 | [diff] [blame] | 144 | curNodes[i]->insertObjRef("Parent", newNode); |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 145 | kids->appendObjRef(std::move(curNodes[i])); |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 146 | } |
| 147 | |
| 148 | // treeCapacity is the number of leaf nodes possible for the |
| 149 | // current set of subtrees being generated. (i.e. 8, 64, 512, ...). |
| 150 | // It is hard to count the number of leaf nodes in the current |
| 151 | // subtree. However, by construction, we know that unless it's the |
| 152 | // last subtree for the current depth, the leaf count will be |
| 153 | // treeCapacity, otherwise it's what ever is left over after |
| 154 | // consuming treeCapacity chunks. |
| 155 | int pageCount = treeCapacity; |
| 156 | if (i == curNodes.count()) { |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 157 | pageCount = ((totalPageCount - 1) % treeCapacity) + 1; |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 158 | } |
halcanary | 72266fd | 2015-05-05 08:00:24 -0700 | [diff] [blame] | 159 | newNode->insertInt("Count", pageCount); |
halcanary | 8103a34 | 2016-03-08 15:10:16 -0800 | [diff] [blame] | 160 | newNode->insertObject("Kids", std::move(kids)); |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 161 | nextRoundNodes.emplace_back(std::move(newNode)); |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 162 | } |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 163 | SkDEBUGCODE( for (const auto& n : curNodes) { SkASSERT(!n); } ); |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 164 | |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 165 | curNodes.swap(&nextRoundNodes); |
| 166 | nextRoundNodes.reset(); |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 167 | treeCapacity *= kNodeSize; |
| 168 | } while (curNodes.count() > 1); |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 169 | return std::move(curNodes[0]); |
halcanary | 2f7ebcb | 2015-03-25 12:45:28 -0700 | [diff] [blame] | 170 | } |
| 171 | |
halcanary | a43b415 | 2015-03-25 12:15:04 -0700 | [diff] [blame] | 172 | //////////////////////////////////////////////////////////////////////////////// |
reed@google.com | 99ac02b | 2013-06-07 20:30:16 +0000 | [diff] [blame] | 173 | |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 174 | SkPDFDocument::SkPDFDocument(SkWStream* stream, |
| 175 | void (*doneProc)(SkWStream*, bool), |
| 176 | SkScalar rasterDpi, |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 177 | const SkDocument::PDFMetadata& metadata, |
| 178 | sk_sp<SkPixelSerializer> jpegEncoder, |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 179 | bool pdfa) |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 180 | : SkDocument(stream, doneProc) |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 181 | , fRasterDpi(rasterDpi) |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 182 | , fMetadata(metadata) |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 183 | , fPDFA(pdfa) { |
Hal Canary | 5c1b360 | 2017-04-17 16:30:06 -0400 | [diff] [blame] | 184 | fCanon.fPixelSerializer = std::move(jpegEncoder); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 185 | } |
| 186 | |
| 187 | SkPDFDocument::~SkPDFDocument() { |
| 188 | // subclasses of SkDocument must call close() in their destructors. |
| 189 | this->close(); |
| 190 | } |
| 191 | |
| 192 | void SkPDFDocument::serialize(const sk_sp<SkPDFObject>& object) { |
| 193 | fObjectSerializer.addObjectRecursively(object); |
| 194 | fObjectSerializer.serializeObjects(this->getStream()); |
| 195 | } |
| 196 | |
Hal Canary | b1de5f9 | 2017-07-01 22:17:15 -0400 | [diff] [blame] | 197 | SkCanvas* SkPDFDocument::onBeginPage(SkScalar width, SkScalar height) { |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 198 | SkASSERT(!fCanvas.get()); // endPage() was called before this. |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 199 | if (fPages.empty()) { |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 200 | // if this is the first page if the document. |
| 201 | fObjectSerializer.serializeHeader(this->getStream(), fMetadata); |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 202 | fDests = sk_make_sp<SkPDFDict>(); |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 203 | if (fPDFA) { |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 204 | SkPDFMetadata::UUID uuid = SkPDFMetadata::CreateUUID(fMetadata); |
halcanary | 8cd4a24 | 2016-04-07 08:56:15 -0700 | [diff] [blame] | 205 | // We use the same UUID for Document ID and Instance ID since this |
| 206 | // is the first revision of this document (and Skia does not |
| 207 | // support revising existing PDF documents). |
| 208 | // If we are not in PDF/A mode, don't use a UUID since testing |
| 209 | // works best with reproducible outputs. |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 210 | fID = SkPDFMetadata::MakePdfId(uuid, uuid); |
| 211 | fXMP = SkPDFMetadata::MakeXMPObject(fMetadata, uuid, uuid); |
halcanary | 8cd4a24 | 2016-04-07 08:56:15 -0700 | [diff] [blame] | 212 | fObjectSerializer.addObjectRecursively(fXMP); |
| 213 | fObjectSerializer.serializeObjects(this->getStream()); |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 214 | } |
halcanary | 712fdf7 | 2015-12-10 08:59:43 -0800 | [diff] [blame] | 215 | } |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 216 | SkISize pageSize = SkISize::Make( |
| 217 | SkScalarRoundToInt(width), SkScalarRoundToInt(height)); |
Hal Canary | a062258 | 2017-06-29 18:51:35 -0400 | [diff] [blame] | 218 | fPageDevice = sk_make_sp<SkPDFDevice>(pageSize, this); |
| 219 | fPageDevice->setFlip(); // Only the top-level device needs to be flipped. |
Hal Canary | 7cbf5e3 | 2017-07-12 13:10:23 -0400 | [diff] [blame] | 220 | fCanvas.reset(new SkCanvas(fPageDevice.get())); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 221 | return fCanvas.get(); |
| 222 | } |
skia.committer@gmail.com | 6319367 | 2013-06-08 07:01:13 +0000 | [diff] [blame] | 223 | |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 224 | void SkPDFDocument::onEndPage() { |
| 225 | SkASSERT(fCanvas.get()); |
| 226 | fCanvas->flush(); |
| 227 | fCanvas.reset(nullptr); |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 228 | SkASSERT(fPageDevice); |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 229 | auto page = sk_make_sp<SkPDFDict>("Page"); |
| 230 | page->insertObject("Resources", fPageDevice->makeResourceDict()); |
| 231 | page->insertObject("MediaBox", fPageDevice->copyMediaBox()); |
| 232 | auto annotations = sk_make_sp<SkPDFArray>(); |
| 233 | fPageDevice->appendAnnotations(annotations.get()); |
| 234 | if (annotations->size() > 0) { |
| 235 | page->insertObject("Annots", std::move(annotations)); |
| 236 | } |
halcanary | ac0e00d | 2016-07-27 11:12:23 -0700 | [diff] [blame] | 237 | auto contentObject = sk_make_sp<SkPDFStream>(fPageDevice->content()); |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 238 | this->serialize(contentObject); |
| 239 | page->insertObjRef("Contents", std::move(contentObject)); |
| 240 | fPageDevice->appendDestinations(fDests.get(), page.get()); |
| 241 | fPages.emplace_back(std::move(page)); |
| 242 | fPageDevice.reset(nullptr); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 243 | } |
reed@google.com | 99ac02b | 2013-06-07 20:30:16 +0000 | [diff] [blame] | 244 | |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 245 | void SkPDFDocument::onAbort() { |
halcanary | 530032a | 2016-08-18 14:22:52 -0700 | [diff] [blame] | 246 | this->reset(); |
| 247 | } |
| 248 | |
| 249 | void SkPDFDocument::reset() { |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 250 | fCanvas.reset(nullptr); |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 251 | fPages.reset(); |
Hal Canary | 5c1b360 | 2017-04-17 16:30:06 -0400 | [diff] [blame] | 252 | renew(&fCanon); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 253 | renew(&fObjectSerializer); |
halcanary | 530032a | 2016-08-18 14:22:52 -0700 | [diff] [blame] | 254 | fFonts.reset(); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 255 | } |
reed@google.com | 99ac02b | 2013-06-07 20:30:16 +0000 | [diff] [blame] | 256 | |
halcanary | 78daeff | 2016-04-07 12:34:59 -0700 | [diff] [blame] | 257 | static sk_sp<SkData> SkSrgbIcm() { |
msarett | c213f0d | 2016-08-01 14:23:32 -0700 | [diff] [blame] | 258 | // Source: http://www.argyllcms.com/icclibsrc.html |
| 259 | static const char kProfile[] = |
| 260 | "\0\0\14\214argl\2 \0\0mntrRGB XYZ \7\336\0\1\0\6\0\26\0\17\0:acspM" |
| 261 | "SFT\0\0\0\0IEC sRGB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\366\326\0\1\0\0\0\0" |
| 262 | "\323-argl\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| 263 | "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\21desc\0\0\1P\0\0\0\231cprt\0" |
| 264 | "\0\1\354\0\0\0gdmnd\0\0\2T\0\0\0pdmdd\0\0\2\304\0\0\0\210tech\0\0\3" |
| 265 | "L\0\0\0\14vued\0\0\3X\0\0\0gview\0\0\3\300\0\0\0$lumi\0\0\3\344\0\0" |
| 266 | "\0\24meas\0\0\3\370\0\0\0$wtpt\0\0\4\34\0\0\0\24bkpt\0\0\0040\0\0\0" |
| 267 | "\24rXYZ\0\0\4D\0\0\0\24gXYZ\0\0\4X\0\0\0\24bXYZ\0\0\4l\0\0\0\24rTR" |
| 268 | "C\0\0\4\200\0\0\10\14gTRC\0\0\4\200\0\0\10\14bTRC\0\0\4\200\0\0\10" |
| 269 | "\14desc\0\0\0\0\0\0\0?sRGB IEC61966-2.1 (Equivalent to www.srgb.co" |
| 270 | "m 1998 HP profile)\0\0\0\0\0\0\0\0\0\0\0?sRGB IEC61966-2.1 (Equiva" |
| 271 | "lent to www.srgb.com 1998 HP profile)\0\0\0\0\0\0\0\0text\0\0\0\0C" |
| 272 | "reated by Graeme W. Gill. Released into the public domain. No Warr" |
| 273 | "anty, Use at your own risk.\0\0desc\0\0\0\0\0\0\0\26IEC http://www" |
| 274 | ".iec.ch\0\0\0\0\0\0\0\0\0\0\0\26IEC http://www.iec.ch\0\0\0\0\0\0\0" |
| 275 | "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| 276 | "\0\0\0\0\0\0desc\0\0\0\0\0\0\0.IEC 61966-2.1 Default RGB colour sp" |
| 277 | "ace - sRGB\0\0\0\0\0\0\0\0\0\0\0.IEC 61966-2.1 Default RGB colour " |
| 278 | "space - sRGB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0sig \0\0\0" |
| 279 | "\0CRT desc\0\0\0\0\0\0\0\rIEC61966-2.1\0\0\0\0\0\0\0\0\0\0\0\rIEC6" |
| 280 | "1966-2.1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| 281 | "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0view\0\0\0\0" |
| 282 | "\0\23\244|\0\24_0\0\20\316\2\0\3\355\262\0\4\23\n\0\3\\g\0\0\0\1XY" |
| 283 | "Z \0\0\0\0\0L\n=\0P\0\0\0W\36\270meas\0\0\0\0\0\0\0\1\0\0\0\0\0\0\0" |
| 284 | "\0\0\0\0\0\0\0\0\0\0\0\2\217\0\0\0\2XYZ \0\0\0\0\0\0\363Q\0\1\0\0\0" |
| 285 | "\1\26\314XYZ \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0XYZ \0\0\0\0\0\0o\240" |
| 286 | "\0\0008\365\0\0\3\220XYZ \0\0\0\0\0\0b\227\0\0\267\207\0\0\30\331X" |
| 287 | "YZ \0\0\0\0\0\0$\237\0\0\17\204\0\0\266\304curv\0\0\0\0\0\0\4\0\0\0" |
| 288 | "\0\5\0\n\0\17\0\24\0\31\0\36\0#\0(\0-\0002\0007\0;\0@\0E\0J\0O\0T\0" |
| 289 | "Y\0^\0c\0h\0m\0r\0w\0|\0\201\0\206\0\213\0\220\0\225\0\232\0\237\0" |
| 290 | "\244\0\251\0\256\0\262\0\267\0\274\0\301\0\306\0\313\0\320\0\325\0" |
| 291 | "\333\0\340\0\345\0\353\0\360\0\366\0\373\1\1\1\7\1\r\1\23\1\31\1\37" |
| 292 | "\1%\1+\0012\0018\1>\1E\1L\1R\1Y\1`\1g\1n\1u\1|\1\203\1\213\1\222\1" |
| 293 | "\232\1\241\1\251\1\261\1\271\1\301\1\311\1\321\1\331\1\341\1\351\1" |
| 294 | "\362\1\372\2\3\2\14\2\24\2\35\2&\2/\0028\2A\2K\2T\2]\2g\2q\2z\2\204" |
| 295 | "\2\216\2\230\2\242\2\254\2\266\2\301\2\313\2\325\2\340\2\353\2\365" |
| 296 | "\3\0\3\13\3\26\3!\3-\0038\3C\3O\3Z\3f\3r\3~\3\212\3\226\3\242\3\256" |
| 297 | "\3\272\3\307\3\323\3\340\3\354\3\371\4\6\4\23\4 \4-\4;\4H\4U\4c\4q" |
| 298 | "\4~\4\214\4\232\4\250\4\266\4\304\4\323\4\341\4\360\4\376\5\r\5\34" |
| 299 | "\5+\5:\5I\5X\5g\5w\5\206\5\226\5\246\5\265\5\305\5\325\5\345\5\366" |
| 300 | "\6\6\6\26\6'\0067\6H\6Y\6j\6{\6\214\6\235\6\257\6\300\6\321\6\343\6" |
| 301 | "\365\7\7\7\31\7+\7=\7O\7a\7t\7\206\7\231\7\254\7\277\7\322\7\345\7" |
| 302 | "\370\10\13\10\37\0102\10F\10Z\10n\10\202\10\226\10\252\10\276\10\322" |
| 303 | "\10\347\10\373\t\20\t%\t:\tO\td\ty\t\217\t\244\t\272\t\317\t\345\t" |
| 304 | "\373\n\21\n'\n=\nT\nj\n\201\n\230\n\256\n\305\n\334\n\363\13\13\13" |
| 305 | "\"\0139\13Q\13i\13\200\13\230\13\260\13\310\13\341\13\371\14\22\14" |
| 306 | "*\14C\14\\\14u\14\216\14\247\14\300\14\331\14\363\r\r\r&\r@\rZ\rt\r" |
| 307 | "\216\r\251\r\303\r\336\r\370\16\23\16.\16I\16d\16\177\16\233\16\266" |
| 308 | "\16\322\16\356\17\t\17%\17A\17^\17z\17\226\17\263\17\317\17\354\20" |
| 309 | "\t\20&\20C\20a\20~\20\233\20\271\20\327\20\365\21\23\0211\21O\21m\21" |
| 310 | "\214\21\252\21\311\21\350\22\7\22&\22E\22d\22\204\22\243\22\303\22" |
| 311 | "\343\23\3\23#\23C\23c\23\203\23\244\23\305\23\345\24\6\24'\24I\24j" |
| 312 | "\24\213\24\255\24\316\24\360\25\22\0254\25V\25x\25\233\25\275\25\340" |
| 313 | "\26\3\26&\26I\26l\26\217\26\262\26\326\26\372\27\35\27A\27e\27\211" |
| 314 | "\27\256\27\322\27\367\30\33\30@\30e\30\212\30\257\30\325\30\372\31" |
| 315 | " \31E\31k\31\221\31\267\31\335\32\4\32*\32Q\32w\32\236\32\305\32\354" |
| 316 | "\33\24\33;\33c\33\212\33\262\33\332\34\2\34*\34R\34{\34\243\34\314" |
| 317 | "\34\365\35\36\35G\35p\35\231\35\303\35\354\36\26\36@\36j\36\224\36" |
| 318 | "\276\36\351\37\23\37>\37i\37\224\37\277\37\352 \25 A l \230 \304 \360" |
| 319 | "!\34!H!u!\241!\316!\373\"'\"U\"\202\"\257\"\335#\n#8#f#\224#\302#\360" |
| 320 | "$\37$M$|$\253$\332%\t%8%h%\227%\307%\367&'&W&\207&\267&\350'\30'I'" |
| 321 | "z'\253'\334(\r(?(q(\242(\324)\6)8)k)\235)\320*\2*5*h*\233*\317+\2+" |
| 322 | "6+i+\235+\321,\5,9,n,\242,\327-\14-A-v-\253-\341.\26.L.\202.\267.\356" |
| 323 | "/$/Z/\221/\307/\376050l0\2440\3331\0221J1\2021\2721\3622*2c2\2332\324" |
| 324 | "3\r3F3\1773\2703\3614+4e4\2364\3305\0235M5\2075\3025\375676r6\2566" |
| 325 | "\3517$7`7\2347\3278\0248P8\2148\3109\0059B9\1779\2749\371:6:t:\262" |
| 326 | ":\357;-;k;\252;\350<'<e<\244<\343=\"=a=\241=\340> >`>\240>\340?!?a" |
| 327 | "?\242?\342@#@d@\246@\347A)AjA\254A\356B0BrB\265B\367C:C}C\300D\3DG" |
| 328 | "D\212D\316E\22EUE\232E\336F\"FgF\253F\360G5G{G\300H\5HKH\221H\327I" |
| 329 | "\35IcI\251I\360J7J}J\304K\14KSK\232K\342L*LrL\272M\2MJM\223M\334N%" |
| 330 | "NnN\267O\0OIO\223O\335P'PqP\273Q\6QPQ\233Q\346R1R|R\307S\23S_S\252" |
| 331 | "S\366TBT\217T\333U(UuU\302V\17V\\V\251V\367WDW\222W\340X/X}X\313Y\32" |
| 332 | "YiY\270Z\7ZVZ\246Z\365[E[\225[\345\\5\\\206\\\326]']x]\311^\32^l^\275" |
| 333 | "_\17_a_\263`\5`W`\252`\374aOa\242a\365bIb\234b\360cCc\227c\353d@d\224" |
| 334 | "d\351e=e\222e\347f=f\222f\350g=g\223g\351h?h\226h\354iCi\232i\361j" |
| 335 | "Hj\237j\367kOk\247k\377lWl\257m\10m`m\271n\22nkn\304o\36oxo\321p+p" |
| 336 | "\206p\340q:q\225q\360rKr\246s\1s]s\270t\24tpt\314u(u\205u\341v>v\233" |
| 337 | "v\370wVw\263x\21xnx\314y*y\211y\347zFz\245{\4{c{\302|!|\201|\341}A" |
| 338 | "}\241~\1~b~\302\177#\177\204\177\345\200G\200\250\201\n\201k\201\315" |
| 339 | "\2020\202\222\202\364\203W\203\272\204\35\204\200\204\343\205G\205" |
| 340 | "\253\206\16\206r\206\327\207;\207\237\210\4\210i\210\316\2113\211\231" |
| 341 | "\211\376\212d\212\312\2130\213\226\213\374\214c\214\312\2151\215\230" |
| 342 | "\215\377\216f\216\316\2176\217\236\220\6\220n\220\326\221?\221\250" |
| 343 | "\222\21\222z\222\343\223M\223\266\224 \224\212\224\364\225_\225\311" |
| 344 | "\2264\226\237\227\n\227u\227\340\230L\230\270\231$\231\220\231\374" |
| 345 | "\232h\232\325\233B\233\257\234\34\234\211\234\367\235d\235\322\236" |
| 346 | "@\236\256\237\35\237\213\237\372\240i\240\330\241G\241\266\242&\242" |
| 347 | "\226\243\6\243v\243\346\244V\244\307\2458\245\251\246\32\246\213\246" |
| 348 | "\375\247n\247\340\250R\250\304\2517\251\251\252\34\252\217\253\2\253" |
| 349 | "u\253\351\254\\\254\320\255D\255\270\256-\256\241\257\26\257\213\260" |
| 350 | "\0\260u\260\352\261`\261\326\262K\262\302\2638\263\256\264%\264\234" |
| 351 | "\265\23\265\212\266\1\266y\266\360\267h\267\340\270Y\270\321\271J\271" |
| 352 | "\302\272;\272\265\273.\273\247\274!\274\233\275\25\275\217\276\n\276" |
| 353 | "\204\276\377\277z\277\365\300p\300\354\301g\301\343\302_\302\333\303" |
| 354 | "X\303\324\304Q\304\316\305K\305\310\306F\306\303\307A\307\277\310=" |
| 355 | "\310\274\311:\311\271\3128\312\267\3136\313\266\3145\314\265\3155\315" |
| 356 | "\265\3166\316\266\3177\317\270\3209\320\272\321<\321\276\322?\322\301" |
| 357 | "\323D\323\306\324I\324\313\325N\325\321\326U\326\330\327\\\327\340" |
| 358 | "\330d\330\350\331l\331\361\332v\332\373\333\200\334\5\334\212\335\20" |
| 359 | "\335\226\336\34\336\242\337)\337\257\3406\340\275\341D\341\314\342" |
| 360 | "S\342\333\343c\343\353\344s\344\374\345\204\346\r\346\226\347\37\347" |
| 361 | "\251\3502\350\274\351F\351\320\352[\352\345\353p\353\373\354\206\355" |
| 362 | "\21\355\234\356(\356\264\357@\357\314\360X\360\345\361r\361\377\362" |
| 363 | "\214\363\31\363\247\3644\364\302\365P\365\336\366m\366\373\367\212" |
| 364 | "\370\31\370\250\3718\371\307\372W\372\347\373w\374\7\374\230\375)\375" |
| 365 | "\272\376K\376\334\377m\377\377"; |
| 366 | const size_t kProfileLength = 3212; |
| 367 | static_assert(kProfileLength == sizeof(kProfile) - 1, ""); |
| 368 | return SkData::MakeWithoutCopy(kProfile, kProfileLength); |
halcanary | 78daeff | 2016-04-07 12:34:59 -0700 | [diff] [blame] | 369 | } |
| 370 | |
| 371 | static sk_sp<SkPDFStream> make_srgb_color_profile() { |
halcanary | fe8f0e0 | 2016-07-27 14:14:04 -0700 | [diff] [blame] | 372 | sk_sp<SkPDFStream> stream = sk_make_sp<SkPDFStream>(SkSrgbIcm()); |
halcanary | fa25106 | 2016-07-29 10:13:18 -0700 | [diff] [blame] | 373 | stream->dict()->insertInt("N", 3); |
halcanary | 78daeff | 2016-04-07 12:34:59 -0700 | [diff] [blame] | 374 | sk_sp<SkPDFArray> array = sk_make_sp<SkPDFArray>(); |
| 375 | array->appendScalar(0.0f); |
| 376 | array->appendScalar(1.0f); |
| 377 | array->appendScalar(0.0f); |
| 378 | array->appendScalar(1.0f); |
| 379 | array->appendScalar(0.0f); |
| 380 | array->appendScalar(1.0f); |
halcanary | fa25106 | 2016-07-29 10:13:18 -0700 | [diff] [blame] | 381 | stream->dict()->insertObject("Range", std::move(array)); |
halcanary | 78daeff | 2016-04-07 12:34:59 -0700 | [diff] [blame] | 382 | return stream; |
| 383 | } |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 384 | |
| 385 | static sk_sp<SkPDFArray> make_srgb_output_intents() { |
| 386 | // sRGB is specified by HTML, CSS, and SVG. |
| 387 | auto outputIntent = sk_make_sp<SkPDFDict>("OutputIntent"); |
| 388 | outputIntent->insertName("S", "GTS_PDFA1"); |
| 389 | outputIntent->insertString("RegistryName", "http://www.color.org"); |
| 390 | outputIntent->insertString("OutputConditionIdentifier", |
| 391 | "Custom"); |
| 392 | outputIntent->insertString("Info","sRGB IEC61966-2.1"); |
| 393 | outputIntent->insertObjRef("DestOutputProfile", |
| 394 | make_srgb_color_profile()); |
| 395 | auto intentArray = sk_make_sp<SkPDFArray>(); |
| 396 | intentArray->appendObject(std::move(outputIntent)); |
| 397 | return intentArray; |
| 398 | } |
halcanary | 78daeff | 2016-04-07 12:34:59 -0700 | [diff] [blame] | 399 | |
reed | d14df7c | 2016-09-22 14:12:46 -0700 | [diff] [blame] | 400 | void SkPDFDocument::onClose(SkWStream* stream) { |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 401 | SkASSERT(!fCanvas.get()); |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 402 | if (fPages.empty()) { |
halcanary | 530032a | 2016-08-18 14:22:52 -0700 | [diff] [blame] | 403 | this->reset(); |
reed | d14df7c | 2016-09-22 14:12:46 -0700 | [diff] [blame] | 404 | return; |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 405 | } |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 406 | auto docCatalog = sk_make_sp<SkPDFDict>("Catalog"); |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 407 | if (fPDFA) { |
halcanary | 8cd4a24 | 2016-04-07 08:56:15 -0700 | [diff] [blame] | 408 | SkASSERT(fXMP); |
| 409 | docCatalog->insertObjRef("Metadata", fXMP); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 410 | // Don't specify OutputIntents if we are not in PDF/A mode since |
| 411 | // no one has ever asked for this feature. |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 412 | docCatalog->insertObject("OutputIntents", make_srgb_output_intents()); |
| 413 | } |
| 414 | SkASSERT(!fPages.empty()); |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 415 | docCatalog->insertObjRef("Pages", generate_page_tree(&fPages)); |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 416 | SkASSERT(fPages.empty()); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 417 | |
halcanary | cc77c12 | 2016-03-23 06:26:31 -0700 | [diff] [blame] | 418 | if (fDests->size() > 0) { |
| 419 | docCatalog->insertObjRef("Dests", std::move(fDests)); |
reed@google.com | 99ac02b | 2013-06-07 20:30:16 +0000 | [diff] [blame] | 420 | } |
| 421 | |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 422 | // Build font subsetting info before calling addObjectRecursively(). |
halcanary | 530032a | 2016-08-18 14:22:52 -0700 | [diff] [blame] | 423 | SkPDFCanon* canon = &fCanon; |
| 424 | fFonts.foreach([canon](SkPDFFont* p){ p->getFontSubset(canon); }); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 425 | fObjectSerializer.addObjectRecursively(docCatalog); |
| 426 | fObjectSerializer.serializeObjects(this->getStream()); |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 427 | fObjectSerializer.serializeFooter(this->getStream(), docCatalog, fID); |
halcanary | 530032a | 2016-08-18 14:22:52 -0700 | [diff] [blame] | 428 | this->reset(); |
halcanary | 50e82e6 | 2016-03-21 13:45:05 -0700 | [diff] [blame] | 429 | } |
| 430 | |
reed@google.com | 99ac02b | 2013-06-07 20:30:16 +0000 | [diff] [blame] | 431 | /////////////////////////////////////////////////////////////////////////////// |
| 432 | |
halcanary | 23f4d4d | 2016-03-12 05:59:39 -0800 | [diff] [blame] | 433 | sk_sp<SkDocument> SkPDFMakeDocument(SkWStream* stream, |
| 434 | void (*proc)(SkWStream*, bool), |
| 435 | SkScalar dpi, |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 436 | const SkDocument::PDFMetadata& metadata, |
| 437 | sk_sp<SkPixelSerializer> jpeg, |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 438 | bool pdfa) { |
Hal Canary | a062258 | 2017-06-29 18:51:35 -0400 | [diff] [blame] | 439 | if (dpi <= 0) { |
| 440 | dpi = 72.0f; |
| 441 | } |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 442 | return stream ? sk_make_sp<SkPDFDocument>(stream, proc, dpi, metadata, |
| 443 | std::move(jpeg), pdfa) |
halcanary | 488165e | 2016-04-22 06:10:21 -0700 | [diff] [blame] | 444 | : nullptr; |
halcanary | 23f4d4d | 2016-03-12 05:59:39 -0800 | [diff] [blame] | 445 | } |
| 446 | |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 447 | sk_sp<SkDocument> SkDocument::MakePDF(const char path[], SkScalar dpi) { |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 448 | auto delete_wstream = [](SkWStream* stream, bool) { delete stream; }; |
halcanary | 022c2bd | 2016-09-02 11:29:46 -0700 | [diff] [blame] | 449 | auto stream = skstd::make_unique<SkFILEWStream>(path); |
halcanary | 23f4d4d | 2016-03-12 05:59:39 -0800 | [diff] [blame] | 450 | return stream->isValid() |
halcanary | 4b65666 | 2016-04-27 07:45:18 -0700 | [diff] [blame] | 451 | ? SkPDFMakeDocument(stream.release(), delete_wstream, dpi, |
| 452 | SkDocument::PDFMetadata(), nullptr, |
| 453 | false) |
| 454 | : nullptr; |
| 455 | } |
| 456 | |
| 457 | sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream, |
| 458 | SkScalar dpi, |
| 459 | const SkDocument::PDFMetadata& metadata, |
| 460 | sk_sp<SkPixelSerializer> jpegEncoder, |
| 461 | bool pdfa) { |
| 462 | return SkPDFMakeDocument(stream, nullptr, dpi, metadata, |
| 463 | std::move(jpegEncoder), pdfa); |
reed@google.com | 99ac02b | 2013-06-07 20:30:16 +0000 | [diff] [blame] | 464 | } |