1 /*
   2  * Copyright (c) 2003, 2020, 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 package sun.font;
  27 
  28 import java.lang.ref.SoftReference;
  29 import java.lang.ref.WeakReference;
  30 import java.awt.Font;
  31 import java.awt.GraphicsEnvironment;
  32 import java.awt.Rectangle;
  33 import java.awt.geom.AffineTransform;
  34 import java.awt.geom.GeneralPath;
  35 import java.awt.geom.NoninvertibleTransformException;
  36 import java.awt.geom.Point2D;
  37 import java.awt.geom.Rectangle2D;
  38 import java.util.concurrent.ConcurrentHashMap;
  39 import static sun.awt.SunHints.*;
  40 
  41 
  42 public class FileFontStrike extends PhysicalStrike {
  43 
  44     /* fffe and ffff are values we specially interpret as meaning
  45      * invisible glyphs.
  46      */
  47     static final int INVISIBLE_GLYPHS = 0x0fffe;
  48 
  49     private FileFont fileFont;
  50 
  51     /* REMIND: replace this scheme with one that installs a cache
  52      * instance of the appropriate type. It will require changes in
  53      * FontStrikeDisposer and NativeStrike etc.
  54      */
  55     private static final int UNINITIALISED = 0;
  56     private static final int INTARRAY      = 1;
  57     private static final int LONGARRAY     = 2;
  58     private static final int SEGINTARRAY   = 3;
  59     private static final int SEGLONGARRAY  = 4;
  60 
  61     private volatile int glyphCacheFormat = UNINITIALISED;
  62 
  63     /* segmented arrays are blocks of 32 */
  64     private static final int SEGSHIFT = 5;
  65     private static final int SEGSIZE  = 1 << SEGSHIFT;
  66 
  67     private boolean segmentedCache;
  68     private int[][] segIntGlyphImages;
  69     private long[][] segLongGlyphImages;
  70 
  71     /* The "metrics" information requested by clients is usually nothing
  72      * more than the horizontal advance of the character.
  73      * In most cases this advance and other metrics information is stored
  74      * in the glyph image cache.
  75      * But in some cases we do not automatically retrieve the glyph
  76      * image when the advance is requested. In those cases we want to
  77      * cache the advances since this has been shown to be important for
  78      * performance.
  79      * The segmented cache is used in cases when the single array
  80      * would be too large.
  81      */
  82     private float[] horizontalAdvances;
  83     private float[][] segHorizontalAdvances;
  84 
  85     /* Outline bounds are used when printing and when drawing outlines
  86      * to the screen. On balance the relative rarity of these cases
  87      * and the fact that getting this requires generating a path at
  88      * the scaler level means that its probably OK to store these
  89      * in a Java-level hashmap as the trade-off between time and space.
  90      * Later can revisit whether to cache these at all, or elsewhere.
  91      * Should also profile whether subsequent to getting the bounds, the
  92      * outline itself is also requested. The 1.4 implementation doesn't
  93      * cache outlines so you could generate the path twice - once to get
  94      * the bounds and again to return the outline to the client.
  95      * If the two uses are coincident then also look into caching outlines.
  96      * One simple optimisation is that we could store the last single
  97      * outline retrieved. This assumes that bounds then outline will always
  98      * be retrieved for a glyph rather than retrieving bounds for all glyphs
  99      * then outlines for all glyphs.
 100      */
 101     ConcurrentHashMap<Integer, Rectangle2D.Float> boundsMap;
 102     SoftReference<ConcurrentHashMap<Integer, Point2D.Float>>
 103         glyphMetricsMapRef;
 104 
 105     AffineTransform invertDevTx;
 106 
 107     boolean useNatives;
 108     NativeStrike[] nativeStrikes;
 109 
 110     /* Used only for communication to native layer */
 111     private int intPtSize;
 112 
 113     /* Perform global initialisation needed for Windows native rasterizer */
 114     private static native boolean initNative();
 115     private static boolean isXPorLater = false;
 116     static {
 117         if (FontUtilities.isWindows && !FontUtilities.useJDKScaler &&
 118             !GraphicsEnvironment.isHeadless()) {
 119             isXPorLater = initNative();
 120         }
 121     }
 122 
 123     FileFontStrike(FileFont fileFont, FontStrikeDesc desc) {
 124         super(fileFont, desc);
 125         this.fileFont = fileFont;
 126 
 127         if (desc.style != fileFont.style) {
 128           /* If using algorithmic styling, the base values are
 129            * boldness = 1.0, italic = 0.0. The superclass constructor
 130            * initialises these.
 131            */
 132             if ((desc.style & Font.ITALIC) == Font.ITALIC &&
 133                 (fileFont.style & Font.ITALIC) == 0) {
 134                 algoStyle = true;
 135                 italic = 0.7f;
 136             }
 137             if ((desc.style & Font.BOLD) == Font.BOLD &&
 138                 ((fileFont.style & Font.BOLD) == 0)) {
 139                 algoStyle = true;
 140                 boldness = 1.33f;
 141             }
 142         }
 143         double[] matrix = new double[4];
 144         AffineTransform at = desc.glyphTx;
 145         at.getMatrix(matrix);
 146         if (!desc.devTx.isIdentity() &&
 147             desc.devTx.getType() != AffineTransform.TYPE_TRANSLATION) {
 148             try {
 149                 invertDevTx = desc.devTx.createInverse();
 150             } catch (NoninvertibleTransformException e) {
 151             }
 152         }
 153 
 154         /* If any of the values is NaN then substitute the null scaler context.
 155          * This will return null images, zero advance, and empty outlines
 156          * as no rendering need take place in this case.
 157          * We pass in the null scaler as the singleton null context
 158          * requires it. However
 159          */
 160         if (Double.isNaN(matrix[0]) || Double.isNaN(matrix[1]) ||
 161             Double.isNaN(matrix[2]) || Double.isNaN(matrix[3]) ||
 162             fileFont.getScaler() == null) {
 163             pScalerContext = NullFontScaler.getNullScalerContext();
 164         } else {
 165             pScalerContext = fileFont.getScaler().createScalerContext(matrix,
 166                                     desc.aaHint, desc.fmHint,
 167                                     boldness, italic);
 168         }
 169 
 170         mapper = fileFont.getMapper();
 171         int numGlyphs = mapper.getNumGlyphs();
 172 
 173         /* Always segment for fonts with > 256 glyphs, but also for smaller
 174          * fonts with non-typical sizes and transforms.
 175          * Segmenting for all non-typical pt sizes helps to minimize memory
 176          * usage when very many distinct strikes are created.
 177          * The size range of 0->5 and 37->INF for segmenting is arbitrary
 178          * but the intention is that typical GUI integer point sizes (6->36)
 179          * should not segment unless there's another reason to do so.
 180          */
 181         float ptSize = (float)matrix[3]; // interpreted only when meaningful.
 182         int iSize = intPtSize = (int)ptSize;
 183         boolean isSimpleTx = (at.getType() & complexTX) == 0;
 184         segmentedCache =
 185             (numGlyphs > SEGSIZE << 3) ||
 186             ((numGlyphs > SEGSIZE << 1) &&
 187              (!isSimpleTx || ptSize != iSize || iSize < 6 || iSize > 36));
 188 
 189         /* This can only happen if we failed to allocate memory for context.
 190          * NB: in such case we may still have some memory in java heap
 191          *     but subsequent attempt to allocate null scaler context
 192          *     may fail too (cause it is allocate in the native heap).
 193          *     It is not clear how to make this more robust but on the
 194          *     other hand getting NULL here seems to be extremely unlikely.
 195          */
 196         if (pScalerContext == 0L) {
 197             /* REMIND: when the code is updated to install cache objects
 198              * rather than using a switch this will be more efficient.
 199              */
 200             this.disposer = new FontStrikeDisposer(fileFont, desc);
 201             initGlyphCache();
 202             pScalerContext = NullFontScaler.getNullScalerContext();
 203             SunFontManager.getInstance().deRegisterBadFont(fileFont);
 204             return;
 205         }
 206         /* First, see if native code should be used to create the glyph.
 207          * GDI will return the integer metrics, not fractional metrics, which
 208          * may be requested for this strike, so we would require here that :
 209          * desc.fmHint != INTVAL_FRACTIONALMETRICS_ON
 210          * except that the advance returned by GDI is always overwritten by
 211          * the JDK rasteriser supplied one (see getGlyphImageFromWindows()).
 212          */
 213         if (FontUtilities.isWindows && isXPorLater &&
 214             !FontUtilities.useJDKScaler &&
 215             !GraphicsEnvironment.isHeadless() &&
 216             !fileFont.useJavaRasterizer &&
 217             (desc.aaHint == INTVAL_TEXT_ANTIALIAS_LCD_HRGB ||
 218              desc.aaHint == INTVAL_TEXT_ANTIALIAS_LCD_HBGR) &&
 219             (matrix[1] == 0.0 && matrix[2] == 0.0 &&
 220              matrix[0] == matrix[3] &&
 221              matrix[0] >= 3.0 && matrix[0] <= 100.0) &&
 222             !((TrueTypeFont)fileFont).useEmbeddedBitmapsForSize(intPtSize)) {
 223             useNatives = true;
 224         }
 225         if (FontUtilities.isWindows) {
 226             FontUtilities.logInfo("Strike for " + fileFont + " at size = " + intPtSize +
 227                  " use natives = " + useNatives +
 228                  " useJavaRasteriser = " + fileFont.useJavaRasterizer +
 229                  " AAHint = " + desc.aaHint +
 230                  " Has Embedded bitmaps = " +
 231                  ((TrueTypeFont)fileFont).
 232                  useEmbeddedBitmapsForSize(intPtSize));
 233         }
 234         this.disposer = new FontStrikeDisposer(fileFont, desc, pScalerContext);
 235 
 236         /* Always get the image and the advance together for smaller sizes
 237          * that are likely to be important to rendering performance.
 238          * The pixel size of 48.0 can be thought of as
 239          * "maximumSizeForGetImageWithAdvance".
 240          * This should be no greater than OutlineTextRender.THRESHOLD.
 241          */
 242         double maxSz = 48.0;
 243         getImageWithAdvance =
 244             Math.abs(at.getScaleX()) <= maxSz &&
 245             Math.abs(at.getScaleY()) <= maxSz &&
 246             Math.abs(at.getShearX()) <= maxSz &&
 247             Math.abs(at.getShearY()) <= maxSz;
 248 
 249         /* Some applications request advance frequently during layout.
 250          * If we are not getting and caching the image with the advance,
 251          * there is a potentially significant performance penalty if the
 252          * advance is repeatedly requested before requesting the image.
 253          * We should at least cache the horizontal advance.
 254          * REMIND: could use info in the font, eg hmtx, to retrieve some
 255          * advances. But still want to cache it here.
 256          */
 257 
 258         if (!getImageWithAdvance) {
 259             if (!segmentedCache) {
 260                 horizontalAdvances = new float[numGlyphs];
 261                 /* use max float as uninitialised advance */
 262                 for (int i=0; i<numGlyphs; i++) {
 263                     horizontalAdvances[i] = Float.MAX_VALUE;
 264                 }
 265             } else {
 266                 int numSegments = (numGlyphs + SEGSIZE-1)/SEGSIZE;
 267                 segHorizontalAdvances = new float[numSegments][];
 268             }
 269         }
 270     }
 271 
 272     /* A number of methods are delegated by the strike to the scaler
 273      * context which is a shared resource on a physical font.
 274      */
 275 
 276     public int getNumGlyphs() {
 277         return fileFont.getNumGlyphs();
 278     }
 279 
 280     long getGlyphImageFromNative(int glyphCode) {
 281         if (FontUtilities.isWindows) {
 282             return getGlyphImageFromWindows(glyphCode);
 283         } else {
 284             return getGlyphImageFromX11(glyphCode);
 285         }
 286     }
 287 
 288     /* There's no global state conflicts, so this method is not
 289      * presently synchronized.
 290      */
 291     private native long _getGlyphImageFromWindows(String family,
 292                                                   int style,
 293                                                   int size,
 294                                                   int glyphCode,
 295                                                   boolean fracMetrics,
 296                                                   int fontDataSize);
 297 
 298     long getGlyphImageFromWindows(int glyphCode) {
 299         String family = fileFont.getFamilyName(null);
 300         int style = desc.style & Font.BOLD | desc.style & Font.ITALIC
 301             | fileFont.getStyle();
 302         int size = intPtSize;
 303         long ptr = _getGlyphImageFromWindows
 304             (family, style, size, glyphCode,
 305              desc.fmHint == INTVAL_FRACTIONALMETRICS_ON,
 306              ((TrueTypeFont)fileFont).fontDataSize);
 307         if (ptr != 0) {
 308             /* Get the advance from the JDK rasterizer. This is mostly
 309              * necessary for the fractional metrics case, but there are
 310              * also some very small number (<0.25%) of marginal cases where
 311              * there is some rounding difference between windows and JDK.
 312              * After these are resolved, we can restrict this extra
 313              * work to the FM case.
 314              */
 315             float advance = getGlyphAdvance(glyphCode, false);
 316             StrikeCache.unsafe.putFloat(ptr + StrikeCache.xAdvanceOffset,
 317                                         advance);
 318             return ptr;
 319         } else {
 320             FontUtilities.logWarning("Failed to render glyph using GDI: code=" + glyphCode
 321                                 + ", fontFamily=" + family + ", style=" + style
 322                                 + ", size=" + size);
 323             return fileFont.getGlyphImage(pScalerContext, glyphCode);
 324         }
 325     }
 326 
 327     /* Try the native strikes first, then try the fileFont strike */
 328     long getGlyphImageFromX11(int glyphCode) {
 329         long glyphPtr;
 330         char charCode = fileFont.glyphToCharMap[glyphCode];
 331         for (int i=0;i<nativeStrikes.length;i++) {
 332             CharToGlyphMapper mapper = fileFont.nativeFonts[i].getMapper();
 333             int gc = mapper.charToGlyph(charCode)&0xffff;
 334             if (gc != mapper.getMissingGlyphCode()) {
 335                 glyphPtr = nativeStrikes[i].getGlyphImagePtrNoCache(gc);
 336                 if (glyphPtr != 0L) {
 337                     return glyphPtr;
 338                 }
 339             }
 340         }
 341         return fileFont.getGlyphImage(pScalerContext, glyphCode);
 342     }
 343 
 344     long getGlyphImagePtr(int glyphCode) {
 345         if (glyphCode >= INVISIBLE_GLYPHS) {
 346             return StrikeCache.invisibleGlyphPtr;
 347         }
 348         long glyphPtr = 0L;
 349         if ((glyphPtr = getCachedGlyphPtr(glyphCode)) != 0L) {
 350             return glyphPtr;
 351         } else {
 352             if (useNatives) {
 353                 glyphPtr = getGlyphImageFromNative(glyphCode);
 354                 if (glyphPtr == 0L) {
 355                     FontUtilities.logInfo("Strike for " + fileFont +
 356                          " at size = " + intPtSize +
 357                          " couldn't get native glyph for code = " + glyphCode);
 358                  }
 359             } if (glyphPtr == 0L) {
 360                 glyphPtr = fileFont.getGlyphImage(pScalerContext,
 361                                                   glyphCode);
 362             }
 363             return setCachedGlyphPtr(glyphCode, glyphPtr);
 364         }
 365     }
 366 
 367     void getGlyphImagePtrs(int[] glyphCodes, long[] images, int  len) {
 368 
 369         for (int i=0; i<len; i++) {
 370             int glyphCode = glyphCodes[i];
 371             if (glyphCode >= INVISIBLE_GLYPHS) {
 372                 images[i] = StrikeCache.invisibleGlyphPtr;
 373                 continue;
 374             } else if ((images[i] = getCachedGlyphPtr(glyphCode)) != 0L) {
 375                 continue;
 376             } else {
 377                 long glyphPtr = 0L;
 378                 if (useNatives) {
 379                     glyphPtr = getGlyphImageFromNative(glyphCode);
 380                 } if (glyphPtr == 0L) {
 381                     glyphPtr = fileFont.getGlyphImage(pScalerContext,
 382                                                       glyphCode);
 383                 }
 384                 images[i] = setCachedGlyphPtr(glyphCode, glyphPtr);
 385             }
 386         }
 387     }
 388 
 389     /* The following method is called from CompositeStrike as a special case.
 390      */
 391     int getSlot0GlyphImagePtrs(int[] glyphCodes, long[] images, int len) {
 392 
 393         int convertedCnt = 0;
 394 
 395         for (int i=0; i<len; i++) {
 396             int glyphCode = glyphCodes[i];
 397             if (glyphCode >>> 24 != 0) {
 398                 return convertedCnt;
 399             } else {
 400                 convertedCnt++;
 401             }
 402             if (glyphCode >= INVISIBLE_GLYPHS) {
 403                 images[i] = StrikeCache.invisibleGlyphPtr;
 404                 continue;
 405             } else if ((images[i] = getCachedGlyphPtr(glyphCode)) != 0L) {
 406                 continue;
 407             } else {
 408                 long glyphPtr = 0L;
 409                 if (useNatives) {
 410                     glyphPtr = getGlyphImageFromNative(glyphCode);
 411                 }
 412                 if (glyphPtr == 0L) {
 413                     glyphPtr = fileFont.getGlyphImage(pScalerContext,
 414                                                       glyphCode);
 415                 }
 416                 images[i] = setCachedGlyphPtr(glyphCode, glyphPtr);
 417             }
 418         }
 419         return convertedCnt;
 420     }
 421 
 422     /* Only look in the cache */
 423     long getCachedGlyphPtr(int glyphCode) {
 424         try {
 425             return getCachedGlyphPtrInternal(glyphCode);
 426         } catch (Exception e) {
 427           NullFontScaler nullScaler =
 428              (NullFontScaler)FontScaler.getNullScaler();
 429           long nullSC = NullFontScaler.getNullScalerContext();
 430           return nullScaler.getGlyphImage(nullSC, glyphCode);
 431         }
 432     }
 433 
 434     private long getCachedGlyphPtrInternal(int glyphCode) {
 435         switch (glyphCacheFormat) {
 436             case INTARRAY:
 437                 return intGlyphImages[glyphCode] & INTMASK;
 438             case SEGINTARRAY:
 439                 int segIndex = glyphCode >> SEGSHIFT;
 440                 if (segIntGlyphImages[segIndex] != null) {
 441                     int subIndex = glyphCode % SEGSIZE;
 442                     return segIntGlyphImages[segIndex][subIndex] & INTMASK;
 443                 } else {
 444                     return 0L;
 445                 }
 446             case LONGARRAY:
 447                 return longGlyphImages[glyphCode];
 448             case SEGLONGARRAY:
 449                 segIndex = glyphCode >> SEGSHIFT;
 450                 if (segLongGlyphImages[segIndex] != null) {
 451                     int subIndex = glyphCode % SEGSIZE;
 452                     return segLongGlyphImages[segIndex][subIndex];
 453                 } else {
 454                     return 0L;
 455                 }
 456         }
 457         /* If reach here cache is UNINITIALISED. */
 458         return 0L;
 459     }
 460 
 461     private synchronized long setCachedGlyphPtr(int glyphCode, long glyphPtr) {
 462         try {
 463             return setCachedGlyphPtrInternal(glyphCode, glyphPtr);
 464         } catch (Exception e) {
 465             switch (glyphCacheFormat) {
 466                 case INTARRAY:
 467                 case SEGINTARRAY:
 468                     StrikeCache.freeIntPointer((int)glyphPtr);
 469                     break;
 470                 case LONGARRAY:
 471                 case SEGLONGARRAY:
 472                     StrikeCache.freeLongPointer(glyphPtr);
 473                     break;
 474              }
 475              NullFontScaler nullScaler =
 476                  (NullFontScaler)FontScaler.getNullScaler();
 477              long nullSC = NullFontScaler.getNullScalerContext();
 478              return nullScaler.getGlyphImage(nullSC, glyphCode);
 479         }
 480     }
 481 
 482     private long setCachedGlyphPtrInternal(int glyphCode, long glyphPtr) {
 483         switch (glyphCacheFormat) {
 484             case INTARRAY:
 485                 if (intGlyphImages[glyphCode] == 0) {
 486                     intGlyphImages[glyphCode] = (int)glyphPtr;
 487                     return glyphPtr;
 488                 } else {
 489                     StrikeCache.freeIntPointer((int)glyphPtr);
 490                     return intGlyphImages[glyphCode] & INTMASK;
 491                 }
 492 
 493             case SEGINTARRAY:
 494                 int segIndex = glyphCode >> SEGSHIFT;
 495                 int subIndex = glyphCode % SEGSIZE;
 496                 if (segIntGlyphImages[segIndex] == null) {
 497                     segIntGlyphImages[segIndex] = new int[SEGSIZE];
 498                 }
 499                 if (segIntGlyphImages[segIndex][subIndex] == 0) {
 500                     segIntGlyphImages[segIndex][subIndex] = (int)glyphPtr;
 501                     return glyphPtr;
 502                 } else {
 503                     StrikeCache.freeIntPointer((int)glyphPtr);
 504                     return segIntGlyphImages[segIndex][subIndex] & INTMASK;
 505                 }
 506 
 507             case LONGARRAY:
 508                 if (longGlyphImages[glyphCode] == 0L) {
 509                     longGlyphImages[glyphCode] = glyphPtr;
 510                     return glyphPtr;
 511                 } else {
 512                     StrikeCache.freeLongPointer(glyphPtr);
 513                     return longGlyphImages[glyphCode];
 514                 }
 515 
 516            case SEGLONGARRAY:
 517                 segIndex = glyphCode >> SEGSHIFT;
 518                 subIndex = glyphCode % SEGSIZE;
 519                 if (segLongGlyphImages[segIndex] == null) {
 520                     segLongGlyphImages[segIndex] = new long[SEGSIZE];
 521                 }
 522                 if (segLongGlyphImages[segIndex][subIndex] == 0L) {
 523                     segLongGlyphImages[segIndex][subIndex] = glyphPtr;
 524                     return glyphPtr;
 525                 } else {
 526                     StrikeCache.freeLongPointer(glyphPtr);
 527                     return segLongGlyphImages[segIndex][subIndex];
 528                 }
 529         }
 530 
 531         /* Reach here only when the cache is not initialised which is only
 532          * for the first glyph to be initialised in the strike.
 533          * Initialise it and recurse. Note that we are already synchronized.
 534          */
 535         initGlyphCache();
 536         return setCachedGlyphPtr(glyphCode, glyphPtr);
 537     }
 538 
 539     /* Called only from synchronized code or constructor */
 540     private synchronized void initGlyphCache() {
 541 
 542         int numGlyphs = mapper.getNumGlyphs();
 543         int tmpFormat = UNINITIALISED;
 544         if (segmentedCache) {
 545             int numSegments = (numGlyphs + SEGSIZE-1)/SEGSIZE;
 546             if (longAddresses) {
 547                 tmpFormat = SEGLONGARRAY;
 548                 segLongGlyphImages = new long[numSegments][];
 549                 this.disposer.segLongGlyphImages = segLongGlyphImages;
 550              } else {
 551                  tmpFormat = SEGINTARRAY;
 552                  segIntGlyphImages = new int[numSegments][];
 553                  this.disposer.segIntGlyphImages = segIntGlyphImages;
 554              }
 555         } else {
 556             if (longAddresses) {
 557                 tmpFormat = LONGARRAY;
 558                 longGlyphImages = new long[numGlyphs];
 559                 this.disposer.longGlyphImages = longGlyphImages;
 560             } else {
 561                 tmpFormat = INTARRAY;
 562                 intGlyphImages = new int[numGlyphs];
 563                 this.disposer.intGlyphImages = intGlyphImages;
 564             }
 565         }
 566         glyphCacheFormat = tmpFormat;
 567     }
 568 
 569     float getGlyphAdvance(int glyphCode) {
 570         return getGlyphAdvance(glyphCode, true);
 571     }
 572 
 573     /* Metrics info is always retrieved. If the GlyphInfo address is non-zero
 574      * then metrics info there is valid and can just be copied.
 575      * This is in user space coordinates unless getUserAdv == false.
 576      * Device space advance should not be propagated out of this class.
 577      */
 578     private float getGlyphAdvance(int glyphCode, boolean getUserAdv) {
 579         float advance;
 580 
 581         if (glyphCode >= INVISIBLE_GLYPHS) {
 582             return 0f;
 583         }
 584 
 585         /* Notes on the (getUserAdv == false) case.
 586          *
 587          * Setting getUserAdv == false is internal to this class.
 588          * If there's no graphics transform we can let
 589          * getGlyphAdvance take its course, and potentially caching in
 590          * advances arrays, except for signalling that
 591          * getUserAdv == false means there is no need to create an image.
 592          * It is possible that code already calculated the user advance,
 593          * and it is desirable to take advantage of that work.
 594          * But, if there's a transform and we want device advance, we
 595          * can't use any values cached in the advances arrays - unless
 596          * first re-transform them into device space using 'desc.devTx'.
 597          * invertDevTx is null if the graphics transform is identity,
 598          * a translate, or non-invertible. The latter case should
 599          * not ever occur in the getUserAdv == false path.
 600          * In other words its either null, or the inversion of a
 601          * simple uniform scale. If its null, we can populate and
 602          * use the advance caches as normal.
 603          *
 604          * If we don't find a cached value, obtain the device advance and
 605          * return it. This will get stashed on the image by the caller and any
 606          * subsequent metrics calls will be able to use it as is the case
 607          * whenever an image is what is initially requested.
 608          *
 609          * Don't query if there's a value cached on the image, since this
 610          * getUserAdv==false code path is entered solely when none exists.
 611          */
 612         if (horizontalAdvances != null) {
 613             advance = horizontalAdvances[glyphCode];
 614             if (advance != Float.MAX_VALUE) {
 615                 if (!getUserAdv && invertDevTx != null) {
 616                     Point2D.Float metrics = new Point2D.Float(advance, 0f);
 617                     desc.devTx.deltaTransform(metrics, metrics);
 618                     return metrics.x;
 619                 } else {
 620                     return advance;
 621                 }
 622             }
 623         } else if (segmentedCache && segHorizontalAdvances != null) {
 624             int segIndex = glyphCode >> SEGSHIFT;
 625             float[] subArray = segHorizontalAdvances[segIndex];
 626             if (subArray != null) {
 627                 advance = subArray[glyphCode % SEGSIZE];
 628                 if (advance != Float.MAX_VALUE) {
 629                     if (!getUserAdv && invertDevTx != null) {
 630                         Point2D.Float metrics = new Point2D.Float(advance, 0f);
 631                         desc.devTx.deltaTransform(metrics, metrics);
 632                         return metrics.x;
 633                     } else {
 634                         return advance;
 635                     }
 636                 }
 637             }
 638         }
 639 
 640         if (!getUserAdv && invertDevTx != null) {
 641             Point2D.Float metrics = new Point2D.Float();
 642             fileFont.getGlyphMetrics(pScalerContext, glyphCode, metrics);
 643             return metrics.x;
 644         }
 645 
 646         if (invertDevTx != null || !getUserAdv) {
 647             /* If there is a device transform need x & y advance to
 648              * transform back into user space.
 649              */
 650             advance = getGlyphMetrics(glyphCode, getUserAdv).x;
 651         } else {
 652             long glyphPtr;
 653             if (getImageWithAdvance) {
 654                 /* A heuristic optimisation says that for most cases its
 655                  * worthwhile retrieving the image at the same time as the
 656                  * advance. So here we get the image data even if its not
 657                  * already cached.
 658                  */
 659                 glyphPtr = getGlyphImagePtr(glyphCode);
 660             } else {
 661                 glyphPtr = getCachedGlyphPtr(glyphCode);
 662             }
 663             if (glyphPtr != 0L) {
 664                 advance = StrikeCache.unsafe.getFloat
 665                     (glyphPtr + StrikeCache.xAdvanceOffset);
 666 
 667             } else {
 668                 advance = fileFont.getGlyphAdvance(pScalerContext, glyphCode);
 669             }
 670         }
 671 
 672         if (horizontalAdvances != null) {
 673             horizontalAdvances[glyphCode] = advance;
 674         } else if (segmentedCache && segHorizontalAdvances != null) {
 675             int segIndex = glyphCode >> SEGSHIFT;
 676             int subIndex = glyphCode % SEGSIZE;
 677             if (segHorizontalAdvances[segIndex] == null) {
 678                 segHorizontalAdvances[segIndex] = new float[SEGSIZE];
 679                 for (int i=0; i<SEGSIZE; i++) {
 680                      segHorizontalAdvances[segIndex][i] = Float.MAX_VALUE;
 681                 }
 682             }
 683             segHorizontalAdvances[segIndex][subIndex] = advance;
 684         }
 685         return advance;
 686     }
 687 
 688     float getCodePointAdvance(int cp) {
 689         return getGlyphAdvance(mapper.charToGlyph(cp));
 690     }
 691 
 692     /**
 693      * Result and pt are both in device space.
 694      */
 695     void getGlyphImageBounds(int glyphCode, Point2D.Float pt,
 696                              Rectangle result) {
 697 
 698         long ptr = getGlyphImagePtr(glyphCode);
 699         float topLeftX, topLeftY;
 700 
 701         /* With our current design NULL ptr is not possible
 702            but if we eventually allow scalers to return NULL pointers
 703            this check might be actually useful. */
 704         if (ptr == 0L) {
 705             result.x = (int) Math.floor(pt.x+0.5f);
 706             result.y = (int) Math.floor(pt.y+0.5f);
 707             result.width = result.height = 0;
 708             return;
 709         }
 710 
 711         topLeftX = StrikeCache.unsafe.getFloat(ptr+StrikeCache.topLeftXOffset);
 712         topLeftY = StrikeCache.unsafe.getFloat(ptr+StrikeCache.topLeftYOffset);
 713 
 714         result.x = (int)Math.floor(pt.x + topLeftX + 0.5f);
 715         result.y = (int)Math.floor(pt.y + topLeftY + 0.5f);
 716         result.width =
 717             StrikeCache.unsafe.getShort(ptr+StrikeCache.widthOffset)  &0x0ffff;
 718         result.height =
 719             StrikeCache.unsafe.getShort(ptr+StrikeCache.heightOffset) &0x0ffff;
 720 
 721         /* HRGB LCD text may have padding that is empty. This is almost always
 722          * going to be when topLeftX is -2 or less.
 723          * Try to return a tighter bounding box in that case.
 724          * If the first three bytes of every row are all zero, then
 725          * add 1 to "x" and reduce "width" by 1.
 726          */
 727         if ((desc.aaHint == INTVAL_TEXT_ANTIALIAS_LCD_HRGB ||
 728              desc.aaHint == INTVAL_TEXT_ANTIALIAS_LCD_HBGR)
 729             && topLeftX <= -2.0f) {
 730             int minx = getGlyphImageMinX(ptr, result.x);
 731             if (minx > result.x) {
 732                 result.x += 1;
 733                 result.width -=1;
 734             }
 735         }
 736     }
 737 
 738     private int getGlyphImageMinX(long ptr, int origMinX) {
 739 
 740         int width = StrikeCache.unsafe.getChar(ptr+StrikeCache.widthOffset);
 741         int height = StrikeCache.unsafe.getChar(ptr+StrikeCache.heightOffset);
 742         int rowBytes =
 743             StrikeCache.unsafe.getChar(ptr+StrikeCache.rowBytesOffset);
 744 
 745         if (rowBytes == width) {
 746             return origMinX;
 747         }
 748 
 749         long pixelData =
 750             StrikeCache.unsafe.getAddress(ptr + StrikeCache.pixelDataOffset);
 751 
 752         if (pixelData == 0L) {
 753             return origMinX;
 754         }
 755 
 756         for (int y=0;y<height;y++) {
 757             for (int x=0;x<3;x++) {
 758                 if (StrikeCache.unsafe.getByte(pixelData+y*rowBytes+x) != 0) {
 759                     return origMinX;
 760                 }
 761             }
 762         }
 763         return origMinX+1;
 764     }
 765 
 766     /* These 3 metrics methods below should be implemented to return
 767      * values in user space.
 768      */
 769     StrikeMetrics getFontMetrics() {
 770         if (strikeMetrics == null) {
 771             strikeMetrics =
 772                 fileFont.getFontMetrics(pScalerContext);
 773             if (invertDevTx != null) {
 774                 strikeMetrics.convertToUserSpace(invertDevTx);
 775             }
 776         }
 777         return strikeMetrics;
 778     }
 779 
 780     Point2D.Float getGlyphMetrics(int glyphCode) {
 781         return getGlyphMetrics(glyphCode, true);
 782     }
 783 
 784     private Point2D.Float getGlyphMetrics(int glyphCode, boolean getImage) {
 785         Point2D.Float metrics = new Point2D.Float();
 786 
 787         // !!! or do we force sgv user glyphs?
 788         if (glyphCode >= INVISIBLE_GLYPHS) {
 789             return metrics;
 790         }
 791         long glyphPtr;
 792         if (getImageWithAdvance && getImage) {
 793             /* A heuristic optimisation says that for most cases its
 794              * worthwhile retrieving the image at the same time as the
 795              * metrics. So here we get the image data even if its not
 796              * already cached.
 797              */
 798             glyphPtr = getGlyphImagePtr(glyphCode);
 799         } else {
 800              glyphPtr = getCachedGlyphPtr(glyphCode);
 801         }
 802         if (glyphPtr != 0L) {
 803             metrics = new Point2D.Float();
 804             metrics.x = StrikeCache.unsafe.getFloat
 805                 (glyphPtr + StrikeCache.xAdvanceOffset);
 806             metrics.y = StrikeCache.unsafe.getFloat
 807                 (glyphPtr + StrikeCache.yAdvanceOffset);
 808             /* advance is currently in device space, need to convert back
 809              * into user space.
 810              * This must not include the translation component. */
 811             if (invertDevTx != null) {
 812                 invertDevTx.deltaTransform(metrics, metrics);
 813             }
 814         } else {
 815             /* We sometimes cache these metrics as they are expensive to
 816              * generate for large glyphs.
 817              * We never reach this path if we obtain images with advances.
 818              * But if we do not obtain images with advances its possible that
 819              * we first obtain this information, then the image, and never
 820              * will access this value again.
 821              */
 822             Integer key = Integer.valueOf(glyphCode);
 823             Point2D.Float value = null;
 824             ConcurrentHashMap<Integer, Point2D.Float> glyphMetricsMap = null;
 825             if (glyphMetricsMapRef != null) {
 826                 glyphMetricsMap = glyphMetricsMapRef.get();
 827             }
 828             if (glyphMetricsMap != null) {
 829                 value = glyphMetricsMap.get(key);
 830                 if (value != null) {
 831                     metrics.x = value.x;
 832                     metrics.y = value.y;
 833                     /* already in user space */
 834                     return metrics;
 835                 }
 836             }
 837             if (value == null) {
 838                 fileFont.getGlyphMetrics(pScalerContext, glyphCode, metrics);
 839                 /* advance is currently in device space, need to convert back
 840                  * into user space.
 841                  */
 842                 if (invertDevTx != null) {
 843                     invertDevTx.deltaTransform(metrics, metrics);
 844                 }
 845                 value = new Point2D.Float(metrics.x, metrics.y);
 846                 /* We aren't synchronizing here so it is possible to
 847                  * overwrite the map with another one but this is harmless.
 848                  */
 849                 if (glyphMetricsMap == null) {
 850                     glyphMetricsMap =
 851                         new ConcurrentHashMap<Integer, Point2D.Float>();
 852                     glyphMetricsMapRef =
 853                         new SoftReference<ConcurrentHashMap<Integer,
 854                         Point2D.Float>>(glyphMetricsMap);
 855                 }
 856                 glyphMetricsMap.put(key, value);
 857             }
 858         }
 859         return metrics;
 860     }
 861 
 862     Point2D.Float getCharMetrics(char ch) {
 863         return getGlyphMetrics(mapper.charToGlyph(ch));
 864     }
 865 
 866     /* The caller of this can be trusted to return a copy of this
 867      * return value rectangle to public API. In fact frequently it
 868      * can't use this return value directly anyway.
 869      * This returns bounds in device space. Currently the only
 870      * caller is SGV and it converts back to user space.
 871      * We could change things so that this code does the conversion so
 872      * that all coords coming out of the font system are converted back
 873      * into user space even if they were measured in device space.
 874      * The same applies to the other methods that return outlines (below)
 875      * But it may make particular sense for this method that caches its
 876      * results.
 877      * There'd be plenty of exceptions, to this too, eg getGlyphPoint needs
 878      * device coords as its called from native layout and getGlyphImageBounds
 879      * is used by GlyphVector.getGlyphPixelBounds which is specified to
 880      * return device coordinates, the image pointers aren't really used
 881      * up in Java code either.
 882      */
 883     Rectangle2D.Float getGlyphOutlineBounds(int glyphCode) {
 884 
 885         if (boundsMap == null) {
 886             boundsMap = new ConcurrentHashMap<Integer, Rectangle2D.Float>();
 887         }
 888 
 889         Integer key = Integer.valueOf(glyphCode);
 890         Rectangle2D.Float bounds = boundsMap.get(key);
 891 
 892         if (bounds == null) {
 893             bounds = fileFont.getGlyphOutlineBounds(pScalerContext, glyphCode);
 894             boundsMap.put(key, bounds);
 895         }
 896         return bounds;
 897     }
 898 
 899     public Rectangle2D getOutlineBounds(int glyphCode) {
 900         return fileFont.getGlyphOutlineBounds(pScalerContext, glyphCode);
 901     }
 902 
 903     private
 904         WeakReference<ConcurrentHashMap<Integer,GeneralPath>> outlineMapRef;
 905 
 906     GeneralPath getGlyphOutline(int glyphCode, float x, float y) {
 907 
 908         GeneralPath gp = null;
 909         ConcurrentHashMap<Integer, GeneralPath> outlineMap = null;
 910 
 911         if (outlineMapRef != null) {
 912             outlineMap = outlineMapRef.get();
 913             if (outlineMap != null) {
 914                 gp = outlineMap.get(glyphCode);
 915             }
 916         }
 917 
 918         if (gp == null) {
 919             gp = fileFont.getGlyphOutline(pScalerContext, glyphCode, 0, 0);
 920             if (outlineMap == null) {
 921                 outlineMap = new ConcurrentHashMap<Integer, GeneralPath>();
 922                 outlineMapRef =
 923                    new WeakReference
 924                        <ConcurrentHashMap<Integer,GeneralPath>>(outlineMap);
 925             }
 926             outlineMap.put(glyphCode, gp);
 927         }
 928         gp = (GeneralPath)gp.clone(); // mutable!
 929         if (x != 0f || y != 0f) {
 930             gp.transform(AffineTransform.getTranslateInstance(x, y));
 931         }
 932         return gp;
 933     }
 934 
 935     GeneralPath getGlyphVectorOutline(int[] glyphs, float x, float y) {
 936         return fileFont.getGlyphVectorOutline(pScalerContext,
 937                                               glyphs, glyphs.length, x, y);
 938     }
 939 
 940     protected void adjustPoint(Point2D.Float pt) {
 941         if (invertDevTx != null) {
 942             invertDevTx.deltaTransform(pt, pt);
 943         }
 944     }
 945 }