SkPDFType1Font.cpp File Reference

#include "src/pdf/SkPDFType1Font.h"
#include "include/core/SkData.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkStream.h"
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkMacros.h"
#include "include/private/base/SkSpan_impl.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkBitmaskEnum.h"
#include "src/core/SkAdvancedTypefaceMetrics.h"
#include "src/core/SkGlyph.h"
#include "src/core/SkStrikeSpec.h"
#include "src/core/SkTHash.h"
#include "src/pdf/SkPDFDocumentPriv.h"
#include "src/pdf/SkPDFFont.h"
#include "src/pdf/SkPDFTypes.h"
#include <ctype.h>
#include <cstdint>
#include <cstring>
#include <memory>
#include <utility>
#include <vector>

Go to the source code of this file.

Functions
static bool	parsePFBSection (const uint8_t **src, size_t *len, int sectionType, size_t *size)
static bool	parsePFB (const uint8_t *src, size_t size, size_t *headerLen, size_t *dataLen, size_t *trailerLen)
static bool	parsePFA (const char *src, size_t size, size_t *headerLen, size_t *hexDataLen, size_t *dataLen, size_t *trailerLen)
static int8_t	hexToBin (uint8_t c)
static sk_sp< SkData >	convert_type1_font_stream (std::unique_ptr< SkStreamAsset > srcStream, size_t *headerLen, size_t *dataLen, size_t *trailerLen)
static bool	can_embed (const SkAdvancedTypefaceMetrics &metrics)
static SkScalar	from_font_units (SkScalar scaled, uint16_t emSize)
static SkPDFIndirectReference	make_type1_font_descriptor (SkPDFDocument *doc, const SkTypeface *typeface, const SkAdvancedTypefaceMetrics *info)
static const std::vector< SkString > &	type_1_glyphnames (SkPDFDocument *canon, const SkTypeface *typeface)
static SkPDFIndirectReference	type1_font_descriptor (SkPDFDocument *doc, const SkTypeface *typeface)
void	SkPDFEmitType1Font (const SkPDFFont &pdfFont, SkPDFDocument *doc)

Function Documentation

can_embed()

static bool can_embed ( const SkAdvancedTypefaceMetrics &  metrics )

inlinestatic

Definition at line 242 of file SkPDFType1Font.cpp.

                                                                       {
    return !SkToBool(metrics.fFlags & SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag);
}

convert_type1_font_stream()

static sk_sp< SkData > convert_type1_font_stream ( std::unique_ptr< SkStreamAsset >  srcStream, size_t *  headerLen, size_t *  dataLen, size_t *  trailerLen  )

static

