SkPDFDocument Class Reference

#include <SkPDFDocumentPriv.h>

Inheritance diagram for SkPDFDocument:

Public Member Functions
	SkPDFDocument (SkWStream *, SkPDF::Metadata)
	~SkPDFDocument () override
SkCanvas *	onBeginPage (SkScalar, SkScalar) override
void	onEndPage () override
void	onClose (SkWStream *) override
void	onAbort () override
SkPDFIndirectReference	emit (const SkPDFObject &, SkPDFIndirectReference)
SkPDFIndirectReference	emit (const SkPDFObject &o)
template<typename T >
void	emitStream (const SkPDFDict &dict, T writeStream, SkPDFIndirectReference ref)
const SkPDF::Metadata &	metadata () const
SkPDFIndirectReference	getPage (size_t pageIndex) const
bool	hasCurrentPage () const
SkPDFIndirectReference	currentPage () const
SkPDFTagTree::Mark	createMarkIdForNodeId (int nodeId, SkPoint)
int	createStructParentKeyForNodeId (int nodeId)
void	addNodeTitle (int nodeId, SkSpan< const char >)
std::unique_ptr< SkPDFArray >	getAnnotations ()
SkPDFIndirectReference	reserveRef ()
SkString	nextFontSubsetTag ()
SkExecutor *	executor () const
void	incrementJobCount ()
void	signalJobComplete ()
size_t	currentPageIndex ()
size_t	pageCount ()
const SkMatrix &	currentPageTransform () const
Public Member Functions inherited from SkDocument
SkCanvas *	beginPage (SkScalar width, SkScalar height, const SkRect *content=nullptr)
void	endPage ()
void	close ()
void	abort ()
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Public Attributes
skia_private::THashMap< SkPDFImageShaderKey, SkPDFIndirectReference, SkPDFImageShaderKey::Hash >	fImageShaderMap
skia_private::THashMap< SkPDFGradientShader::Key, SkPDFIndirectReference, SkPDFGradientShader::KeyHash >	fGradientPatternMap
skia_private::THashMap< SkBitmapKey, SkPDFIndirectReference >	fPDFBitmapMap
skia_private::THashMap< SkPDFIccProfileKey, SkPDFIndirectReference, SkPDFIccProfileKey::Hash >	fICCProfileMap
skia_private::THashMap< uint32_t, std::unique_ptr< SkAdvancedTypefaceMetrics > >	fTypefaceMetrics
skia_private::THashMap< uint32_t, std::vector< SkString > >	fType1GlyphNames
skia_private::THashMap< uint32_t, std::vector< SkUnichar > >	fToUnicodeMap
skia_private::THashMap< uint32_t, SkPDFIndirectReference >	fFontDescriptors
skia_private::THashMap< uint32_t, SkPDFIndirectReference >	fType3FontDescriptors
skia_private::THashMap< uint64_t, SkPDFFont >	fFontMap
skia_private::THashMap< SkPDFStrokeGraphicState, SkPDFIndirectReference, SkPDFStrokeGraphicState::Hash >	fStrokeGSMap
skia_private::THashMap< SkPDFFillGraphicState, SkPDFIndirectReference, SkPDFFillGraphicState::Hash >	fFillGSMap
SkPDFIndirectReference	fInvertFunction
SkPDFIndirectReference	fNoSmaskGraphicState
std::vector< std::unique_ptr< SkPDFLink > >	fCurrentPageLinks
std::vector< SkPDFNamedDestination >	fNamedDestinations

Additional Inherited Members
Protected Types inherited from SkDocument
enum	State { kBetweenPages_State , kInPage_State , kClosed_State }
Protected Member Functions inherited from SkDocument
	SkDocument (SkWStream *)
	~SkDocument () override
virtual SkCanvas *	onBeginPage (SkScalar width, SkScalar height)=0
virtual void	onEndPage ()=0
virtual void	onClose (SkWStream *)=0
virtual void	onAbort ()=0
SkWStream *	getStream ()
State	getState () const

Detailed Description

Concrete implementation of SkDocument that creates PDF files. This class does not produced linearized or optimized PDFs; instead it it attempts to use a minimum amount of RAM.

Definition at line 95 of file SkPDFDocumentPriv.h.

Constructor & Destructor Documentation

SkPDFDocument()

SkPDFDocument::SkPDFDocument	(	SkWStream *	stream,
		SkPDF::Metadata	metadata
	)

