Fix limit on size of glyph paths.

src/ports/SkFontHost_win.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAdvancedTypefaceMetrics.h"
 #include "SkBase64.h"
 #include "SkColorPriv.h"
 #include "SkData.h"
 #include "SkDescriptor.h"
 #include "SkFontDescriptor.h"
 #include "SkFontHost.h"
 #include "SkGlyph.h"
 #include "SkMaskGamma.h"
 #include "SkOTUtils.h"
 #include "SkPath.h"
 #include "SkStream.h"
 #include "SkString.h"
+#include "SkTemplates.h"
 #include "SkThread.h"
 #include "SkTypeface_win.h"
 #include "SkTypefaceCache.h"
 #include "SkUtils.h"
 
 #include "SkTypes.h"
 #include <tchar.h>
 #include <usp10.h>
 #include <objbase.h>
 
 static void (*gEnsureLOGFONTAccessibleProc)(const LOGFONT&);
 
 void SkTypeface_SetEnsureLOGFONTAccessibleProc(void (*proc)(const LOGFONT&)) {
     gEnsureLOGFONTAccessibleProc = proc;
 }
 
 static void call_ensure_accessible(const LOGFONT& lf) {
     if (gEnsureLOGFONTAccessibleProc) {
         gEnsureLOGFONTAccessibleProc(lf);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // always packed xxRRGGBB
 typedef uint32_t SkGdiRGB;
 
-template <typename T> T* SkTAddByteOffset(T* ptr, size_t byteOffset) {
-    return (T*)((char*)ptr + byteOffset);
-}
-
 // define this in your Makefile or .gyp to enforce AA requests
 // which GDI ignores at small sizes. This flag guarantees AA
 // for rotated text, regardless of GDI's notions.
 //#define SK_ENFORCE_ROTATED_TEXT_AA_ON_WINDOWS
 
-// client3d has to undefine this for now
-#define CAN_USE_LOGFONT_NAME
-
 static bool isLCD(const SkScalerContext::Rec& rec) {
     return SkMask::kLCD16_Format == rec.fMaskFormat ||
            SkMask::kLCD32_Format == rec.fMaskFormat;
 }
 
 static bool bothZero(SkScalar a, SkScalar b) {
     return 0 == a && 0 == b;
 }
 
 // returns false if there is any non-90-rotation or skew
@@ skipping 13 matching lines @@
     if (SkMask::kA8_Format == rec.fMaskFormat && !isAxisAligned(rec)) {
         return true;
     }
 #endif
     // false means allow GDI to generate the bits
     return false;
 }
 
 using namespace skia_advanced_typeface_metrics_utils;
 
-static const uint16_t BUFFERSIZE = (16384 - 32);
-static uint8_t glyphbuf[BUFFERSIZE];
-
 /**
  *  Since LOGFONT wants its textsize as an int, and we support fractional sizes,
  *  and since we have a cache of LOGFONTs for our tyepfaces, we always set the
  *  lfHeight to a canonical size, and then we use the 2x2 matrix to achieve the
  *  actual requested size.
  *
  *  Not critical to match the font's upem, but we want it big enough to avoid
  *  precision loss for GDI calls that return ints (e.g. GetOutlineFontMetrics).
  */
 static const int gCanonicalTextSize = 2048;
@@ skipping 440 matching lines @@
 };
 
 static float mul2float(SkScalar a, SkScalar b) {
     return SkScalarToFloat(SkScalarMul(a, b));
 }
 
 static FIXED float2FIXED(float x) {
     return SkFixedToFIXED(SkFloatToFixed(x));
 }
 
-SK_DECLARE_STATIC_MUTEX(gFTMutex);
-
 #define HIRES_TEXTSIZE  2048
 #define HIRES_SHIFT     11
 static inline SkFixed HiResToFixed(int value) {
     return value << (16 - HIRES_SHIFT);
 }
 
 static bool needHiResMetrics(const SkScalar mat[2][2]) {
     return mat[1][0] || mat[0][1];
 }
 
