Work around changes in OSX 10.10.

src/ports/SkFontHost_mac.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.
  */
 
 #ifdef SK_BUILD_FOR_MAC
 #import <ApplicationServices/ApplicationServices.h>
@@ skipping 28 matching lines @@
 #include "SkStream.h"
 #include "SkThread.h"
 #include "SkTypeface_mac.h"
 #include "SkUtils.h"
 #include "SkTypefaceCache.h"
 #include "SkFontMgr.h"
 #include "SkUtils.h"
 
 #include <dlfcn.h>
 
+#define SK_SHOW_TEXT_BLIT_COVERAGE 0

[mtklein, 2015/01/08 14:45:54]

Add a little note about what's going on here?  Is this something like //
Brighten all components to a minimum so coverage is more visible?

[bungeman-skia, 2015/01/08 16:21:58]

Done. Hmmm... I keep adding this without explanation as it becomes useful.
FreeType and GDI both already have this (with the same name). I should add this
to DirectWrite and move this define out to SkUserConfig. On the other hand it's
nice to control it within the compilation unit as that means faster cycle times
to turning it on, and also I can turn it on for GDI but not for DirectWrite so I
can tell who is drawing with what. But yeah, this is just a debugging aid which
makes the bounding box visible. With most formats it forces the alpha to some
minimum value, with black and white I normally put dots in the corners.

