/*
|
* Copyright 2016 Google Inc.
|
*
|
* Use of this source code is governed by a BSD-style license that can be
|
* found in the LICENSE file.
|
*/
|
|
#include "SkPDFMakeCIDGlyphWidthsArray.h"
|
|
#include "SkPDFGlyphUse.h"
|
#include "SkPaint.h"
|
#include "SkStrike.h"
|
#include "SkTo.h"
|
|
#include <vector>
|
|
// TODO(halcanary): Write unit tests for SkPDFMakeCIDGlyphWidthsArray().
|
|
// TODO(halcanary): The logic in this file originated in several
|
// disparate places. I feel sure that someone could simplify this
|
// down to a single easy-to-read function.
|
|
namespace {
|
|
struct AdvanceMetric {
|
enum MetricType {
|
kDefault, // Default advance: fAdvance.count = 1
|
kRange, // Advances for a range: fAdvance.count = fEndID-fStartID
|
kRun // fStartID-fEndID have same advance: fAdvance.count = 1
|
};
|
MetricType fType;
|
uint16_t fStartId;
|
uint16_t fEndId;
|
std::vector<int16_t> fAdvance;
|
AdvanceMetric(uint16_t startId) : fStartId(startId) {}
|
AdvanceMetric(AdvanceMetric&&) = default;
|
AdvanceMetric& operator=(AdvanceMetric&& other) = default;
|
AdvanceMetric(const AdvanceMetric&) = delete;
|
AdvanceMetric& operator=(const AdvanceMetric&) = delete;
|
};
|
const int16_t kInvalidAdvance = SK_MinS16;
|
const int16_t kDontCareAdvance = SK_MinS16 + 1;
|
} // namespace
|
|
// scale from em-units to base-1000, returning as a SkScalar
|
static SkScalar from_font_units(SkScalar scaled, uint16_t emSize) {
|
if (emSize == 1000) {
|
return scaled;
|
} else {
|
return scaled * 1000 / emSize;
|
}
|
}
|
|
static SkScalar scale_from_font_units(int16_t val, uint16_t emSize) {
|
return from_font_units(SkIntToScalar(val), emSize);
|
}
|
|
static void strip_uninteresting_trailing_advances_from_range(
|
AdvanceMetric* range) {
|
SkASSERT(range);
|
|
int expectedAdvanceCount = range->fEndId - range->fStartId + 1;
|
if (SkToInt(range->fAdvance.size()) < expectedAdvanceCount) {
|
return;
|
}
|
|
for (int i = expectedAdvanceCount - 1; i >= 0; --i) {
|
if (range->fAdvance[i] != kDontCareAdvance &&
|
range->fAdvance[i] != kInvalidAdvance &&
|
range->fAdvance[i] != 0) {
|
range->fEndId = range->fStartId + i;
|
break;
|
}
|
}
|
}
|
|
static void zero_wildcards_in_range(AdvanceMetric* range) {
|
SkASSERT(range);
|
if (range->fType != AdvanceMetric::kRange) {
|
return;
|
}
|
SkASSERT(SkToInt(range->fAdvance.size()) == range->fEndId - range->fStartId + 1);
|
|
// Zero out wildcards.
|
for (size_t i = 0; i < range->fAdvance.size(); ++i) {
|
if (range->fAdvance[i] == kDontCareAdvance) {
|
range->fAdvance[i] = 0;
|
}
|
}
|
}
|
|
static void finish_range(
|
AdvanceMetric* range,
|
int endId,
|
AdvanceMetric::MetricType type) {
|
range->fEndId = endId;
|
range->fType = type;
|
strip_uninteresting_trailing_advances_from_range(range);
|
size_t newLength;
|
if (type == AdvanceMetric::kRange) {
|
newLength = range->fEndId - range->fStartId + 1;
|
} else {
|
if (range->fEndId == range->fStartId) {
|
range->fType = AdvanceMetric::kRange;
|
}
|
newLength = 1;
|
}
|
SkASSERT(range->fAdvance.size() >= newLength);
|
range->fAdvance.resize(newLength);
|
zero_wildcards_in_range(range);
|
}
|
|
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.size() == 1);
|
*defaultAdvance = range.fAdvance[0];
|
break;
|
}
|
case AdvanceMetric::kRange: {
|
auto advanceArray = SkPDFMakeArray();
|
for (size_t j = 0; j < range.fAdvance.size(); 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.size() == 1);
|
result->appendInt(range.fStartId);
|
result->appendInt(range.fEndId);
|
result->appendScalar(
|
scale_from_font_units(range.fAdvance[0], emSize));
|
break;
|
}
|
}
|
}
|
|
/** Retrieve advance data for glyphs. Used by the PDF backend. */
|
// TODO(halcanary): this function is complex enough to need its logic
|
// tested with unit tests.
|
std::unique_ptr<SkPDFArray> SkPDFMakeCIDGlyphWidthsArray(SkStrike* cache,
|
const SkPDFGlyphUse* subset,
|
uint16_t emSize,
|
int16_t* defaultAdvance) {
|
// Assuming that on average, the ASCII representation of an advance plus
|
// a space is 8 characters and the ASCII representation of a glyph id is 3
|
// characters, then the following cut offs for using different range types
|
// apply:
|
// The cost of stopping and starting the range is 7 characters
|
// a. Removing 4 0's or don't care's is a win
|
// The cost of stopping and starting the range plus a run is 22
|
// characters
|
// b. Removing 3 repeating advances is a win
|
// c. Removing 2 repeating advances and 3 don't cares is a win
|
// When not currently in a range the cost of a run over a range is 16
|
// characaters, so:
|
// d. Removing a leading 0/don't cares is a win because it is omitted
|
// e. Removing 2 repeating advances is a win
|
|
auto result = SkPDFMakeArray();
|
int num_glyphs = SkToInt(cache->getGlyphCount());
|
|
bool prevRange = false;
|
|
int16_t lastAdvance = kInvalidAdvance;
|
int repeatedAdvances = 0;
|
int wildCardsInRun = 0;
|
int trailingWildCards = 0;
|
|
// Limit the loop count to glyph id ranges provided.
|
int lastIndex = num_glyphs;
|
if (subset) {
|
while (!subset->has(lastIndex - 1) && lastIndex > 0) {
|
--lastIndex;
|
}
|
}
|
AdvanceMetric curRange(0);
|
|
for (int gId = 0; gId <= lastIndex; gId++) {
|
int16_t advance = kInvalidAdvance;
|
if (gId < lastIndex) {
|
if (!subset || 0 == gId || subset->has(gId)) {
|
advance = (int16_t)cache->getGlyphIDAdvance(gId).fAdvanceX;
|
} else {
|
advance = kDontCareAdvance;
|
}
|
}
|
if (advance == lastAdvance) {
|
repeatedAdvances++;
|
trailingWildCards = 0;
|
} else if (advance == kDontCareAdvance) {
|
wildCardsInRun++;
|
trailingWildCards++;
|
} else if (SkToInt(curRange.fAdvance.size()) ==
|
repeatedAdvances + 1 + wildCardsInRun) { // All in run.
|
if (lastAdvance == 0) {
|
curRange.fStartId = gId; // reset
|
curRange.fAdvance.resize(0);
|
trailingWildCards = 0;
|
} else if (repeatedAdvances + 1 >= 2 || trailingWildCards >= 4) {
|
finish_range(&curRange, gId - 1, AdvanceMetric::kRun);
|
compose_advance_data(curRange, emSize, defaultAdvance, result.get());
|
prevRange = true;
|
curRange = AdvanceMetric(gId);
|
trailingWildCards = 0;
|
}
|
repeatedAdvances = 0;
|
wildCardsInRun = trailingWildCards;
|
trailingWildCards = 0;
|
} else {
|
if (lastAdvance == 0 &&
|
repeatedAdvances + 1 + wildCardsInRun >= 4) {
|
finish_range(&curRange,
|
gId - repeatedAdvances - wildCardsInRun - 2,
|
AdvanceMetric::kRange);
|
compose_advance_data(curRange, emSize, defaultAdvance, result.get());
|
prevRange = true;
|
curRange = AdvanceMetric(gId);
|
trailingWildCards = 0;
|
} else if (trailingWildCards >= 4 && repeatedAdvances + 1 < 2) {
|
finish_range(&curRange, gId - trailingWildCards - 1,
|
AdvanceMetric::kRange);
|
compose_advance_data(curRange, emSize, defaultAdvance, result.get());
|
prevRange = true;
|
curRange = AdvanceMetric(gId);
|
trailingWildCards = 0;
|
} else if (lastAdvance != 0 &&
|
(repeatedAdvances + 1 >= 3 ||
|
(repeatedAdvances + 1 >= 2 && wildCardsInRun >= 3))) {
|
finish_range(&curRange,
|
gId - repeatedAdvances - wildCardsInRun - 2,
|
AdvanceMetric::kRange);
|
compose_advance_data(curRange, emSize, defaultAdvance, result.get());
|
curRange =
|
AdvanceMetric(gId - repeatedAdvances - wildCardsInRun - 1);
|
curRange.fAdvance.push_back(lastAdvance);
|
finish_range(&curRange, gId - 1, AdvanceMetric::kRun);
|
compose_advance_data(curRange, emSize, defaultAdvance, result.get());
|
prevRange = true;
|
curRange = AdvanceMetric(gId);
|
trailingWildCards = 0;
|
}
|
repeatedAdvances = 0;
|
wildCardsInRun = trailingWildCards;
|
trailingWildCards = 0;
|
}
|
curRange.fAdvance.push_back(advance);
|
if (advance != kDontCareAdvance) {
|
lastAdvance = advance;
|
}
|
}
|
if (curRange.fStartId == lastIndex) {
|
if (!prevRange) {
|
return nullptr; // https://crbug.com/567031
|
}
|
} else {
|
finish_range(&curRange, lastIndex - 1, AdvanceMetric::kRange);
|
compose_advance_data(curRange, emSize, defaultAdvance, result.get());
|
}
|
return result;
|
}
|