Definition at line 233 of file SkPDFDocument.cpp.

    : SkDocument(stream)
    , fMetadata(std::move(metadata)) {
    constexpr float kDpiForRasterScaleOne = 72.0f;
    if (fMetadata.fRasterDPI != kDpiForRasterScaleOne) {
        fInverseRasterScale = kDpiForRasterScaleOne / fMetadata.fRasterDPI;
        fRasterScale        = fMetadata.fRasterDPI / kDpiForRasterScaleOne;
    }
    if (fMetadata.fStructureElementTreeRoot) {
        fTagTree.init(fMetadata.fStructureElementTreeRoot, fMetadata.fOutline);
    }
    fExecutor = fMetadata.fExecutor;
}

~SkPDFDocument()

SkPDFDocument::~SkPDFDocument ( )

override

Definition at line 248 of file SkPDFDocument.cpp.

                              {
    // subclasses of SkDocument must call close() in their destructors.
    this->close();
}

Member Function Documentation

addNodeTitle()

void SkPDFDocument::addNodeTitle	(	int	nodeId,
		SkSpan< const char >	title
	)

Definition at line 567 of file SkPDFDocument.cpp.

                                                                     {
    fTagTree.addNodeTitle(nodeId, std::move(title));
}

createMarkIdForNodeId()

SkPDFTagTree::Mark SkPDFDocument::createMarkIdForNodeId	(	int	nodeId,
		SkPoint	p
	)

Definition at line 558 of file SkPDFDocument.cpp.

                                                                           {
    // If the mark isn't on a page (like when emitting a Type3 glyph)
    // return a temporary mark not attached to the tag tree, node id, or page.
    if (!this->hasCurrentPage()) {
        return SkPDFTagTree::Mark();
    }
    return fTagTree.createMarkIdForNodeId(nodeId, SkToUInt(this->currentPageIndex()), p);
}

createStructParentKeyForNodeId()

int SkPDFDocument::createStructParentKeyForNodeId

(

int

nodeId

)

Definition at line 571 of file SkPDFDocument.cpp.

                                                            {
    // Structure elements are tied to pages, so don't emit one if not on a page.
    if (!this->hasCurrentPage()) {
        return -1;
    }
    return fTagTree.createStructParentKeyForNodeId(nodeId, SkToUInt(this->currentPageIndex()));
}

currentPage()

SkPDFIndirectReference SkPDFDocument::currentPage ( ) const

inline

Definition at line 131 of file SkPDFDocumentPriv.h.

                                               {
        return SkASSERT(this->hasCurrentPage() && !fPageRefs.empty()), fPageRefs.back();
    }

currentPageIndex()

size_t SkPDFDocument::currentPageIndex ( )

inline

Definition at line 155 of file SkPDFDocumentPriv.h.

{ return fPages.size(); }

currentPageTransform()

const SkMatrix & SkPDFDocument::currentPageTransform

(

)

const

Definition at line 549 of file SkPDFDocument.cpp.

                                                          {
    static constexpr const SkMatrix gIdentity;
    // If not on a page (like when emitting a Type3 glyph) return identity.
    if (!this->hasCurrentPage()) {
        return gIdentity;
    }
    return fPageDevice->initialTransform();
}

emit() [1/2]

SkPDFIndirectReference SkPDFDocument::emit	(	const SkPDFObject &	object,
		SkPDFIndirectReference	ref
	)

Serialize the object, as well as any other objects it indirectly refers to. If any any other objects have been added to the SkPDFObjNumMap without serializing them, they will be serialized as well.

It might go without saying that objects should not be changed after calling serialize, since those changes will be too late.

Definition at line 253 of file SkPDFDocument.cpp.

                                                                                               {
    SkAutoMutexExclusive lock(fMutex);
    object.emitObject(this->beginObject(ref));
    this->endObject();
    return ref;
}

emit() [2/2]

SkPDFIndirectReference SkPDFDocument::emit ( const SkPDFObject &  o )

inline

Definition at line 114 of file SkPDFDocumentPriv.h.

{ return this->emit(o, this->reserveRef()); }

emitStream()

template<typename T >

void SkPDFDocument::emitStream ( const SkPDFDict &  dict, T  writeStream, SkPDFIndirectReference  ref  )

inline

Definition at line 117 of file SkPDFDocumentPriv.h.

                                                                                      {
        SkAutoMutexExclusive lock(fMutex);
        SkWStream* stream = this->beginObject(ref);
        dict.emitObject(stream);
        stream->writeText(" stream\n");
        writeStream(stream);
        stream->writeText("\nendstream");
        this->endObject();
    }

executor()

SkExecutor * SkPDFDocument::executor ( ) const

inline

Definition at line 152 of file SkPDFDocumentPriv.h.

{ return fExecutor; }

getAnnotations()

std::unique_ptr< SkPDFArray > SkPDFDocument::getAnnotations