+
 class SkScalerContext_Mac;
 
 // CTFontManagerCopyAvailableFontFamilyNames() is not always available, so we
 // provide a wrapper here that will return an empty array if need be.
 static CFArrayRef SkCTFontManagerCopyAvailableFontFamilyNames() {
 #ifdef SK_BUILD_FOR_IOS
     return CFArrayCreate(NULL, NULL, 0, NULL);
 #else
     return CTFontManagerCopyAvailableFontFamilyNames();
 #endif
@@ skipping 615 matching lines @@
      *
      *  Used on Snow Leopard to correct CTFontGetVerticalTranslationsForGlyphs.
      *  Used on Lion to correct CTFontGetBoundingRectsForGlyphs.
      */
     SkMatrix fFUnitMatrix;
 
     Offscreen fOffscreen;
     AutoCFRelease<CTFontRef> fCTFont;
     CGAffineTransform fInvTransform;
 
-    /** Vertical variant of fCTFont.
+    /** Unrotated variant of fCTFont.
+     *
+     *  In 10.10.1 CTFontGetAdvancesForGlyphs applies the font transform to the width of the
+     *  advances, but always sets the height to 0. This font is used to get the advances of the
+     *  unrotated glyph, and then the rotation is applied separately.
      *
      *  CT vertical metrics are pre-rotated (in em space, before transform) 90deg clock-wise.
      *  This makes kCTFontDefaultOrientation dangerous, because the metrics from
      *  kCTFontHorizontalOrientation are in a different space from kCTFontVerticalOrientation.
-     *  Use fCTVerticalFont with kCTFontVerticalOrientation to get metrics in the same space.
+     *  With kCTFontVerticalOrientation the advances must be unrotated.
      */
-    AutoCFRelease<CTFontRef> fCTVerticalFont;
+    AutoCFRelease<CTFontRef> fCTUnrotatedFont;
 
     AutoCFRelease<CGFontRef> fCGFont;
     SkAutoTMalloc<GlyphRect> fFBoundingBoxes;
     uint16_t fFBoundingBoxesGlyphOffset;
     uint16_t fGlyphCount;
     bool fGeneratedFBoundingBoxes;
     const bool fDoSubPosition;
     const bool fVertical;
 
     friend class Offscreen;
@@ skipping 20 matching lines @@
     // As a result, it is necessary to know the actual device size and request that.
     SkVector scale;
     SkMatrix skTransform;
     fRec.computeMatrices(SkScalerContextRec::kVertical_PreMatrixScale, &scale, &skTransform,
                          NULL, NULL, &fFUnitMatrix);
     CGAffineTransform transform = MatrixToCGAffineTransform(skTransform);
     fInvTransform = CGAffineTransformInvert(transform);
 
     AutoCFRelease<CTFontDescriptorRef> ctFontDesc;
     if (fVertical) {
+        // Setting the vertical orientation here affects the character to glyph mapping.
         AutoCFRelease<CFMutableDictionaryRef> cfAttributes(CFDictionaryCreateMutable(
                 kCFAllocatorDefault, 0,
                 &kCFTypeDictionaryKeyCallBacks,
                 &kCFTypeDictionaryValueCallBacks));
         if (cfAttributes) {
             CTFontOrientation ctOrientation = kCTFontVerticalOrientation;
             AutoCFRelease<CFNumberRef> cfVertical(CFNumberCreate(
                     kCFAllocatorDefault, kCFNumberSInt32Type, &ctOrientation));
             CFDictionaryAddValue(cfAttributes, kCTFontOrientationAttribute, cfVertical);
             ctFontDesc.reset(CTFontDescriptorCreateWithAttributes(cfAttributes));
         }
     }
 
     // The transform contains everything except the requested text size.
     // Some properties, like 'trak', are based on the text size (before applying the matrix).
     CGFloat textSize = ScalarToCG(scale.y());
 
     fCTFont.reset(CTFontCreateCopyWithAttributes(ctFont, textSize, &transform, ctFontDesc));
     fCGFont.reset(CTFontCopyGraphicsFont(fCTFont, NULL));
-    if (fVertical) {
-        CGAffineTransform rotateLeft = CGAffineTransformMake(0, -1, 1, 0, 0, 0);
-        transform = CGAffineTransformConcat(rotateLeft, transform);
-        fCTVerticalFont.reset(CTFontCreateCopyWithAttributes(ctFont, textSize, &transform, NULL));
-    }
+    fCTUnrotatedFont.reset(CTFontCreateCopyWithAttributes(ctFont, textSize,
+                                                          &CGAffineTransformIdentity, NULL));
 
     // The fUnitMatrix includes the text size (and em) as it is used to scale the raw font data.
     SkScalar emPerFUnit = SkScalarInvert(SkIntToScalar(CGFontGetUnitsPerEm(fCGFont)));
     fFUnitMatrix.preScale(emPerFUnit, -emPerFUnit);
 }
 
 extern "C" {
 
 /** CTFontDrawGlyphs was introduced in 10.7. */
 typedef void (*CTFontDrawGlyphsProc)(CTFontRef, const CGGlyph[], const CGPoint[],
@@ skipping 123 matching lines @@
     }
 
     // CoreText and CoreGraphics always draw using the horizontal baseline origin.
     if (context.fVertical) {
         SkPoint offset;
         context.getVerticalOffset(glyphID, &offset);
         subX += offset.fX;
         subY += offset.fY;
     }
 
-    // CTFontDrawGlyphs and CGContextShowGlyphsAtPositions take 'positions' which are in text space.
-    // The glyph location (in device space) must be mapped into text space, so that CG can convert
-    // it back into device space.
     CGPoint point = CGPointMake(-glyph.fLeft + subX, glyph.fTop + glyph.fHeight - subY);
-    point = CGPointApplyAffineTransform(point, context.fInvTransform);
+    if (darwinVersion() < 14) {
+        // Prior to 10.10, CTFontDrawGlyphs and (the no longer used) CGContextShowGlyphsAtPositions

[mtklein, 2015/01/08 14:45:54]

might drop off the bit about no-longer-used code?

[bungeman-skia, 2015/01/08 16:21:58]

Done. Thanks for reminding me about this comment. After some investigation, it
turns out the behavior of CGContextShowGlyphsAtPositions has actually not
changed, and seems to still have the old behavior.

+        // take 'positions' which are in text space. The glyph location (in device space) must be
+        // mapped into text space, so that CG can convert it back into device space.
+        // In 10.10 and later, this is handled directly in CTFontDrawGlyphs.
+        point = CGPointApplyAffineTransform(point, context.fInvTransform);
+    }
     ctFontDrawGlyphs(context.fCTFont, &glyphID, &point, 1, fCG);
 
     SkASSERT(rowBytesPtr);
     *rowBytesPtr = rowBytes;
     return image;
 }
 
 void SkScalerContext_Mac::getVerticalOffset(CGGlyph glyphID, SkPoint* offset) const {
     // Snow Leopard returns cgVertOffset in completely un-transformed FUnits (em space, y up).
     // Lion and Leopard return cgVertOffset in CG units (pixels, y up).
@@ skipping 86 matching lines @@
     this->generateMetrics(glyph);
 }
 
 void SkScalerContext_Mac::generateMetrics(SkGlyph* glyph) {
     const CGGlyph cgGlyph = (CGGlyph) glyph->getGlyphID();
     glyph->zeroMetrics();
 
     // The following block produces cgAdvance in CG units (pixels, y up).
     CGSize cgAdvance;
     if (fVertical) {
-        CTFontGetAdvancesForGlyphs(fCTVerticalFont, kCTFontVerticalOrientation,
+        CTFontGetAdvancesForGlyphs(fCTUnrotatedFont, kCTFontVerticalOrientation,
                                    &cgGlyph, &cgAdvance, 1);
+        // Vertical metrics are rotated 90 degrees.

[mtklein, 2015/01/08 14:45:54]

... 90 degrees clockwise.  ?

[bungeman-skia, 2015/01/08 16:21:58]

Done. As if they were horizontal. They're not really rotated, they just stick
the advance in the width instead of the height. I hadn't really thought about it
that way until I just tried to decide if it was rotated clockwise or not.

+        SkTSwap(cgAdvance.height, cgAdvance.width);
+        cgAdvance.height = -cgAdvance.height;
     } else {
-        CTFontGetAdvancesForGlyphs(fCTFont, kCTFontHorizontalOrientation,
+        CTFontGetAdvancesForGlyphs(fCTUnrotatedFont, kCTFontHorizontalOrientation,
                                    &cgGlyph, &cgAdvance, 1);
     }
+    cgAdvance = CGSizeApplyAffineTransform(cgAdvance, CTFontGetMatrix(fCTFont));
     glyph->fAdvanceX =  SkFloatToFixed_Check(cgAdvance.width);
     glyph->fAdvanceY = -SkFloatToFixed_Check(cgAdvance.height);
 
     // The following produces skBounds in SkGlyph units (pixels, y down),
     // or returns early if skBounds would be empty.
     SkRect skBounds;
 
     // On Mountain Lion, CTFontGetBoundingRectsForGlyphs with kCTFontVerticalOrientation and
     // CTFontGetVerticalTranslationsForGlyphs do not agree when using OTF CFF fonts.
     // For TTF fonts these two do agree and we can use CTFontGetBoundingRectsForGlyphs to get
@@ skipping 120 matching lines @@
         }
         *dst++ = mask;
     }
 }
 
 template<bool APPLY_PREBLEND>
 static inline uint8_t rgb_to_a8(CGRGBPixel rgb, const uint8_t* table8) {
     U8CPU r = (rgb >> 16) & 0xFF;
     U8CPU g = (rgb >>  8) & 0xFF;
     U8CPU b = (rgb >>  0) & 0xFF;
-    return sk_apply_lut_if<APPLY_PREBLEND>(SkComputeLuminance(r, g, b), table8);
+    U8CPU lum = sk_apply_lut_if<APPLY_PREBLEND>(SkComputeLuminance(r, g, b), table8);
+#if SK_SHOW_TEXT_BLIT_COVERAGE
+    lum = SkTMax(lum, (U8CPU)0x30);
+#endif
+    return lum;
 }
 template<bool APPLY_PREBLEND>
 static void rgb_to_a8(const CGRGBPixel* SK_RESTRICT cgPixels, size_t cgRowBytes,
                       const SkGlyph& glyph, const uint8_t* table8) {
     const int width = glyph.fWidth;
     size_t dstRB = glyph.rowBytes();
     uint8_t* SK_RESTRICT dst = (uint8_t*)glyph.fImage;
 
     for (int y = 0; y < glyph.fHeight; y++) {
         for (int i = 0; i < width; ++i) {
             dst[i] = rgb_to_a8<APPLY_PREBLEND>(cgPixels[i], table8);
         }
         cgPixels = (CGRGBPixel*)((char*)cgPixels + cgRowBytes);
         dst += dstRB;
     }
 }
 
 template<bool APPLY_PREBLEND>
 static inline uint16_t rgb_to_lcd16(CGRGBPixel rgb, const uint8_t* tableR,
                                                     const uint8_t* tableG,
                                                     const uint8_t* tableB) {
     U8CPU r = sk_apply_lut_if<APPLY_PREBLEND>((rgb >> 16) & 0xFF, tableR);
     U8CPU g = sk_apply_lut_if<APPLY_PREBLEND>((rgb >>  8) & 0xFF, tableG);
     U8CPU b = sk_apply_lut_if<APPLY_PREBLEND>((rgb >>  0) & 0xFF, tableB);
+#if SK_SHOW_TEXT_BLIT_COVERAGE
+    r = SkTMax(r, (U8CPU)0x30);
+    g = SkTMax(g, (U8CPU)0x30);
+    b = SkTMax(b, (U8CPU)0x30);
+#endif
     return SkPack888ToRGB16(r, g, b);
 }
 template<bool APPLY_PREBLEND>
 static void rgb_to_lcd16(const CGRGBPixel* SK_RESTRICT cgPixels, size_t cgRowBytes, const SkGlyph& glyph,
                          const uint8_t* tableR, const uint8_t* tableG, const uint8_t* tableB) {
     const int width = glyph.fWidth;
     size_t dstRB = glyph.rowBytes();
     uint16_t* SK_RESTRICT dst = (uint16_t*)glyph.fImage;
 
     for (int y = 0; y < glyph.fHeight; y++) {
         for (int i = 0; i < width; i++) {
             dst[i] = rgb_to_lcd16<APPLY_PREBLEND>(cgPixels[i], tableR, tableG, tableB);
         }
         cgPixels = (CGRGBPixel*)((char*)cgPixels + cgRowBytes);
         dst = (uint16_t*)((char*)dst + dstRB);
     }
 }
 
 static SkPMColor cgpixels_to_pmcolor(CGRGBPixel rgb) {
     U8CPU a = (rgb >> 24) & 0xFF;
     U8CPU r = (rgb >> 16) & 0xFF;
     U8CPU g = (rgb >>  8) & 0xFF;
     U8CPU b = (rgb >>  0) & 0xFF;
-
+#if SK_SHOW_TEXT_BLIT_COVERAGE
+    a = SkTMax(a, (U8CPU)0x30);
+#endif
     return SkPackARGB32(a, r, g, b);
 }
 
 template <typename T> T* SkTAddByteOffset(T* ptr, size_t byteOffset) {
     return (T*)((char*)ptr + byteOffset);
 }
 
 void SkScalerContext_Mac::generateImage(const SkGlyph& glyph) {
     CGGlyph cgGlyph = (CGGlyph) glyph.getGlyphID();
 
@@ skipping 1049 matching lines @@
         }
         return face;
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgr_Mac);
 }