1 /*
   2  * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /*
  27  * (C) Copyright IBM Corp. 1998-2001 - All Rights Reserved
  28  *
  29  * The original version of this source code and documentation is
  30  * copyrighted and owned by IBM. These materials are provided
  31  * under terms of a License Agreement between IBM and Sun.
  32  * This technology is protected by multiple US and International
  33  * patents. This notice and attribution to IBM may not be removed.
  34  */
  35 
  36 #include "FontInstanceAdapter.h"
  37 
  38 FontInstanceAdapter::FontInstanceAdapter(JNIEnv *theEnv,
  39                                          jobject theFont2D,
  40                                          jobject theFontStrike,
  41                                          float *matrix,
  42                                          le_int32 xRes, le_int32 yRes,
  43                                          le_int32 theUPEM,
  44                                          TTLayoutTableCache *ltables)
  45     : env(theEnv), font2D(theFont2D), fontStrike(theFontStrike),
  46       xppem(0), yppem(0),
  47       xScaleUnitsToPoints(0), yScaleUnitsToPoints(0),
  48       xScalePixelsToUnits(0), yScalePixelsToUnits(0),
  49       upem(theUPEM), layoutTables(ltables)
  50 {
  51     xPointSize = euclidianDistance(matrix[0], matrix[1]);
  52     yPointSize = euclidianDistance(matrix[2], matrix[3]);
  53 
  54     txMat[0] = matrix[0]/xPointSize;
  55     txMat[1] = matrix[1]/xPointSize;
  56     txMat[2] = matrix[2]/yPointSize;
  57     txMat[3] = matrix[3]/yPointSize;
  58 
  59     xppem = ((float) xRes / 72) * xPointSize;
  60     yppem = ((float) yRes / 72) * yPointSize;
  61 
  62     xScaleUnitsToPoints = xPointSize / upem;
  63     yScaleUnitsToPoints = yPointSize / upem;
  64 
  65     xScalePixelsToUnits = upem / xppem;
  66     yScalePixelsToUnits = upem / yppem;
  67 };
  68 
  69 
  70 const void *FontInstanceAdapter::getFontTable(LETag tableTag) const
  71 {
  72   size_t ignored = 0;
  73   return getFontTable(tableTag, ignored);
  74 }
  75 
  76 static const LETag cacheMap[LAYOUTCACHE_ENTRIES] = {
  77   GPOS_TAG, GDEF_TAG, GSUB_TAG, MORT_TAG, MORX_TAG, KERN_TAG
  78 };
  79 
  80 const void *FontInstanceAdapter::getFontTable(LETag tableTag, size_t &length) const
  81 {
  82   length = 0;
  83 
  84   if (!layoutTables) { // t1 font
  85     return 0;
  86   }
  87 
  88   // cache in font's pscaler object
  89   // font disposer will handle for us
  90 
  91   int cacheIdx;
  92   for (cacheIdx=0;cacheIdx<LAYOUTCACHE_ENTRIES;cacheIdx++) {
  93     if (tableTag==cacheMap[cacheIdx]) break;
  94   }
  95 
  96   if (cacheIdx<LAYOUTCACHE_ENTRIES) { // if found
  97     if (layoutTables->entries[cacheIdx].len != -1) {
  98       length = layoutTables->entries[cacheIdx].len;
  99       return layoutTables->entries[cacheIdx].ptr;
 100     }
 101   } else {
 102     //fprintf(stderr, "unexpected table request from font instance adapter: %x\n", tableTag);
 103     // (don't load any other tables)
 104     return 0;
 105   }
 106 
 107   jbyte* result = 0;
 108   jsize  len = 0;
 109   jbyteArray tableBytes = (jbyteArray)
 110     env->CallObjectMethod(font2D, sunFontIDs.getTableBytesMID, tableTag);
 111   if (!IS_NULL(tableBytes)) {
 112     len = env->GetArrayLength(tableBytes);
 113     result = new jbyte[len];
 114     env->GetByteArrayRegion(tableBytes, 0, len, result);
 115   }
 116 
 117   if (cacheIdx<LAYOUTCACHE_ENTRIES) { // if cacheable table
 118     layoutTables->entries[cacheIdx].len = len;
 119     layoutTables->entries[cacheIdx].ptr = (const void*)result;
 120   }
 121 
 122   length = len;
 123   return (const void*)result;
 124 };
 125 
 126 LEGlyphID FontInstanceAdapter::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper) const
 127 {
 128     LEUnicode32 mappedChar = mapper->mapChar(ch);
 129 
 130     if (mappedChar == 0xFFFF || mappedChar == 0xFFFE) {
 131         return 0xFFFF;
 132     }
 133 
 134     if (mappedChar == 0x200C || mappedChar == 0x200D) {
 135         return 1;
 136     }
 137 
 138     LEGlyphID id = (LEGlyphID)env->CallIntMethod(font2D, sunFontIDs.f2dCharToGlyphMID, (jint)mappedChar);
 139     return id;
 140 }
 141 
 142 LEGlyphID FontInstanceAdapter::mapCharToGlyph(LEUnicode32 ch) const
 143 {
 144     LEGlyphID id = (LEGlyphID)env->CallIntMethod(font2D, sunFontIDs.f2dCharToGlyphMID, ch);
 145     return id;
 146 }
 147 
 148 void FontInstanceAdapter::mapCharsToWideGlyphs(const LEUnicode chars[],
 149     le_int32 offset, le_int32 count, le_bool reverse,
 150     const LECharMapper *mapper, le_uint32 glyphs[]) const
 151 {
 152     le_int32 i, out = 0, dir = 1;
 153 
 154     if (reverse) {
 155         out = count - 1;
 156         dir = -1;
 157     }
 158 
 159     for (i = offset; i < offset + count; i += 1, out += dir) {
 160                 LEUnicode16 high = chars[i];
 161                 LEUnicode32 code = high;
 162 
 163                 if (i < offset + count - 1 && high >= 0xD800 && high <= 0xDBFF) {
 164                         LEUnicode16 low = chars[i + 1];
 165 
 166                         if (low >= 0xDC00 && low <= 0xDFFF) {
 167                                 code = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
 168                         }
 169                 }
 170 
 171         glyphs[out] = mapCharToWideGlyph(code, mapper);
 172 
 173                 if (code >= 0x10000) {
 174                         i += 1;
 175                         glyphs[out += dir] = 0xFFFF;
 176                 }
 177     }
 178 }
 179 
 180 le_uint32 FontInstanceAdapter::mapCharToWideGlyph(LEUnicode32 ch, const LECharMapper *mapper) const
 181 {
 182     LEUnicode32 mappedChar = mapper->mapChar(ch);
 183 
 184     if (mappedChar == 0xFFFF) {
 185         return 0xFFFF;
 186     }
 187 
 188     if (mappedChar == 0x200C || mappedChar == 0x200D) {
 189         return 1;
 190     }
 191 
 192     return (LEGlyphID)env->CallIntMethod(font2D, sunFontIDs.charToGlyphMID,
 193                                          mappedChar);
 194 }
 195 
 196 void FontInstanceAdapter::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const
 197 {
 198     getWideGlyphAdvance((le_uint32)glyph, advance);
 199 }
 200 
 201 void FontInstanceAdapter::getKerningAdjustment(LEPoint &adjustment) const
 202 {
 203     float xx, xy, yx, yy;
 204     le_bool isIdentityMatrix;
 205 
 206     isIdentityMatrix = (txMat[0] == 1 && txMat[1] == 0 &&
 207                         txMat[2] == 0 && txMat[3] == 1);
 208 
 209     if (!isIdentityMatrix) {
 210       xx = adjustment.fX;
 211       xy = xx * txMat[1];
 212       xx = xx * txMat[0];
 213 
 214       yy = adjustment.fY;
 215       yx = yy * txMat[2];
 216       yy = yy * txMat[3];
 217 
 218       adjustment.fX = xx + yx;
 219       adjustment.fY = xy + yy;
 220     }
 221 
 222     jobject pt = env->NewObject(sunFontIDs.pt2DFloatClass,
 223                                 sunFontIDs.pt2DFloatCtr,
 224                                 adjustment.fX, adjustment.fY);





 225     env->CallObjectMethod(fontStrike, sunFontIDs.adjustPointMID, pt);
 226     adjustment.fX = env->GetFloatField(pt, sunFontIDs.xFID);
 227     adjustment.fY = env->GetFloatField(pt, sunFontIDs.yFID);

 228 }
 229 
 230 void FontInstanceAdapter::getWideGlyphAdvance(le_uint32 glyph, LEPoint &advance) const
 231 {
 232     if ((glyph & 0xfffe) == 0xfffe) {
 233         advance.fX = 0;
 234         advance.fY = 0;
 235         return;
 236     }
 237     jobject pt = env->CallObjectMethod(fontStrike,
 238                                        sunFontIDs.getGlyphMetricsMID, glyph);
 239     if (pt != NULL) {
 240         advance.fX = env->GetFloatField(pt, sunFontIDs.xFID);
 241         advance.fY = env->GetFloatField(pt, sunFontIDs.yFID);
 242         env->DeleteLocalRef(pt);
 243     }
 244 }
 245 
 246 le_bool FontInstanceAdapter::getGlyphPoint(LEGlyphID glyph,
 247                                            le_int32 pointNumber,
 248                                            LEPoint &point) const
 249 {
 250   /* This upcall is not ideal, since it will make another down call.
 251    * The intention is to move up some of this code into Java. But
 252    * a HashMap has been added to the Java PhysicalStrike object to cache
 253    * these points so that they don't need to be repeatedly recalculated
 254    * which is expensive as it needs the font scaler to re-generate the
 255    * hinted glyph outline. This turns out to be a huge win over 1.4.x
 256    */
 257      jobject pt = env->CallObjectMethod(fontStrike,
 258                                         sunFontIDs.getGlyphPointMID,
 259                                         glyph, pointNumber);
 260      if (pt != NULL) {
 261        /* point is a java.awt.geom.Point2D.Float */
 262         point.fX = env->GetFloatField(pt, sunFontIDs.xFID);
 263         /* convert from java coordinate system to internal '+y up' coordinate system */
 264         point.fY = -env->GetFloatField(pt, sunFontIDs.yFID);
 265         return true;
 266      } else {
 267         return false;
 268      }
 269 }
 270 
 271 void FontInstanceAdapter::transformFunits(float xFunits, float yFunits, LEPoint &pixels) const
 272 {
 273     float xx, xy, yx, yy;
 274     le_bool isIdentityMatrix;
 275 
 276     isIdentityMatrix = (txMat[0] == 1 && txMat[1] == 0 &&
 277                         txMat[2] == 0 && txMat[3] == 1);
 278 
 279     xx = xFunits * xScaleUnitsToPoints;
 280     xy = 0;
 281     if (!isIdentityMatrix) {
 282         xy = xx * txMat[1];
 283         xx = xx * txMat[0];
 284     };
 285 
 286     yx = 0;
 287     yy = yFunits * yScaleUnitsToPoints;
 288     if (!isIdentityMatrix) {
 289         yx = yy * txMat[2];
 290         yy = yy * txMat[3];
 291     };
 292     pixels.fX = xx + yx;
 293     pixels.fY = xy + yy;
 294 }
 295 
 296 
 297 float FontInstanceAdapter::euclidianDistance(float a, float b)
 298 {
 299     if (a < 0) {
 300         a = -a;
 301     }
 302 
 303     if (b < 0) {
 304         b = -b;
 305     }
 306 
 307     if (a == 0) {
 308         return b;
 309     }
 310 
 311     if (b == 0) {
 312         return a;
 313     }
 314 
 315     float root = a > b ? a + (b / 2) : b + (a / 2); /* Do an initial approximation, in root */
 316 
 317         /* An unrolled Newton-Raphson iteration sequence */
 318     root = (root + (a * (a / root)) + (b * (b / root)) + 1) / 2;
 319     root = (root + (a * (a / root)) + (b * (b / root)) + 1) / 2;
 320     root = (root + (a * (a / root)) + (b * (b / root)) + 1) / 2;
 321 
 322     return root;
 323 }
--- EOF ---