refactor emboldenGlyph

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"
 #include "SkColorPriv.h"
@@ skipping 197 matching lines @@
     // 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);
+    // Caller must lock gFTMutex before calling this function.
+    // update FreeType2 glyph slot with glyph emboldened
+    void emboldenIfNeeded(FT_Face face, FT_GlyphSlot glyph);
 };
 
 ///////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
 struct SkFaceRec {
     SkFaceRec*      fNext;
     FT_Face         fFace;
     FT_StreamRec    fFTStream;
     SkStream*       fSkStream;
@@ skipping 900 matching lines @@
         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);
-    }
+    emboldenIfNeeded(fFace, fFace->glyph);
     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 {
@@ skipping 29 matching lines @@
     err = FT_Load_Glyph( fFace, glyph->getGlyphID(fBaseGlyphCount), fLoadGlyphFlags );
     if (err != 0) {
 #if 0
         SkDEBUGF(("SkScalerContext_FreeType::generateMetrics(%x): FT_Load_Glyph(glyph:%d flags:%x) returned 0x%x\n",
                     fFaceRec->fFontID, glyph->getGlyphID(fBaseGlyphCount), fLoadGlyphFlags, err));
 #endif
     ERROR:
         glyph->zeroMetrics();
         return;
     }
+    emboldenIfNeeded(fFace, fFace->glyph);
 
     switch ( fFace->glyph->format ) {
       case FT_GLYPH_FORMAT_OUTLINE:
         if (0 == fFace->glyph->outline.n_contours) {
             glyph->fWidth = 0;
             glyph->fHeight = 0;
             glyph->fTop = 0;
             glyph->fLeft = 0;
         } else {
-            if (fRec.fFlags & kEmbolden_Flag && !(fFace->style_flags & FT_STYLE_FLAG_BOLD)) {
-                emboldenOutline(fFace, &fFace->glyph->outline);
-            }
-
             FT_BBox bbox;
             getBBoxForCurrentGlyph(glyph, &bbox, true);
 
             glyph->fWidth   = SkToU16(SkFDot6Floor(bbox.xMax - bbox.xMin));
             glyph->fHeight  = SkToU16(SkFDot6Floor(bbox.yMax - bbox.yMin));
             glyph->fTop     = -SkToS16(SkFDot6Floor(bbox.yMax));
             glyph->fLeft    = SkToS16(SkFDot6Floor(bbox.xMin));
 
             updateGlyphIfLCD(glyph);
         }
         break;
 
       case FT_GLYPH_FORMAT_BITMAP:
-        if (fRec.fFlags & kEmbolden_Flag) {
-            FT_GlyphSlot_Own_Bitmap(fFace->glyph);
-            FT_Bitmap_Embolden(gFTLibrary, &fFace->glyph->bitmap, kBitmapEmboldenStrength, 0);
-        }
-
         if (fRec.fFlags & SkScalerContext::kVertical_Flag) {
             FT_Vector vector;
             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);
             fFace->glyph->bitmap_left += SkFDot6Floor(vector.x);
             fFace->glyph->bitmap_top  += SkFDot6Floor(vector.y);
         }
 
         if (fFace->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_BGRA) {
@@ skipping 58 matching lines @@
 
     err = FT_Load_Glyph( fFace, glyph.getGlyphID(fBaseGlyphCount), fLoadGlyphFlags);
     if (err != 0) {
         SkDEBUGF(("SkScalerContext_FreeType::generateImage: FT_Load_Glyph(glyph:%d width:%d height:%d rb:%d flags:%d) returned 0x%x\n",
                     glyph.getGlyphID(fBaseGlyphCount), glyph.fWidth, glyph.fHeight, glyph.rowBytes(), fLoadGlyphFlags, err));
     ERROR:
         memset(glyph.fImage, 0, glyph.rowBytes() * glyph.fHeight);
         return;
     }
 
+    emboldenIfNeeded(fFace, fFace->glyph);
     generateGlyphImage(fFace, glyph);
 }
 
 
 void SkScalerContext_FreeType::generatePath(const SkGlyph& glyph,
                                             SkPath* path) {
     SkAutoMutexAcquire  ac(gFTMutex);
 
     SkASSERT(&glyph && path);
 
     if (this->setupSize()) {
         path->reset();
         return;
     }
 
     uint32_t flags = fLoadGlyphFlags;
     flags |= FT_LOAD_NO_BITMAP; // ignore embedded bitmaps so we're sure to get the outline
     flags &= ~FT_LOAD_RENDER;   // don't scan convert (we just want the outline)
 
     FT_Error err = FT_Load_Glyph( fFace, glyph.getGlyphID(fBaseGlyphCount), flags);
 
     if (err != 0) {
         SkDEBUGF(("SkScalerContext_FreeType::generatePath: FT_Load_Glyph(glyph:%d flags:%d) returned 0x%x\n",
                     glyph.getGlyphID(fBaseGlyphCount), flags, err));
         path->reset();
         return;
     }
+    emboldenIfNeeded(fFace, fFace->glyph);
 
     generateGlyphPath(fFace, path);
 
     // The path's origin from FreeType is always the horizontal layout origin.
     // Offset the path so that it is relative to the vertical origin if needed.
     if (fRec.fFlags & SkScalerContext::kVertical_Flag) {
         FT_Vector vector;
         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);
@@ skipping 121 matching lines @@
         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;
     }
 }
 
+void SkScalerContext_FreeType::emboldenIfNeeded(FT_Face face, FT_GlyphSlot glyph)
+{
+    if (fRec.fFlags & SkScalerContext::kEmbolden_Flag) {
+        switch ( glyph->format ) {
+            case FT_GLYPH_FORMAT_OUTLINE:
+                FT_Pos strength;
+                strength = FT_MulFix(face->units_per_EM, face->size->metrics.y_scale) / 24;
+                FT_Outline_Embolden(&glyph->outline, strength);
+                break;
+            case FT_GLYPH_FORMAT_BITMAP:
+                FT_GlyphSlot_Own_Bitmap(glyph);
+                FT_Bitmap_Embolden(glyph->library, &glyph->bitmap, kBitmapEmboldenStrength, 0);
+                break;
+            default:
+                SkDEBUGFAIL("unknown glyph format");
+        }
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkUtils.h"
 
 static SkUnichar next_utf8(const void** chars) {
     return SkUTF8_NextUnichar((const char**)chars);
 }
 
 static SkUnichar next_utf16(const void** chars) {
     return SkUTF16_NextUnichar((const uint16_t**)chars);
@@ skipping 183 matching lines @@
         *style = (SkTypeface::Style) tempStyle;
     }
     if (isFixedPitch) {
         *isFixedPitch = FT_IS_FIXED_WIDTH(face);
     }
 
     FT_Done_Face(face);
     FT_Done_FreeType(library);
     return true;
 }