Fix vertical text scaling on Mac.

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.
  */
 
 #include <vector>
 #ifdef SK_BUILD_FOR_MAC
@@ skipping 282 matching lines @@
                                                    SkScalar sx = SK_Scalar1,
                                                    SkScalar sy = SK_Scalar1) {
     return CGAffineTransformMake( ScalarToCG(matrix[SkMatrix::kMScaleX] * sx),
                                  -ScalarToCG(matrix[SkMatrix::kMSkewY]  * sy),
                                  -ScalarToCG(matrix[SkMatrix::kMSkewX]  * sx),
                                   ScalarToCG(matrix[SkMatrix::kMScaleY] * sy),
                                   ScalarToCG(matrix[SkMatrix::kMTransX] * sx),
                                   ScalarToCG(matrix[SkMatrix::kMTransY] * sy));
 }
 
 static SkScalar getFontScale(CGFontRef cgFont) {

[bungeman-skia, 2013/05/10 17:08:03]

This is an ambiguous name, emPerFUnit would be more accurate.

     int unitsPerEm = CGFontGetUnitsPerEm(cgFont);
     return SkScalarInvert(SkIntToScalar(unitsPerEm));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #define BITMAP_INFO_RGB (kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host)
 #define BITMAP_INFO_GRAY (kCGImageAlphaNone)
 
 /**
@@ skipping 327 matching lines @@
         if (face) {
             SkTypefaceCache::Add(face, style);
         } else {
             face = GetDefaultFace();
             face->ref();
         }
     }
     return face;
 }
 
-static void flip(SkMatrix* matrix) {
-    matrix->setSkewX(-matrix->getSkewX());
-    matrix->setSkewY(-matrix->getSkewY());
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 struct GlyphRect {
     int16_t fMinX;
     int16_t fMinY;
     int16_t fMaxX;
     int16_t fMaxY;
 };
 
 class SkScalerContext_Mac : public SkScalerContext {
@@ skipping 11 matching lines @@
     void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE;
     void generateFontMetrics(SkPaint::FontMetrics* mX, SkPaint::FontMetrics* mY) SK_OVERRIDE;
 
 private:
     static void CTPathElement(void *info, const CGPathElement *element);
     uint16_t getFBoundingBoxesGlyphOffset();
     void getVerticalOffset(CGGlyph glyphID, SkIPoint* offset) const;
     bool generateBBoxes();
 
     CGAffineTransform fTransform;
-    SkMatrix fUnitMatrix; // without font size
-    SkMatrix fVerticalMatrix; // unit rotated
     SkMatrix fMatrix; // with font size
     SkMatrix fFBoundingBoxesMatrix; // lion-specific fix
     Offscreen fOffscreen;
     AutoCFRelease<CTFontRef> fCTFont;
-    AutoCFRelease<CTFontRef> fCTVerticalFont; // for vertical advance
     AutoCFRelease<CGFontRef> fCGFont;
     GlyphRect* fFBoundingBoxes;
     uint16_t fFBoundingBoxesGlyphOffset;
     uint16_t fGlyphCount;
     bool fGeneratedFBoundingBoxes;
-    bool fDoSubPosition;
-    bool fVertical;
+    const bool fDoSubPosition;
+    const bool fVertical;
 
     friend class Offscreen;
 
     typedef SkScalerContext INHERITED;
 };
 
 SkScalerContext_Mac::SkScalerContext_Mac(SkTypeface_Mac* typeface,
                                          const SkDescriptor* desc)
         : INHERITED(typeface, desc)
         , fFBoundingBoxes(NULL)
         , fFBoundingBoxesGlyphOffset(0)
         , fGeneratedFBoundingBoxes(false)
+        , fDoSubPosition(SkToBool(fRec.fFlags & kSubpixelPositioning_Flag))
+        , fVertical(SkToBool(fRec.fFlags & kVertical_Flag))
+
 {
     CTFontRef ctFont = typeface->fFontRef.get();
     CFIndex numGlyphs = CTFontGetGlyphCount(ctFont);
-
-    // Get the state we need
+    SkASSERT(numGlyphs >= 1 && numGlyphs <= 0xFFFF);
+    fGlyphCount = SkToU16(numGlyphs);
+    
     fRec.getSingleMatrix(&fMatrix);
-    fUnitMatrix = fMatrix;
-
-    // extract the font size out of the matrix, but leave the skewing for italic
-    SkScalar reciprocal = SkScalarInvert(fRec.fTextSize);
-    fUnitMatrix.preScale(reciprocal, reciprocal);
-
-    SkASSERT(numGlyphs >= 1 && numGlyphs <= 0xFFFF);
-
     fTransform = MatrixToCGAffineTransform(fMatrix);
-
-    CGAffineTransform transform;
-    CGFloat unitFontSize;
-    if (isLeopard()) {
-        // passing 1 for pointSize to Leopard sets the font size to 1 pt.
-        // pass the CoreText size explicitly
-        transform = MatrixToCGAffineTransform(fUnitMatrix);
-        unitFontSize = SkScalarToFloat(fRec.fTextSize);
-    } else {
-        // since our matrix includes everything, we pass 1 for pointSize
-        transform = fTransform;
-        unitFontSize = 1;
-    }
-    flip(&fUnitMatrix); // flip to fix up bounds later
-    fVertical = SkToBool(fRec.fFlags & kVertical_Flag);
+    
     AutoCFRelease<CTFontDescriptorRef> ctFontDesc;
     if (fVertical) {
         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 = CTFontDescriptorCreateWithAttributes(cfAttributes);
         }
     }
-    fCTFont = CTFontCreateCopyWithAttributes(ctFont, unitFontSize, &transform, ctFontDesc);
+    // Since our matrix includes everything, we pass 1 for size.
+    fCTFont = CTFontCreateCopyWithAttributes(ctFont, 1.f, &fTransform, ctFontDesc);
     fCGFont = CTFontCopyGraphicsFont(fCTFont, NULL);
-    if (fVertical) {
-        CGAffineTransform rotateLeft = CGAffineTransformMake(0, -1, 1, 0, 0, 0);
-        transform = CGAffineTransformConcat(rotateLeft, transform);
-        fCTVerticalFont = CTFontCreateCopyWithAttributes(ctFont, unitFontSize, &transform, NULL);
-        fVerticalMatrix = fUnitMatrix;
-        if (isSnowLeopard()) {
-            SkScalar scale = SkScalarMul(fRec.fTextSize, getFontScale(fCGFont));
-            fVerticalMatrix.preScale(scale, scale);
-        } else {
-            fVerticalMatrix.preRotate(SkIntToScalar(90));
-        }
-        fVerticalMatrix.postScale(SK_Scalar1, -SK_Scalar1);
-    }
-    fGlyphCount = SkToU16(numGlyphs);
-    fDoSubPosition = SkToBool(fRec.fFlags & kSubpixelPositioning_Flag);
 }
 
 SkScalerContext_Mac::~SkScalerContext_Mac() {
     delete[] fFBoundingBoxes;
 }
 
 CGRGBPixel* Offscreen::getCG(const SkScalerContext_Mac& context, const SkGlyph& glyph,
                              CGGlyph glyphID, size_t* rowBytesPtr,
                              bool generateA8FromLCD) {
     if (!fRGBSpace) {
@@ skipping 33 matching lines @@
                                     rowBytes, fRGBSpace, BITMAP_INFO_RGB);
 
         // skia handles quantization itself, so we disable this for cg to get
         // full fractional data from them.
         CGContextSetAllowsFontSubpixelQuantization(fCG, false);
         CGContextSetShouldSubpixelQuantizeFonts(fCG, false);
 
         CGContextSetTextDrawingMode(fCG, kCGTextFill);
         CGContextSetFont(fCG, context.fCGFont);
         CGContextSetFontSize(fCG, 1);
         CGContextSetTextMatrix(fCG, context.fTransform);

[bungeman-skia, 2013/05/10 17:08:03]

Can this just be the transform from the CTFont? If so, we can drop fTransform
entirely.

 
         CGContextSetAllowsFontSubpixelPositioning(fCG, context.fDoSubPosition);
         CGContextSetShouldSubpixelPositionFonts(fCG, context.fDoSubPosition);
 
         // Draw white on black to create mask.
         // TODO: Draw black on white and invert, CG has a special case codepath.
         CGContextSetGrayFillColor(fCG, 1.0f, 1.0f);
 
         // force our checks below to happen
         fDoAA = !doAA;
@@ skipping 15 matching lines @@
 
     // erase to black
     sk_memset_rect32(image, 0, glyph.fWidth, glyph.fHeight, rowBytes);
 
     float subX = 0;
     float subY = 0;
     if (context.fDoSubPosition) {
         subX = SkFixedToFloat(glyph.getSubXFixed());
         subY = SkFixedToFloat(glyph.getSubYFixed());
     }
+    
+    // CGContextShowGlyphsAtPoint always draws using the horizontal baseline origin.
+    // Get the offset from the vertical origin to the horizontal origin.
     if (context.fVertical) {
         SkIPoint offset;
         context.getVerticalOffset(glyphID, &offset);
         subX += offset.fX;
         subY += offset.fY;
     }
+    
     CGContextShowGlyphsAtPoint(fCG, -glyph.fLeft + subX,
                                glyph.fTop + glyph.fHeight - subY,
                                &glyphID, 1);
 
     SkASSERT(rowBytesPtr);
     *rowBytesPtr = rowBytes;
     return image;
 }
 
 void SkScalerContext_Mac::getVerticalOffset(CGGlyph glyphID, SkIPoint* offset) const {
     CGSize vertOffset;
-    CTFontGetVerticalTranslationsForGlyphs(fCTVerticalFont, &glyphID, &vertOffset, 1);
-    const SkPoint trans = {CGToScalar(vertOffset.width),
-                           CGToScalar(vertOffset.height)};
-    SkPoint floatOffset;
-    fVerticalMatrix.mapPoints(&floatOffset, &trans, 1);
-    if (!isSnowLeopard()) {
-    // SnowLeopard fails to apply the font's matrix to the vertical metrics,
-    // but Lion and Leopard do. The unit matrix describes the font's matrix at
-    // point size 1. There may be some way to avoid mapping here by setting up
-    // fVerticalMatrix differently, but this works for now.
-        fUnitMatrix.mapPoints(&floatOffset, 1);
+    CTFontGetVerticalTranslationsForGlyphs(fCTFont, &glyphID, &vertOffset, 1);
+
+    // SnowLeopard returns vertOffset in completely un-transformed em units.
+    // Lion and Leopard return vertOffset in transformed font units.
+    if (isSnowLeopard()) {
+        CGFloat emPerUnit = 1.0f / CGFontGetUnitsPerEm(fCGFont);
+        CGAffineTransform t = CGAffineTransformConcat(fTransform, CGAffineTransformMakeScale(emPerUnit, emPerUnit));
+        vertOffset = CGSizeApplyAffineTransform(vertOffset, t);
     }
-    offset->fX = SkScalarRound(floatOffset.fX);
-    offset->fY = SkScalarRound(floatOffset.fY);
+    
+    offset->fX = SkScalarRound(vertOffset.width);
+    offset->fY = SkScalarRound(-vertOffset.height);
 }
 
 uint16_t SkScalerContext_Mac::getFBoundingBoxesGlyphOffset() {
     if (fFBoundingBoxesGlyphOffset) {
         return fFBoundingBoxesGlyphOffset;
     }
     fFBoundingBoxesGlyphOffset = fGlyphCount; // fallback for all fonts
     AutoCGTable<SkOTTableHorizontalHeader> hheaTable(fCGFont);
     if (hheaTable.fData) {
         fFBoundingBoxesGlyphOffset = SkEndian_SwapBE16(hheaTable->numberOfHMetrics);
@@ skipping 36 matching lines @@
     uint16_t entries = fGlyphCount - fFBoundingBoxesGlyphOffset;
     fFBoundingBoxes = new GlyphRect[entries];
 
     SkOTTableHead::IndexToLocFormat locaFormat = headTable->indexToLocFormat;
     SkOTTableGlyph::Iterator glyphDataIter(*glyfTable.fData, *locaTable.fData, locaFormat);
     glyphDataIter.advance(fFBoundingBoxesGlyphOffset);
     for (uint16_t boundingBoxesIndex = 0; boundingBoxesIndex < entries; ++boundingBoxesIndex) {
         const SkOTTableGlyphData* glyphData = glyphDataIter.next();
         GlyphRect& rect = fFBoundingBoxes[boundingBoxesIndex];
         rect.fMinX = SkEndian_SwapBE16(glyphData->xMin);
-        rect.fMinY = SkEndian_SwapBE16(glyphData->yMin);
+        rect.fMinY = -SkEndian_SwapBE16(glyphData->yMin);
         rect.fMaxX = SkEndian_SwapBE16(glyphData->xMax);
-        rect.fMaxY = SkEndian_SwapBE16(glyphData->yMax);
+        rect.fMaxY = -SkEndian_SwapBE16(glyphData->yMax);
     }
     fFBoundingBoxesMatrix = fMatrix;
-    flip(&fFBoundingBoxesMatrix);
     SkScalar fontScale = getFontScale(fCGFont);
     fFBoundingBoxesMatrix.preScale(fontScale, fontScale);

[bungeman-skia, 2013/05/10 17:08:03]

The matrix used in getVerticalOffset for SnowLeopard is the same (as it goes
from y-down FUnits to SkGlyph units). Rename fFBoundingBoxesMatrix to
fFUnitTransform (or something to parallel fTransform) and use in both places. In
fact, fTransform is now used outside the constructor only to set up the
offscreen CGContext since it is magically hidden inside the CTFont itself.

     return true;
 }
 
 unsigned SkScalerContext_Mac::generateGlyphCount(void) {
     return fGlyphCount;
 }
 
 uint16_t SkScalerContext_Mac::generateCharToGlyph(SkUnichar uni) {
     CGGlyph     cgGlyph;
     UniChar     theChar;
@@ skipping 12 matching lines @@
     return cgGlyph;
 }
 
 void SkScalerContext_Mac::generateAdvance(SkGlyph* glyph) {
     this->generateMetrics(glyph);
 }
 
 void SkScalerContext_Mac::generateMetrics(SkGlyph* glyph) {
     CGSize advance;
     CGRect bounds;
-    CGGlyph cgGlyph;
-
-    // Get the state we need
-    cgGlyph = (CGGlyph) glyph->getGlyphID(fBaseGlyphCount);
+    CGGlyph const cgGlyph = (CGGlyph) glyph->getGlyphID(fBaseGlyphCount);
 
     if (fVertical) {
         if (!isSnowLeopard()) {
             // Lion and Leopard respect the vertical font metrics.
-            CTFontGetBoundingRectsForGlyphs(fCTVerticalFont, kCTFontVerticalOrientation,
+            CTFontGetBoundingRectsForGlyphs(fCTFont, kCTFontVerticalOrientation,
                                             &cgGlyph, &bounds, 1);
+            SkTSwap(bounds.origin.x, bounds.origin.y);
+            SkTSwap(bounds.size.width, bounds.size.height);
         } else {
             // Snow Leopard and earlier respect the vertical font metrics for
             // advances, but not bounds, so use the default box and adjust it below.
             CTFontGetBoundingRectsForGlyphs(fCTFont, kCTFontDefaultOrientation,
                                             &cgGlyph, &bounds, 1);
+            bounds.origin.y = -bounds.origin.y - bounds.size.height;
         }
-        CTFontGetAdvancesForGlyphs(fCTVerticalFont, kCTFontVerticalOrientation,
+        CTFontGetAdvancesForGlyphs(fCTFont, kCTFontVerticalOrientation,
                                    &cgGlyph, &advance, 1);
+        SkTSwap(advance.height, advance.width);
     } else {
         CTFontGetBoundingRectsForGlyphs(fCTFont, kCTFontDefaultOrientation,
                                         &cgGlyph, &bounds, 1);
+        bounds.origin.y = -bounds.origin.y - bounds.size.height;
         CTFontGetAdvancesForGlyphs(fCTFont, kCTFontDefaultOrientation,
                                    &cgGlyph, &advance, 1);
+        advance.height = -advance.height;
     }
 
     // BUG?
     // 0x200B (zero-advance space) seems to return a huge (garbage) bounds, when
     // it should be empty. So, if we see a zero-advance, we check if it has an
     // empty path or not, and if so, we jam the bounds to 0. Hopefully a zero-advance
     // is rare, so we won't incur a big performance cost for this extra check.
     if (0 == advance.width && 0 == advance.height) {
         AutoCFRelease<CGPathRef> path(CTFontCreatePathForGlyph(fCTFont, cgGlyph, NULL));
         if (NULL == path || CGPathIsEmpty(path)) {
             bounds = CGRectMake(0, 0, 0, 0);
         }
     }
 
     glyph->zeroMetrics();
-    glyph->fAdvanceX =  SkFloatToFixed_Check(advance.width);
-    glyph->fAdvanceY = -SkFloatToFixed_Check(advance.height);
+    glyph->fAdvanceX = SkFloatToFixed_Check(advance.width);
+    glyph->fAdvanceY = SkFloatToFixed_Check(advance.height);
 
     if (CGRectIsEmpty_inline(bounds)) {
         return;
     }
 
-    if (isLeopard() && !fVertical) {
-        // Leopard does not consider the matrix skew in its bounds.
-        // Run the bounding rectangle through the skew matrix to determine
-        // the true bounds. However, this doesn't work if the font is vertical.
-        // FIXME (Leopard): If the font has synthetic italic (e.g., matrix skew)
-        // and the font is vertical, the bounds need to be recomputed.
-        SkRect glyphBounds = SkRect::MakeXYWH(
-                bounds.origin.x, bounds.origin.y,
-                bounds.size.width, bounds.size.height);
-        fUnitMatrix.mapRect(&glyphBounds);
-        bounds.origin.x = glyphBounds.fLeft;
-        bounds.origin.y = glyphBounds.fTop;
-        bounds.size.width = glyphBounds.width();
-        bounds.size.height = glyphBounds.height();
-    }
-    // Adjust the bounds
-    //
-    // CTFontGetBoundingRectsForGlyphs ignores the font transform, so we need
-    // to transform the bounding box ourselves.
-    //
-    // The bounds are also expanded by 1 pixel, to give CG room for anti-aliasing.
+    // Expand the bounds by 1 pixel, to give CG room for anti-aliasing.
     CGRectInset_inline(&bounds, -1, -1);
 
     // Get the metrics
     bool lionAdjustedMetrics = false;
     if (isLion() || isMountainLion()) {
         if (cgGlyph < fGlyphCount && cgGlyph >= getFBoundingBoxesGlyphOffset() && generateBBoxes()){
             lionAdjustedMetrics = true;
             SkRect adjust;
             const GlyphRect& gRect = fFBoundingBoxes[cgGlyph - fFBoundingBoxesGlyphOffset];
             adjust.set(gRect.fMinX, gRect.fMinY, gRect.fMaxX, gRect.fMaxY);
             fFBoundingBoxesMatrix.mapRect(&adjust);
             bounds.origin.x = SkScalarToFloat(adjust.fLeft) - 1;
             bounds.origin.y = SkScalarToFloat(adjust.fTop) - 1;
         }
         // Lion returns fractions in the bounds
         glyph->fWidth = SkToU16(sk_float_ceil2int(bounds.size.width));
         glyph->fHeight = SkToU16(sk_float_ceil2int(bounds.size.height));
     } else {
         glyph->fWidth = SkToU16(sk_float_round2int(bounds.size.width));
         glyph->fHeight = SkToU16(sk_float_round2int(bounds.size.height));
     }
-    glyph->fTop = SkToS16(-sk_float_round2int(CGRectGetMaxY_inline(bounds)));
-    glyph->fLeft = SkToS16(sk_float_round2int(CGRectGetMinX_inline(bounds)));
-    SkIPoint offset;
+    glyph->fTop = SkToS16(sk_float_round2int(bounds.origin.y));
+    glyph->fLeft = SkToS16(sk_float_round2int(bounds.origin.x));
     if (fVertical && (isSnowLeopard() || lionAdjustedMetrics)) {
         // SnowLeopard doesn't respect vertical metrics, so compute them manually.
         // Also compute them for Lion when the metrics were computed by hand.
+        SkIPoint offset;
         getVerticalOffset(cgGlyph, &offset);
         glyph->fLeft += offset.fX;
         glyph->fTop += offset.fY;
     }
 #ifdef HACK_COLORGLYPHS
     glyph->fMaskFormat = SkMask::kARGB32_Format;
 #endif
 }
 
 #include "SkColorPriv.h"
@@ skipping 1128 matching lines @@
             return NULL;
         }
         return create_from_dataProvider(pr);
     }
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgr_Mac);
 }
 #endif