2 * Copyright 2012 Google Inc.
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
10 #include "SkFontStream.h"
14 #include "SkTypeface.h"
18 //#define DUMP_TTC_TABLES
20 #define kFontTableTag_head SkSetFourByteTag('h', 'e', 'a', 'd')
21 #define kFontTableTag_hhea SkSetFourByteTag('h', 'h', 'e', 'a')
22 #define kFontTableTag_maxp SkSetFourByteTag('m', 'a', 'x', 'p')
24 static const struct TagSize {
27 } gKnownTableSizes[] = {
28 { kFontTableTag_head, 54 },
29 { kFontTableTag_hhea, 36 },
32 // Test that getUnitsPerEm() agrees with a direct lookup in the 'head' table
33 // (if that table is available).
34 static void test_unitsPerEm(skiatest::Reporter* reporter, SkTypeface* face) {
35 int nativeUPEM = face->getUnitsPerEm();
38 size_t size = face->getTableSize(kFontTableTag_head);
40 // unitsPerEm is at offset 18 into the 'head' table.
42 face->getTableData(kFontTableTag_head, 18, sizeof(rawUPEM), &rawUPEM);
43 tableUPEM = SkEndian_SwapBE16(rawUPEM);
47 REPORTER_ASSERT(reporter, tableUPEM == nativeUPEM);
51 // Test that countGlyphs() agrees with a direct lookup in the 'maxp' table
52 // (if that table is available).
53 static void test_countGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
54 int nativeGlyphs = face->countGlyphs();
57 size_t size = face->getTableSize(kFontTableTag_maxp);
59 // glyphs is at offset 4 into the 'maxp' table.
61 face->getTableData(kFontTableTag_maxp, 4, sizeof(rawGlyphs), &rawGlyphs);
62 tableGlyphs = SkEndian_SwapBE16(rawGlyphs);
65 if (tableGlyphs >= 0) {
66 REPORTER_ASSERT(reporter, tableGlyphs == nativeGlyphs);
70 // The following three are all the same code points in various encodings.
72 static uint8_t utf8Chars[] = { 0x61, 0xE4,0xB8,0xAD, 0xD0,0xAF, 0xD7,0x99, 0xD7,0x95, 0xF0,0x9D,0x84,0x9E, 0x61, 0xF0,0xA0,0xAE,0x9F };
73 static uint16_t utf16Chars[] = { 0x0061, 0x4E2D, 0x042F, 0x05D9, 0x05D5, 0xD834,0xDD1E, 0x0061, 0xD842,0xDF9F };
74 static uint32_t utf32Chars[] = { 0x00000061, 0x00004E2D, 0x0000042F, 0x000005D9, 0x000005D5, 0x0001D11E, 0x00000061, 0x00020B9F };
76 struct CharsToGlyphs_TestData {
79 size_t charsByteLength;
80 SkTypeface::Encoding typefaceEncoding;
82 } static charsToGlyphs_TestData[] = {
83 { utf8Chars, 8, sizeof(utf8Chars), SkTypeface::kUTF8_Encoding, "Simple UTF-8" },
84 { utf16Chars, 8, sizeof(utf16Chars), SkTypeface::kUTF16_Encoding, "Simple UTF-16" },
85 { utf32Chars, 8, sizeof(utf32Chars), SkTypeface::kUTF32_Encoding, "Simple UTF-32" },
88 // Test that SkPaint::textToGlyphs agrees with SkTypeface::charsToGlyphs.
89 static void test_charsToGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
90 uint16_t paintGlyphIds[256];
91 uint16_t faceGlyphIds[256];
93 for (size_t testIndex = 0; testIndex < SK_ARRAY_COUNT(charsToGlyphs_TestData); ++testIndex) {
94 CharsToGlyphs_TestData& test = charsToGlyphs_TestData[testIndex];
97 paint.setTypeface(face);
98 paint.setTextEncoding((SkPaint::TextEncoding)test.typefaceEncoding);
99 paint.textToGlyphs(test.chars, test.charsByteLength, paintGlyphIds);
101 face->charsToGlyphs(test.chars, test.typefaceEncoding, faceGlyphIds, test.charCount);
103 for (int i = 0; i < test.charCount; ++i) {
105 face->getFamilyName(&name);
107 a.appendf("%s, paintGlyphIds[%d] = %d, faceGlyphIds[%d] = %d, face = %s",
108 test.name, i, (int)paintGlyphIds[i], i, (int)faceGlyphIds[i], name.c_str());
109 REPORTER_ASSERT_MESSAGE(reporter, paintGlyphIds[i] == faceGlyphIds[i], a.c_str());
114 static void test_fontstream(skiatest::Reporter* reporter,
115 SkStream* stream, int ttcIndex) {
116 int n = SkFontStream::GetTableTags(stream, ttcIndex, NULL);
117 SkAutoTArray<SkFontTableTag> array(n);
119 int n2 = SkFontStream::GetTableTags(stream, ttcIndex, array.get());
120 REPORTER_ASSERT(reporter, n == n2);
122 for (int i = 0; i < n; ++i) {
123 #ifdef DUMP_TTC_TABLES
125 SkFontTableTag t = array[i];
126 str.appendUnichar((t >> 24) & 0xFF);
127 str.appendUnichar((t >> 16) & 0xFF);
128 str.appendUnichar((t >> 8) & 0xFF);
129 str.appendUnichar((t >> 0) & 0xFF);
130 SkDebugf("[%d:%d] '%s'\n", ttcIndex, i, str.c_str());
132 size_t size = SkFontStream::GetTableSize(stream, ttcIndex, array[i]);
133 for (size_t j = 0; j < SK_ARRAY_COUNT(gKnownTableSizes); ++j) {
134 if (gKnownTableSizes[j].fTag == array[i]) {
135 REPORTER_ASSERT(reporter, gKnownTableSizes[j].fSize == size);
141 static void test_fontstream(skiatest::Reporter* reporter, SkStream* stream) {
142 int count = SkFontStream::CountTTCEntries(stream);
143 #ifdef DUMP_TTC_TABLES
144 SkDebugf("CountTTCEntries %d\n", count);
146 for (int i = 0; i < count; ++i) {
147 test_fontstream(reporter, stream, i);
151 static void test_fontstream(skiatest::Reporter* reporter) {
152 // This test cannot run if there is no resource path.
153 SkString resourcePath = GetResourcePath();
154 if (resourcePath.isEmpty()) {
155 SkDebugf("Could not run fontstream test because resourcePath not specified.");
158 SkString filename = SkOSPath::Join(resourcePath.c_str(), "test.ttc");
160 SkFILEStream stream(filename.c_str());
161 if (stream.isValid()) {
162 test_fontstream(reporter, &stream);
164 SkDebugf("Could not run fontstream test because test.ttc not found.");
168 static void test_tables(skiatest::Reporter* reporter, SkTypeface* face) {
169 if (false) { // avoid bit rot, suppress warning
170 SkFontID fontID = face->uniqueID();
171 REPORTER_ASSERT(reporter, fontID);
174 int count = face->countTables();
176 SkAutoTMalloc<SkFontTableTag> storage(count);
177 SkFontTableTag* tags = storage.get();
179 int count2 = face->getTableTags(tags);
180 REPORTER_ASSERT(reporter, count2 == count);
182 for (int i = 0; i < count; ++i) {
183 size_t size = face->getTableSize(tags[i]);
184 REPORTER_ASSERT(reporter, size > 0);
188 name[0] = (tags[i] >> 24) & 0xFF;
189 name[1] = (tags[i] >> 16) & 0xFF;
190 name[2] = (tags[i] >> 8) & 0xFF;
191 name[3] = (tags[i] >> 0) & 0xFF;
193 SkDebugf("%s %d\n", name, size);
196 for (size_t j = 0; j < SK_ARRAY_COUNT(gKnownTableSizes); ++j) {
197 if (gKnownTableSizes[j].fTag == tags[i]) {
198 REPORTER_ASSERT(reporter, gKnownTableSizes[j].fSize == size);
202 // do we get the same size from GetTableData and GetTableSize
204 SkAutoMalloc data(size);
205 size_t size2 = face->getTableData(tags[i], 0, size, data.get());
206 REPORTER_ASSERT(reporter, size2 == size);
211 static void test_tables(skiatest::Reporter* reporter) {
212 static const char* const gNames[] = {
213 NULL, // default font
214 "Helvetica", "Arial",
215 "Times", "Times New Roman",
216 "Courier", "Courier New",
217 "Terminal", "MS Sans Serif",
218 "Hiragino Mincho ProN", "MS PGothic",
221 for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); ++i) {
222 SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(gNames[i], SkTypeface::kNormal));
225 SkDebugf("%s\n", gNames[i]);
227 test_tables(reporter, face);
228 test_unitsPerEm(reporter, face);
229 test_countGlyphs(reporter, face);
230 test_charsToGlyphs(reporter, face);
236 * Verifies that the advance values returned by generateAdvance and
237 * generateMetrics match.
239 static void test_advances(skiatest::Reporter* reporter) {
240 static const char* const faces[] = {
241 NULL, // default font
242 "Arial", "Times", "Times New Roman", "Helvetica", "Courier",
243 "Courier New", "Verdana", "monospace",
246 static const struct {
247 SkPaint::Hinting hinting;
250 { SkPaint::kNo_Hinting, 0 },
251 { SkPaint::kNo_Hinting, SkPaint::kLinearText_Flag },
252 { SkPaint::kNo_Hinting, SkPaint::kSubpixelText_Flag },
253 { SkPaint::kSlight_Hinting, 0 },
254 { SkPaint::kSlight_Hinting, SkPaint::kLinearText_Flag },
255 { SkPaint::kSlight_Hinting, SkPaint::kSubpixelText_Flag },
256 { SkPaint::kNormal_Hinting, 0 },
257 { SkPaint::kNormal_Hinting, SkPaint::kLinearText_Flag },
258 { SkPaint::kNormal_Hinting, SkPaint::kSubpixelText_Flag },
261 static const struct {
267 // these two exercise obliquing (skew)
268 { SK_Scalar1, -SK_Scalar1/4 },
269 { SK_Scalar1/2, -SK_Scalar1/4 },
273 char txt[] = "long.text.with.lots.of.dots.";
275 for (size_t i = 0; i < SK_ARRAY_COUNT(faces); i++) {
276 SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(faces[i], SkTypeface::kNormal));
277 paint.setTypeface(face);
279 for (size_t j = 0; j < SK_ARRAY_COUNT(settings); j++) {
280 paint.setHinting(settings[j].hinting);
281 paint.setLinearText((settings[j].flags & SkPaint::kLinearText_Flag) != 0);
282 paint.setSubpixelText((settings[j].flags & SkPaint::kSubpixelText_Flag) != 0);
284 for (size_t k = 0; k < SK_ARRAY_COUNT(gScaleRec); ++k) {
285 paint.setTextScaleX(gScaleRec[k].fScaleX);
286 paint.setTextSkewX(gScaleRec[k].fSkewX);
290 // For no hinting and light hinting this should take the
291 // optimized generateAdvance path.
292 SkScalar width1 = paint.measureText(txt, strlen(txt));
294 // Requesting the bounds forces a generateMetrics call.
295 SkScalar width2 = paint.measureText(txt, strlen(txt), &bounds);
297 // SkDebugf("Font: %s, generateAdvance: %f, generateMetrics: %f\n",
298 // faces[i], SkScalarToFloat(width1), SkScalarToFloat(width2));
300 REPORTER_ASSERT(reporter, width1 == width2);
306 DEF_TEST(FontHost, reporter) {
307 test_tables(reporter);
308 test_fontstream(reporter);
309 test_advances(reporter);
312 // need tests for SkStrSearch