@@ skipping 13 matching lines @@
     }
 }
 
 SkScalerContext_Windows::SkScalerContext_Windows(SkTypeface* rawTypeface,
                                                  const SkDescriptor* desc)
         : SkScalerContext(rawTypeface, desc)
         , fDDC(0)
         , fFont(0)
         , fSavefont(0)
         , fSC(0)
-        , fGlyphCount(-1) {
-    SkAutoMutexAcquire  ac(gFTMutex);
-
+        , fGlyphCount(-1)
+{
     LogFontTypeface* typeface = reinterpret_cast<LogFontTypeface*>(rawTypeface);
 
     fDDC = ::CreateCompatibleDC(NULL);
     SetGraphicsMode(fDDC, GM_ADVANCED);
     SetBkMode(fDDC, TRANSPARENT);
 
     // Scaling by the DPI is inconsistent with how Skia draws elsewhere
     //SkScalar height = -(fRec.fTextSize * GetDeviceCaps(ddc, LOGPIXELSY) / 72);
     LOGFONT lf = typeface->fLogFont;
     lf.lfHeight = -gCanonicalTextSize;
@@ skipping 312 matching lines @@
  *  can get linear values.
  *
  *  GDI grayscale appears to use a hard-coded gamma of 2.3.
  *
  *  GDI grayscale appears to draw using the black and white rasterizer at four
  *  times the size and then downsamples to compute the coverage mask. As a
  *  result there are only seventeen total grays. This lack of fidelity means
  *  that shifting into other color spaces is imprecise.
  */
 static const uint8_t* getInverseGammaTableGDI() {
+    // Since build_power_table is idempotent, many threads can build gTableGdi
+    // simultaneously.
     static bool gInited;
     static uint8_t gTableGdi[256];
-    if (!gInited) {
+    if (gInited) {
+        // Need a L/L (read) barrier (acquire not needed). If gInited is observed
+        // true then gTableGdi is observable, but it must be requested.
+    } else {
         build_power_table(gTableGdi, 2.3f);
+        // Need a S/S (write) barrier (release not needed) here so that this
+        // write to gInited becomes observable after gTableGdi.
         gInited = true;
     }
     return gTableGdi;
 }
 
 /**
  *  This will invert the gamma applied by GDI ClearType, so we can get linear
  *  values.
  *
  *  GDI ClearType uses SPI_GETFONTSMOOTHINGCONTRAST / 1000 as the gamma value.
  *  If this value is not specified, the default is a gamma of 1.4.
  */
 static const uint8_t* getInverseGammaTableClearType() {
+    // We don't expect SPI_GETFONTSMOOTHINGCONTRAST to ever change, so building
+    // gTableClearType with build_power_table is effectively idempotent.
     static bool gInited;
     static uint8_t gTableClearType[256];
-    if (!gInited) {
+    if (gInited) {
+        // Need a L/L (read) barrier (acquire not needed). If gInited is observed
+        // true then gTableClearType is observable, but it must be requested.
+    } else {
         UINT level = 0;
         if (!SystemParametersInfo(SPI_GETFONTSMOOTHINGCONTRAST, 0, &level, 0) || !level) {
             // can't get the data, so use a default
             level = 1400;
         }
         build_power_table(gTableClearType, level / 1000.0f);
+        // Need a S/S (write) barrier (release not needed) here so that this
+        // write to gInited becomes observable after gTableClearType.
         gInited = true;
     }
     return gTableClearType;
 }
 
 #include "SkColorPriv.h"
 
 //Cannot assume that the input rgb is gray due to possible setting of kGenA8FromLCD_Flag.
 template<bool APPLY_PREBLEND>
 static inline uint8_t rgb_to_a8(SkGdiRGB rgb, const uint8_t* table8) {
@@ skipping 35 matching lines @@
     return (c + (c & 1)) & 0x00FFFFFF;
 }
 
 static bool is_rgb_really_bw(const SkGdiRGB* src, int width, int height, int srcRB) {
     for (int y = 0; y < height; ++y) {
         for (int x = 0; x < width; ++x) {
             if (is_not_black_or_white(src[x])) {
                 return false;
             }
         }
-        src = SkTAddByteOffset(src, srcRB);
+        src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
     }
     return true;
 }
 
 // gdi's bitmap is upside-down, so we reverse dst walking in Y
 // whenever we copy it into skia's buffer
 static void rgb_to_bw(const SkGdiRGB* SK_RESTRICT src, size_t srcRB,
                       const SkGlyph& glyph) {
     const int width = glyph.fWidth;
     const size_t dstRB = (width + 7) >> 3;
@@ skipping 24 matching lines @@
         }
         if (bitCount > 0) {
             unsigned byte = 0;
             unsigned mask = 0x80;
             for (int i = 0; i < bitCount; i++) {
                 byte |= src[i] & mask;
                 mask >>= 1;
             }
             dst[byteCount] = byte;
         }
-        src = SkTAddByteOffset(src, srcRB);
+        src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
         dst -= dstRB;
     }
 }
 
 template<bool APPLY_PREBLEND>
 static void rgb_to_a8(const SkGdiRGB* SK_RESTRICT src, size_t srcRB,
                       const SkGlyph& glyph, const uint8_t* table8) {
     const size_t dstRB = glyph.rowBytes();
     const int width = glyph.fWidth;
     uint8_t* SK_RESTRICT dst = (uint8_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
 
     for (int y = 0; y < glyph.fHeight; y++) {
         for (int i = 0; i < width; i++) {
             dst[i] = rgb_to_a8<APPLY_PREBLEND>(src[i], table8);
         }
-        src = SkTAddByteOffset(src, srcRB);
+        src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
         dst -= dstRB;
     }
 }
 
 template<bool APPLY_PREBLEND>
 static void rgb_to_lcd16(const SkGdiRGB* SK_RESTRICT src, size_t srcRB, const SkGlyph& glyph,
                          const uint8_t* tableR, const uint8_t* tableG, const uint8_t* tableB) {
     const size_t dstRB = glyph.rowBytes();
     const int width = glyph.fWidth;
     uint16_t* SK_RESTRICT dst = (uint16_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
 
     for (int y = 0; y < glyph.fHeight; y++) {
         for (int i = 0; i < width; i++) {
             dst[i] = rgb_to_lcd16<APPLY_PREBLEND>(src[i], tableR, tableG, tableB);
         }
-        src = SkTAddByteOffset(src, srcRB);
+        src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
         dst = (uint16_t*)((char*)dst - dstRB);
     }
 }
 
 template<bool APPLY_PREBLEND>
 static void rgb_to_lcd32(const SkGdiRGB* SK_RESTRICT src, size_t srcRB, const SkGlyph& glyph,
                          const uint8_t* tableR, const uint8_t* tableG, const uint8_t* tableB) {
     const size_t dstRB = glyph.rowBytes();
     const int width = glyph.fWidth;
     uint32_t* SK_RESTRICT dst = (uint32_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
 
     for (int y = 0; y < glyph.fHeight; y++) {
         for (int i = 0; i < width; i++) {
             dst[i] = rgb_to_lcd32<APPLY_PREBLEND>(src[i], tableR, tableG, tableB);
         }
-        src = SkTAddByteOffset(src, srcRB);
+        src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
         dst = (uint32_t*)((char*)dst - dstRB);
     }
 }
 
 static inline unsigned clamp255(unsigned x) {
     SkASSERT(x <= 256);
     return x - (x >> 8);
 }
 
 void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) {
-    SkAutoMutexAcquire ac(gFTMutex);
     SkASSERT(fDDC);
 
     const bool isBW = SkMask::kBW_Format == fRec.fMaskFormat;
     const bool isAA = !isLCD(fRec);
 
     size_t srcRB;
     const void* bits = fOffscreen.draw(glyph, isBW, &srcRB);
     if (NULL == bits) {
         LogFontTypeface::EnsureAccessible(this->getTypeface());
         bits = fOffscreen.draw(glyph, isBW, &srcRB);
@@ skipping 18 matching lines @@
         //Other code may also be applying the pre-blend, so we'd need another
         //one with this and one without.
         SkGdiRGB* addr = (SkGdiRGB*)bits;
         for (int y = 0; y < glyph.fHeight; ++y) {
             for (int x = 0; x < glyph.fWidth; ++x) {
                 int r = (addr[x] >> 16) & 0xFF;
                 int g = (addr[x] >>  8) & 0xFF;
                 int b = (addr[x] >>  0) & 0xFF;
                 addr[x] = (table[r] << 16) | (table[g] << 8) | table[b];
             }
-            addr = SkTAddByteOffset(addr, srcRB);
+            addr = SkTAddOffset<SkGdiRGB>(addr, srcRB);
         }
     }
 
     int width = glyph.fWidth;
     size_t dstRB = glyph.rowBytes();
     if (isBW) {
         const uint8_t* src = (const uint8_t*)bits;
         uint8_t* dst = (uint8_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
         for (int y = 0; y < glyph.fHeight; y++) {
             memcpy(dst, src, dstRB);
@@ skipping 31 matching lines @@
                 } else {
                     rgb_to_lcd32<false>(src, srcRB, glyph,
                                         fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);
                 }
             }
         }
     }
 }
 
 void SkScalerContext_Windows::generatePath(const SkGlyph& glyph, SkPath* path) {
-
-    SkAutoMutexAcquire ac(gFTMutex);
-
     SkASSERT(&glyph && path);
     SkASSERT(fDDC);
 
     path->reset();
 
     GLYPHMETRICS gm;
-    uint32_t total_size = GetGlyphOutlineW(fDDC, glyph.fID, GGO_NATIVE | GGO_GLYPH_INDEX, &gm, BUFFERSIZE, glyphbuf, &fMat22);
+
+    // Out of all the fonts on a typical Windows box,
+    // 25% of glyphs require more than 2KB.
+    // 1% of glyphs require more than 4KB.
+    // 0.01% of glyphs require more than 8KB.
+    // 8KB is less than 1% of the normal 1MB stack on Windows.
+    // Note that some web fonts glyphs require more than 20KB.
+    static const uint16_t BUFFERSIZE = (1 << 13);
+    SkAutoSTMalloc<BUFFERSIZE, uint8_t> glyphbuf(BUFFERSIZE);
+
+    const UINT flags = GGO_NATIVE | GGO_GLYPH_INDEX;
+    DWORD total_size = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, BUFFERSIZE, glyphbuf, &fMat22);
     if (GDI_ERROR == total_size) {
-        LogFontTypeface::EnsureAccessible(this->getTypeface());
-        total_size = GetGlyphOutlineW(fDDC, glyph.fID, GGO_NATIVE | GGO_GLYPH_INDEX, &gm, BUFFERSIZE, glyphbuf, &fMat22);
+        // GDI_ERROR because the BUFFERSIZE was too small, or because the data was not accessible.
+        // When the data is not accessable GetGlyphOutlineW fails rather quickly,
+        // so just try to get the size. If that fails then ensure the data is accessible.
+        total_size = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, 0, NULL, &fMat22);
         if (GDI_ERROR == total_size) {
-            SkASSERT(false);
-            return;
+            LogFontTypeface::EnsureAccessible(this->getTypeface());
+            total_size = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, 0, NULL, &fMat22);
+            if (GDI_ERROR == total_size) {
+                SkASSERT(false);
+                return;
+            }
+        }
+
+        glyphbuf.reset(total_size);
+
+        DWORD ret = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, total_size, glyphbuf, &fMat22);
+        if (GDI_ERROR == ret) {
+            LogFontTypeface::EnsureAccessible(this->getTypeface());
+            ret = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, total_size, glyphbuf, &fMat22);
+            if (GDI_ERROR == ret) {
+                SkASSERT(false);
+                return;
+            }
         }
     }
 
     const uint8_t* cur_glyph = glyphbuf;
     const uint8_t* end_glyph = glyphbuf + total_size;
 
     while (cur_glyph < end_glyph) {
         const TTPOLYGONHEADER* th = (TTPOLYGONHEADER*)cur_glyph;
 
         const uint8_t* end_poly = cur_glyph + th->cb;
@@ skipping 637 matching lines @@
         return this->createFromStream(stream);
     }
 
 private:
     SkTDArray<ENUMLOGFONTEX> fLogFontArray;
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgrGDI);
 }