(

)

Definition at line 338 of file SkPDFDocument.cpp.

                                                        {
    std::unique_ptr<SkPDFArray> array;
    size_t count = fCurrentPageLinks.size();
    if (0 == count) {
        return array;  // is nullptr
    }
    array = SkPDFMakeArray();
    array->reserve(count);
    for (const auto& link : fCurrentPageLinks) {
        SkPDFDict annotation("Annot");
        populate_link_annotation(&annotation, link->fRect);
        if (link->fType == SkPDFLink::Type::kUrl) {
            std::unique_ptr<SkPDFDict> action = SkPDFMakeDict("Action");
            action->insertName("S", "URI");
            // This is documented to be a 7 bit ASCII (byte) string.
            action->insertByteString("URI", ToValidUtf8String(*link->fData));
            annotation.insertObject("A", std::move(action));
        } else if (link->fType == SkPDFLink::Type::kNamedDestination) {
            annotation.insertName("Dest", ToValidUtf8String(*link->fData));
        } else {
            SkDEBUGFAIL("Unknown link type.");
        }
 
        if (link->fNodeId) {
            int structParentKey = createStructParentKeyForNodeId(link->fNodeId);
            if (structParentKey != -1) {
                annotation.insertInt("StructParent", structParentKey);
            }
        }
 
        SkPDFIndirectReference annotationRef = emit(annotation);
        array->appendRef(annotationRef);
        if (link->fNodeId) {
            fTagTree.addNodeAnnotation(link->fNodeId, annotationRef, SkToUInt(this->currentPageIndex()));
        }
    }
    return array;
}

getPage()

SkPDFIndirectReference SkPDFDocument::getPage

(

size_t

pageIndex

)

const

Definition at line 544 of file SkPDFDocument.cpp.

                                                                    {
    SkASSERT(pageIndex < fPageRefs.size());
    return fPageRefs[pageIndex];
}

hasCurrentPage()

bool SkPDFDocument::hasCurrentPage ( ) const

inline

Definition at line 130 of file SkPDFDocumentPriv.h.

{ return bool(fPageDevice); }

incrementJobCount()

void SkPDFDocument::incrementJobCount

(

)

Definition at line 672 of file SkPDFDocument.cpp.

{ fJobCount++; }

metadata()

const SkPDF::Metadata & SkPDFDocument::metadata ( ) const

inline

Definition at line 127 of file SkPDFDocumentPriv.h.

{ return fMetadata; }

nextFontSubsetTag()

SkString SkPDFDocument::nextFontSubsetTag

(

)

Definition at line 592 of file SkPDFDocument.cpp.

                                          {
    // PDF 32000-1:2008 Section 9.6.4 FontSubsets "The tag shall consist of six uppercase letters"
    // "followed by a plus sign" "different subsets in the same PDF file shall have different tags."
    // There are 26^6 or 308,915,776 possible values. So start in range then increment and mod.
    uint32_t thisFontSubsetTag = fNextFontSubsetTag;
    fNextFontSubsetTag = (fNextFontSubsetTag + 1u) % 308915776u;
 
    SkString subsetTag(7);
    char* subsetTagData = subsetTag.data();
    for (size_t i = 0; i < 6; ++i) {
        subsetTagData[i] = 'A' + (thisFontSubsetTag % 26);
        thisFontSubsetTag /= 26;
    }
    subsetTagData[6] = '+';
    return subsetTag;
}

onAbort()

void SkPDFDocument::onAbort ( )

overridevirtual

Implements SkDocument.

Definition at line 405 of file SkPDFDocument.cpp.

                            {
    this->waitForJobs();
}

onBeginPage()

SkCanvas * SkPDFDocument::onBeginPage ( SkScalar  width, SkScalar  height  )

overridevirtual

Implements SkDocument.

