static void compose_advance_data(const AdvanceMetric& range, uint16_t emSize, int16_t* defaultAdvance, SkPDFArray* result) { switch (range.fType) { case AdvanceMetric::kDefault: { SkASSERT(range.fAdvance.count() == 1); *defaultAdvance = range.fAdvance[0]; break; } case AdvanceMetric::kRange: { auto advanceArray = sk_make_sp<SkPDFArray>(); for (int j = 0; j < range.fAdvance.count(); j++) advanceArray->appendScalar( scale_from_font_units(range.fAdvance[j], emSize)); result->appendInt(range.fStartId); result->appendObject(std::move(advanceArray)); break; } case AdvanceMetric::kRun: { SkASSERT(range.fAdvance.count() == 1); result->appendInt(range.fStartId); result->appendInt(range.fEndId); result->appendScalar( scale_from_font_units(range.fAdvance[0], emSize)); break; } } }
static void populate_type_1_font(SkPDFDict* font, const SkAdvancedTypefaceMetrics& info, const std::vector<SkString>& glyphNames, SkTypeface* typeface, SkGlyphID firstGlyphID, SkGlyphID lastGlyphID) { font->insertName("Subtype", "Type1"); 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 glyphCache = SkPDFFont::MakeVectorCache(typeface, &emSize); auto widths = sk_make_sp<SkPDFArray>(); SkScalar advance = glyphCache->getGlyphIDAdvance(0).fAdvanceX; widths->appendScalar(from_font_units(advance, SkToU16(emSize))); for (unsigned gID = firstGlyphID; gID <= lastGlyphID; gID++) { advance = glyphCache->getGlyphIDAdvance(gID).fAdvanceX; widths->appendScalar(from_font_units(advance, SkToU16(emSize))); } font->insertObject("Widths", std::move(widths)); } auto encDiffs = sk_make_sp<SkPDFArray>(); 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 = sk_make_sp<SkPDFDict>("Encoding"); encoding->insertObject("Differences", std::move(encDiffs)); font->insertObject("Encoding", std::move(encoding)); }
static void add_type3_font_info(SkPDFCanon* canon, SkPDFDict* font, SkTypeface* typeface, const SkBitSet& subset, SkGlyphID firstGlyphID, SkGlyphID lastGlyphID) { const SkAdvancedTypefaceMetrics* metrics = SkPDFFont::GetMetrics(typeface, canon); SkASSERT(lastGlyphID >= firstGlyphID); // Remove unused glyphs at the end of the range. // Keep the lastGlyphID >= firstGlyphID invariant true. while (lastGlyphID > firstGlyphID && !subset.has(lastGlyphID)) { --lastGlyphID; } int unitsPerEm; auto cache = SkPDFFont::MakeVectorCache(typeface, &unitsPerEm); SkASSERT(cache); SkScalar emSize = (SkScalar)unitsPerEm; font->insertName("Subtype", "Type3"); // Flip about the x-axis and scale by 1/emSize. SkMatrix fontMatrix; fontMatrix.setScale(SkScalarInvert(emSize), -SkScalarInvert(emSize)); font->insertObject("FontMatrix", SkPDFUtils::MatrixToArray(fontMatrix)); auto charProcs = sk_make_sp<SkPDFDict>(); auto encoding = sk_make_sp<SkPDFDict>("Encoding"); auto encDiffs = sk_make_sp<SkPDFArray>(); // length(firstGlyphID .. lastGlyphID) == lastGlyphID - firstGlyphID + 1 // plus 1 for glyph 0; SkASSERT(firstGlyphID > 0); SkASSERT(lastGlyphID >= firstGlyphID); int glyphCount = lastGlyphID - firstGlyphID + 2; // one other entry for the index of first glyph. encDiffs->reserve(glyphCount + 1); encDiffs->appendInt(0); // index of first glyph auto widthArray = sk_make_sp<SkPDFArray>(); widthArray->reserve(glyphCount); SkIRect bbox = SkIRect::MakeEmpty(); sk_sp<SkPDFStream> emptyStream; for (SkGlyphID gID : SingleByteGlyphIdIterator(firstGlyphID, lastGlyphID)) { bool skipGlyph = gID != 0 && !subset.has(gID); SkString characterName; SkScalar advance = 0.0f; SkIRect glyphBBox; if (skipGlyph) { characterName.set("g0"); } else { characterName.printf("g%X", gID); const SkGlyph& glyph = cache->getGlyphIDMetrics(gID); advance = SkFloatToScalar(glyph.fAdvanceX); glyphBBox = SkIRect::MakeXYWH(glyph.fLeft, glyph.fTop, glyph.fWidth, glyph.fHeight); bbox.join(glyphBBox); const SkPath* path = cache->findPath(glyph); if (path && !path->isEmpty()) { SkDynamicMemoryWStream content; setGlyphWidthAndBoundingBox(SkFloatToScalar(glyph.fAdvanceX), glyphBBox, &content); SkPDFUtils::EmitPath(*path, SkPaint::kFill_Style, &content); SkPDFUtils::PaintPath(SkPaint::kFill_Style, path->getFillType(), &content); charProcs->insertObjRef( characterName, sk_make_sp<SkPDFStream>( std::unique_ptr<SkStreamAsset>(content.detachAsStream()))); } else { if (!emptyStream) { emptyStream = sk_make_sp<SkPDFStream>( std::unique_ptr<SkStreamAsset>( new SkMemoryStream((size_t)0))); } charProcs->insertObjRef(characterName, emptyStream); } } encDiffs->appendName(characterName.c_str()); widthArray->appendScalar(advance); } encoding->insertObject("Differences", std::move(encDiffs)); font->insertInt("FirstChar", 0); font->insertInt("LastChar", lastGlyphID - firstGlyphID + 1); /* FontBBox: "A rectangle expressed in the glyph coordinate system, specifying the font bounding box. This is the smallest rectangle enclosing the shape that would result if all of the glyphs of the font were placed with their origins coincident and then filled." */ auto fontBBox = sk_make_sp<SkPDFArray>(); fontBBox->reserve(4); fontBBox->appendInt(bbox.left()); fontBBox->appendInt(bbox.bottom()); fontBBox->appendInt(bbox.right()); fontBBox->appendInt(bbox.top()); font->insertObject("FontBBox", std::move(fontBBox)); font->insertName("CIDToGIDMap", "Identity"); if (metrics && metrics->fGlyphToUnicode.count() > 0) { font->insertObjRef("ToUnicode", SkPDFMakeToUnicodeCmap(metrics->fGlyphToUnicode, &subset, false, firstGlyphID, lastGlyphID)); } auto descriptor = sk_make_sp<SkPDFDict>("FontDescriptor"); int32_t fontDescriptorFlags = kPdfSymbolic; if (metrics) { // Type3 FontDescriptor does not require all the same fields. descriptor->insertName("FontName", metrics->fPostScriptName); descriptor->insertInt("ItalicAngle", metrics->fItalicAngle); fontDescriptorFlags |= (int32_t)metrics->fStyle; // Adobe requests CapHeight, XHeight, and StemV be added // to "greatly help our workflow downstream". if (metrics->fCapHeight != 0) { descriptor->insertInt("CapHeight", metrics->fCapHeight); } if (metrics->fStemV != 0) { descriptor->insertInt("StemV", metrics->fStemV); } SkScalar xHeight = cache->getFontMetrics().fXHeight; if (xHeight != 0) { descriptor->insertScalar("XHeight", xHeight); } } descriptor->insertInt("Flags", fontDescriptorFlags); font->insertObjRef("FontDescriptor", std::move(descriptor)); font->insertObject("Widths", std::move(widthArray)); font->insertObject("Encoding", std::move(encoding)); font->insertObject("CharProcs", std::move(charProcs)); }
static std::unique_ptr<SkPDFDict> gradientStitchCode(const SkShader::GradientInfo& info) { auto retval = SkPDFMakeDict(); // normalize color stops int colorCount = info.fColorCount; std::vector<SkColor> colors(info.fColors, info.fColors + colorCount); std::vector<SkScalar> colorOffsets(info.fColorOffsets, info.fColorOffsets + colorCount); int i = 1; while (i < colorCount - 1) { // ensure stops are in order if (colorOffsets[i - 1] > colorOffsets[i]) { colorOffsets[i] = colorOffsets[i - 1]; } // remove points that are between 2 coincident points if ((colorOffsets[i - 1] == colorOffsets[i]) && (colorOffsets[i] == colorOffsets[i + 1])) { colorCount -= 1; colors.erase(colors.begin() + i); colorOffsets.erase(colorOffsets.begin() + i); } else { i++; } } // find coincident points and slightly move them over for (i = 1; i < colorCount - 1; i++) { if (colorOffsets[i - 1] == colorOffsets[i]) { colorOffsets[i] += 0.00001f; } } // check if last 2 stops coincide if (colorOffsets[i - 1] == colorOffsets[i]) { colorOffsets[i - 1] -= 0.00001f; } SkAutoSTMalloc<4, ColorTuple> colorDataAlloc(colorCount); ColorTuple *colorData = colorDataAlloc.get(); for (int i = 0; i < colorCount; i++) { colorData[i][0] = SkColorGetR(colors[i]); colorData[i][1] = SkColorGetG(colors[i]); colorData[i][2] = SkColorGetB(colors[i]); } // no need for a stitch function if there are only 2 stops. if (colorCount == 2) return createInterpolationFunction(colorData[0], colorData[1]); auto encode = SkPDFMakeArray(); auto bounds = SkPDFMakeArray(); auto functions = SkPDFMakeArray(); retval->insertObject("Domain", SkPDFMakeArray(0, 1)); retval->insertInt("FunctionType", 3); for (int i = 1; i < colorCount; i++) { if (i > 1) { bounds->appendScalar(colorOffsets[i-1]); } encode->appendScalar(0); encode->appendScalar(1.0f); functions->appendObject(createInterpolationFunction(colorData[i-1], colorData[i])); } retval->insertObject("Encode", std::move(encode)); retval->insertObject("Bounds", std::move(bounds)); retval->insertObject("Functions", std::move(functions)); return retval; }