Definition at line 156 of file SkPDFType1Font.cpp.

                                                                   {
    size_t srcLen = srcStream ? srcStream->getLength() : 0;
    SkASSERT(srcLen);
    if (!srcLen) {
        return nullptr;
    }
    // Flatten and Nul-terminate the source stream so that we can use
    // strstr() to search it.
    AutoTMalloc<uint8_t> sourceBuffer(SkToInt(srcLen + 1));
    (void)srcStream->read(sourceBuffer.get(), srcLen);
    sourceBuffer[SkToInt(srcLen)] = 0;
    const uint8_t* src = sourceBuffer.get();
 
    if (parsePFB(src, srcLen, headerLen, dataLen, trailerLen)) {
        static const int kPFBSectionHeaderLength = 6;
        const size_t length = *headerLen + *dataLen + *trailerLen;
        SkASSERT(length > 0);
        SkASSERT(length + (2 * kPFBSectionHeaderLength) <= srcLen);
 
        sk_sp<SkData> data(SkData::MakeUninitialized(length));
 
        const uint8_t* const srcHeader = src + kPFBSectionHeaderLength;
        // There is a six-byte section header before header and data
        // (but not trailer) that we're not going to copy.
        const uint8_t* const srcData = srcHeader + *headerLen + kPFBSectionHeaderLength;
        const uint8_t* const srcTrailer = srcData + *headerLen;
 
        uint8_t* const resultHeader = (uint8_t*)data->writable_data();
        uint8_t* const resultData = resultHeader + *headerLen;
        uint8_t* const resultTrailer = resultData + *dataLen;
 
        SkASSERT(resultTrailer + *trailerLen == resultHeader + length);
 
        memcpy(resultHeader,  srcHeader,  *headerLen);
        memcpy(resultData,    srcData,    *dataLen);
        memcpy(resultTrailer, srcTrailer, *trailerLen);
 
        return data;
    }
 
    // A PFA has to be converted for PDF.
    size_t hexDataLen;
    if (!parsePFA((const char*)src, srcLen, headerLen, &hexDataLen, dataLen,
                 trailerLen)) {
        return nullptr;
    }
    const size_t length = *headerLen + *dataLen + *trailerLen;
    SkASSERT(length > 0);
    auto data = SkData::MakeUninitialized(length);
    uint8_t* buffer = (uint8_t*)data->writable_data();
 
    memcpy(buffer, src, *headerLen);
    uint8_t* const resultData = &(buffer[*headerLen]);
 
    const uint8_t* hexData = src + *headerLen;
    const uint8_t* trailer = hexData + hexDataLen;
    size_t outputOffset = 0;
    uint8_t dataByte = 0;  // To hush compiler.
    bool highNibble = true;
    for (; hexData < trailer; hexData++) {
        int8_t curNibble = hexToBin(*hexData);
        if (curNibble < 0) {
            continue;
        }
        if (highNibble) {
            dataByte = curNibble << 4;
            highNibble = false;
        } else {
            dataByte |= curNibble;
            highNibble = true;
            resultData[outputOffset++] = dataByte;
        }
    }
    if (!highNibble) {
        resultData[outputOffset++] = dataByte;
    }
    SkASSERT(outputOffset == *dataLen);
 
    uint8_t* const resultTrailer = &(buffer[SkToInt(*headerLen + outputOffset)]);
    memcpy(resultTrailer, src + *headerLen + hexDataLen, *trailerLen);
    return data;
}

from_font_units()

static SkScalar from_font_units ( SkScalar  scaled, uint16_t  emSize  )

inlinestatic

Definition at line 246 of file SkPDFType1Font.cpp.

                                                                         {
    return emSize == 1000 ? scaled : scaled * 1000 / emSize;
}

hexToBin()

static int8_t hexToBin ( uint8_t  c )

static

Definition at line 143 of file SkPDFType1Font.cpp.

                                  {
    if (!isxdigit(c)) {
        return -1;
    } else if (c <= '9') {
        return c - '0';
    } else if (c <= 'F') {
        return c - 'A' + 10;
    } else if (c <= 'f') {
        return c - 'a' + 10;
    }
    return -1;
}

make_type1_font_descriptor()

static SkPDFIndirectReference make_type1_font_descriptor ( SkPDFDocument *  doc, const SkTypeface *  typeface, const SkAdvancedTypefaceMetrics *  info  )

static

Definition at line 250 of file SkPDFType1Font.cpp.

                                                                                                {
    SkPDFDict descriptor("FontDescriptor");
    uint16_t emSize = SkToU16(typeface->getUnitsPerEm());
    if (info) {
        SkPDFFont::PopulateCommonFontDescriptor(&descriptor, *info, emSize, 0);
        if (can_embed(*info)) {
            int ttcIndex;
            size_t header SK_INIT_TO_AVOID_WARNING;
            size_t data SK_INIT_TO_AVOID_WARNING;
            size_t trailer SK_INIT_TO_AVOID_WARNING;
            std::unique_ptr<SkStreamAsset> rawFontData = typeface->openStream(&ttcIndex);
            sk_sp<SkData> fontData = convert_type1_font_stream(std::move(rawFontData),
                                                               &header, &data, &trailer);
            if (fontData) {
                std::unique_ptr<SkPDFDict> dict = SkPDFMakeDict();
                dict->insertInt("Length1", header);
                dict->insertInt("Length2", data);
                dict->insertInt("Length3", trailer);
                auto fontStream = SkMemoryStream::Make(std::move(fontData));
                descriptor.insertRef("FontFile",
                                     SkPDFStreamOut(std::move(dict), std::move(fontStream),
                                                    doc, SkPDFSteamCompressionEnabled::Yes));
            }
        }
    }
    return doc->emit(descriptor);
}