Definition at line 272 of file SkPDFDocument.cpp.

                                                                    {
    SkASSERT(fCanvas.imageInfo().dimensions().isZero());
    if (fPages.empty()) {
        // if this is the first page if the document.
        {
            SkAutoMutexExclusive autoMutexAcquire(fMutex);
            serializeHeader(&fOffsetMap, this->getStream());
 
        }
 
        fInfoDict = this->emit(*SkPDFMetadata::MakeDocumentInformationDict(fMetadata));
        if (fMetadata.fPDFA) {
            fUUID = SkPDFMetadata::CreateUUID(fMetadata);
            // 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.
            fXMP = SkPDFMetadata::MakeXMPObject(fMetadata, fUUID, fUUID, this);
        }
    }
    // By scaling the page at the device level, we will create bitmap layer
    // devices at the rasterized scale, not the 72dpi scale.  Bitmap layer
    // devices are created when saveLayer is called with an ImageFilter;  see
    // SkPDFDevice::onCreateDevice().
    SkISize pageSize = (SkSize{width, height} * fRasterScale).toRound();
    SkMatrix initialTransform;
    // Skia uses the top left as the origin but PDF natively has the origin at the
    // bottom left. This matrix corrects for that, as well as the raster scale.
    initialTransform.setScaleTranslate(fInverseRasterScale, -fInverseRasterScale,
                                       0, fInverseRasterScale * pageSize.height());
    fPageDevice = sk_make_sp<SkPDFDevice>(pageSize, this, initialTransform);
    reset_object(&fCanvas, fPageDevice);
    fCanvas.scale(fRasterScale, fRasterScale);
    fPageRefs.push_back(this->reserveRef());
    return &fCanvas;
}

onClose()

void SkPDFDocument::onClose ( SkWStream *  stream )

overridevirtual

Implements SkDocument.

Definition at line 609 of file SkPDFDocument.cpp.

                                             {
    SkASSERT(fCanvas.imageInfo().dimensions().isZero());
    if (fPages.empty()) {
        this->waitForJobs();
        return;
    }
    auto docCatalog = SkPDFMakeDict("Catalog");
    if (fMetadata.fPDFA) {
        SkASSERT(fXMP != SkPDFIndirectReference());
        docCatalog->insertRef("Metadata", fXMP);
        // Don't specify OutputIntents if we are not in PDF/A mode since
        // no one has ever asked for this feature.
        docCatalog->insertObject("OutputIntents", make_srgb_output_intents(this));
    }
 
    docCatalog->insertRef("Pages", generate_page_tree(this, std::move(fPages), fPageRefs));
 
    if (!fNamedDestinations.empty()) {
        docCatalog->insertRef("Dests", append_destinations(this, fNamedDestinations));
        fNamedDestinations.clear();
    }
 
    // Handle tagged PDFs.
    if (SkPDFIndirectReference root = fTagTree.makeStructTreeRoot(this)) {
        // In the document catalog, indicate that this PDF is tagged.
        auto markInfo = SkPDFMakeDict("MarkInfo");
        markInfo->insertBool("Marked", true);
        docCatalog->insertObject("MarkInfo", std::move(markInfo));
        docCatalog->insertRef("StructTreeRoot", root);
 
        if (SkPDFIndirectReference outline = fTagTree.makeOutline(this)) {
            docCatalog->insertRef("Outlines", outline);
        }
    }
 
    // If ViewerPreferences DisplayDocTitle isn't set to true, accessibility checks will fail.
    if (!fMetadata.fTitle.isEmpty()) {
        auto viewerPrefs = SkPDFMakeDict("ViewerPreferences");
        viewerPrefs->insertBool("DisplayDocTitle", true);
        docCatalog->insertObject("ViewerPreferences", std::move(viewerPrefs));
    }
 
    SkString lang = fMetadata.fLang;
    if (lang.isEmpty()) {
        lang = fTagTree.getRootLanguage();
    }
    if (!lang.isEmpty()) {
        docCatalog->insertTextString("Lang", lang);
    }
 
    auto docCatalogRef = this->emit(*docCatalog);
 
    for (const SkPDFFont* f : get_fonts(*this)) {
        f->emitSubset(this);
    }
 
    this->waitForJobs();
    {
        SkAutoMutexExclusive autoMutexAcquire(fMutex);
        serialize_footer(fOffsetMap, this->getStream(), fInfoDict, docCatalogRef, fUUID);
    }
}

onEndPage()

void SkPDFDocument::onEndPage ( )

overridevirtual

Implements SkDocument.

Definition at line 377 of file SkPDFDocument.cpp.

                              {
    SkASSERT(!fCanvas.imageInfo().dimensions().isZero());
    reset_object(&fCanvas);
    SkASSERT(fPageDevice);
 
    auto page = SkPDFMakeDict("Page");
 
    SkSize mediaSize = fPageDevice->imageInfo().dimensions() * fInverseRasterScale;
    std::unique_ptr<SkStreamAsset> pageContent = fPageDevice->content();
    auto resourceDict = fPageDevice->makeResourceDict();
    SkASSERT(!fPageRefs.empty());
    fPageDevice = nullptr;
 
    page->insertObject("Resources", std::move(resourceDict));
    page->insertObject("MediaBox", SkPDFUtils::RectToArray(SkRect::MakeSize(mediaSize)));
 
    if (std::unique_ptr<SkPDFArray> annotations = getAnnotations()) {
        page->insertObject("Annots", std::move(annotations));
        fCurrentPageLinks.clear();
    }
 
    page->insertRef("Contents", SkPDFStreamOut(nullptr, std::move(pageContent), this));
    // The StructParents unique identifier for each page is just its
    // 0-based page index.
    page->insertInt("StructParents", SkToInt(this->currentPageIndex()));
    fPages.emplace_back(std::move(page));
}

