blob: ec53c54fa24b3a0c8771d037f001659908961935 [file] [log] [blame]
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkAdvancedTypefaceMetrics.h"
#include "SkBitmap.h"
#include "SkCanvas.h"
#include "SkDescriptor.h"
#include "SkFontDescriptor.h"
#include "SkGlyph.h"
#include "SkMakeUnique.h"
#include "SkMask.h"
#include "SkPaintPriv.h"
#include "SkScalerContext.h"
#include "SkTestScalerContext.h"
#include "SkTypefaceCache.h"
SkTestFont::SkTestFont(const SkTestFontData& fontData)
: INHERITED()
, fCharCodes(fontData.fCharCodes)
, fCharCodesCount(fontData.fCharCodes ? fontData.fCharCodesCount : 0)
, fWidths(fontData.fWidths)
, fMetrics(fontData.fMetrics)
, fName(fontData.fName)
, fPaths(nullptr)
{
init(fontData.fPoints, fontData.fVerbs);
#ifdef SK_DEBUG
sk_bzero(fDebugBits, sizeof(fDebugBits));
sk_bzero(fDebugOverage, sizeof(fDebugOverage));
#endif
}
SkTestFont::~SkTestFont() {
for (unsigned index = 0; index < fCharCodesCount; ++index) {
delete fPaths[index];
}
delete[] fPaths;
}
#ifdef SK_DEBUG
#include "SkMutex.h"
SK_DECLARE_STATIC_MUTEX(gUsedCharsMutex);
#endif
int SkTestFont::codeToIndex(SkUnichar charCode) const {
#ifdef SK_DEBUG // detect missing test font data
{
SkAutoMutexAcquire ac(gUsedCharsMutex);
if (charCode >= ' ' && charCode <= '~') {
int bitOffset = charCode - ' ';
fDebugBits[bitOffset >> 3] |= 1 << (bitOffset & 7);
} else {
int index = 0;
while (fDebugOverage[index] != 0 && fDebugOverage[index] != charCode
&& index < (int) sizeof(fDebugOverage)) {
++index;
}
SkASSERT(index < (int) sizeof(fDebugOverage));
if (fDebugOverage[index] == 0) {
fDebugOverage[index] = charCode;
}
}
}
#endif
for (unsigned index = 0; index < fCharCodesCount; ++index) {
if (fCharCodes[index] == (unsigned) charCode) {
return (int) index;
}
}
SkDEBUGF(("missing '%c' (%d) from %s (weight %d, width %d, slant %d)\n",
(char) charCode, charCode, fDebugName,
fDebugStyle.weight(), fDebugStyle.width(), fDebugStyle.slant()));
return 0;
}
void SkTestFont::init(const SkScalar* pts, const unsigned char* verbs) {
fPaths = new SkPath* [fCharCodesCount];
for (unsigned index = 0; index < fCharCodesCount; ++index) {
SkPath* path = new SkPath;
SkPath::Verb verb;
while ((verb = (SkPath::Verb) *verbs++) != SkPath::kDone_Verb) {
switch (verb) {
case SkPath::kMove_Verb:
path->moveTo(pts[0], pts[1]);
pts += 2;
break;
case SkPath::kLine_Verb:
path->lineTo(pts[0], pts[1]);
pts += 2;
break;
case SkPath::kQuad_Verb:
path->quadTo(pts[0], pts[1], pts[2], pts[3]);
pts += 4;
break;
case SkPath::kCubic_Verb:
path->cubicTo(pts[0], pts[1], pts[2], pts[3], pts[4], pts[5]);
pts += 6;
break;
case SkPath::kClose_Verb:
path->close();
break;
default:
SkDEBUGFAIL("bad verb");
return;
}
}
// This should make SkPath::getBounds() queries threadsafe.
path->updateBoundsCache();
fPaths[index] = path;
}
}
SkTestTypeface::SkTestTypeface(sk_sp<SkTestFont> testFont, const SkFontStyle& style)
: SkTypeface(style, false)
, fTestFont(std::move(testFont)) {
}
void SkTestTypeface::getAdvance(SkGlyph* glyph) {
// TODO(benjaminwagner): Update users to use floats.
glyph->fAdvanceX = SkFixedToFloat(fTestFont->fWidths[glyph->getGlyphID()]);
glyph->fAdvanceY = 0;
}
void SkTestTypeface::getFontMetrics(SkPaint::FontMetrics* metrics) {
*metrics = fTestFont->fMetrics;
}
void SkTestTypeface::getMetrics(SkGlyph* glyph) {
// TODO(benjaminwagner): Update users to use floats.
glyph->fAdvanceX = SkFixedToFloat(fTestFont->fWidths[glyph->getGlyphID()]);
glyph->fAdvanceY = 0;
}
void SkTestTypeface::getPath(SkGlyphID glyph, SkPath* path) {
*path = *fTestFont->fPaths[glyph];
}
void SkTestTypeface::onFilterRec(SkScalerContextRec* rec) const {
rec->setHinting(SkPaint::kNo_Hinting);
}
std::unique_ptr<SkAdvancedTypefaceMetrics> SkTestTypeface::onGetAdvancedMetrics() const { // pdf only
std::unique_ptr<SkAdvancedTypefaceMetrics> info(new SkAdvancedTypefaceMetrics);
info->fFontName.set(fTestFont->fName);
int glyphCount = this->onCountGlyphs();
SkTDArray<SkUnichar>& toUnicode = info->fGlyphToUnicode;
toUnicode.setCount(glyphCount);
SkASSERT(glyphCount == SkToInt(fTestFont->fCharCodesCount));
for (int gid = 0; gid < glyphCount; ++gid) {
toUnicode[gid] = SkToS32(fTestFont->fCharCodes[gid]);
}
return info;
}
void SkTestTypeface::onGetFontDescriptor(SkFontDescriptor* desc, bool* isLocal) const {
desc->setFamilyName(fTestFont->fName);
desc->setStyle(this->fontStyle());
*isLocal = false;
}
int SkTestTypeface::onCharsToGlyphs(const void* chars, Encoding encoding,
uint16_t glyphs[], int glyphCount) const {
SkASSERT(encoding == kUTF32_Encoding);
for (int index = 0; index < glyphCount; ++index) {
SkUnichar ch = ((SkUnichar*) chars)[index];
glyphs[index] = fTestFont->codeToIndex(ch);
}
return glyphCount;
}
void SkTestTypeface::onGetFamilyName(SkString* familyName) const {
*familyName = fTestFont->fName;
}
SkTypeface::LocalizedStrings* SkTestTypeface::onCreateFamilyNameIterator() const {
SkString familyName(fTestFont->fName);
SkString language("und"); //undetermined
//SkASSERT(0); // incomplete
return nullptr;
// return new SkOTUtils::LocalizedStrings_SingleName(familyName, language);
}
class SkTestScalerContext : public SkScalerContext {
public:
SkTestScalerContext(sk_sp<SkTestTypeface> face, const SkScalerContextEffects& effects,
const SkDescriptor* desc)
: SkScalerContext(std::move(face), effects, desc)
{
fRec.getSingleMatrix(&fMatrix);
this->forceGenerateImageFromPath();
}
protected:
SkTestTypeface* getTestTypeface() const {
return static_cast<SkTestTypeface*>(this->getTypeface());
}
unsigned generateGlyphCount() override {
return this->getTestTypeface()->onCountGlyphs();
}
uint16_t generateCharToGlyph(SkUnichar uni) override {
uint16_t glyph;
(void) this->getTestTypeface()->onCharsToGlyphs((const void *) &uni,
SkTypeface::kUTF32_Encoding, &glyph, 1);
return glyph;
}
void generateAdvance(SkGlyph* glyph) override {
this->getTestTypeface()->getAdvance(glyph);
const SkVector advance = fMatrix.mapXY(SkFloatToScalar(glyph->fAdvanceX),
SkFloatToScalar(glyph->fAdvanceY));
glyph->fAdvanceX = SkScalarToFloat(advance.fX);
glyph->fAdvanceY = SkScalarToFloat(advance.fY);
}
void generateMetrics(SkGlyph* glyph) override {
this->getTestTypeface()->getMetrics(glyph);
const SkVector advance = fMatrix.mapXY(SkFloatToScalar(glyph->fAdvanceX),
SkFloatToScalar(glyph->fAdvanceY));
glyph->fAdvanceX = SkScalarToFloat(advance.fX);
glyph->fAdvanceY = SkScalarToFloat(advance.fY);
SkPath path;
this->getTestTypeface()->getPath(glyph->getGlyphID(), &path);
path.transform(fMatrix);
SkRect storage;
const SkPaint paint;
const SkRect& newBounds = paint.doComputeFastBounds(path.getBounds(),
&storage,
SkPaint::kFill_Style);
SkIRect ibounds;
newBounds.roundOut(&ibounds);
glyph->fLeft = ibounds.fLeft;
glyph->fTop = ibounds.fTop;
glyph->fWidth = ibounds.width();
glyph->fHeight = ibounds.height();
}
void generateImage(const SkGlyph& glyph) override {
SkPath path;
this->getTestTypeface()->getPath(glyph.getGlyphID(), &path);
SkBitmap bm;
bm.installPixels(SkImageInfo::MakeN32Premul(glyph.fWidth, glyph.fHeight),
glyph.fImage, glyph.rowBytes());
bm.eraseColor(0);
SkCanvas canvas(bm);
canvas.translate(-SkIntToScalar(glyph.fLeft),
-SkIntToScalar(glyph.fTop));
canvas.concat(fMatrix);
SkPaint paint;
paint.setAntiAlias(true);
canvas.drawPath(path, paint);
}
void generatePath(SkGlyphID glyph, SkPath* path) override {
this->getTestTypeface()->getPath(glyph, path);
path->transform(fMatrix);
}
void generateFontMetrics(SkPaint::FontMetrics* metrics) override {
this->getTestTypeface()->getFontMetrics(metrics);
SkPaintPriv::ScaleFontMetrics(metrics, fMatrix.getScaleY());
}
private:
SkMatrix fMatrix;
};
SkScalerContext* SkTestTypeface::onCreateScalerContext(
const SkScalerContextEffects& effects, const SkDescriptor* desc) const
{
return new SkTestScalerContext(sk_ref_sp(const_cast<SkTestTypeface*>(this)), effects, desc);
}