parsePFA()

static bool parsePFA ( const char *  src, size_t  size, size_t *  headerLen, size_t *  hexDataLen, size_t *  dataLen, size_t *  trailerLen  )

static

Definition at line 90 of file SkPDFType1Font.cpp.

                                                                              {
    const char* end = src + size;
 
    const char* dataPos = strstr(src, "eexec");
    if (!dataPos) {
        return false;
    }
    dataPos += strlen("eexec");
    while ((*dataPos == '\n' || *dataPos == '\r' || *dataPos == ' ') &&
            dataPos < end) {
        dataPos++;
    }
    *headerLen = dataPos - src;
 
    const char* trailerPos = strstr(dataPos, "cleartomark");
    if (!trailerPos) {
        return false;
    }
    int zeroCount = 0;
    for (trailerPos--; trailerPos > dataPos && zeroCount < 512; trailerPos--) {
        if (*trailerPos == '\n' || *trailerPos == '\r' || *trailerPos == ' ') {
            continue;
        } else if (*trailerPos == '0') {
            zeroCount++;
        } else {
            return false;
        }
    }
    if (zeroCount != 512) {
        return false;
    }
 
    *hexDataLen = trailerPos - src - *headerLen;
    *trailerLen = size - *headerLen - *hexDataLen;
 
    // Verify that the data section is hex encoded and count the bytes.
    int nibbles = 0;
    for (; dataPos < trailerPos; dataPos++) {
        if (isspace(*dataPos)) {
            continue;
        }
        // isxdigit() is locale-sensitive https://bugs.skia.org/8285
        if (nullptr == strchr("0123456789abcdefABCDEF", *dataPos)) {
            return false;
        }
        nibbles++;
    }
    *dataLen = (nibbles + 1) / 2;
 
    return true;
}

parsePFB()

static bool parsePFB ( const uint8_t *  src, size_t  size, size_t *  headerLen, size_t *  dataLen, size_t *  trailerLen  )

static

Definition at line 71 of file SkPDFType1Font.cpp.

                                                          {
    const uint8_t* srcPtr = src;
    size_t remaining = size;
 
    return parsePFBSection(&srcPtr, &remaining, 1, headerLen) &&
           parsePFBSection(&srcPtr, &remaining, 2, dataLen) &&
           parsePFBSection(&srcPtr, &remaining, 1, trailerLen) &&
           parsePFBSection(&srcPtr, &remaining, 3, nullptr);
}

parsePFBSection()

static bool parsePFBSection ( const uint8_t **  src, size_t *  len, int  sectionType, size_t *  size  )

static

Definition at line 45 of file SkPDFType1Font.cpp.

                                          {
    // PFB sections have a two or six bytes header. 0x80 and a one byte
    // section type followed by a four byte section length.  Type one is
    // an ASCII section (includes a length), type two is a binary section
    // (includes a length) and type three is an EOF marker with no length.
    const uint8_t* buf = *src;
    if (*len < 2 || buf[0] != 0x80 || buf[1] != sectionType) {
        return false;
    } else if (buf[1] == 3) {
        return true;
    } else if (*len < 6) {
        return false;
    }
 
    *size = (size_t)buf[2] | ((size_t)buf[3] << 8) | ((size_t)buf[4] << 16) |
            ((size_t)buf[5] << 24);
    size_t consumed = *size + 6;
    if (consumed > *len) {
        return false;
    }
    *src = *src + consumed;
    *len = *len - consumed;
    return true;
}

SkPDFEmitType1Font()

void SkPDFEmitType1Font	(	const SkPDFFont &	pdfFont,
		SkPDFDocument *	doc
	)

