Supports the cap height for FreeType even when TT OS2 version is 1.

src/ports/SkFontHost_FreeType.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 "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 195 matching lines @@
     bool        fDoLinearMetrics;
     bool        fLCDIsVert;
 
     // Need scalar versions for generateFontMetrics
     SkVector    fScale;
     SkMatrix    fMatrix22Scalar;
 
     FT_Error setupSize();
     void getBBoxForCurrentGlyph(SkGlyph* glyph, FT_BBox* bbox,
                                 bool snapToPixelBoundary = false);
+    bool getCBoxForLetter(char letter, FT_BBox* bbox);
     // Caller must lock gFTMutex before calling this function.
     void updateGlyphIfLCD(SkGlyph* glyph);
 };
 
 ///////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
 struct SkFaceRec {
     SkFaceRec*      fNext;
     FT_Face         fFace;
@@ skipping 198 matching lines @@
         return (os2_table->fsType & 0x202) == 0;
     }
     return false;  // We tried, fail safe.
 #endif
 }
 
 static bool GetLetterCBox(FT_Face face, char letter, FT_BBox* bbox) {
     const FT_UInt glyph_id = FT_Get_Char_Index(face, letter);
     if (!glyph_id)
         return false;
-    FT_Load_Glyph(face, glyph_id, FT_LOAD_NO_SCALE);
+    if (FT_Load_Glyph(face, glyph_id, FT_LOAD_NO_SCALE) != 0)
+        return false;
     FT_Outline_Get_CBox(&face->glyph->outline, bbox);
     return true;
 }
 
 static bool getWidthAdvance(FT_Face face, int gId, int16_t* data) {
     FT_Fixed advance = 0;
     if (getAdvances(face, gId, 1, FT_LOAD_NO_SCALE, &advance)) {
         return false;
     }
     SkASSERT(data);
@@ skipping 130 matching lines @@
 
     TT_PCLT* pclt_info;
     TT_OS2* os2_table;
     if ((pclt_info = (TT_PCLT*)FT_Get_Sfnt_Table(face, ft_sfnt_pclt)) != NULL) {
         info->fCapHeight = pclt_info->CapHeight;
         uint8_t serif_style = pclt_info->SerifStyle & 0x3F;
         if (serif_style >= 2 && serif_style <= 6)
             info->fStyle |= SkAdvancedTypefaceMetrics::kSerif_Style;
         else if (serif_style >= 9 && serif_style <= 12)
             info->fStyle |= SkAdvancedTypefaceMetrics::kScript_Style;
-    } else if ((os2_table =
-                (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2)) != NULL) {
+    } else if (((os2_table =
+                 (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2)) != NULL) &&

[bungeman-skia, 2013/12/12 17:12:35]

Note that Skia now has an 80 soft / 100 hard column limit. I'd say put this
assignment all on one line now.

[Yuki, 2013/12/13 09:32:14]

Done.

+               // sCapHeight is available only when version 2 or later.
+               os2_table->version != 0xFFFF &&
+               os2_table->version >= 2) {
         info->fCapHeight = os2_table->sCapHeight;
     } else {
         // Figure out a good guess for CapHeight: average the height of M and X.
         FT_BBox m_bbox, x_bbox;
         bool got_m, got_x;
         got_m = GetLetterCBox(face, 'M', &m_bbox);
         got_x = GetLetterCBox(face, 'X', &x_bbox);
         if (got_m && got_x) {
             info->fCapHeight = (m_bbox.yMax - m_bbox.yMin + x_bbox.yMax -
                     x_bbox.yMin) / 2;
@@ skipping 522 matching lines @@
         vector.x = fFace->glyph->metrics.vertBearingX - fFace->glyph->metrics.horiBearingX;
         vector.y = -fFace->glyph->metrics.vertBearingY - fFace->glyph->metrics.horiBearingY;
         FT_Vector_Transform(&vector, &fMatrix22);
         bbox->xMin += vector.x;
         bbox->xMax += vector.x;
         bbox->yMin += vector.y;
         bbox->yMax += vector.y;
     }
 }
 
+bool SkScalerContext_FreeType::getCBoxForLetter(char letter, FT_BBox* bbox) {
+    const FT_UInt glyph_id = FT_Get_Char_Index(fFace, letter);
+    if (!glyph_id)
+        return false;
+    if (FT_Load_Glyph(fFace, glyph_id, fLoadGlyphFlags) != 0)
+        return false;
+    if ((fRec.fFlags & kEmbolden_Flag) &&
+        !(fFace->style_flags & FT_STYLE_FLAG_BOLD)) {
+        emboldenOutline(fFace, &fFace->glyph->outline);
+    }
+    FT_Outline_Get_CBox(&fFace->glyph->outline, bbox);
+    return true;
+}
+
 void SkScalerContext_FreeType::updateGlyphIfLCD(SkGlyph* glyph) {
     if (isLCD(fRec)) {
         if (fLCDIsVert) {
             glyph->fHeight += gLCDExtra;
             glyph->fTop -= gLCDExtra >> 1;
         } else {
             glyph->fWidth += gLCDExtra;
             glyph->fLeft -= gLCDExtra >> 1;
         }
     }
@@ skipping 212 matching lines @@
     if (!upem) {
         TT_Header* ttHeader = (TT_Header*)FT_Get_Sfnt_Table(face, ft_sfnt_head);
         if (ttHeader) {
             upem = SkIntToScalar(ttHeader->Units_Per_EM);
         }
     }
 
     // use the os/2 table as a source of reasonable defaults.
     SkScalar x_height = 0.0f;
     SkScalar avgCharWidth = 0.0f;
+    SkScalar cap_height = 0.0f;
     TT_OS2* os2 = (TT_OS2*) FT_Get_Sfnt_Table(face, ft_sfnt_os2);
     if (os2) {
         x_height = scaleX * SkIntToScalar(os2->sxHeight) / upem;
         avgCharWidth = SkIntToScalar(os2->xAvgCharWidth) / upem;
+        if (os2->version != 0xFFFF && os2->version >= 2) {
+            cap_height = scaleX * SkIntToScalar(os2->sCapHeight) / upem;
+        }
     }
 
     // pull from format-specific metrics as needed
     SkScalar ascent, descent, leading, xmin, xmax, ymin, ymax;
     if (face->face_flags & FT_FACE_FLAG_SCALABLE) { // scalable outline font
         ascent = -SkIntToScalar(face->ascender) / upem;
         descent = -SkIntToScalar(face->descender) / upem;
         leading = SkIntToScalar(face->height + (face->descender - face->ascender)) / upem;
         xmin = SkIntToScalar(face->bbox.xMin) / upem;
         xmax = SkIntToScalar(face->bbox.xMax) / upem;
         ymin = -SkIntToScalar(face->bbox.yMin) / upem;
         ymax = -SkIntToScalar(face->bbox.yMax) / upem;
-        // we may be able to synthesize x_height from outline
+        // we may be able to synthesize x_height and cap_height from outline
         if (!x_height) {
-            const FT_UInt x_glyph = FT_Get_Char_Index(fFace, 'x');
-            if (x_glyph) {
-                FT_BBox bbox;
-                FT_Load_Glyph(fFace, x_glyph, fLoadGlyphFlags);
-                if ((fRec.fFlags & kEmbolden_Flag) && !(fFace->style_flags & FT_STYLE_FLAG_BOLD)) {
-                    emboldenOutline(fFace, &fFace->glyph->outline);
-                }
-                FT_Outline_Get_CBox(&fFace->glyph->outline, &bbox);
+            FT_BBox bbox;
+            if (getCBoxForLetter('x', &bbox)) {
                 x_height = SkIntToScalar(bbox.yMax) / 64.0f;
             }
         }
+        if (!cap_height) {
+            FT_BBox m_bbox, x_bbox;
+            bool got_m, got_x;
+            FT_Pos avg_height = 0;
+            got_m = getCBoxForLetter('M', &m_bbox);

[bungeman-skia, 2013/12/12 17:12:35]

I think traditionally H is used if available. If the .notdef (glyph 0 by
convention and enforced by FreeType, see
http://www.microsoft.com/typography/otspec/recom.htm) exists and has a non-zero
extent it would probably also be a good candidate. 'M's especially often have
descending flourishes, so it seems like one would use the yMax and ignore the
yMin. I'm assuming that any fonts you tested on have yMin close to 0 for these
characters. Note that above we're just using the yMax for the x-height for
similar reasons.

Since these are the majuscules you're using, it may make more sense to name
these got_M and got_X.

[Yuki, 2013/12/13 09:32:14]

Following your recommendation and tradition, I use yMax of 'H'.

+            got_x = getCBoxForLetter('X', &x_bbox);
+            if (got_m && got_x) {
+                avg_height = (m_bbox.yMax - m_bbox.yMin +
+                              x_bbox.yMax - x_bbox.yMin) / 2;
+            } else if (got_m) {
+                avg_height = m_bbox.yMax - m_bbox.yMin;
+            } else if (got_x) {
+                avg_height = x_bbox.yMax - x_bbox.yMin;
+            }
+            if (avg_height)
+                cap_height = SkIntToScalar(avg_height) / 64.0f;
+        }
     } else if (fStrikeIndex != -1) { // bitmap strike metrics
         SkScalar xppem = SkIntToScalar(face->size->metrics.x_ppem);
         SkScalar yppem = SkIntToScalar(face->size->metrics.y_ppem);
         ascent = -SkIntToScalar(face->size->metrics.ascender) / (yppem * 64.0f);
         descent = -SkIntToScalar(face->size->metrics.descender) / (yppem * 64.0f);
         leading = (SkIntToScalar(face->size->metrics.height) / (yppem * 64.0f))
                 + ascent - descent;
         xmin = 0.0f;
         xmax = SkIntToScalar(face->available_sizes[fStrikeIndex].width) / xppem;
         ymin = descent + leading;
         ymax = ascent - descent;
-        if (!x_height) {
-            x_height = -ascent;
-        }
-        if (!avgCharWidth) {
-            avgCharWidth = xmax - xmin;
-        }
     } else {
         goto ERROR;
     }
 
     // synthesize elements that were not provided by the os/2 table or format-specific metrics
     if (!x_height) {
         x_height = -ascent;
     }
     if (!avgCharWidth) {
         avgCharWidth = xmax - xmin;
     }
+    if (!cap_height) {
+      cap_height = -ascent;
+    }
 
     // disallow negative linespacing
     if (leading < 0.0f) {
         leading = 0.0f;
     }
 
     if (mx) {
         mx->fTop = ymax * mxy;
         mx->fAscent = ascent * mxy;
         mx->fDescent = descent * mxy;
         mx->fBottom = ymin * mxy;
         mx->fLeading = leading * mxy;
         mx->fAvgCharWidth = avgCharWidth * mxy;
         mx->fXMin = xmin;
         mx->fXMax = xmax;
         mx->fXHeight = x_height;
+        mx->fCapHeight = cap_height;
     }
     if (my) {
         my->fTop = ymax * myy;
         my->fAscent = ascent * myy;
         my->fDescent = descent * myy;
         my->fBottom = ymin * myy;
         my->fLeading = leading * myy;
         my->fAvgCharWidth = avgCharWidth * myy;
         my->fXMin = xmin;
         my->fXMax = xmax;
         my->fXHeight = x_height;
+        my->fCapHeight = cap_height;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkUtils.h"
 
 static SkUnichar next_utf8(const void** chars) {
     return SkUTF8_NextUnichar((const char**)chars);
 }
@@ skipping 186 matching lines @@
         *style = (SkTypeface::Style) tempStyle;
     }
     if (isFixedPitch) {
         *isFixedPitch = FT_IS_FIXED_WIDTH(face);
     }
 
     FT_Done_Face(face);
     FT_Done_FreeType(library);
     return true;
 }