src/doc/SkDocument_PDF.cpp - skia.git - Git at Google

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "SkDocument.h"
 #include "SkPDFCanon.h"
 #include "SkPDFDevice.h"
 #include "SkPDFFont.h"
 #include "SkPDFStream.h"
 #include "SkPDFTypes.h"
 #include "SkPDFUtils.h"
 #include "SkStream.h"
 #include "SkPDFMetadata.h"

 class SkPDFDict;

 static void emit_pdf_header(SkWStream* stream) {
     stream->writeText("%PDF-1.4\n%");
     // The PDF spec recommends including a comment with four bytes, all
     // with their high bits set.  This is "Skia" with the high bits set.
     stream->write32(0xD3EBE9E1);
     stream->writeText("\n");
 }

 static void emit_pdf_footer(SkWStream* stream,
                             const SkPDFObjNumMap& objNumMap,
                             const SkPDFSubstituteMap& substitutes,
                             SkPDFObject* docCatalog,
                             int64_t objCount,
                             int32_t xRefFileOffset,
                             SkPDFObject* info /* take ownership */,
                             SkPDFObject* id /* take ownership */) {
     SkPDFDict trailerDict;
     // TODO(http://crbug.com/80908): Linearized format will take a
     //                               Prev entry too.
     trailerDict.insertInt("Size", int(objCount));
     trailerDict.insertObjRef("Root", SkRef(docCatalog));
     SkASSERT(info);
     trailerDict.insertObjRef("Info", info);
     if (id) {
         trailerDict.insertObject("ID", id);
     }
     stream->writeText("trailer\n");
     trailerDict.emitObject(stream, objNumMap, substitutes);
     stream->writeText("\nstartxref\n");
     stream->writeBigDecAsText(xRefFileOffset);
     stream->writeText("\n%%EOF");
 }

 static void perform_font_subsetting(
         const SkTDArray<const SkPDFDevice*>& pageDevices,
         SkPDFSubstituteMap* substituteMap) {
     SkASSERT(substituteMap);

     SkPDFGlyphSetMap usage;
     for (int i = 0; i < pageDevices.count(); ++i) {
         usage.merge(pageDevices[i]->getFontGlyphUsage());
     }
     SkPDFGlyphSetMap::F2BIter iterator(usage);
     const SkPDFGlyphSetMap::FontGlyphSetPair* entry = iterator.next();
     while (entry) {
         SkAutoTUnref<SkPDFFont> subsetFont(
                 entry->fFont->getFontSubset(entry->fGlyphSet));
         if (subsetFont) {
             substituteMap->setSubstitute(entry->fFont, subsetFont.get());
         }
         entry = iterator.next();
     }
 }

 static SkPDFObject* create_pdf_page_content(const SkPDFDevice* pageDevice) {
     SkAutoTDelete<SkStreamAsset> content(pageDevice->content());
     return new SkPDFStream(content.get());
 }

 static SkPDFDict* create_pdf_page(const SkPDFDevice* pageDevice) {
     SkAutoTUnref<SkPDFDict> page(new SkPDFDict("Page"));
     page->insertObject("Resources", pageDevice->createResourceDict());
     page->insertObject("MediaBox", pageDevice->copyMediaBox());
     SkAutoTUnref<SkPDFArray> annotations(new SkPDFArray);
     pageDevice->appendAnnotations(annotations);
     if (annotations->size() > 0) {
         page->insertObject("Annots", annotations.detach());
     }
     page->insertObjRef("Contents", create_pdf_page_content(pageDevice));
     return page.detach();
 }

 static void generate_page_tree(const SkTDArray<SkPDFDict*>& pages,
                                SkTDArray<SkPDFDict*>* pageTree,
                                SkPDFDict** rootNode) {
     // PDF wants a tree describing all the pages in the document.  We arbitrary
     // choose 8 (kNodeSize) as the number of allowed children.  The internal
     // nodes have type "Pages" with an array of children, a parent pointer, and
     // the number of leaves below the node as "Count."  The leaves are passed
     // into the method, have type "Page" and need a parent pointer. This method
     // builds the tree bottom up, skipping internal nodes that would have only
     // one child.
     static const int kNodeSize = 8;

     // curNodes takes a reference to its items, which it passes to pageTree.
     SkTDArray<SkPDFDict*> curNodes;
     curNodes.setReserve(pages.count());
     for (int i = 0; i < pages.count(); i++) {
         SkSafeRef(pages[i]);
         curNodes.push(pages[i]);
     }

     // nextRoundNodes passes its references to nodes on to curNodes.
     SkTDArray<SkPDFDict*> nextRoundNodes;
     nextRoundNodes.setReserve((pages.count() + kNodeSize - 1)/kNodeSize);

     int treeCapacity = kNodeSize;
     do {
         for (int i = 0; i < curNodes.count(); ) {
             if (i > 0 && i + 1 == curNodes.count()) {
                 nextRoundNodes.push(curNodes[i]);
                 break;
             }

             SkAutoTUnref<SkPDFDict> newNode(new SkPDFDict("Pages"));
             SkAutoTUnref<SkPDFArray> kids(new SkPDFArray);
             kids->reserve(kNodeSize);

             int count = 0;
             for (; i < curNodes.count() && count < kNodeSize; i++, count++) {
                 curNodes[i]->insertObjRef("Parent", SkRef(newNode.get()));
                 kids->appendObjRef(SkRef(curNodes[i]));

                 // TODO(vandebo): put the objects in strict access order.
                 // Probably doesn't matter because they are so small.
                 if (curNodes[i] != pages[0]) {
                     pageTree->push(curNodes[i]);  // Transfer reference.
                 } else {
                     SkSafeUnref(curNodes[i]);
                 }
             }

             // treeCapacity is the number of leaf nodes possible for the
             // current set of subtrees being generated. (i.e. 8, 64, 512, ...).
             // It is hard to count the number of leaf nodes in the current
             // subtree. However, by construction, we know that unless it's the
             // last subtree for the current depth, the leaf count will be
             // treeCapacity, otherwise it's what ever is left over after
             // consuming treeCapacity chunks.
             int pageCount = treeCapacity;
             if (i == curNodes.count()) {
                 pageCount = ((pages.count() - 1) % treeCapacity) + 1;
             }
             newNode->insertInt("Count", pageCount);
             newNode->insertObject("Kids", kids.detach());
             nextRoundNodes.push(newNode.detach());  // Transfer reference.
         }

         curNodes = nextRoundNodes;
         nextRoundNodes.rewind();
         treeCapacity *= kNodeSize;
     } while (curNodes.count() > 1);

     pageTree->push(curNodes[0]);  // Transfer reference.
     if (rootNode) {
         *rootNode = curNodes[0];
     }
 }

 static bool emit_pdf_document(const SkTDArray<const SkPDFDevice*>& pageDevices,
                               const SkPDFMetadata& metadata,
                               SkWStream* stream) {
     if (pageDevices.isEmpty()) {
         return false;
     }

     SkTDArray<SkPDFDict*> pages;
     SkAutoTUnref<SkPDFDict> dests(new SkPDFDict);

     for (int i = 0; i < pageDevices.count(); i++) {
         SkASSERT(pageDevices[i]);
         SkASSERT(i == 0 ||
                  pageDevices[i - 1]->getCanon() == pageDevices[i]->getCanon());
         SkAutoTUnref<SkPDFDict> page(create_pdf_page(pageDevices[i]));
         pageDevices[i]->appendDestinations(dests, page.get());
         pages.push(page.detach());
     }

     SkAutoTUnref<SkPDFDict> docCatalog(new SkPDFDict("Catalog"));

     SkAutoTUnref<SkPDFObject> infoDict(
             metadata.createDocumentInformationDict());

     SkAutoTUnref<SkPDFObject> id, xmp;
 #ifdef SK_PDF_GENERATE_PDFA
     SkPDFMetadata::UUID uuid = metadata.uuid();
     // We use the same UUID for Document ID and Instance ID since this
     // is the first revision of this document (and Skia does not
     // support revising existing PDF documents).
     // If we are not in PDF/A mode, don't use a UUID since testing
     // works best with reproducible outputs.
     id.reset(SkPDFMetadata::CreatePdfId(uuid, uuid));
     xmp.reset(metadata.createXMPObject(uuid, uuid));
     docCatalog->insertObjRef("Metadata", xmp.detach());

     // sRGB is specified by HTML, CSS, and SVG.
     SkAutoTUnref<SkPDFDict> outputIntent(new SkPDFDict("OutputIntent"));
     outputIntent->insertName("S", "GTS_PDFA1");
     outputIntent->insertString("RegistryName", "http://www.color.org");
     outputIntent->insertString("OutputConditionIdentifier",
                                "sRGB IEC61966-2.1");
     SkAutoTUnref<SkPDFArray> intentArray(new SkPDFArray);
     intentArray->appendObject(outputIntent.detach());
     // Don't specify OutputIntents if we are not in PDF/A mode since
     // no one has ever asked for this feature.
     docCatalog->insertObject("OutputIntents", intentArray.detach());
 #endif

     SkTDArray<SkPDFDict*> pageTree;
     SkPDFDict* pageTreeRoot;
     generate_page_tree(pages, &pageTree, &pageTreeRoot);
     docCatalog->insertObjRef("Pages", SkRef(pageTreeRoot));

     if (dests->size() > 0) {
         docCatalog->insertObjRef("Dests", dests.detach());
     }

     // Build font subsetting info before proceeding.
     SkPDFSubstituteMap substitutes;
     perform_font_subsetting(pageDevices, &substitutes);

     SkPDFObjNumMap objNumMap;
     objNumMap.addObjectRecursively(infoDict, substitutes);
     objNumMap.addObjectRecursively(docCatalog.get(), substitutes);
     size_t baseOffset = stream->bytesWritten();
     emit_pdf_header(stream);
     SkTDArray<int32_t> offsets;
     for (int i = 0; i < objNumMap.objects().count(); ++i) {
         SkPDFObject* object = objNumMap.objects()[i];
         size_t offset = stream->bytesWritten();
         // This assert checks that size(pdf_header) > 0 and that
         // the output stream correctly reports bytesWritten().
         SkASSERT(offset > baseOffset);
         offsets.push(SkToS32(offset - baseOffset));
         SkASSERT(object == substitutes.getSubstitute(object));
         SkASSERT(objNumMap.getObjectNumber(object) == i + 1);
         stream->writeDecAsText(i + 1);
         stream->writeText(" 0 obj\n");  // Generation number is always 0.
         object->emitObject(stream, objNumMap, substitutes);
         stream->writeText("\nendobj\n");
     }
     int32_t xRefFileOffset = SkToS32(stream->bytesWritten() - baseOffset);

     // Include the zeroth object in the count.
     int32_t objCount = SkToS32(offsets.count() + 1);

     stream->writeText("xref\n0 ");
     stream->writeDecAsText(objCount);
     stream->writeText("\n0000000000 65535 f \n");
     for (int i = 0; i < offsets.count(); i++) {
         SkASSERT(offsets[i] > 0);
         stream->writeBigDecAsText(offsets[i], 10);
         stream->writeText(" 00000 n \n");
     }
     emit_pdf_footer(stream, objNumMap, substitutes, docCatalog.get(), objCount,
                     xRefFileOffset, infoDict.detach(), id.detach());

     // The page tree has both child and parent pointers, so it creates a
     // reference cycle.  We must clear that cycle to properly reclaim memory.
     for (int i = 0; i < pageTree.count(); i++) {
         pageTree[i]->clear();
     }
     pageTree.safeUnrefAll();
     pages.unrefAll();
     return true;
 }

 #if 0
 // TODO(halcanary): expose notEmbeddableCount in SkDocument
 void GetCountOfFontTypes(
         const SkTDArray<SkPDFDevice*>& pageDevices,
         int counts[SkAdvancedTypefaceMetrics::kOther_Font + 1],
         int* notSubsettableCount,
         int* notEmbeddableCount) {
     sk_bzero(counts, sizeof(int) *
                      (SkAdvancedTypefaceMetrics::kOther_Font + 1));
     SkTDArray<SkFontID> seenFonts;
     int notSubsettable = 0;
     int notEmbeddable = 0;

     for (int pageNumber = 0; pageNumber < pageDevices.count(); pageNumber++) {
         const SkTDArray<SkPDFFont*>& fontResources =
                 pageDevices[pageNumber]->getFontResources();
         for (int font = 0; font < fontResources.count(); font++) {
             SkFontID fontID = fontResources[font]->typeface()->uniqueID();
             if (seenFonts.find(fontID) == -1) {
                 counts[fontResources[font]->getType()]++;
                 seenFonts.push(fontID);
                 if (!fontResources[font]->canSubset()) {
                     notSubsettable++;
                 }
                 if (!fontResources[font]->canEmbed()) {
                     notEmbeddable++;
                 }
             }
         }
     }
     if (notSubsettableCount) {
         *notSubsettableCount = notSubsettable;

     }
     if (notEmbeddableCount) {
         *notEmbeddableCount = notEmbeddable;
     }
 }
 #endif

 template <typename T> static T* clone(const T* o) { return o ? new T(*o) : nullptr; }
 ////////////////////////////////////////////////////////////////////////////////

 namespace {
 class SkDocument_PDF : public SkDocument {
 public:
     SkDocument_PDF(SkWStream* stream,
                    void (*doneProc)(SkWStream*, bool),
                    SkScalar rasterDpi,
                    SkPixelSerializer* jpegEncoder)
         : SkDocument(stream, doneProc)
         , fRasterDpi(rasterDpi) {
         fCanon.fPixelSerializer.reset(SkSafeRef(jpegEncoder));
     }

     virtual ~SkDocument_PDF() {
         // subclasses must call close() in their destructors
         this->close();
     }

 protected:
     SkCanvas* onBeginPage(SkScalar width, SkScalar height,
                           const SkRect& trimBox) override {
         SkASSERT(!fCanvas.get());

         SkISize pageSize = SkISize::Make(
                 SkScalarRoundToInt(width), SkScalarRoundToInt(height));
         SkAutoTUnref<SkPDFDevice> device(
                 SkPDFDevice::Create(pageSize, fRasterDpi, &fCanon));
         fCanvas.reset(new SkCanvas(device.get()));
         fPageDevices.push(device.detach());
         fCanvas->clipRect(trimBox);
         fCanvas->translate(trimBox.x(), trimBox.y());
         return fCanvas.get();
     }

     void onEndPage() override {
         SkASSERT(fCanvas.get());
         fCanvas->flush();
         fCanvas.reset(nullptr);
     }

     bool onClose(SkWStream* stream) override {
         SkASSERT(!fCanvas.get());

         bool success = emit_pdf_document(fPageDevices, fMetadata, stream);
         fPageDevices.unrefAll();
         fCanon.reset();
         return success;
     }

     void onAbort() override {
         fPageDevices.unrefAll();
         fCanon.reset();
     }

     void setMetadata(const SkTArray<SkDocument::Attribute>& info,
                      const SkTime::DateTime* creationDate,
                      const SkTime::DateTime* modifiedDate) override {
         fMetadata.fInfo = info;
         fMetadata.fCreation.reset(clone(creationDate));
         fMetadata.fModified.reset(clone(modifiedDate));
     }

 private:
     SkPDFCanon fCanon;
     SkTDArray<const SkPDFDevice*> fPageDevices;
     SkAutoTUnref<SkCanvas> fCanvas;
     SkScalar fRasterDpi;
     SkPDFMetadata fMetadata;
 };
 }  // namespace
 ///////////////////////////////////////////////////////////////////////////////

 SkDocument* SkDocument::CreatePDF(SkWStream* stream, SkScalar dpi) {
     return stream ? new SkDocument_PDF(stream, nullptr, dpi, nullptr) : nullptr;
 }

 SkDocument* SkDocument::CreatePDF(SkWStream* stream,
                                   SkScalar dpi,
                                   SkPixelSerializer* jpegEncoder) {
     return stream
         ? new SkDocument_PDF(stream, nullptr, dpi, jpegEncoder)
         : nullptr;
 }

 SkDocument* SkDocument::CreatePDF(const char path[], SkScalar dpi) {
     SkFILEWStream* stream = new SkFILEWStream(path);
     if (!stream->isValid()) {
         delete stream;
         return nullptr;
     }
     auto delete_wstream = [](SkWStream* stream, bool) { delete stream; };
     return new SkDocument_PDF(stream, delete_wstream, dpi, nullptr);
 }
	/*
	* Copyright 2011 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "SkDocument.h"
	#include "SkPDFCanon.h"
	#include "SkPDFDevice.h"
	#include "SkPDFFont.h"
	#include "SkPDFStream.h"
	#include "SkPDFTypes.h"
	#include "SkPDFUtils.h"
	#include "SkStream.h"
	#include "SkPDFMetadata.h"

	class SkPDFDict;

	static void emit_pdf_header(SkWStream* stream) {
	stream->writeText("%PDF-1.4\n%");
	// The PDF spec recommends including a comment with four bytes, all
	// with their high bits set. This is "Skia" with the high bits set.
	stream->write32(0xD3EBE9E1);
	stream->writeText("\n");
	}

	static void emit_pdf_footer(SkWStream* stream,
	const SkPDFObjNumMap& objNumMap,
	const SkPDFSubstituteMap& substitutes,
	SkPDFObject* docCatalog,
	int64_t objCount,
	int32_t xRefFileOffset,
	SkPDFObject* info /* take ownership */,
	SkPDFObject* id /* take ownership */) {
	SkPDFDict trailerDict;
	// TODO(http://crbug.com/80908): Linearized format will take a
	// Prev entry too.
	trailerDict.insertInt("Size", int(objCount));
	trailerDict.insertObjRef("Root", SkRef(docCatalog));
	SkASSERT(info);
	trailerDict.insertObjRef("Info", info);
	if (id) {
	trailerDict.insertObject("ID", id);
	}
	stream->writeText("trailer\n");
	trailerDict.emitObject(stream, objNumMap, substitutes);
	stream->writeText("\nstartxref\n");
	stream->writeBigDecAsText(xRefFileOffset);
	stream->writeText("\n%%EOF");
	}

	static void perform_font_subsetting(
	const SkTDArray<const SkPDFDevice*>& pageDevices,
	SkPDFSubstituteMap* substituteMap) {
	SkASSERT(substituteMap);

	SkPDFGlyphSetMap usage;
	for (int i = 0; i < pageDevices.count(); ++i) {
	usage.merge(pageDevices[i]->getFontGlyphUsage());
	}
	SkPDFGlyphSetMap::F2BIter iterator(usage);
	const SkPDFGlyphSetMap::FontGlyphSetPair* entry = iterator.next();
	while (entry) {
	SkAutoTUnref<SkPDFFont> subsetFont(
	entry->fFont->getFontSubset(entry->fGlyphSet));
	if (subsetFont) {
	substituteMap->setSubstitute(entry->fFont, subsetFont.get());
	}
	entry = iterator.next();
	}
	}

	static SkPDFObject* create_pdf_page_content(const SkPDFDevice* pageDevice) {
	SkAutoTDelete<SkStreamAsset> content(pageDevice->content());
	return new SkPDFStream(content.get());
	}

	static SkPDFDict* create_pdf_page(const SkPDFDevice* pageDevice) {
	SkAutoTUnref<SkPDFDict> page(new SkPDFDict("Page"));
	page->insertObject("Resources", pageDevice->createResourceDict());
	page->insertObject("MediaBox", pageDevice->copyMediaBox());
	SkAutoTUnref<SkPDFArray> annotations(new SkPDFArray);
	pageDevice->appendAnnotations(annotations);
	if (annotations->size() > 0) {
	page->insertObject("Annots", annotations.detach());
	}
	page->insertObjRef("Contents", create_pdf_page_content(pageDevice));
	return page.detach();
	}

	static void generate_page_tree(const SkTDArray<SkPDFDict*>& pages,
	SkTDArray<SkPDFDict> pageTree,
	SkPDFDict** rootNode) {
	// PDF wants a tree describing all the pages in the document. We arbitrary
	// choose 8 (kNodeSize) as the number of allowed children. The internal
	// nodes have type "Pages" with an array of children, a parent pointer, and
	// the number of leaves below the node as "Count." The leaves are passed
	// into the method, have type "Page" and need a parent pointer. This method
	// builds the tree bottom up, skipping internal nodes that would have only
	// one child.
	static const int kNodeSize = 8;

	// curNodes takes a reference to its items, which it passes to pageTree.
	SkTDArray<SkPDFDict*> curNodes;
	curNodes.setReserve(pages.count());
	for (int i = 0; i < pages.count(); i++) {
	SkSafeRef(pages[i]);
	curNodes.push(pages[i]);
	}

	// nextRoundNodes passes its references to nodes on to curNodes.
	SkTDArray<SkPDFDict*> nextRoundNodes;
	nextRoundNodes.setReserve((pages.count() + kNodeSize - 1)/kNodeSize);

	int treeCapacity = kNodeSize;
	do {
	for (int i = 0; i < curNodes.count(); ) {
	if (i > 0 && i + 1 == curNodes.count()) {
	nextRoundNodes.push(curNodes[i]);
	break;
	}

	SkAutoTUnref<SkPDFDict> newNode(new SkPDFDict("Pages"));
	SkAutoTUnref<SkPDFArray> kids(new SkPDFArray);
	kids->reserve(kNodeSize);

	int count = 0;
	for (; i < curNodes.count() && count < kNodeSize; i++, count++) {
	curNodes[i]->insertObjRef("Parent", SkRef(newNode.get()));
	kids->appendObjRef(SkRef(curNodes[i]));

	// TODO(vandebo): put the objects in strict access order.
	// Probably doesn't matter because they are so small.
	if (curNodes[i] != pages[0]) {
	pageTree->push(curNodes[i]); // Transfer reference.
	} else {
	SkSafeUnref(curNodes[i]);
	}
	}

	// treeCapacity is the number of leaf nodes possible for the
	// current set of subtrees being generated. (i.e. 8, 64, 512, ...).
	// It is hard to count the number of leaf nodes in the current
	// subtree. However, by construction, we know that unless it's the
	// last subtree for the current depth, the leaf count will be
	// treeCapacity, otherwise it's what ever is left over after
	// consuming treeCapacity chunks.
	int pageCount = treeCapacity;
	if (i == curNodes.count()) {
	pageCount = ((pages.count() - 1) % treeCapacity) + 1;
	}
	newNode->insertInt("Count", pageCount);
	newNode->insertObject("Kids", kids.detach());
	nextRoundNodes.push(newNode.detach()); // Transfer reference.
	}

	curNodes = nextRoundNodes;
	nextRoundNodes.rewind();
	treeCapacity *= kNodeSize;
	} while (curNodes.count() > 1);

	pageTree->push(curNodes[0]); // Transfer reference.
	if (rootNode) {
	*rootNode = curNodes[0];
	}
	}

	static bool emit_pdf_document(const SkTDArray<const SkPDFDevice*>& pageDevices,
	const SkPDFMetadata& metadata,
	SkWStream* stream) {
	if (pageDevices.isEmpty()) {
	return false;
	}

	SkTDArray<SkPDFDict*> pages;
	SkAutoTUnref<SkPDFDict> dests(new SkPDFDict);

	for (int i = 0; i < pageDevices.count(); i++) {
	SkASSERT(pageDevices[i]);
	SkASSERT(i == 0 \|\|
	pageDevices[i - 1]->getCanon() == pageDevices[i]->getCanon());
	SkAutoTUnref<SkPDFDict> page(create_pdf_page(pageDevices[i]));
	pageDevices[i]->appendDestinations(dests, page.get());
	pages.push(page.detach());
	}

	SkAutoTUnref<SkPDFDict> docCatalog(new SkPDFDict("Catalog"));

	SkAutoTUnref<SkPDFObject> infoDict(
	metadata.createDocumentInformationDict());

	SkAutoTUnref<SkPDFObject> id, xmp;
	#ifdef SK_PDF_GENERATE_PDFA
	SkPDFMetadata::UUID uuid = metadata.uuid();
	// We use the same UUID for Document ID and Instance ID since this
	// is the first revision of this document (and Skia does not
	// support revising existing PDF documents).
	// If we are not in PDF/A mode, don't use a UUID since testing
	// works best with reproducible outputs.
	id.reset(SkPDFMetadata::CreatePdfId(uuid, uuid));
	xmp.reset(metadata.createXMPObject(uuid, uuid));
	docCatalog->insertObjRef("Metadata", xmp.detach());

	// sRGB is specified by HTML, CSS, and SVG.
	SkAutoTUnref<SkPDFDict> outputIntent(new SkPDFDict("OutputIntent"));
	outputIntent->insertName("S", "GTS_PDFA1");
	outputIntent->insertString("RegistryName", "http://www.color.org");
	outputIntent->insertString("OutputConditionIdentifier",
	"sRGB IEC61966-2.1");
	SkAutoTUnref<SkPDFArray> intentArray(new SkPDFArray);
	intentArray->appendObject(outputIntent.detach());
	// Don't specify OutputIntents if we are not in PDF/A mode since
	// no one has ever asked for this feature.
	docCatalog->insertObject("OutputIntents", intentArray.detach());
	#endif

	SkTDArray<SkPDFDict*> pageTree;
	SkPDFDict* pageTreeRoot;
	generate_page_tree(pages, &pageTree, &pageTreeRoot);
	docCatalog->insertObjRef("Pages", SkRef(pageTreeRoot));

	if (dests->size() > 0) {
	docCatalog->insertObjRef("Dests", dests.detach());
	}

	// Build font subsetting info before proceeding.
	SkPDFSubstituteMap substitutes;
	perform_font_subsetting(pageDevices, &substitutes);

	SkPDFObjNumMap objNumMap;
	objNumMap.addObjectRecursively(infoDict, substitutes);
	objNumMap.addObjectRecursively(docCatalog.get(), substitutes);
	size_t baseOffset = stream->bytesWritten();
	emit_pdf_header(stream);
	SkTDArray<int32_t> offsets;
	for (int i = 0; i < objNumMap.objects().count(); ++i) {
	SkPDFObject* object = objNumMap.objects()[i];
	size_t offset = stream->bytesWritten();
	// This assert checks that size(pdf_header) > 0 and that
	// the output stream correctly reports bytesWritten().
	SkASSERT(offset > baseOffset);
	offsets.push(SkToS32(offset - baseOffset));
	SkASSERT(object == substitutes.getSubstitute(object));
	SkASSERT(objNumMap.getObjectNumber(object) == i + 1);
	stream->writeDecAsText(i + 1);
	stream->writeText(" 0 obj\n"); // Generation number is always 0.
	object->emitObject(stream, objNumMap, substitutes);
	stream->writeText("\nendobj\n");
	}
	int32_t xRefFileOffset = SkToS32(stream->bytesWritten() - baseOffset);

	// Include the zeroth object in the count.
	int32_t objCount = SkToS32(offsets.count() + 1);

	stream->writeText("xref\n0 ");
	stream->writeDecAsText(objCount);
	stream->writeText("\n0000000000 65535 f \n");
	for (int i = 0; i < offsets.count(); i++) {
	SkASSERT(offsets[i] > 0);
	stream->writeBigDecAsText(offsets[i], 10);
	stream->writeText(" 00000 n \n");
	}
	emit_pdf_footer(stream, objNumMap, substitutes, docCatalog.get(), objCount,
	xRefFileOffset, infoDict.detach(), id.detach());

	// The page tree has both child and parent pointers, so it creates a
	// reference cycle. We must clear that cycle to properly reclaim memory.
	for (int i = 0; i < pageTree.count(); i++) {
	pageTree[i]->clear();
	}
	pageTree.safeUnrefAll();
	pages.unrefAll();
	return true;
	}

	#if 0
	// TODO(halcanary): expose notEmbeddableCount in SkDocument
	void GetCountOfFontTypes(
	const SkTDArray<SkPDFDevice*>& pageDevices,
	int counts[SkAdvancedTypefaceMetrics::kOther_Font + 1],
	int* notSubsettableCount,
	int* notEmbeddableCount) {
	sk_bzero(counts, sizeof(int) *
	(SkAdvancedTypefaceMetrics::kOther_Font + 1));
	SkTDArray<SkFontID> seenFonts;
	int notSubsettable = 0;
	int notEmbeddable = 0;

	for (int pageNumber = 0; pageNumber < pageDevices.count(); pageNumber++) {
	const SkTDArray<SkPDFFont*>& fontResources =
	pageDevices[pageNumber]->getFontResources();
	for (int font = 0; font < fontResources.count(); font++) {
	SkFontID fontID = fontResources[font]->typeface()->uniqueID();
	if (seenFonts.find(fontID) == -1) {
	counts[fontResources[font]->getType()]++;
	seenFonts.push(fontID);
	if (!fontResources[font]->canSubset()) {
	notSubsettable++;
	}
	if (!fontResources[font]->canEmbed()) {
	notEmbeddable++;
	}
	}
	}
	}
	if (notSubsettableCount) {
	*notSubsettableCount = notSubsettable;

	}
	if (notEmbeddableCount) {
	*notEmbeddableCount = notEmbeddable;
	}
	}
	#endif

	template <typename T> static T* clone(const T* o) { return o ? new T(*o) : nullptr; }
	////////////////////////////////////////////////////////////////////////////////

	namespace {
	class SkDocument_PDF : public SkDocument {
	public:
	SkDocument_PDF(SkWStream* stream,
	void (doneProc)(SkWStream, bool),
	SkScalar rasterDpi,
	SkPixelSerializer* jpegEncoder)
	: SkDocument(stream, doneProc)
	, fRasterDpi(rasterDpi) {
	fCanon.fPixelSerializer.reset(SkSafeRef(jpegEncoder));
	}

	virtual ~SkDocument_PDF() {
	// subclasses must call close() in their destructors
	this->close();
	}

	protected:
	SkCanvas* onBeginPage(SkScalar width, SkScalar height,
	const SkRect& trimBox) override {
	SkASSERT(!fCanvas.get());

	SkISize pageSize = SkISize::Make(
	SkScalarRoundToInt(width), SkScalarRoundToInt(height));
	SkAutoTUnref<SkPDFDevice> device(
	SkPDFDevice::Create(pageSize, fRasterDpi, &fCanon));
	fCanvas.reset(new SkCanvas(device.get()));
	fPageDevices.push(device.detach());
	fCanvas->clipRect(trimBox);
	fCanvas->translate(trimBox.x(), trimBox.y());
	return fCanvas.get();
	}

	void onEndPage() override {
	SkASSERT(fCanvas.get());
	fCanvas->flush();
	fCanvas.reset(nullptr);
	}

	bool onClose(SkWStream* stream) override {
	SkASSERT(!fCanvas.get());

	bool success = emit_pdf_document(fPageDevices, fMetadata, stream);
	fPageDevices.unrefAll();
	fCanon.reset();
	return success;
	}

	void onAbort() override {
	fPageDevices.unrefAll();
	fCanon.reset();
	}

	void setMetadata(const SkTArray<SkDocument::Attribute>& info,
	const SkTime::DateTime* creationDate,
	const SkTime::DateTime* modifiedDate) override {
	fMetadata.fInfo = info;
	fMetadata.fCreation.reset(clone(creationDate));
	fMetadata.fModified.reset(clone(modifiedDate));
	}

	private:
	SkPDFCanon fCanon;
	SkTDArray<const SkPDFDevice*> fPageDevices;
	SkAutoTUnref<SkCanvas> fCanvas;
	SkScalar fRasterDpi;
	SkPDFMetadata fMetadata;
	};
	} // namespace
	///////////////////////////////////////////////////////////////////////////////

	SkDocument* SkDocument::CreatePDF(SkWStream* stream, SkScalar dpi) {
	return stream ? new SkDocument_PDF(stream, nullptr, dpi, nullptr) : nullptr;
	}

	SkDocument* SkDocument::CreatePDF(SkWStream* stream,
	SkScalar dpi,
	SkPixelSerializer* jpegEncoder) {
	return stream
	? new SkDocument_PDF(stream, nullptr, dpi, jpegEncoder)
	: nullptr;
	}

	SkDocument* SkDocument::CreatePDF(const char path[], SkScalar dpi) {
	SkFILEWStream* stream = new SkFILEWStream(path);
	if (!stream->isValid()) {
	delete stream;
	return nullptr;
	}
	auto delete_wstream = [](SkWStream* stream, bool) { delete stream; };
	return new SkDocument_PDF(stream, delete_wstream, dpi, nullptr);
	}