Recycle temporary glyph buffers in FontFreeType.

Author: j-jorge

core/2d/FontAtlas.cpp

@@ -385,17 +385,18 @@ bool FontAtlas::prepareLetterDefinitions(const std::u32string& utf32Text)
                 if (charRenderer)
                 {
                     unsigned int glyphIndex = fallbackFaceInfo->currentGlyphIndex;
-                    bitmap =
-                        charRenderer->getGlyphBitmapByIndex(glyphIndex, bitmapWidth, bitmapHeight, tempRect, tempDef.xAdvance);
+                    bitmap = charRenderer->getGlyphBitmapByIndex(glyphIndex, bitmapWidth, bitmapHeight, tempRect,
+                                                                 tempDef.xAdvance);
                     _missingGlyphFallbackFonts.emplace(charCode, std::make_pair(charRenderer, glyphIndex));
                 }
             }
         }
         else
         {  // found fallback font for missing charas, getGlyphBitmap without fallback
-            charRenderer = missingIt->second.first;
+            charRenderer            = missingIt->second.first;
             unsigned int glyphIndex = missingIt->second.second;
-            bitmap = charRenderer->getGlyphBitmapByIndex(glyphIndex, bitmapWidth, bitmapHeight, tempRect, tempDef.xAdvance);
+            bitmap =
+                charRenderer->getGlyphBitmapByIndex(glyphIndex, bitmapWidth, bitmapHeight, tempRect, tempDef.xAdvance);
         }
         if (bitmap && bitmapWidth > 0 && bitmapHeight > 0)
         {
@@ -419,11 +420,11 @@ bool FontAtlas::prepareLetterDefinitions(const std::u32string& utf32Text)
                     addNewPage();
                 }
             }
-            glyphHeight = static_cast<int>(bitmapHeight) + _letterPadding + _letterEdgeExtend;
+            glyphHeight     = static_cast<int>(bitmapHeight) + _letterPadding + _letterEdgeExtend;
             _currLineHeight = std::max(glyphHeight, _currLineHeight);
             charRenderer->renderCharAt(_currentPageData, (int)_currentPageOrigX + adjustForExtend,
                                        (int)_currentPageOrigY + adjustForExtend, bitmap, bitmapWidth, bitmapHeight,
-                                        _width, _height);
+                                       _width, _height);
 
             tempDef.U         = _currentPageOrigX;
             tempDef.V         = _currentPageOrigY;
@@ -438,7 +439,8 @@ bool FontAtlas::prepareLetterDefinitions(const std::u32string& utf32Text)
         }
         else
         {
-            delete[] bitmap;
+            if (bitmap)
+                charRenderer->releaseBuffer(bitmap);
 
             tempDef.validDefinition = !!tempDef.xAdvance;
             tempDef.width           = 0;
@@ -463,8 +465,8 @@ bool FontAtlas::prepareLetterDefinitions(const std::u32string& utf32Text)
 void FontAtlas::updateTextureContent(backend::PixelFormat format, int startY)
 {
     auto data = _currentPageData + (_width * (int)startY << _strideShift);
-    _atlasTextures[_currentPage]->updateWithSubData(data, 0, startY, _width,
-                                                    (std::min)((int)_currentPageOrigY - startY + _currLineHeight, _height));
+    _atlasTextures[_currentPage]->updateWithSubData(
+        data, 0, startY, _width, (std::min)((int)_currentPageOrigY - startY + _currLineHeight, _height));
 }
 
 void FontAtlas::addNewPage()
@@ -549,4 +551,4 @@ void FontAtlas::setAntiAliasTexParameters()
     }
 }
 
-}
+}  // namespace ax

core/2d/FontFreeType.cpp