Definition at line 307 of file SkPDFType1Font.cpp.

                                                                      {
    SkTypeface* typeface = pdfFont.typeface();
    const std::vector<SkString>& glyphNames = type_1_glyphnames(doc, typeface);
    SkGlyphID firstGlyphID = pdfFont.firstGlyphID();
    SkGlyphID lastGlyphID = pdfFont.lastGlyphID();
 
    SkPDFDict font("Font");
    font.insertRef("FontDescriptor", type1_font_descriptor(doc, typeface));
    font.insertName("Subtype", "Type1");
    if (const SkAdvancedTypefaceMetrics* info = SkPDFFont::GetMetrics(typeface, doc)) {
        font.insertName("BaseFont", info->fPostScriptName);
    }
 
    // glyphCount not including glyph 0
    unsigned glyphCount = 1 + lastGlyphID - firstGlyphID;
    SkASSERT(glyphCount > 0 && glyphCount <= 255);
    font.insertInt("FirstChar", (size_t)0);
    font.insertInt("LastChar", (size_t)glyphCount);
    {
        int emSize;
        auto widths = SkPDFMakeArray();
 
        int glyphRangeSize = lastGlyphID - firstGlyphID + 2;
        AutoTArray<SkGlyphID> glyphIDs{glyphRangeSize};
        glyphIDs[0] = 0;
        for (unsigned gId = firstGlyphID; gId <= lastGlyphID; gId++) {
            glyphIDs[gId - firstGlyphID + 1] = gId;
        }
        SkStrikeSpec strikeSpec = SkStrikeSpec::MakePDFVector(*typeface, &emSize);
        SkBulkGlyphMetrics metrics{strikeSpec};
        auto glyphs = metrics.glyphs(SkSpan(glyphIDs.get(), glyphRangeSize));
        for (int i = 0; i < glyphRangeSize; ++i) {
            widths->appendScalar(from_font_units(glyphs[i]->advanceX(), SkToU16(emSize)));
        }
        font.insertObject("Widths", std::move(widths));
    }
    auto encDiffs = SkPDFMakeArray();
    encDiffs->reserve(lastGlyphID - firstGlyphID + 3);
    encDiffs->appendInt(0);
 
    SkASSERT(glyphNames.size() > lastGlyphID);
    const SkString unknown("UNKNOWN");
    encDiffs->appendName(glyphNames[0].isEmpty() ? unknown : glyphNames[0]);
    for (int gID = firstGlyphID; gID <= lastGlyphID; gID++) {
        encDiffs->appendName(glyphNames[gID].isEmpty() ? unknown : glyphNames[gID]);
    }
 
    auto encoding = SkPDFMakeDict("Encoding");
    encoding->insertObject("Differences", std::move(encDiffs));
    font.insertObject("Encoding", std::move(encoding));
 
    doc->emit(font, pdfFont.indirectReference());
}

type1_font_descriptor()

static SkPDFIndirectReference type1_font_descriptor ( SkPDFDocument *  doc, const SkTypeface *  typeface  )

static

Definition at line 294 of file SkPDFType1Font.cpp.

                                                                                {
    SkTypefaceID typefaceID = typeface->uniqueID();
    if (SkPDFIndirectReference* ptr = doc->fFontDescriptors.find(typefaceID)) {
        return *ptr;
    }
    const SkAdvancedTypefaceMetrics* info = SkPDFFont::GetMetrics(typeface, doc);
    auto fontDescriptor = make_type1_font_descriptor(doc, typeface, info);
    doc->fFontDescriptors.set(typefaceID, fontDescriptor);
    return fontDescriptor;
}

type_1_glyphnames()

static const std::vector< SkString > & type_1_glyphnames ( SkPDFDocument *  canon, const SkTypeface *  typeface  )

static

Definition at line 281 of file SkPDFType1Font.cpp.

                                                                                  {
    SkTypefaceID typefaceID = typeface->uniqueID();
    const std::vector<SkString>* glyphNames = canon->fType1GlyphNames.find(typefaceID);
    if (!glyphNames) {
        std::vector<SkString> names(typeface->countGlyphs());
        SkPDFFont::GetType1GlyphNames(*typeface, names.data());
        glyphNames = canon->fType1GlyphNames.set(typefaceID, std::move(names));
    }
    SkASSERT(glyphNames);
    return *glyphNames;
}