1 /*
2 * @(#)KernTable.cpp 1.1 04/10/13
3 *
4 * (C) Copyright IBM Corp. 2004-2014 - All Rights Reserved
5 *
6 */
7
8 #include "KernTable.h"
9 #include "LEFontInstance.h"
10 #include "LEGlyphStorage.h"
11
12 #include "LESwaps.h"
13 #include "OpenTypeUtilities.h"
14
15 #include <stdio.h>
16
17 #define KERNTABLE_DEBUG 0
18
19 U_NAMESPACE_BEGIN
20
21 struct PairInfo {
22 le_uint16 left; // left glyph of kern pair
23 le_uint16 right; // right glyph of kern pair
24 le_int16 value; // fword, kern value in funits
25 };
26 #define KERN_PAIRINFO_SIZE 6
27 LE_CORRECT_SIZE(PairInfo, KERN_PAIRINFO_SIZE)
28
29 #define SWAP_KEY(p) (((le_uint32) SWAPW((p)->left) << 16) | SWAPW((p)->right))
30
31 struct Subtable_0 {
32 le_uint16 nPairs;
33 le_uint16 searchRange;
34 le_uint16 entrySelector;
35 le_uint16 rangeShift;
36 };
37 #define KERN_SUBTABLE_0_HEADER_SIZE 8
38 LE_CORRECT_SIZE(Subtable_0, KERN_SUBTABLE_0_HEADER_SIZE)
39
40 // Kern table version 0 only
41 struct SubtableHeader {
42 le_uint16 version;
43 le_uint16 length;
44 le_uint16 coverage;
45 };
46 #define KERN_SUBTABLE_HEADER_SIZE 6
47 LE_CORRECT_SIZE(SubtableHeader, KERN_SUBTABLE_HEADER_SIZE)
48
49 // Version 0 only, version 1 has different layout
50 struct KernTableHeader {
51 le_uint16 version;
52 le_uint16 nTables;
53 };
54 #define KERN_TABLE_HEADER_SIZE 4
LE_CORRECT_SIZE(KernTableHeader,KERN_TABLE_HEADER_SIZE)55 LE_CORRECT_SIZE(KernTableHeader, KERN_TABLE_HEADER_SIZE)
56
57 #define COVERAGE_HORIZONTAL 0x1
58 #define COVERAGE_MINIMUM 0x2
59 #define COVERAGE_CROSS 0x4
60 #define COVERAGE_OVERRIDE 0x8
61
62 /*
63 * This implementation has support for only one subtable, so if the font has
64 * multiple subtables, only the first will be used. If this turns out to
65 * be a problem in practice we should add it.
66 *
67 * This also supports only version 0 of the kern table header, only
68 * Apple supports the latter.
69 *
70 * This implementation isn't careful about the kern table flags, and
71 * might invoke kerning when it is not supposed to. That too I'm
72 * leaving for a bug fix.
73 *
74 * TODO: support multiple subtables
75 * TODO: respect header flags
76 */
77 KernTable::KernTable(const LETableReference& base, LEErrorCode &success)
78 : pairs(), fTable(base)
79 {
80 if(LE_FAILURE(success) || fTable.isEmpty()) {
81 #if KERNTABLE_DEBUG
82 fprintf(stderr, "no kern data\n");
83 #endif
84 return;
85 }
86 LEReferenceTo<KernTableHeader> header(fTable, success);
87
88 #if KERNTABLE_DEBUG
89 // dump first 32 bytes of header
90 for (int i = 0; i < 64; ++i) {
91 fprintf(stderr, "%0.2x ", ((const char*)header.getAlias())[i]&0xff);
92 if (((i+1)&0xf) == 0) {
93 fprintf(stderr, "\n");
94 } else if (((i+1)&0x7) == 0) {
95 fprintf(stderr, " ");
96 }
97 }
98 #endif
99
100 if(LE_FAILURE(success)) return;
101
102 if (!header.isEmpty() && header->version == 0 && SWAPW(header->nTables) > 0) {
103 LEReferenceTo<SubtableHeader> subhead(header, success, KERN_TABLE_HEADER_SIZE);
104
105 if (LE_SUCCESS(success) && !subhead.isEmpty() && subhead->version == 0) {
106 coverage = SWAPW(subhead->coverage);
107
108 if (coverage & COVERAGE_HORIZONTAL) { // only handle horizontal kerning
109 LEReferenceTo<Subtable_0> table(subhead, success, KERN_SUBTABLE_HEADER_SIZE);
110
111 if(table.isEmpty() || LE_FAILURE(success)) return;
112
113 nPairs = SWAPW(table->nPairs);
114
115 #if 0 // some old fonts have bad values here...
116 searchRange = SWAPW(table->searchRange);
117 entrySelector = SWAPW(table->entrySelector);
118 rangeShift = SWAPW(table->rangeShift);
119 #else
120 entrySelector = OpenTypeUtilities::highBit(nPairs);
121 searchRange = (1 << entrySelector) * KERN_PAIRINFO_SIZE;
122 rangeShift = (nPairs * KERN_PAIRINFO_SIZE) - searchRange;
123 #endif
124
125 if(LE_SUCCESS(success) && nPairs>0) {
126 // pairs is an instance member, and table is on the stack.
127 // set 'pairs' based on table.getAlias(). This will range check it.
128
129 pairs = LEReferenceToArrayOf<PairInfo>(fTable, // based on overall table
130 success,
131 (const PairInfo*)table.getAlias(), // subtable 0 + ..
132 KERN_SUBTABLE_0_HEADER_SIZE, // .. offset of header size
133 nPairs); // count
134 }
135
136 #if 0
137 fprintf(stderr, "coverage: %0.4x nPairs: %d pairs %p\n", coverage, nPairs, pairs.getAlias());
138 fprintf(stderr, " searchRange: %d entrySelector: %d rangeShift: %d\n", searchRange, entrySelector, rangeShift);
139 fprintf(stderr, "[[ ignored font table entries: range %d selector %d shift %d ]]\n", SWAPW(table->searchRange), SWAPW(table->entrySelector), SWAPW(table->rangeShift));
140 #endif
141 #if KERNTABLE_DEBUG
142 fprintf(stderr, "coverage: %0.4x nPairs: %d pairs 0x%x\n", coverage, nPairs, pairs);
143 fprintf(stderr, " searchRange: %d entrySelector: %d rangeShift: %d\n", searchRange, entrySelector, rangeShift);
144
145 if(LE_SUCCESS(success) {
146 // dump part of the pair list
147 char ids[256];
148
149 for (int i = 256; --i >= 0;) {
150 LEGlyphID id = font->mapCharToGlyph(i);
151
152 if (id < 256) {
153 ids[id] = (char)i;
154 }
155 }
156
157 for (i = 0; i < nPairs; ++i) {
158 const PairInfo& p = pairs[i, success];
159
160 le_uint16 left = p->left;
161 le_uint16 right = p->right;
162
163
164 if (left < 256 && right < 256) {
165 char c = ids[left];
166
167 if (c > 0x20 && c < 0x7f) {
168 fprintf(stderr, "%c/", c & 0xff);
169 } else {
170 printf(stderr, "%0.2x/", c & 0xff);
171 }
172
173 c = ids[right];
174 if (c > 0x20 && c < 0x7f) {
175 fprintf(stderr, "%c ", c & 0xff);
176 } else {
177 fprintf(stderr, "%0.2x ", c & 0xff);
178 }
179 }
180 }
181 }
182 #endif
183 }
184 }
185 }
186 }
187
188
189 /*
190 * Process the glyph positions. The positions array has two floats for each
191 g * glyph, plus a trailing pair to mark the end of the last glyph.
192 */
193 void KernTable::process(LEGlyphStorage& storage, LEErrorCode &success)
194 {
195 if (LE_SUCCESS(success) && !pairs.isEmpty()) {
196
197 le_uint32 key = storage[0]; // no need to mask off high bits
198 float adjust = 0;
199
200 for (int i = 1, e = storage.getGlyphCount(); LE_SUCCESS(success)&& i < e; ++i) {
201 key = key << 16 | (storage[i] & 0xffff);
202
203 // argh, to do a binary search, we need to have the pair list in sorted order
204 // but it is not in sorted order on win32 platforms because of the endianness difference
205 // so either I have to swap the element each time I examine it, or I have to swap
206 // all the elements ahead of time and store them in the font
207
208 const PairInfo *p = pairs.getAlias(0, success);
209
210 LEReferenceTo<PairInfo> tpRef(pairs, success, rangeShift); // ((char*)pairs) + rangeShift
211 const PairInfo *tp = tpRef.getAlias();
212 if(LE_FAILURE(success)) return; // get out.
213
214 if (key > SWAP_KEY(tp)) {
215 p = tp;
216 }
217
218 #if KERNTABLE_DEBUG
219 fprintf(stderr, "binary search for %0.8x\n", key);
220 #endif
221
222 le_uint32 probe = searchRange;
223
224 while (probe > KERN_PAIRINFO_SIZE && LE_SUCCESS(success)) {
225 probe >>= 1;
226 tpRef = LEReferenceTo<PairInfo>(pairs, success, p, probe); // (char*)p + probe
227 tp = tpRef.getAlias();
228 le_uint32 tkey = SWAP_KEY(tp);
229 if(LE_FAILURE(success)) break;
230 #if KERNTABLE_DEBUG
231 fprintf(stdout, " %.3d (%0.8x)\n", ((char*)tp - (char*)pairs)/KERN_PAIRINFO_SIZE, tkey);
232 #endif
233 if (tkey <= key && LE_SUCCESS(success)) {
234 if (tkey == key) {
235 le_int16 value = SWAPW(tp->value);
236 #if KERNTABLE_DEBUG
237 fprintf(stdout, "binary found kerning pair %x:%x at %d, value: 0x%x (%g)\n",
238 storage[i-1], storage[i], i, value & 0xffff, font->xUnitsToPoints(value));
239 fflush(stdout);
240 #endif
241 adjust += fTable.getFont()->xUnitsToPoints(value);
242 break;
243 }
244
245 p = tp;
246 }
247 }
248
249 storage.adjustPosition(i, adjust, 0, success);
250 }
251
252 storage.adjustPosition(storage.getGlyphCount(), adjust, 0, success);
253 }
254 }
255
256 U_NAMESPACE_END
257
258