@@ -210,6 +210,12 @@ FontFreeType::FontFreeType(bool distanceFieldEnabled /* = false */, float outlin
 
 FontFreeType::~FontFreeType()
 {
+    AX_ASSERT(_usedBuffers.empty());
+
+    for (const BufferPool& p : _availableBuffers)
+        for (uint8_t* b : p.buffers)
+            delete[] b;
+
     if (_FTInitialized)
     {
         if (_stroker)
@@ -503,15 +509,15 @@ unsigned char* FontFreeType::getGlyphBitmapByIndex(unsigned int glyphIndex,
 
         if (_outlineSize > 0 && outWidth > 0 && outHeight > 0)
         {
-            auto copyBitmap = new unsigned char[outWidth * outHeight];
-            memcpy(copyBitmap, ret, outWidth * outHeight * sizeof(unsigned char));
+            uint8_t* const copyBitmap = acquireBuffer(outWidth * outHeight);
+            memcpy(copyBitmap, ret, outWidth * outHeight * sizeof(uint8_t));
 
             FT_BBox bbox;
             auto outlineBitmap = getGlyphBitmapWithOutline(glyphIndex, bbox);
             if (outlineBitmap == nullptr)
             {
                 ret = nullptr;
-                delete[] copyBitmap;
+                releaseBuffer(copyBitmap);
                 break;
             }
 
@@ -540,7 +546,7 @@ unsigned char* FontFreeType::getGlyphBitmapByIndex(unsigned int glyphIndex,
             {
                 FT_Pos index, index2;
                 auto imageSize = blendWidth * blendHeight * 2;
-                blendImage     = new unsigned char[imageSize];
+                blendImage     = acquireBuffer(imageSize);
                 memset(blendImage, 0, imageSize);
 
                 auto px = outlineMinX - blendImageMinX;
@@ -573,8 +579,8 @@ unsigned char* FontFreeType::getGlyphBitmapByIndex(unsigned int glyphIndex,
             outWidth            = static_cast<int>(blendWidth);
             outHeight           = static_cast<int>(blendHeight);
 
-            delete[] outlineBitmap;
-            delete[] copyBitmap;
+            releaseBuffer(outlineBitmap);
+            releaseBuffer(copyBitmap);
             ret = blendImage;
         }
 
@@ -588,6 +594,24 @@ unsigned char* FontFreeType::getGlyphBitmapByIndex(unsigned int glyphIndex,
     return nullptr;
 }
 
+/**
+ * Put the given buffer back into the pool of buffers.
+ */
+void FontFreeType::releaseBuffer(uint8_t* buffer)
+{
+    const UsedBuffersMap::iterator it = _usedBuffers.find(buffer);
+    AX_ASSERT(it != _usedBuffers.end());
+
+    for (BufferPool& p : _availableBuffers)
+        if (p.capacity == it->second)
+        {
+            p.buffers.emplace_back(buffer);
+            break;
+        }
+
+    _usedBuffers.erase(it);
+}
+
 unsigned char* FontFreeType::getGlyphBitmapWithOutline(unsigned int glyphIndex, FT_BBox& bbox)
 {
     unsigned char* ret = nullptr;
@@ -607,7 +631,7 @@ unsigned char* FontFreeType::getGlyphBitmapWithOutline(unsigned int glyphIndex,
                     int32_t rows  = static_cast<int32_t>((bbox.yMax - bbox.yMin) >> 6);
 
                     FT_Bitmap bmp;
-                    bmp.buffer = new unsigned char[width * rows];
+                    bmp.buffer = acquireBuffer(width * rows);
                     memset(bmp.buffer, 0, width * rows);
                     bmp.width      = (int)width;
                     bmp.rows       = (int)rows;
@@ -653,7 +677,7 @@ void FontFreeType::renderCharAt(unsigned char* dest,
             memcpy(dest + (iX + (iY * atlasWidth)) * 2, bitmap + bitmap_y * 2, bitmapWidth * 2);
             ++iY;
         }
-        delete[] bitmap;
+        releaseBuffer(bitmap);
     }
     else
     {
@@ -710,4 +734,56 @@ void FontFreeType::releaseFont(std::string_view fontName)
     }
 }
 
+/**
+ * Find a buffer with a capacity larger or equal to the given size. If there is
+ * no such buffer, a new one is created. In all cases the returned buffer is
+ * added to the used buffers list and will have to be released via
+ * releaseBuffer.
+ */
+uint8_t* FontFreeType::acquireBuffer(size_t size)
+{
+    const size_t n = _availableBuffers.size();
+
+    // Index of the first pool of large enough buffers. If we could not find a
+    // buffer for the given size, this is also the index where a new pool will
+    // be inserted.
+    size_t new_pool_index = n;
+
+    // Find the place where the best pool for our size should be.
+    for (size_t i = 0; i != n; ++i)
+        if (_availableBuffers[i].capacity >= size)
+        {
+            new_pool_index = i;
+            break;
+        }
+
+    // Now search for a pool with an available buffer.
+    for (size_t i = new_pool_index; i != n; ++i)
+    {
+        BufferPool& p = _availableBuffers[i];
+
+        // A pool with large enough buffers and an available one.
+        if (!p.buffers.empty())
+        {
+            uint8_t* const buffer = p.buffers.back();
+            p.buffers.pop_back();
+            _usedBuffers[buffer] = p.capacity;
+
+            return buffer;
+        }
+    }
+
+    if ((new_pool_index == n) || (_availableBuffers[new_pool_index].capacity != size))
+        // Either all pools have capacities smaller than the requested size, or else
+        // We have pools with capacity larger than the requested size but none had
+        // an available buffer. We create a new pool for the requested size so
+        // we'll be ready to receive the buffer in releaseBuffer.
+        _availableBuffers.emplace(_availableBuffers.begin() + new_pool_index)->capacity = size;
+
+    uint8_t* const buffer(new uint8_t[size]);
+    _usedBuffers[buffer] = size;
+
+    return buffer;
+}
+
 }  // namespace ax

core/2d/FontFreeType.h

@@ -28,7 +28,11 @@
 
 #include "2d/Font.h"
 #include "2d/IFontEngine.h"
+
+#include <tsl/robin_map.h>
+
 #include <string>
+#include <memory>
 
 namespace ax
 {
@@ -133,6 +137,7 @@ class AX_DLL FontFreeType : public Font
                                          int& outHeight,
                                          Rect& outRect,
                                          int& xAdvance);
+    void releaseBuffer(uint8_t* buffer);
 
     int getFontAscender() const;
     const char* getFontFamily() const;
@@ -169,6 +174,8 @@ class AX_DLL FontFreeType : public Font
 
     void setGlyphCollection(GlyphCollection glyphs, std::string_view customGlyphs);
 
+    uint8_t* acquireBuffer(size_t size);
+
     FT_Face _fontFace;
     FT_Stream _fontStream;
     FT_Stroker _stroker;
@@ -183,9 +190,23 @@ class AX_DLL FontFreeType : public Font
 
     GlyphCollection _usedGlyphs;
     std::string _customGlyphs;
+
+    struct BufferPool
+    {
+        size_t capacity;
+        std::vector<uint8_t*> buffers;
+    };
+
+    using BufferPoolVector = std::vector<BufferPool>;
+    // using UsedBuffersMap   = tsl::robin_map<uint8_t*, size_t>;
+    using UsedBuffersMap = std::unordered_map<uint8_t*, size_t>;
+
+    /// Those are sorted by increasing capacity.
+    BufferPoolVector _availableBuffers;
+    UsedBuffersMap _usedBuffers;
 };
 
 // end of _2d group
 /// @}
 
-}
+}  // namespace ax