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) &&
+               // 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 bbox;
+            if (getCBoxForLetter('H', &bbox)) {
+                cap_height = SkIntToScalar(bbox.yMax) / 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;
 }