/*
* Copyright (C) 2011 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <ctype.h>
#include "SkFontHost.h"
#include "SkGlyphCache.h"
#include "SkPaint.h"
#include "SkPDFDevice.h"
#include "SkPDFFont.h"
#include "SkPDFStream.h"
#include "SkPDFTypes.h"
#include "SkPDFUtils.h"
#include "SkRefCnt.h"
#include "SkScalar.h"
#include "SkStream.h"
#include "SkTypeface.h"
#include "SkTypes.h"
#include "SkUtils.h"
namespace {
bool parsePFBSection(const uint8_t** src, size_t* len, int sectionType,
size_t* size) {
// 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;
if (buf[1] == 3)
return true;
if (*len < 6)
return false;
*size = buf[2] | (buf[3] << 8) | (buf[4] << 16) | (buf[5] << 24);
size_t consumed = *size + 6;
if (consumed > *len)
return false;
*src = *src + consumed;
*len = *len - consumed;
return true;
}
bool parsePFB(const uint8_t* src, size_t size, size_t* headerLen,
size_t* dataLen, size_t* trailerLen) {
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, NULL);
}
/* The sections of a PFA file are implicitly defined. The body starts
* after the line containing "eexec," and the trailer starts with 512
* literal 0's followed by "cleartomark" (plus arbitrary white space).
*
* This function assumes that src is NUL terminated, but the NUL
* termination is not included in size.
*
*/
bool parsePFA(const char* src, size_t size, size_t* headerLen,
size_t* hexDataLen, size_t* dataLen, size_t* trailerLen) {
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;
if (!isxdigit(*dataPos))
return false;
nibbles++;
}
*dataLen = (nibbles + 1) / 2;
return true;
}
int8_t hexToBin(uint8_t c) {
if (!isxdigit(c))
return -1;
if (c <= '9') return c - '0';
if (c <= 'F') return c - 'A' + 10;
if (c <= 'f') return c - 'a' + 10;
return -1;
}
SkStream* handleType1Stream(SkStream* srcStream, size_t* headerLen,
size_t* dataLen, size_t* trailerLen) {
// srcStream may be backed by a file or a unseekable fd, so we may not be
// able to use skip(), rewind(), or getMemoryBase(). read()ing through
// the input only once is doable, but very ugly. Furthermore, it'd be nice
// if the data was NUL terminated so that we can use strstr() to search it.
// Make as few copies as possible given these constraints.
SkDynamicMemoryWStream dynamicStream;
SkRefPtr<SkMemoryStream> staticStream;
const uint8_t* src;
size_t srcLen;
if ((srcLen = srcStream->getLength()) > 0) {
staticStream = new SkMemoryStream(srcLen + 1);
staticStream->unref(); // new and SkRefPtr both took a ref.
src = (const uint8_t*)staticStream->getMemoryBase();
if (srcStream->getMemoryBase() != NULL) {
memcpy((void *)src, srcStream->getMemoryBase(), srcLen);
} else {
size_t read = 0;
while (read < srcLen) {
size_t got = srcStream->read((void *)staticStream->getAtPos(),
srcLen - read);
if (got == 0)
return NULL;
read += got;
staticStream->seek(read);
}
}
((uint8_t *)src)[srcLen] = 0;
} else {
static const size_t bufSize = 4096;
uint8_t buf[bufSize];
size_t amount;
while ((amount = srcStream->read(buf, bufSize)) > 0)
dynamicStream.write(buf, amount);
amount = 0;
dynamicStream.write(&amount, 1); // NULL terminator.
// getStream makes another copy, but we couldn't do any better.
src = (const uint8_t*)dynamicStream.getStream();
srcLen = dynamicStream.getOffset() - 1;
}
if (parsePFB(src, srcLen, headerLen, dataLen, trailerLen)) {
SkMemoryStream* result =
new SkMemoryStream(*headerLen + *dataLen + *trailerLen);
memcpy((char*)result->getAtPos(), src + 6, *headerLen);
result->seek(*headerLen);
memcpy((char*)result->getAtPos(), src + 6 + *headerLen + 6, *dataLen);
result->seek(*headerLen + *dataLen);
memcpy((char*)result->getAtPos(), src + 6 + *headerLen + 6 + *dataLen,
*trailerLen);
result->rewind();
return result;
}
// A PFA has to be converted for PDF.
size_t hexDataLen;
if (parsePFA((const char*)src, srcLen, headerLen, &hexDataLen, dataLen,
trailerLen)) {
SkMemoryStream* result =
new SkMemoryStream(*headerLen + *dataLen + *trailerLen);
memcpy((char*)result->getAtPos(), src, *headerLen);
result->seek(*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++) {
char curNibble = hexToBin(*hexData);
if (curNibble < 0)
continue;
if (highNibble) {
dataByte = curNibble << 4;
highNibble = false;
} else {
dataByte |= curNibble;
highNibble = true;
((char *)result->getAtPos())[outputOffset++] = dataByte;
}
}
if (!highNibble)
((char *)result->getAtPos())[outputOffset++] = dataByte;
SkASSERT(outputOffset == *dataLen);
result->seek(*headerLen + outputOffset);
memcpy((char *)result->getAtPos(), src + *headerLen + hexDataLen,
*trailerLen);
result->rewind();
return result;
}
return NULL;
}
// scale from em-units to base-1000, returning as a SkScalar
SkScalar scaleFromFontUnits(int16_t val, uint16_t emSize) {
SkScalar scaled = SkIntToScalar(val);
if (emSize == 1000) {
return scaled;
} else {
return SkScalarMulDiv(scaled, 1000, emSize);
}
}
void setGlyphWidthAndBoundingBox(SkScalar width, SkIRect box,
SkWStream* content) {
// Specify width and bounding box for the glyph.
SkPDFScalar::Append(width, content);
content->writeText(" 0 ");
content->writeDecAsText(box.fLeft);
content->writeText(" ");
content->writeDecAsText(box.fTop);
content->writeText(" ");
content->writeDecAsText(box.fRight);
content->writeText(" ");
content->writeDecAsText(box.fBottom);
content->writeText(" d1\n");
}
SkPDFArray* makeFontBBox(SkIRect glyphBBox, uint16_t emSize) {
SkPDFArray* bbox = new SkPDFArray;
bbox->reserve(4);
bbox->append(new SkPDFScalar(scaleFromFontUnits(glyphBBox.fLeft,
emSize)))->unref();
bbox->append(new SkPDFScalar(scaleFromFontUnits(glyphBBox.fBottom,
emSize)))->unref();
bbox->append(new SkPDFScalar(scaleFromFontUnits(glyphBBox.fRight,
emSize)))->unref();
bbox->append(new SkPDFScalar(scaleFromFontUnits(glyphBBox.fTop,
emSize)))->unref();
return bbox;
}
SkPDFArray* appendWidth(const int16_t& width, uint16_t emSize,
SkPDFArray* array) {
array->append(new SkPDFScalar(scaleFromFontUnits(width, emSize)))->unref();
return array;
}
SkPDFArray* appendVerticalAdvance(
const SkAdvancedTypefaceMetrics::VerticalMetric& advance,
uint16_t emSize, SkPDFArray* array) {
appendWidth(advance.fVerticalAdvance, emSize, array);
appendWidth(advance.fOriginXDisp, emSize, array);
appendWidth(advance.fOriginYDisp, emSize, array);
return array;
}
template <typename Data>
SkPDFArray* composeAdvanceData(
SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* advanceInfo,
uint16_t emSize,
SkPDFArray* (*appendAdvance)(const Data& advance, uint16_t emSize,
SkPDFArray* array),
Data* defaultAdvance) {
SkPDFArray* result = new SkPDFArray();
for (; advanceInfo != NULL; advanceInfo = advanceInfo->fNext.get()) {
switch (advanceInfo->fType) {
case SkAdvancedTypefaceMetrics::WidthRange::kDefault: {
SkASSERT(advanceInfo->fAdvance.count() == 1);
*defaultAdvance = advanceInfo->fAdvance[0];
break;
}
case SkAdvancedTypefaceMetrics::WidthRange::kRange: {
SkRefPtr<SkPDFArray> advanceArray = new SkPDFArray();
advanceArray->unref(); // SkRefPtr and new both took a ref.
for (int j = 0; j < advanceInfo->fAdvance.count(); j++)
appendAdvance(advanceInfo->fAdvance[j], emSize,
advanceArray.get());
result->append(new SkPDFInt(advanceInfo->fStartId))->unref();
result->append(advanceArray.get());
break;
}
case SkAdvancedTypefaceMetrics::WidthRange::kRun: {
SkASSERT(advanceInfo->fAdvance.count() == 1);
result->append(new SkPDFInt(advanceInfo->fStartId))->unref();
result->append(new SkPDFInt(advanceInfo->fEndId))->unref();
appendAdvance(advanceInfo->fAdvance[0], emSize, result);
break;
}
}
}
return result;
}
} // namespace
static void append_tounicode_header(SkDynamicMemoryWStream* cmap) {
// 12 dict begin: 12 is an Adobe-suggested value. Shall not change.
// It's there to prevent old version Adobe Readers from malfunctioning.
const char* kHeader =
"/CIDInit /ProcSet findresource begin\n"
"12 dict begin\n"
"begincmap\n";
cmap->writeText(kHeader);
// The /CIDSystemInfo must be consistent to the one in
// SkPDFFont::populateCIDFont().
// We can not pass over the system info object here because the format is
// different. This is not a reference object.
const char* kSysInfo =
"/CIDSystemInfo\n"
"<< /Registry (Adobe)\n"
"/Ordering (UCS)\n"
"/Supplement 0\n"
">> def\n";
cmap->writeText(kSysInfo);
// The CMapName must be consistent to /CIDSystemInfo above.
// /CMapType 2 means ToUnicode.
// We specify codespacerange from 0x0000 to 0xFFFF because we convert our
// code table from unsigned short (16-bits). Codespace range just tells the
// PDF processor the valid range. It does not matter whether a complete
// mapping is provided or not.
const char* kTypeInfo =
"/CMapName /Adobe-Identity-UCS def\n"
"/CMapType 2 def\n"
"1 begincodespacerange\n"
"<0000> <FFFF>\n"
"endcodespacerange\n";
cmap->writeText(kTypeInfo);
}
static void append_cmap_bfchar_table(uint16_t* glyph_id, SkUnichar* unicode,
size_t count,
SkDynamicMemoryWStream* cmap) {
cmap->writeDecAsText(count);
cmap->writeText(" beginbfchar\n");
for (size_t i = 0; i < count; ++i) {
cmap->writeText("<");
cmap->writeHexAsText(glyph_id[i], 4);
cmap->writeText("> <");
cmap->writeHexAsText(unicode[i], 4);
cmap->writeText(">\n");
}
cmap->writeText("endbfchar\n");
}
static void append_cmap_footer(SkDynamicMemoryWStream* cmap) {
const char* kFooter =
"endcmap\n"
"CMapName currentdict /CMap defineresource pop\n"
"end\n"
"end";
cmap->writeText(kFooter);
}
// Generate <bfchar> table according to PDF spec 1.4 and Adobe Technote 5014.
static void append_cmap_bfchar_sections(
const SkTDArray<SkUnichar>& glyphUnicode,
SkDynamicMemoryWStream* cmap) {
// PDF spec defines that every bf* list can have at most 100 entries.
const size_t kMaxEntries = 100;
uint16_t glyphId[kMaxEntries];
SkUnichar unicode[kMaxEntries];
size_t index = 0;
for (int i = 0; i < glyphUnicode.count(); i++) {
if (glyphUnicode[i]) {
glyphId[index] = i;
unicode[index] = glyphUnicode[i];
++index;
}
if (index == kMaxEntries) {
append_cmap_bfchar_table(glyphId, unicode, index, cmap);
index = 0;
}
}
if (index) {
append_cmap_bfchar_table(glyphId, unicode, index, cmap);
}
}
/* Font subset design: It would be nice to be able to subset fonts
* (particularly type 3 fonts), but it's a lot of work and not a priority.
*
* Resources are canonicalized and uniqueified by pointer so there has to be
* some additional state indicating which subset of the font is used. It
* must be maintained at the page granularity and then combined at the document
* granularity. a) change SkPDFFont to fill in its state on demand, kind of
* like SkPDFGraphicState. b) maintain a per font glyph usage class in each
* page/pdf device. c) in the document, retrieve the per font glyph usage
* from each page and combine it and ask for a resource with that subset.
*/
SkPDFFont::~SkPDFFont() {
SkAutoMutexAcquire lock(canonicalFontsMutex());
int index;
if (find(SkTypeface::UniqueID(fTypeface.get()), fFirstGlyphID, &index)) {
canonicalFonts().removeShuffle(index);
#ifdef SK_DEBUG
SkASSERT(!fDescendant);
} else {
SkASSERT(fDescendant);
#endif
}
fResources.unrefAll();
}
void SkPDFFont::getResources(SkTDArray<SkPDFObject*>* resourceList) {
resourceList->setReserve(resourceList->count() + fResources.count());
for (int i = 0; i < fResources.count(); i++) {
resourceList->push(fResources[i]);
fResources[i]->ref();
fResources[i]->getResources(resourceList);
}
}
SkTypeface* SkPDFFont::typeface() {
return fTypeface.get();
}
SkAdvancedTypefaceMetrics::FontType SkPDFFont::getType() {
return fType;
}
bool SkPDFFont::hasGlyph(uint16_t id) {
return (id >= fFirstGlyphID && id <= fLastGlyphID) || id == 0;
}
bool SkPDFFont::multiByteGlyphs() {
return fMultiByteGlyphs;
}
size_t SkPDFFont::glyphsToPDFFontEncoding(uint16_t* glyphIDs,
size_t numGlyphs) {
// A font with multibyte glyphs will support all glyph IDs in a single font.
if (fMultiByteGlyphs) {
return numGlyphs;
}
for (size_t i = 0; i < numGlyphs; i++) {
if (glyphIDs[i] == 0) {
continue;
}
if (glyphIDs[i] < fFirstGlyphID || glyphIDs[i] > fLastGlyphID) {
return i;
}
glyphIDs[i] -= (fFirstGlyphID - 1);
}
return numGlyphs;
}
// static
SkPDFFont* SkPDFFont::getFontResource(SkTypeface* typeface, uint16_t glyphID) {
SkAutoMutexAcquire lock(canonicalFontsMutex());
const uint32_t fontID = SkTypeface::UniqueID(typeface);
int index;
if (find(fontID, glyphID, &index)) {
canonicalFonts()[index].fFont->ref();
return canonicalFonts()[index].fFont;
}
SkRefPtr<SkAdvancedTypefaceMetrics> fontInfo;
SkPDFDict* fontDescriptor = NULL;
if (index >= 0) {
SkPDFFont* relatedFont = canonicalFonts()[index].fFont;
SkASSERT(relatedFont->fFontInfo.get());
fontInfo = relatedFont->fFontInfo;
fontDescriptor = relatedFont->fDescriptor.get();
} else {
SkAdvancedTypefaceMetrics::PerGlyphInfo info;
info = SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo;
info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
info, SkAdvancedTypefaceMetrics::kGlyphNames_PerGlyphInfo);
info = SkTBitOr<SkAdvancedTypefaceMetrics::PerGlyphInfo>(
info, SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo);
fontInfo = SkFontHost::GetAdvancedTypefaceMetrics(fontID, info);
SkSafeUnref(fontInfo.get()); // SkRefPtr and Get both took a reference.
}
SkPDFFont* font = new SkPDFFont(fontInfo.get(), typeface, glyphID, false,
fontDescriptor);
FontRec newEntry(font, fontID, font->fFirstGlyphID);
index = canonicalFonts().count();
canonicalFonts().push(newEntry);
return font; // Return the reference new SkPDFFont() created.
}
// static
SkTDArray<SkPDFFont::FontRec>& SkPDFFont::canonicalFonts() {
// This initialization is only thread safe with gcc.
static SkTDArray<FontRec> gCanonicalFonts;
return gCanonicalFonts;
}
// static
SkMutex& SkPDFFont::canonicalFontsMutex() {
// This initialization is only thread safe with gcc.
static SkMutex gCanonicalFontsMutex;
return gCanonicalFontsMutex;
}
// static
bool SkPDFFont::find(uint32_t fontID, uint16_t glyphID, int* index) {
// TODO(vandebo) optimize this, do only one search?
FontRec search(NULL, fontID, glyphID);
*index = canonicalFonts().find(search);
if (*index >= 0)
return true;
search.fGlyphID = 0;
*index = canonicalFonts().find(search);
return false;
}
SkPDFFont::SkPDFFont(class SkAdvancedTypefaceMetrics* fontInfo,
SkTypeface* typeface,
uint16_t glyphID,
bool descendantFont,
SkPDFDict* fontDescriptor)
: SkPDFDict("Font"),
fTypeface(typeface),
fType(fontInfo ? fontInfo->fType :
SkAdvancedTypefaceMetrics::kNotEmbeddable_Font),
#ifdef SK_DEBUG
fDescendant(descendantFont),
#endif
fMultiByteGlyphs(false),
fFirstGlyphID(1),
fLastGlyphID(fontInfo ? fontInfo->fLastGlyphID : 0),
fFontInfo(fontInfo),
fDescriptor(fontDescriptor) {
if (fontInfo && fontInfo->fMultiMaster) {
NOT_IMPLEMENTED(true, true);
fType = SkAdvancedTypefaceMetrics::kOther_Font;
}
if (fType == SkAdvancedTypefaceMetrics::kType1CID_Font ||
fType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
if (descendantFont) {
populateCIDFont();
} else {
populateType0Font();
}
// No need to hold onto the font info for fonts types that
// support multibyte glyphs.
fFontInfo = NULL;
return;
}
if (fType == SkAdvancedTypefaceMetrics::kType1_Font &&
populateType1Font(glyphID)) {
return;
}
SkASSERT(fType == SkAdvancedTypefaceMetrics::kType1_Font ||
fType == SkAdvancedTypefaceMetrics::kCFF_Font ||
fType == SkAdvancedTypefaceMetrics::kOther_Font ||
fType == SkAdvancedTypefaceMetrics::kNotEmbeddable_Font);
populateType3Font(glyphID);
}
void SkPDFFont::populateType0Font() {
fMultiByteGlyphs = true;
insert("Subtype", new SkPDFName("Type0"))->unref();
insert("BaseFont", new SkPDFName(fFontInfo->fFontName))->unref();
insert("Encoding", new SkPDFName("Identity-H"))->unref();
SkRefPtr<SkPDFArray> descendantFonts = new SkPDFArray();
descendantFonts->unref(); // SkRefPtr and new took a reference.
// Pass ref new created to fResources.
fResources.push(
new SkPDFFont(fFontInfo.get(), fTypeface.get(), 1, true, NULL));
descendantFonts->append(new SkPDFObjRef(fResources.top()))->unref();
insert("DescendantFonts", descendantFonts.get());
populateToUnicodeTable();
}
void SkPDFFont::populateToUnicodeTable() {
if (fFontInfo.get() == NULL ||
fFontInfo->fGlyphToUnicode.begin() == NULL) {
return;
}
SkDynamicMemoryWStream cmap;
append_tounicode_header(&cmap);
append_cmap_bfchar_sections(fFontInfo->fGlyphToUnicode, &cmap);
append_cmap_footer(&cmap);
SkRefPtr<SkMemoryStream> cmapStream = new SkMemoryStream();
cmapStream->unref(); // SkRefPtr and new took a reference.
cmapStream->setMemoryOwned(cmap.detach(), cmap.getOffset());
SkRefPtr<SkPDFStream> pdfCmap = new SkPDFStream(cmapStream.get());
fResources.push(pdfCmap.get()); // Pass reference from new.
insert("ToUnicode", new SkPDFObjRef(pdfCmap.get()))->unref();
}
void SkPDFFont::populateCIDFont() {
fMultiByteGlyphs = true;
insert("BaseFont", new SkPDFName(fFontInfo->fFontName))->unref();
if (fFontInfo->fType == SkAdvancedTypefaceMetrics::kType1CID_Font) {
insert("Subtype", new SkPDFName("CIDFontType0"))->unref();
} else if (fFontInfo->fType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
insert("Subtype", new SkPDFName("CIDFontType2"))->unref();
insert("CIDToGIDMap", new SkPDFName("Identity"))->unref();
} else {
SkASSERT(false);
}
SkRefPtr<SkPDFDict> sysInfo = new SkPDFDict;
sysInfo->unref(); // SkRefPtr and new both took a reference.
sysInfo->insert("Registry", new SkPDFString("Adobe"))->unref();
sysInfo->insert("Ordering", new SkPDFString("Identity"))->unref();
sysInfo->insert("Supplement", new SkPDFInt(0))->unref();
insert("CIDSystemInfo", sysInfo.get());
addFontDescriptor(0);
if (fFontInfo->fGlyphWidths.get()) {
int16_t defaultWidth = 0;
SkRefPtr<SkPDFArray> widths =
composeAdvanceData(fFontInfo->fGlyphWidths.get(),
fFontInfo->fEmSize, &appendWidth, &defaultWidth);
widths->unref(); // SkRefPtr and compose both took a reference.
if (widths->size())
insert("W", widths.get());
if (defaultWidth != 0) {
insert("DW", new SkPDFScalar(scaleFromFontUnits(
defaultWidth, fFontInfo->fEmSize)))->unref();
}
}
if (fFontInfo->fVerticalMetrics.get()) {
struct SkAdvancedTypefaceMetrics::VerticalMetric defaultAdvance;
defaultAdvance.fVerticalAdvance = 0;
defaultAdvance.fOriginXDisp = 0;
defaultAdvance.fOriginYDisp = 0;
SkRefPtr<SkPDFArray> advances =
composeAdvanceData(fFontInfo->fVerticalMetrics.get(),
fFontInfo->fEmSize, &appendVerticalAdvance,
&defaultAdvance);
advances->unref(); // SkRefPtr and compose both took a ref.
if (advances->size())
insert("W2", advances.get());
if (defaultAdvance.fVerticalAdvance ||
defaultAdvance.fOriginXDisp ||
defaultAdvance.fOriginYDisp) {
insert("DW2", appendVerticalAdvance(defaultAdvance,
fFontInfo->fEmSize,
new SkPDFArray))->unref();
}
}
}
bool SkPDFFont::populateType1Font(int16_t glyphID) {
SkASSERT(!fFontInfo->fVerticalMetrics.get());
SkASSERT(fFontInfo->fGlyphWidths.get());
adjustGlyphRangeForSingleByteEncoding(glyphID);
int16_t defaultWidth = 0;
const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry = NULL;
const SkAdvancedTypefaceMetrics::WidthRange* widthEntry;
for (widthEntry = fFontInfo.get()->fGlyphWidths.get();
widthEntry != NULL;
widthEntry = widthEntry->fNext.get()) {
switch (widthEntry->fType) {
case SkAdvancedTypefaceMetrics::WidthRange::kDefault:
defaultWidth = widthEntry->fAdvance[0];
break;
case SkAdvancedTypefaceMetrics::WidthRange::kRun:
SkASSERT(false);
break;
case SkAdvancedTypefaceMetrics::WidthRange::kRange:
SkASSERT(widthRangeEntry == NULL);
widthRangeEntry = widthEntry;
break;
}
}
if (!addFontDescriptor(defaultWidth))
return false;
insert("Subtype", new SkPDFName("Type1"))->unref();
insert("BaseFont", new SkPDFName(fFontInfo->fFontName))->unref();
addWidthInfoFromRange(defaultWidth, widthRangeEntry);
SkRefPtr<SkPDFDict> encoding = new SkPDFDict("Encoding");
encoding->unref(); // SkRefPtr and new both took a reference.
insert("Encoding", encoding.get());
SkRefPtr<SkPDFArray> encDiffs = new SkPDFArray;
encDiffs->unref(); // SkRefPtr and new both took a reference.
encoding->insert("Differences", encDiffs.get());
encDiffs->reserve(fLastGlyphID - fFirstGlyphID + 2);
encDiffs->append(new SkPDFInt(1))->unref();
for (int gID = fFirstGlyphID; gID <= fLastGlyphID; gID++) {
encDiffs->append(
new SkPDFName(fFontInfo->fGlyphNames->get()[gID]))->unref();
}
if (fFontInfo->fLastGlyphID <= 255)
fFontInfo = NULL;
return true;
}
void SkPDFFont::populateType3Font(int16_t glyphID) {
SkPaint paint;
paint.setTypeface(fTypeface.get());
paint.setTextSize(1000);
SkAutoGlyphCache autoCache(paint, NULL);
SkGlyphCache* cache = autoCache.getCache();
// If fLastGlyphID isn't set (because there is not fFontInfo), look it up.
if (fLastGlyphID == 0) {
fLastGlyphID = cache->getGlyphCount() - 1;
}
adjustGlyphRangeForSingleByteEncoding(glyphID);
insert("Subtype", new SkPDFName("Type3"))->unref();
// Flip about the x-axis and scale by 1/1000.
SkMatrix fontMatrix;
fontMatrix.setScale(SkScalarInvert(1000), -SkScalarInvert(1000));
insert("FontMatrix", SkPDFUtils::MatrixToArray(fontMatrix))->unref();
SkRefPtr<SkPDFDict> charProcs = new SkPDFDict;
charProcs->unref(); // SkRefPtr and new both took a reference.
insert("CharProcs", charProcs.get());
SkRefPtr<SkPDFDict> encoding = new SkPDFDict("Encoding");
encoding->unref(); // SkRefPtr and new both took a reference.
insert("Encoding", encoding.get());
SkRefPtr<SkPDFArray> encDiffs = new SkPDFArray;
encDiffs->unref(); // SkRefPtr and new both took a reference.
encoding->insert("Differences", encDiffs.get());
encDiffs->reserve(fLastGlyphID - fFirstGlyphID + 2);
encDiffs->append(new SkPDFInt(1))->unref();
SkRefPtr<SkPDFArray> widthArray = new SkPDFArray();
widthArray->unref(); // SkRefPtr and new both took a ref.
SkIRect bbox = SkIRect::MakeEmpty();
for (int gID = fFirstGlyphID; gID <= fLastGlyphID; gID++) {
SkString characterName;
characterName.printf("gid%d", gID);
encDiffs->append(new SkPDFName(characterName))->unref();
const SkGlyph& glyph = cache->getGlyphIDMetrics(gID);
widthArray->append(new SkPDFScalar(SkFixedToScalar(glyph.fAdvanceX)))->unref();
SkIRect glyphBBox = SkIRect::MakeXYWH(glyph.fLeft, glyph.fTop,
glyph.fWidth, glyph.fHeight);
bbox.join(glyphBBox);
SkDynamicMemoryWStream content;
setGlyphWidthAndBoundingBox(SkFixedToScalar(glyph.fAdvanceX), glyphBBox,
&content);
const SkPath* path = cache->findPath(glyph);
if (path) {
SkPDFUtils::EmitPath(*path, &content);
SkPDFUtils::PaintPath(paint.getStyle(), path->getFillType(),
&content);
}
SkRefPtr<SkMemoryStream> glyphStream = new SkMemoryStream();
glyphStream->unref(); // SkRefPtr and new both took a ref.
glyphStream->setMemoryOwned(content.detach(), content.getOffset());
SkRefPtr<SkPDFStream> glyphDescription =
new SkPDFStream(glyphStream.get());
// SkRefPtr and new both ref()'d charProcs, pass one.
fResources.push(glyphDescription.get());
charProcs->insert(characterName.c_str(),
new SkPDFObjRef(glyphDescription.get()))->unref();
}
insert("FontBBox", makeFontBBox(bbox, 1000))->unref();
insert("FirstChar", new SkPDFInt(fFirstGlyphID))->unref();
insert("LastChar", new SkPDFInt(fLastGlyphID))->unref();
insert("Widths", widthArray.get());
insert("CIDToGIDMap", new SkPDFName("Identity"))->unref();
if (fFontInfo && fFontInfo->fLastGlyphID <= 255)
fFontInfo = NULL;
populateToUnicodeTable();
}
bool SkPDFFont::addFontDescriptor(int16_t defaultWidth) {
if (fDescriptor.get() != NULL) {
fResources.push(fDescriptor.get());
fDescriptor->ref();
insert("FontDescriptor", new SkPDFObjRef(fDescriptor.get()))->unref();
return true;
}
fDescriptor = new SkPDFDict("FontDescriptor");
fDescriptor->unref(); // SkRefPtr and new both took a ref.
switch (fFontInfo->fType) {
case SkAdvancedTypefaceMetrics::kType1_Font: {
size_t header SK_INIT_TO_AVOID_WARNING;
size_t data SK_INIT_TO_AVOID_WARNING;
size_t trailer SK_INIT_TO_AVOID_WARNING;
SkRefPtr<SkStream> rawFontData =
SkFontHost::OpenStream(SkTypeface::UniqueID(fTypeface.get()));
rawFontData->unref(); // SkRefPtr and OpenStream both took a ref.
SkStream* fontData = handleType1Stream(rawFontData.get(), &header,
&data, &trailer);
if (fontData == NULL)
return false;
SkRefPtr<SkPDFStream> fontStream = new SkPDFStream(fontData);
// SkRefPtr and new both ref()'d fontStream, pass one.
fResources.push(fontStream.get());
fontStream->insert("Length1", new SkPDFInt(header))->unref();
fontStream->insert("Length2", new SkPDFInt(data))->unref();
fontStream->insert("Length3", new SkPDFInt(trailer))->unref();
fDescriptor->insert("FontFile",
new SkPDFObjRef(fontStream.get()))->unref();
break;
}
case SkAdvancedTypefaceMetrics::kTrueType_Font: {
SkRefPtr<SkStream> fontData =
SkFontHost::OpenStream(SkTypeface::UniqueID(fTypeface.get()));
fontData->unref(); // SkRefPtr and OpenStream both took a ref.
SkRefPtr<SkPDFStream> fontStream = new SkPDFStream(fontData.get());
// SkRefPtr and new both ref()'d fontStream, pass one.
fResources.push(fontStream.get());
fontStream->insert("Length1",
new SkPDFInt(fontData->getLength()))->unref();
fDescriptor->insert("FontFile2",
new SkPDFObjRef(fontStream.get()))->unref();
break;
}
case SkAdvancedTypefaceMetrics::kCFF_Font:
case SkAdvancedTypefaceMetrics::kType1CID_Font: {
SkRefPtr<SkStream> fontData =
SkFontHost::OpenStream(SkTypeface::UniqueID(fTypeface.get()));
fontData->unref(); // SkRefPtr and OpenStream both took a ref.
SkRefPtr<SkPDFStream> fontStream = new SkPDFStream(fontData.get());
// SkRefPtr and new both ref()'d fontStream, pass one.
fResources.push(fontStream.get());
if (fFontInfo->fType == SkAdvancedTypefaceMetrics::kCFF_Font) {
fontStream->insert("Subtype", new SkPDFName("Type1C"))->unref();
} else {
fontStream->insert("Subtype",
new SkPDFName("CIDFontType0c"))->unref();
}
fDescriptor->insert("FontFile3",
new SkPDFObjRef(fontStream.get()))->unref();
break;
}
default:
SkASSERT(false);
}
const uint16_t emSize = fFontInfo->fEmSize;
fResources.push(fDescriptor.get());
fDescriptor->ref();
insert("FontDescriptor", new SkPDFObjRef(fDescriptor.get()))->unref();
fDescriptor->insert("FontName", new SkPDFName(
fFontInfo->fFontName))->unref();
fDescriptor->insert("Flags", new SkPDFInt(fFontInfo->fStyle))->unref();
fDescriptor->insert("Ascent", new SkPDFScalar(
scaleFromFontUnits(fFontInfo->fAscent, emSize)))->unref();
fDescriptor->insert("Descent", new SkPDFScalar(
scaleFromFontUnits(fFontInfo->fDescent, emSize)))->unref();
fDescriptor->insert("StemV", new SkPDFScalar(
scaleFromFontUnits(fFontInfo->fStemV, emSize)))->unref();
fDescriptor->insert("CapHeight", new SkPDFScalar(
scaleFromFontUnits(fFontInfo->fCapHeight, emSize)))->unref();
fDescriptor->insert("ItalicAngle", new SkPDFInt(
fFontInfo->fItalicAngle))->unref();
fDescriptor->insert("FontBBox", makeFontBBox(fFontInfo->fBBox,
fFontInfo->fEmSize))->unref();
if (defaultWidth > 0) {
fDescriptor->insert("MissingWidth", new SkPDFScalar(
scaleFromFontUnits(defaultWidth, emSize)))->unref();
}
return true;
}
void SkPDFFont::addWidthInfoFromRange(
int16_t defaultWidth,
const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry) {
SkRefPtr<SkPDFArray> widthArray = new SkPDFArray();
widthArray->unref(); // SkRefPtr and new both took a ref.
int firstChar = 0;
if (widthRangeEntry) {
const uint16_t emSize = fFontInfo->fEmSize;
int startIndex = fFirstGlyphID - widthRangeEntry->fStartId;
int endIndex = startIndex + fLastGlyphID - fFirstGlyphID + 1;
if (startIndex < 0)
startIndex = 0;
if (endIndex > widthRangeEntry->fAdvance.count())
endIndex = widthRangeEntry->fAdvance.count();
if (widthRangeEntry->fStartId == 0) {
appendWidth(widthRangeEntry->fAdvance[0], emSize, widthArray.get());
} else {
firstChar = startIndex + widthRangeEntry->fStartId;
}
for (int i = startIndex; i < endIndex; i++)
appendWidth(widthRangeEntry->fAdvance[i], emSize, widthArray.get());
} else {
appendWidth(defaultWidth, 1000, widthArray.get());
}
insert("FirstChar", new SkPDFInt(firstChar))->unref();
insert("LastChar",
new SkPDFInt(firstChar + widthArray->size() - 1))->unref();
insert("Widths", widthArray.get());
}
void SkPDFFont::adjustGlyphRangeForSingleByteEncoding(int16_t glyphID) {
// Single byte glyph encoding supports a max of 255 glyphs.
fFirstGlyphID = glyphID - (glyphID - 1) % 255;
if (fLastGlyphID > fFirstGlyphID + 255 - 1) {
fLastGlyphID = fFirstGlyphID + 255 - 1;
}
}
bool SkPDFFont::FontRec::operator==(const SkPDFFont::FontRec& b) const {
if (fFontID != b.fFontID)
return false;
if (fFont != NULL && b.fFont != NULL) {
return fFont->fFirstGlyphID == b.fFont->fFirstGlyphID &&
fFont->fLastGlyphID == b.fFont->fLastGlyphID;
}
if (fGlyphID == 0 || b.fGlyphID == 0)
return true;
if (fFont != NULL) {
return fFont->fFirstGlyphID <= b.fGlyphID &&
b.fGlyphID <= fFont->fLastGlyphID;
} else if (b.fFont != NULL) {
return b.fFont->fFirstGlyphID <= fGlyphID &&
fGlyphID <= b.fFont->fLastGlyphID;
}
return fGlyphID == b.fGlyphID;
}
SkPDFFont::FontRec::FontRec(SkPDFFont* font, uint32_t fontID, uint16_t glyphID)
: fFont(font),
fFontID(fontID),
fGlyphID(glyphID) {
}