icuSources/layout/KernTable.cpp

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