pageCount()

size_t SkPDFDocument::pageCount ( )

inline

Definition at line 156 of file SkPDFDocumentPriv.h.

{ return fPageRefs.size(); }

reserveRef()

SkPDFIndirectReference SkPDFDocument::reserveRef ( )

inline

Definition at line 147 of file SkPDFDocumentPriv.h.

{ return SkPDFIndirectReference{fNextObjectNumber++}; }

signalJobComplete()

void SkPDFDocument::signalJobComplete

(

)

Definition at line 674 of file SkPDFDocument.cpp.

{ fSemaphore.signal(); }

Member Data Documentation

fCurrentPageLinks

std::vector<std::unique_ptr<SkPDFLink> > SkPDFDocument::fCurrentPageLinks

Definition at line 185 of file SkPDFDocumentPriv.h.

fFillGSMap

skia_private::THashMap<SkPDFFillGraphicState, SkPDFIndirectReference, SkPDFFillGraphicState::Hash> SkPDFDocument::fFillGSMap

Definition at line 182 of file SkPDFDocumentPriv.h.

fFontDescriptors

skia_private::THashMap<uint32_t, SkPDFIndirectReference> SkPDFDocument::fFontDescriptors

Definition at line 174 of file SkPDFDocumentPriv.h.

fFontMap

skia_private::THashMap<uint64_t, SkPDFFont> SkPDFDocument::fFontMap

Definition at line 176 of file SkPDFDocumentPriv.h.

fGradientPatternMap

skia_private::THashMap<SkPDFGradientShader::Key, SkPDFIndirectReference, SkPDFGradientShader::KeyHash> SkPDFDocument::fGradientPatternMap

Definition at line 166 of file SkPDFDocumentPriv.h.

fICCProfileMap

skia_private::THashMap<SkPDFIccProfileKey, SkPDFIndirectReference, SkPDFIccProfileKey::Hash> SkPDFDocument::fICCProfileMap

Definition at line 170 of file SkPDFDocumentPriv.h.

fImageShaderMap

skia_private::THashMap<SkPDFImageShaderKey, SkPDFIndirectReference, SkPDFImageShaderKey::Hash> SkPDFDocument::fImageShaderMap

Definition at line 163 of file SkPDFDocumentPriv.h.

fInvertFunction

SkPDFIndirectReference SkPDFDocument::fInvertFunction

Definition at line 183 of file SkPDFDocumentPriv.h.

fNamedDestinations

std::vector<SkPDFNamedDestination> SkPDFDocument::fNamedDestinations

Definition at line 186 of file SkPDFDocumentPriv.h.

fNoSmaskGraphicState

SkPDFIndirectReference SkPDFDocument::fNoSmaskGraphicState

Definition at line 184 of file SkPDFDocumentPriv.h.

fPDFBitmapMap

skia_private::THashMap<SkBitmapKey, SkPDFIndirectReference> SkPDFDocument::fPDFBitmapMap

Definition at line 167 of file SkPDFDocumentPriv.h.

fStrokeGSMap

skia_private::THashMap<SkPDFStrokeGraphicState, SkPDFIndirectReference, SkPDFStrokeGraphicState::Hash> SkPDFDocument::fStrokeGSMap

Definition at line 179 of file SkPDFDocumentPriv.h.

fToUnicodeMap

skia_private::THashMap<uint32_t, std::vector<SkUnichar> > SkPDFDocument::fToUnicodeMap

Definition at line 173 of file SkPDFDocumentPriv.h.

fType1GlyphNames

skia_private::THashMap<uint32_t, std::vector<SkString> > SkPDFDocument::fType1GlyphNames

Definition at line 172 of file SkPDFDocumentPriv.h.

fType3FontDescriptors

skia_private::THashMap<uint32_t, SkPDFIndirectReference> SkPDFDocument::fType3FontDescriptors

Definition at line 175 of file SkPDFDocumentPriv.h.

fTypefaceMetrics

skia_private::THashMap<uint32_t, std::unique_ptr<SkAdvancedTypefaceMetrics> > SkPDFDocument::fTypefaceMetrics

Definition at line 171 of file SkPDFDocumentPriv.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/pdf/SkPDFDocumentPriv.h
• third_party/skia/src/pdf/SkPDFDocument.cpp