You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
276 lines
9.1 KiB
276 lines
9.1 KiB
/*
|
|
* Copyright 2012 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "include/core/SkFont.h"
|
|
#include "include/core/SkPaint.h"
|
|
#include "include/core/SkStream.h"
|
|
#include "include/core/SkTypeface.h"
|
|
#include "src/core/SkAutoMalloc.h"
|
|
#include "src/core/SkEndian.h"
|
|
#include "src/core/SkFontStream.h"
|
|
#include "src/core/SkOSFile.h"
|
|
#include "tests/Test.h"
|
|
#include "tools/Resources.h"
|
|
|
|
//#define DUMP_TABLES
|
|
//#define DUMP_TTC_TABLES
|
|
|
|
#define kFontTableTag_head SkSetFourByteTag('h', 'e', 'a', 'd')
|
|
#define kFontTableTag_hhea SkSetFourByteTag('h', 'h', 'e', 'a')
|
|
#define kFontTableTag_maxp SkSetFourByteTag('m', 'a', 'x', 'p')
|
|
|
|
static const struct TagSize {
|
|
SkFontTableTag fTag;
|
|
size_t fSize;
|
|
} gKnownTableSizes[] = {
|
|
{ kFontTableTag_head, 54 },
|
|
{ kFontTableTag_hhea, 36 },
|
|
};
|
|
|
|
// Test that getUnitsPerEm() agrees with a direct lookup in the 'head' table
|
|
// (if that table is available).
|
|
static void test_unitsPerEm(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
|
|
int nativeUPEM = face->getUnitsPerEm();
|
|
|
|
int tableUPEM = -1;
|
|
size_t size = face->getTableSize(kFontTableTag_head);
|
|
if (size) {
|
|
// unitsPerEm is at offset 18 into the 'head' table.
|
|
uint16_t rawUPEM;
|
|
face->getTableData(kFontTableTag_head, 18, sizeof(rawUPEM), &rawUPEM);
|
|
tableUPEM = SkEndian_SwapBE16(rawUPEM);
|
|
}
|
|
|
|
if (tableUPEM >= 0) {
|
|
REPORTER_ASSERT(reporter, tableUPEM == nativeUPEM);
|
|
}
|
|
}
|
|
|
|
// Test that countGlyphs() agrees with a direct lookup in the 'maxp' table
|
|
// (if that table is available).
|
|
static void test_countGlyphs(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
|
|
int nativeGlyphs = face->countGlyphs();
|
|
|
|
int tableGlyphs = -1;
|
|
size_t size = face->getTableSize(kFontTableTag_maxp);
|
|
if (size) {
|
|
// glyphs is at offset 4 into the 'maxp' table.
|
|
uint16_t rawGlyphs;
|
|
face->getTableData(kFontTableTag_maxp, 4, sizeof(rawGlyphs), &rawGlyphs);
|
|
tableGlyphs = SkEndian_SwapBE16(rawGlyphs);
|
|
}
|
|
|
|
if (tableGlyphs >= 0) {
|
|
REPORTER_ASSERT(reporter, tableGlyphs == nativeGlyphs);
|
|
}
|
|
}
|
|
|
|
static void test_fontstream(skiatest::Reporter* reporter, SkStream* stream, int ttcIndex) {
|
|
int n = SkFontStream::GetTableTags(stream, ttcIndex, nullptr);
|
|
SkAutoTArray<SkFontTableTag> array(n);
|
|
|
|
int n2 = SkFontStream::GetTableTags(stream, ttcIndex, array.get());
|
|
REPORTER_ASSERT(reporter, n == n2);
|
|
|
|
for (int i = 0; i < n; ++i) {
|
|
#ifdef DUMP_TTC_TABLES
|
|
SkString str;
|
|
SkFontTableTag t = array[i];
|
|
str.appendUnichar((t >> 24) & 0xFF);
|
|
str.appendUnichar((t >> 16) & 0xFF);
|
|
str.appendUnichar((t >> 8) & 0xFF);
|
|
str.appendUnichar((t >> 0) & 0xFF);
|
|
SkDebugf("[%d:%d] '%s'\n", ttcIndex, i, str.c_str());
|
|
#endif
|
|
size_t size = SkFontStream::GetTableSize(stream, ttcIndex, array[i]);
|
|
for (size_t j = 0; j < SK_ARRAY_COUNT(gKnownTableSizes); ++j) {
|
|
if (gKnownTableSizes[j].fTag == array[i]) {
|
|
REPORTER_ASSERT(reporter, gKnownTableSizes[j].fSize == size);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void test_fontstream(skiatest::Reporter* reporter) {
|
|
std::unique_ptr<SkStreamAsset> stream(GetResourceAsStream("fonts/test.ttc"));
|
|
if (!stream) {
|
|
SkDebugf("Skipping FontHostTest::test_fontstream\n");
|
|
return;
|
|
}
|
|
|
|
int count = SkFontStream::CountTTCEntries(stream.get());
|
|
#ifdef DUMP_TTC_TABLES
|
|
SkDebugf("CountTTCEntries %d\n", count);
|
|
#endif
|
|
for (int i = 0; i < count; ++i) {
|
|
test_fontstream(reporter, stream.get(), i);
|
|
}
|
|
}
|
|
|
|
// Exercise this rare cmap format (platform 3, encoding 0)
|
|
static void test_symbolfont(skiatest::Reporter* reporter) {
|
|
auto tf = MakeResourceAsTypeface("fonts/SpiderSymbol.ttf");
|
|
if (tf) {
|
|
SkUnichar c = 0xf021;
|
|
uint16_t g = SkFont(tf).unicharToGlyph(c);
|
|
REPORTER_ASSERT(reporter, g == 3);
|
|
} else {
|
|
// not all platforms support data fonts, so we just note that failure
|
|
SkDebugf("Skipping FontHostTest::test_symbolfont\n");
|
|
}
|
|
}
|
|
|
|
static void test_tables(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
|
|
if (false) { // avoid bit rot, suppress warning
|
|
SkFontID fontID = face->uniqueID();
|
|
REPORTER_ASSERT(reporter, fontID);
|
|
}
|
|
|
|
int count = face->countTables();
|
|
|
|
SkAutoTMalloc<SkFontTableTag> storage(count);
|
|
SkFontTableTag* tags = storage.get();
|
|
|
|
int count2 = face->getTableTags(tags);
|
|
REPORTER_ASSERT(reporter, count2 == count);
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
size_t size = face->getTableSize(tags[i]);
|
|
REPORTER_ASSERT(reporter, size > 0);
|
|
|
|
#ifdef DUMP_TABLES
|
|
char name[5];
|
|
name[0] = (tags[i] >> 24) & 0xFF;
|
|
name[1] = (tags[i] >> 16) & 0xFF;
|
|
name[2] = (tags[i] >> 8) & 0xFF;
|
|
name[3] = (tags[i] >> 0) & 0xFF;
|
|
name[4] = 0;
|
|
SkDebugf("%s %d\n", name, size);
|
|
#endif
|
|
|
|
for (size_t j = 0; j < SK_ARRAY_COUNT(gKnownTableSizes); ++j) {
|
|
if (gKnownTableSizes[j].fTag == tags[i]) {
|
|
REPORTER_ASSERT(reporter, gKnownTableSizes[j].fSize == size);
|
|
}
|
|
}
|
|
|
|
// do we get the same size from GetTableData and GetTableSize
|
|
{
|
|
SkAutoMalloc data(size);
|
|
size_t size2 = face->getTableData(tags[i], 0, size, data.get());
|
|
REPORTER_ASSERT(reporter, size2 == size);
|
|
sk_sp<SkData> data2 = face->copyTableData(tags[i]);
|
|
REPORTER_ASSERT(reporter, size == data2->size());
|
|
REPORTER_ASSERT(reporter, !memcmp(data.get(), data2->data(), size));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void test_tables(skiatest::Reporter* reporter) {
|
|
static const char* const gNames[] = {
|
|
nullptr, // default font
|
|
"Helvetica", "Arial",
|
|
"Times", "Times New Roman",
|
|
"Courier", "Courier New",
|
|
"Terminal", "MS Sans Serif",
|
|
"Hiragino Mincho ProN", "MS PGothic",
|
|
};
|
|
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); ++i) {
|
|
sk_sp<SkTypeface> face(SkTypeface::MakeFromName(gNames[i], SkFontStyle()));
|
|
if (face) {
|
|
#ifdef DUMP_TABLES
|
|
SkDebugf("%s\n", gNames[i]);
|
|
#endif
|
|
test_tables(reporter, face);
|
|
test_unitsPerEm(reporter, face);
|
|
test_countGlyphs(reporter, face);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Verifies that the advance values returned by generateAdvance and
|
|
* generateMetrics match.
|
|
*/
|
|
static void test_advances(skiatest::Reporter* reporter) {
|
|
static const char* const faces[] = {
|
|
nullptr, // default font
|
|
"Arial", "Times", "Times New Roman", "Helvetica", "Courier",
|
|
"Courier New", "Verdana", "monospace",
|
|
};
|
|
|
|
static const struct {
|
|
SkFontHinting hinting;
|
|
bool linear;
|
|
bool subpixel;
|
|
} settings[] = {
|
|
{ SkFontHinting::kNone, false, false },
|
|
{ SkFontHinting::kNone, true, false },
|
|
{ SkFontHinting::kNone, false, true },
|
|
{ SkFontHinting::kSlight, false, false },
|
|
{ SkFontHinting::kSlight, true, false },
|
|
{ SkFontHinting::kSlight, false, true },
|
|
{ SkFontHinting::kNormal, false, false },
|
|
{ SkFontHinting::kNormal, true, false },
|
|
{ SkFontHinting::kNormal, false, true },
|
|
};
|
|
|
|
static const struct {
|
|
SkScalar fScaleX;
|
|
SkScalar fSkewX;
|
|
} gScaleRec[] = {
|
|
{ SK_Scalar1, 0 },
|
|
{ SK_Scalar1/2, 0 },
|
|
// these two exercise obliquing (skew)
|
|
{ SK_Scalar1, -SK_Scalar1/4 },
|
|
{ SK_Scalar1/2, -SK_Scalar1/4 },
|
|
};
|
|
|
|
SkFont font;
|
|
char const * const txt = "long.text.with.lots.of.dots.";
|
|
size_t textLen = strlen(txt);
|
|
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(faces); i++) {
|
|
font.setTypeface(SkTypeface::MakeFromName(faces[i], SkFontStyle()));
|
|
|
|
for (size_t j = 0; j < SK_ARRAY_COUNT(settings); j++) {
|
|
font.setHinting(settings[j].hinting);
|
|
font.setLinearMetrics(settings[j].linear);
|
|
font.setSubpixel(settings[j].subpixel);
|
|
|
|
for (size_t k = 0; k < SK_ARRAY_COUNT(gScaleRec); ++k) {
|
|
font.setScaleX(gScaleRec[k].fScaleX);
|
|
font.setSkewX(gScaleRec[k].fSkewX);
|
|
|
|
SkRect bounds;
|
|
|
|
// For no hinting and light hinting this should take the
|
|
// optimized generateAdvance path.
|
|
SkScalar width1 = font.measureText(txt, textLen, SkTextEncoding::kUTF8);
|
|
|
|
// Requesting the bounds forces a generateMetrics call.
|
|
SkScalar width2 = font.measureText(txt, textLen, SkTextEncoding::kUTF8, &bounds);
|
|
|
|
// SkDebugf("Font: %s, generateAdvance: %f, generateMetrics: %f\n",
|
|
// faces[i], SkScalarToFloat(width1), SkScalarToFloat(width2));
|
|
|
|
REPORTER_ASSERT(reporter, width1 == width2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DEF_TEST(FontHost, reporter) {
|
|
test_tables(reporter);
|
|
test_fontstream(reporter);
|
|
test_advances(reporter);
|
|
test_symbolfont(reporter);
|
|
}
|
|
|
|
// need tests for SkStrSearch
|