Speed up generateImage by re-using the outline/bitmap that has already been loaded.

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 172 matching lines @@
 private:
     SkFaceRec*  fFaceRec;
     FT_Face     fFace;              // reference to shared face in gFaceRecHead
     FT_Size     fFTSize;            // our own copy
     SkFixed     fScaleX, fScaleY;
     FT_Matrix   fMatrix22;
     uint32_t    fLoadGlyphFlags;
     bool        fDoLinearMetrics;
     bool        fLCDIsVert;
 
+    // since different scalercontext may share the same face
+    // using a ID to identify which settings are activated
+    // this can help us to skip some unnecessary FreeType2 calls
+    uint32_t    fUniqueID;
+
     // Need scalar versions for generateFontMetrics
     SkVector    fScale;
     SkMatrix    fMatrix22Scalar;
 
     FT_Error setupSize();
     void getBBoxForCurrentGlyph(SkGlyph* glyph, FT_BBox* bbox,
                                 bool snapToPixelBoundary = false);
     // Caller must lock gFTMutex before calling this function.
     void updateGlyphIfLCD(SkGlyph* glyph);
 };
 
 ///////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
 struct SkFaceRec {
     SkFaceRec*      fNext;
     FT_Face         fFace;
     FT_StreamRec    fFTStream;
     SkStream*       fSkStream;
     uint32_t        fRefCnt;
     uint32_t        fFontID;
 
+    // record some information about the last glyph loaded
+    // drawText will generateImage just after generateMetrics in most cases
+    // a simple check can help us to skip the unnecessary call to FT_Load_Glyph
+    // which is time consuming, especially for composite glyphs
+    uint32_t        fActivatedContextID;
+    // glyph that has been already loaded, which is also ready for generateImage
+    uint16_t        fGlyphLoaded;
+
     // assumes ownership of the stream, will call unref() when its done
     SkFaceRec(SkStream* strm, uint32_t fontID);
     ~SkFaceRec() {
         fSkStream->unref();
     }
 };
 
 extern "C" {
     static unsigned long sk_stream_read(FT_Stream       stream,
                                         unsigned long   offset,
@@ skipping 117 matching lines @@
     AutoFTAccess(const SkTypeface* tf) : fRec(NULL), fFace(NULL) {
         gFTMutex.acquire();
         if (1 == ++gFTCount) {
             if (!InitFreetype()) {
                 sk_throw();
             }
         }
         fRec = ref_ft_face(tf);
         if (fRec) {
             fFace = fRec->fFace;
+            // someone will access to the FreeType face
+            fRec->fActivatedContextID = 0;
+            fRec->fGlyphLoaded = 0;
         }
     }
 
     ~AutoFTAccess() {
         if (fFace) {
             unref_ft_face(fFace);
         }
         if (0 == --gFTCount) {
             FT_Done_FreeType(gFTLibrary);
         }
@@ skipping 403 matching lines @@
 
     // load the font file
     fFTSize = NULL;
     fFace = NULL;
     fFaceRec = ref_ft_face(typeface);
     if (NULL == fFaceRec) {
         return;
     }
     fFace = fFaceRec->fFace;
 
+    // set ID for current scaler context
+    // start from 1, regarding 0 as invalid
+    static uint32_t gScalerContextID = 1;
+    fUniqueID = gScalerContextID++;
+
     // compute our factors from the record
 
     SkMatrix    m;
 
     fRec.getSingleMatrix(&m);
 
 #ifdef DUMP_STRIKE_CREATION
     SkString     keyString;
     SkFontHost::GetDescriptorKeyString(desc, &keyString);
     printf("========== strike [%g %g %g] [%g %g %g %g] hints %d format %d %s\n", SkScalarToFloat(fRec.fTextSize),
@@ skipping 100 matching lines @@
 
         fLoadGlyphFlags = loadFlags;
         fDoLinearMetrics = linearMetrics;
     }
 
     // now create the FT_Size
 
     {
         FT_Error    err;
 
+        // no activated scaler context setting for the face
+        fFaceRec->fActivatedContextID = 0;
+        // regarding glyph 0 as an invalid glyph outline that we need to reload
+        fFaceRec->fGlyphLoaded = 0;
+
         err = FT_New_Size(fFace, &fFTSize);
         if (err != 0) {
             SkDEBUGF(("SkScalerContext_FreeType::FT_New_Size(%x): FT_Set_Char_Size(0x%x, 0x%x) returned 0x%x\n",
                         fFaceRec->fFontID, fScaleX, fScaleY, err));
             fFace = NULL;
             return;
         }
 
         err = FT_Activate_Size(fFTSize);
         if (err != 0) {
             SkDEBUGF(("SkScalerContext_FreeType::FT_Activate_Size(%x, 0x%x, 0x%x) returned 0x%x\n",
                         fFaceRec->fFontID, fScaleX, fScaleY, err));
             fFTSize = NULL;
         }
 
         err = FT_Set_Char_Size( fFace,
                                 SkFixedToFDot6(fScaleX), SkFixedToFDot6(fScaleY),
                                 72, 72);
         if (err != 0) {
             SkDEBUGF(("SkScalerContext_FreeType::FT_Set_Char_Size(%x, 0x%x, 0x%x) returned 0x%x\n",
                         fFaceRec->fFontID, fScaleX, fScaleY, err));
             fFace = NULL;
             return;
         }
 
         FT_Set_Transform( fFace, &fMatrix22, NULL);
+
+        // current scaler context setting is enabled for the face
+        fFaceRec->fActivatedContextID = fUniqueID;
     }
 }
 
 SkScalerContext_FreeType::~SkScalerContext_FreeType() {
     SkAutoMutexAcquire  ac(gFTMutex);
 
     if (fFTSize != NULL) {
         FT_Done_Size(fFTSize);
     }
 
     if (fFace != NULL) {
         unref_ft_face(fFace);
     }
     if (--gFTCount == 0) {
 //        SkDEBUGF(("FT_Done_FreeType\n"));
         FT_Done_FreeType(gFTLibrary);
         SkDEBUGCODE(gFTLibrary = NULL;)
     }
 }
 
 /*  We call this before each use of the fFace, since we may be sharing
     this face with other context (at different sizes).
 */
 FT_Error SkScalerContext_FreeType::setupSize() {
-    FT_Error    err = FT_Activate_Size(fFTSize);
+    FT_Error    err = 0;
 
-    if (err != 0) {
-        SkDEBUGF(("SkScalerContext_FreeType::FT_Activate_Size(%x, 0x%x, 0x%x) returned 0x%x\n",
-                    fFaceRec->fFontID, fScaleX, fScaleY, err));
-        fFTSize = NULL;
-    } else {
-        // seems we need to reset this every time (not sure why, but without it
-        // I get random italics from some other fFTSize)
-        FT_Set_Transform( fFace, &fMatrix22, NULL);
+    if (fFaceRec->fActivatedContextID != fUniqueID) {
+        // no scalercontext settings are activated for the FreeType face now
+        fFaceRec->fActivatedContextID = 0;
+        fFaceRec->fGlyphLoaded = 0;
+        err = FT_Activate_Size(fFTSize);
+        if (err != 0) {
+            SkDEBUGF(("SkScalerContext_FreeType::FT_Activate_Size(%x, 0x%x, 0x%x) returned 0x%x\n",
+                fFaceRec->fFontID, fScaleX, fScaleY, err));
+            fFTSize = NULL;
+        } else {
+            // seems we need to reset this every time (not sure why, but without it
+            // I get random italics from some other fFTSize)
+            FT_Set_Transform( fFace, &fMatrix22, NULL);
+            // current scalercontext settings are activated
+            fFaceRec->fActivatedContextID = fUniqueID;
+        }
     }
     return err;
 }
 
 unsigned SkScalerContext_FreeType::generateGlyphCount() {
     return fFace->num_glyphs;
 }
 
 uint16_t SkScalerContext_FreeType::generateCharToGlyph(SkUnichar uni) {
     return SkToU16(FT_Get_Char_Index( fFace, uni ));
@@ skipping 103 matching lines @@
 
     glyph->fRsbDelta = 0;
     glyph->fLsbDelta = 0;
 
     FT_Error    err;
 
     if (this->setupSize()) {
         goto ERROR;
     }
 
-    err = FT_Load_Glyph( fFace, glyph->getGlyphID(fBaseGlyphCount), fLoadGlyphFlags );
+    // this glyph will be loaded to FreeType glyph slot
+    fFaceRec->fGlyphLoaded = glyph->getGlyphID(fBaseGlyphCount);
+    err = FT_Load_Glyph( fFace, fFaceRec->fGlyphLoaded, 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();
+        // glyph not loadded
+        fFaceRec->fGlyphLoaded = 0;
         return;
     }
+    emboldenIfNeeded(fFace, fFace->glyph);
 
     switch ( fFace->glyph->format ) {
       case FT_GLYPH_FORMAT_OUTLINE: {
         FT_BBox bbox;
 
         if (0 == fFace->glyph->outline.n_contours) {
             glyph->fWidth = 0;
             glyph->fHeight = 0;
             glyph->fTop = 0;
             glyph->fLeft = 0;
             break;
         }
 
-        if (fRec.fFlags & kEmbolden_Flag) {
-            emboldenOutline(fFace, &fFace->glyph->outline);
-        }
-
         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);
         }
 
         glyph->fWidth   = SkToU16(fFace->glyph->bitmap.width);
@@ skipping 35 matching lines @@
     SkDEBUGF(("FT_Set_Char_Size(this:%p sx:%x sy:%x ", this, fScaleX, fScaleY));
     SkDEBUGF(("Metrics(glyph:%d flags:0x%x) w:%d\n", glyph->getGlyphID(fBaseGlyphCount), fLoadGlyphFlags, glyph->fWidth));
 #endif
 }
 
 
 void SkScalerContext_FreeType::generateImage(const SkGlyph& glyph) {
     SkAutoMutexAcquire  ac(gFTMutex);
 
     FT_Error    err;
+    uint16_t    glyphLoaded;
 
     if (this->setupSize()) {
         goto ERROR;
     }
 
-    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;
+    glyphLoaded = fFaceRec->fGlyphLoaded;
+    // no need to remember what is in the FreeType glyph slot
+    // since the skia glyph cache won't query image for the same glyph shortly
+    fFaceRec->fGlyphLoaded = 0;
+    if (glyphLoaded == 0 || glyphLoaded != glyph.getGlyphID(fBaseGlyphCount)) {
+        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)
 
+    // FreeType glyph slot will be invalid for generateImage
+    fFaceRec->fGlyphLoaded = 0;
     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 50 matching lines @@
     ys[4] = leading;
     ys[5] = os2 ? os2->xAvgCharWidth : 0;
 
     SkScalar x_height;
     if (os2 && os2->sxHeight) {
         x_height = fScale.x() * os2->sxHeight / upem;
     } else {
         const FT_UInt x_glyph = FT_Get_Char_Index(fFace, 'x');
         if (x_glyph) {
             FT_BBox bbox;
+            // just set the glyph to be invalid for generateImage
+            fFaceRec->fGlyphLoaded = 0;
             FT_Load_Glyph(fFace, x_glyph, fLoadGlyphFlags);
-            if (fRec.fFlags & kEmbolden_Flag) {
-                emboldenOutline(fFace, &fFace->glyph->outline);
-            }
+            emboldenIfNeeded(fFace, fFace->glyph);
             FT_Outline_Get_CBox(&fFace->glyph->outline, &bbox);
             x_height = bbox.yMax / 64.0f;
         } else {
             x_height = 0;
         }
     }
 
     // convert upem-y values into scalar points
     for (int i = 0; i < 6; i++) {
         SkScalar y = scaleY * ys[i] / upem;
@@ skipping 220 matching lines @@
         *style = (SkTypeface::Style) tempStyle;
     }
     if (isFixedPitch) {
         *isFixedPitch = FT_IS_FIXED_WIDTH(face);
     }
 
     FT_Done_Face(face);
     FT_Done_FreeType(library);
     return true;
 }