[Git][freetype/freetype-demos][gsoc-2022-chariri-3] [ftinspect] Extract

Charlie Jiang pushed to branch gsoc-2022-chariri-3 at FreeType / FreeType Demo Programs

Commits:

e9fcd920

by Charlie Jiang at 2022-08-24T00:00:06+08:00

[ftinspect] Extract out rendering-related code from `Engine`.

The current `Engine` class is too huge, so moving rendering code out
to a new class `RenderingEngine`.

* src/ftinspect/engine/rendering.cpp, src/ftinspect/engine/rendering.hpp:
  New file.

* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
  Move out code. Add getters for the rendering engine to use.

* src/ftinspect/CMakeLists.txt, src/ftinspect/meson.build: Updated.

* src/ftinspect/**: Updated to incorporate the refactoring.

11 changed files:

src/ftinspect/CMakeLists.txt
src/ftinspect/engine/engine.cpp
src/ftinspect/engine/engine.hpp
+ src/ftinspect/engine/rendering.cpp
+ src/ftinspect/engine/rendering.hpp
src/ftinspect/engine/stringrenderer.cpp
src/ftinspect/glyphcomponents/glyphbitmap.cpp
src/ftinspect/glyphcomponents/glyphcontinuous.cpp
src/ftinspect/meson.build
src/ftinspect/panels/settingpanel.cpp
src/ftinspect/panels/singular.cpp

Changes:

src/ftinspect/CMakeLists.txt

@@ -28,6 +28,7 @@ add_executable(ftinspect
    "engine/fontinfo.cpp"
    "engine/fontinfonamesmapping.cpp"
    "engine/mmgx.cpp"
 +  "engine/rendering.cpp"
    "engine/renderutils.cpp"
    "glyphcomponents/glyphbitmap.cpp"

src/ftinspect/engine/engine.cpp

@@ -163,9 +163,7 @@ Engine::Engine()
+   }
    queryEngine();
+-
 -  setForeground(QColor(Qt::black).rgba());
 -  setBackground(QColor(Qt::white).rgba());
 +  renderingEngine_ = std::make_unique<RenderingEngine>(this);
+ }
@@ -649,57 +647,6 @@ Engine::loadGlyphWithoutUpdate(int glyphIndex,
+ }
 -bool
 -Engine::convertGlyphToBitmapGlyph(FT_Glyph src,
 -                      FT_Glyph* out)
 -{
 -  if (src->format == FT_GLYPH_FORMAT_BITMAP)
 -  {
 -    *out = src;
 -    return false;
 -  }
 -  if (src->format != FT_GLYPH_FORMAT_OUTLINE)
 -  {
 -    *out = NULL;
 -    return false;
 -    // TODO support SVG
 -  }
+-
 -  if (src->format == FT_GLYPH_FORMAT_OUTLINE)
 -  {
 -    FT_Glyph out2 = src;
 -    auto error = FT_Glyph_To_Bitmap(&out2,
 -                                    static_cast<FT_Render_Mode>(renderMode_),
 -                                    nullptr,
 -                                    false);
 -    if (error)
 -    {
 -      *out = NULL;
 -      return false;
 -    }
 -    *out = out2;
 -    return true;
 -  }
+-
 -  *out = NULL;
 -  return false;
 -}
+-
+-
 -FT_Bitmap
 -Engine::convertBitmapTo8Bpp(FT_Bitmap* bitmap)
 -{
 -  FT_Bitmap out;
 -  out.buffer = NULL;
 -  auto error = FT_Bitmap_Convert(library_, bitmap, &out, 1);
 -  if (error)
 -  {
 -    // XXX handling?
 -  }
 -  return out;
 -}
+-
+-
  bool
  Engine::renderReady()
+ {
@@ -751,7 +698,7 @@ Engine::setGamma(double gamma)
    if (gamma_ != gamma)
+   {
      gamma_ = gamma;
 -    calculateForegroundTable();
 +    renderingEngine_->calculateForegroundTable();
+   }
+ }
@@ -824,28 +771,6 @@ Engine::applyMMGXDesignCoords(FT_Fixed* coords,
+ }
 -void
 -Engine::setForeground(QRgb foreground)
 -{
 -  if (foregroundTable_.size() != 256 || foreground != foregroundColor_)
 -  {
 -    foregroundColor_ = foreground;
 -    calculateForegroundTable();
 -  }
 -}
+-
+-
 -void
 -Engine::setBackground(QRgb background)
 -{
 -  if (foregroundTable_.size() != 256 || background != backgroundColor_)
 -  {
 -    backgroundColor_ = background;
 -    calculateForegroundTable();
 -  }
 -}
+-
+-
  void
  Engine::update()
+ {
@@ -1023,400 +948,6 @@ Engine::loadPaletteInfos()
+ }
 -void
 -Engine::calculateForegroundTable()
 -{
 -  foregroundTable_.resize(256);
+-
 -  // Yes I know this is horribly slow, but we're only calculating the table once
 -  // and can use it for all rendering if the color and gamma isn't changing.
+-
 -  double br = std::pow(qRed(backgroundColor_) / 255.0, gamma_);
 -  double bg = std::pow(qGreen(backgroundColor_) / 255.0, gamma_);
 -  double bb = std::pow(qBlue(backgroundColor_) / 255.0, gamma_);
 -  double invGamma = 1 / gamma_;
+-
 -  for (int i = 0; i <= 0xFF; i++)
 -  {
 -    double foreAlpha = i * qAlpha(foregroundColor_) / 255.0 / 255.0;
 -    double backAlpha = 1 - foreAlpha;
 -    double r = std::pow(qRed(foregroundColor_) / 255.0, gamma_);
 -    double g = std::pow(qGreen(foregroundColor_) / 255.0, gamma_);
 -    double b = std::pow(qBlue(foregroundColor_) / 255.0, gamma_);
+-
 -    r = br * backAlpha + r * foreAlpha;
 -    g = bg * backAlpha + g * foreAlpha;
 -    b = bb * backAlpha + b * foreAlpha;
+-
 -    r = std::pow(r, invGamma);
 -    g = std::pow(g, invGamma);
 -    b = std::pow(b, invGamma);
+-
 -    foregroundTable_[i]
 -        = qRgba(static_cast<int>(r * 255),
 -                static_cast<int>(g * 255),
 -                static_cast<int>(b * 255),
 -                255);
 -  }
 -}
+-
+-
 -void
 -convertLCDToARGB(FT_Bitmap& bitmap,
 -                 QImage& image,
 -                 bool isBGR,
 -                 QVector<QRgb>& colorTable)
 -{
 -  int height = bitmap.rows;
 -  int width = bitmap.width / 3;
 -  int width3 = bitmap.width;
+-
 -  unsigned char* srcPtr = bitmap.buffer;
 -  unsigned* dstPtr = reinterpret_cast<unsigned*>(image.bits());
+-
 -  int offR = !isBGR ? 0 : 2;
 -  int offG = 1;
 -  int offB = isBGR ? 0 : 2;
 -  for (int i = 0; i < height; i++)
 -  {
 -    for (int j = 0; j < width3; j += 3)
 -    {
 -      unsigned char ar = srcPtr[j + offR];
 -      unsigned char ag = srcPtr[j + offG];
 -      unsigned char ab = srcPtr[j + offB];
 -      unsigned dr = colorTable[ar] & 0xFF;
 -      unsigned dg = colorTable[ag] & 0xFF;
 -      unsigned db = colorTable[ab] & 0xFF;
 -      *dstPtr = (0xFFu << 24) | (dr << 16) | (dg << 8) | db;
 -      dstPtr++;
 -    }
 -    srcPtr += bitmap.pitch;
 -    dstPtr += image.bytesPerLine() / 4 - width; // skip blank area
 -  }
 -}
+-
+-
 -void
 -convertLCDVToARGB(FT_Bitmap& bitmap,
 -                  QImage& image,
 -                  bool isBGR,
 -                  QVector<QRgb>& colorTable)
 -{
 -  int height = bitmap.rows / 3;
 -  int width = bitmap.width;
 -  int srcPitch = bitmap.pitch;
+-
 -  unsigned char* srcPtr = bitmap.buffer;
 -  unsigned* dstPtr = reinterpret_cast<unsigned*>(image.bits());
+-
 -  int offR = !isBGR ? 0 : 2 * srcPitch;
 -  int offG = srcPitch;
 -  int offB = isBGR ? 0 : 2 * srcPitch;
 -  for (int i = 0; i < height; i++)
 -  {
 -    for (int j = 0; j < width; j++)
 -    {
 -      unsigned char ar = srcPtr[j + offR];
 -      unsigned char ag = srcPtr[j + offG];
 -      unsigned char ab = srcPtr[j + offB];
 -      unsigned dr = colorTable[ar] & 0xFF;
 -      unsigned dg = colorTable[ag] & 0xFF;
 -      unsigned db = colorTable[ab] & 0xFF;
 -      *dstPtr = (0xFFu << 24) | (dr << 16) | (dg << 8) | db;
 -      dstPtr++;
 -    }
 -    srcPtr += 3ull * srcPitch;                  // move 3 lines
 -    dstPtr += image.bytesPerLine() / 4 - width; // skip blank area
 -  }
 -}
+-
+-
 -QImage*
 -Engine::convertBitmapToQImage(FT_Bitmap* src)
 -{
 -  QImage* result = NULL;
+-
 -  auto& bmap = *src;
 -  bool ownBitmap = false;
+-
 -  int width = INT_MAX, height = INT_MAX;
 -  if (bmap.width < INT_MAX)
 -    width = static_cast<int>(bmap.width);
 -  if (bmap.rows < INT_MAX)
 -    height = static_cast<int>(bmap.rows);
 -  auto format = QImage::Format_Indexed8; // goto crossing init
+-
 -  if (bmap.pixel_mode == FT_PIXEL_MODE_GRAY2
 -      || bmap.pixel_mode == FT_PIXEL_MODE_GRAY4)
 -  {
 -    bmap = convertBitmapTo8Bpp(&bmap);
 -    if (!bmap.buffer)
 -      goto cleanup;
 -    ownBitmap = true;
 -  }
+-
 -  if (bmap.pixel_mode == FT_PIXEL_MODE_LCD)
 -    width /= 3;
 -  else if (bmap.pixel_mode == FT_PIXEL_MODE_LCD_V)
 -    height /= 3;
+-
 -  switch (bmap.pixel_mode)
 -  {
 -  case FT_PIXEL_MODE_MONO:
 -    format = QImage::Format_Mono;
 -    break;
 -  case FT_PIXEL_MODE_GRAY:
 -    format = QImage::Format_Indexed8;
 -    break;
 -  case FT_PIXEL_MODE_BGRA:
 -    // XXX "ARGB" here means BGRA due to endianness - may be problematic
 -    // on big-endian machines
 -    format = QImage::Format_ARGB32_Premultiplied;
 -    break;
 -  case FT_PIXEL_MODE_LCD:
 -  case FT_PIXEL_MODE_LCD_V:
 -    format = QImage::Format_ARGB32;
 -    break;
 -  default:
 -    goto cleanup;
 -  }
+-
 -  switch (bmap.pixel_mode)
 -  {
 -  case FT_PIXEL_MODE_MONO:
 -  case FT_PIXEL_MODE_GRAY:
 -  case FT_PIXEL_MODE_BGRA:
 -    {
 -      QImage image(bmap.buffer,
 -                   width, height,
 -                   bmap.pitch,
 -                   format);
 -      if (bmap.pixel_mode == FT_PIXEL_MODE_GRAY)
 -        image.setColorTable(foregroundTable_);
 -      else if (bmap.pixel_mode == FT_PIXEL_MODE_MONO)
 -      {
 -        image.setColorCount(2);
 -        image.setColor(0, static_cast<QRgb>(0)); // transparent
 -        image.setColor(1, foregroundTable_[0xFF]);
 -      }
 -      result = new QImage(image.copy());
 -      // Don't directly use `image` since we're destroying the image
 -    }
 -    break;
 -  case FT_PIXEL_MODE_LCD:;
 -    result = new QImage(width, height, format);
 -    convertLCDToARGB(bmap, *result, lcdUsesBGR_, foregroundTable_);
 -    break;
 -  case FT_PIXEL_MODE_LCD_V:;
 -    result = new QImage(width, height, format);
 -    convertLCDVToARGB(bmap, *result, lcdUsesBGR_, foregroundTable_);
 -    break;
 -  }
+-
 -cleanup:
 -  if (ownBitmap)
 -    FT_Bitmap_Done(library_, &bmap);
+-
 -  return result;
 -}
+-
+-
 -QImage*
 -Engine::convertGlyphToQImage(FT_Glyph src,
 -                             QRect* outRect,
 -                             bool inverseRectY)
 -{
 -  FT_BitmapGlyph bitmapGlyph;
 -  bool ownBitmapGlyph
 -    = convertGlyphToBitmapGlyph(src, reinterpret_cast<FT_Glyph*>(&bitmapGlyph));
 -  if (!bitmapGlyph)
 -    return NULL;
+-
 -  auto result = convertBitmapToQImage(&bitmapGlyph->bitmap);
+-
 -  if (result && outRect)
 -  {
 -    outRect->setLeft(bitmapGlyph->left);
 -    if (inverseRectY)
 -      outRect->setTop(-bitmapGlyph->top);
 -    else
 -      outRect->setTop(bitmapGlyph->top);
 -    if (bitmapGlyph->bitmap.width < INT_MAX)
 -      outRect->setWidth(static_cast<int>(bitmapGlyph->bitmap.width));
 -    else
 -      outRect->setWidth(INT_MAX);
+-
 -    if (bitmapGlyph->bitmap.rows < INT_MAX)
 -      outRect->setHeight(static_cast<int>(bitmapGlyph->bitmap.rows));
 -    else
 -      outRect->setHeight(INT_MAX);
 -  }
+-
 -  if (ownBitmapGlyph)
 -    FT_Done_Glyph(reinterpret_cast<FT_Glyph>(bitmapGlyph));
+-
 -  return result;
 -}
+-
+-
 -QPoint
 -Engine::computeGlyphOffset(FT_Glyph glyph, bool inverseY)
 -{
 -  if (glyph->format == FT_GLYPH_FORMAT_OUTLINE)
 -  {
 -    FT_BBox cbox;
 -    FT_Outline_Get_CBox(&reinterpret_cast<FT_OutlineGlyph>(glyph)->outline,
 -                        &cbox);
 -    cbox.xMin &= ~63;
 -    cbox.yMin &= ~63;
 -    cbox.xMax = (cbox.xMax + 63) & ~63;
 -    cbox.yMax = (cbox.yMax + 63) & ~63;
 -    if (inverseY)
 -      cbox.yMax = -cbox.yMax;
 -    return { static_cast<int>(cbox.xMin / 64),
 -             static_cast<int>(cbox.yMax / 64) };
 -  }
 -  if (glyph->format == FT_GLYPH_FORMAT_BITMAP)
 -  {
 -    auto bg = reinterpret_cast<FT_BitmapGlyph>(glyph);
 -    if (inverseY)
 -      return { bg->left, -bg->top };
 -    return { bg->left, bg->top };
 -  }
+-
 -  return {};
 -}
+-
+-
 -QImage*
 -Engine::tryDirectRenderColorLayers(int glyphIndex,
 -                                   QRect* outRect,
 -                                   bool inverseRectY)
 -{
 -  if (palette_ == NULL
 -      || !useColorLayer_
 -      || paletteIndex_ >= paletteData_.num_palettes)
 -    return NULL;
+-
 -  FT_LayerIterator iter = {};
+-
 -  FT_UInt layerGlyphIdx = 0;
 -  FT_UInt layerColorIdx = 0;
+-
 -  bool next = FT_Get_Color_Glyph_Layer(ftSize_->face,
 -                                       glyphIndex,
 -                                       &layerGlyphIdx,
 -                                       &layerColorIdx,
 -                                       &iter);
 -  if (!next)
 -    return NULL;
+-
 -  // temporarily change lf
 -  auto oldLoadFlags = imageType_.flags;
 -  auto loadFlags = oldLoadFlags;
 -  loadFlags &= ~FT_LOAD_COLOR;
 -  loadFlags |= FT_LOAD_RENDER;
+-
 -  loadFlags &= ~FT_LOAD_TARGET_(0xF);
 -  loadFlags |= FT_LOAD_TARGET_NORMAL;
 -  imageType_.flags = loadFlags;
+-
 -  FT_Bitmap bitmap = {};
 -  FT_Bitmap_Init(&bitmap);
+-
 -  FT_Vector bitmapOffset = {};
 -  bool failed = false;
+-
 -  do
 -  {
 -    FT_Vector slotOffset;
 -    FT_Glyph glyph;
 -    if (FTC_ImageCache_Lookup(imageCache_,
 -                              &imageType_,
 -                              layerGlyphIdx,
 -                              &glyph,
 -                              NULL))
 -    {
 -      // XXX Error handling
 -      failed = true;
 -      break;
 -    }
+-
 -    if (glyph->format != FT_GLYPH_FORMAT_BITMAP)
 -      continue;
+-
 -    auto bitmapGlyph = reinterpret_cast<FT_BitmapGlyph>(glyph);
 -    slotOffset.x = bitmapGlyph->left << 6;
 -    slotOffset.y = bitmapGlyph->top << 6;
+-
 -    FT_Color color = {};
+-
 -    if (layerColorIdx == 0xFFFF)
 -    {
 -      // TODO: FT_Palette_Get_Foreground_Color: #1134
 -      if (paletteData_.palette_flags
 -          && (paletteData_.palette_flags[paletteIndex_]
 -              & FT_PALETTE_FOR_DARK_BACKGROUND))
 -      {
 -        /* white opaque */
 -        color.blue = 0xFF;
 -        color.green = 0xFF;
 -        color.red = 0xFF;
 -        color.alpha = 0xFF;
 -      }
 -      else
 -      {
 -        /* black opaque */
 -        color.blue = 0x00;
 -        color.green = 0x00;
 -        color.red = 0x00;
 -        color.alpha = 0xFF;
 -      }
 -    }
 -    else if (layerColorIdx < paletteData_.num_palette_entries)
 -      color = palette_[layerColorIdx];
 -    else
 -      continue;
+-
 -    if (FT_Bitmap_Blend(library_,
 -                        &bitmapGlyph->bitmap, slotOffset,
 -                        &bitmap, &bitmapOffset,
 -                        color))
 -    {
 -      // XXX error
 -      failed = true;
 -      break;
 -    }
 -  } while (FT_Get_Color_Glyph_Layer(ftSize_->face,
 -                                    glyphIndex,
 -                                    &layerGlyphIdx,
 -                                    &layerColorIdx,
 -                                    &iter));
+-
 -  imageType_.flags = oldLoadFlags;
 -  if (failed)
 -  {
 -    FT_Bitmap_Done(library_, &bitmap);
 -    return NULL;
 -  }
+-
 -  auto img = convertBitmapToQImage(&bitmap);
 -  if (outRect)
 -  {
 -    outRect->moveLeft(static_cast<int>(bitmapOffset.x >> 6));
 -    if (inverseRectY)
 -      outRect->moveTop(static_cast<int>(-bitmapOffset.y >> 6));
 -    else
 -      outRect->moveTop(static_cast<int>(bitmapOffset.y >> 6));
 -    outRect->setSize(img->size());
 -  }
+-
 -  FT_Bitmap_Done(library_, &bitmap);
+-
 -  return img;
 -}
+-
+-
  QHash<FT_Glyph_Format, QString> glyphFormatNamesCache;
  QHash<FT_Glyph_Format, QString>&
  glyphFormatNames()

src/ftinspect/engine/engine.hpp

@@ -10,8 +10,10 @@
  #include "paletteinfo.hpp"
  #include "fontinfo.hpp"
  #include "mmgx.hpp"
 +#include "rendering.hpp"
  #include <vector>
 +#include <memory>
  #include <utility>
  #include <QString>
  #include <QMap>
@@ -90,29 +92,6 @@ public:
                                    FTC_Node* outNode = NULL,
                                    bool forceRender = false);
 -  // Return `true` if you need to free `out`
 -  // `out` will be set to NULL in cases of error
 -  bool convertGlyphToBitmapGlyph(FT_Glyph src, FT_Glyph* out);
 -  FT_Bitmap convertBitmapTo8Bpp(FT_Bitmap* bitmap);
 -  QImage* convertBitmapToQImage(FT_Bitmap* src);
 -  QImage* convertGlyphToQImage(FT_Glyph src,
 -                               QRect* outRect,
 -                               bool inverseRectY);
 -  QPoint computeGlyphOffset(FT_Glyph glyph, bool inverseY);
+-
 -  /*
 -   * Directly render the glyph at the specified index
 -   * to a `QImage`. If you want to perform color-layer
 -   * rendering, call this before trying to load the
 -   * glyph and do normal rendering, If the returning
 -   * value is non-NULL, then there's no need to
 -   * load the glyph the normal way, just draw the `QImage`.
 -   * Will return NULL if not enabled or color layers not available.
 -   */
 -  QImage* tryDirectRenderColorLayers(int glyphIndex,
 -                                     QRect* outRect,
 -                                     bool inverseRectY = false);
+-
    // reload current triplet, but with updated settings, useful for updating
    // `ftSize_` only
    void reloadFont();
@@ -128,6 +107,7 @@ public:
    FT_Library ftLibrary() const { return library_; }
    FTC_Manager cacheManager() { return cacheManager_; }
 +  FTC_ImageCache imageCacheManager() { return imageCache_; }
    int dpi() { return dpi_; }
    double pointSize() { return pointSize_; }
@@ -137,7 +117,7 @@ public:
    int numberOfOpenedFonts();
    int currentFontIndex() { return curFontIndex_; }
    FT_Face currentFallbackFtFace() { return ftFallbackFace_; }
 -  // FT_Size currentFtSize() { return ftSize_; }
 +  FT_Size currentFtSize() { return ftSize_; }
    int currentFontType() const { return fontType_; }
    const QString& currentFamilyName() { return curFamilyName_; }
    const QString& currentStyleName() { return curStyleName_; }
@@ -170,13 +150,26 @@ public:
    std::vector<int> currentFontFixedSizes();
    FontFileManager& fontFileManager() { return fontFileManager_; }
    EngineDefaultValues& engineDefaults() { return engineDefaults_; }
++
 +  double gamma() { return gamma_; }
    bool antiAliasingEnabled() { return antiAliasingEnabled_; }
    bool doHinting() { return doHinting_; }
    bool embeddedBitmapEnabled() { return embeddedBitmap_; }
    bool lcdUsingSubPixelPositioning() { return lcdSubPixelPositioning_; }
 +  bool useColorLayer() { return useColorLayer_; }
 +  bool lcdUsesBGR() { return lcdUsesBGR_; }
 +  FT_Render_Mode
 +  renderMode()
 +  {
 +    return static_cast<FT_Render_Mode>(renderMode_);
 +  }
 +  FTC_ImageType imageType() { return &imageType_; }
++
 +  int paletteIndex() { return paletteIndex_; }
 +  FT_Color* currentPalette() { return palette_; }
 +  FT_Palette_Data& currentFontPaletteData() { return paletteData_; }
 -  QRgb foreground() { return foregroundColor_; }
 -  QRgb background() { return backgroundColor_; }
 +  RenderingEngine* renderingEngine() { return renderingEngine_.get(); }
    //////// Setters (direct or indirect)
@@ -217,9 +210,6 @@ public:
    void setStemDarkening(bool darkening);
    void applyMMGXDesignCoords(FT_Fixed* coords, size_t count);
 -  void setForeground(QRgb foreground);
 -  void setBackground(QRgb background);
+-
    //////// Misc
    friend FT_Error faceRequester(FTC_FaceID,
@@ -287,14 +277,10 @@ private:
    double gamma_;
    unsigned long loadFlags_;
 -  QRgb backgroundColor_;
 -  QRgb foregroundColor_;
 -  QRgb foregroundColorBlended_;
 -  QVector<QRgb> foregroundTable_;
 +  std::unique_ptr<RenderingEngine> renderingEngine_;
    void queryEngine();
    void loadPaletteInfos();
 -  void calculateForegroundTable();
    // Safe to put the impl to the cpp.
    template <class Func>

src/ftinspect/engine/rendering.cpp

 +// rendering.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#include "rendering.hpp"
++
 +#include <cmath>
 +#include <freetype/ftbitmap.h>
++
 +#include "engine.hpp"
++
++
 +RenderingEngine::RenderingEngine(Engine* engine)
 +: engine_(engine)
 +{
 +  setForeground(QColor(Qt::black).rgba());
 +  setBackground(QColor(Qt::white).rgba());
 +}
++
++
 +void
 +RenderingEngine::setForeground(QRgb foreground)
 +{
 +  if (foregroundTable_.size() != 256 || foreground != foregroundColor_)
 +  {
 +    foregroundColor_ = foreground;
 +    calculateForegroundTable();
 +  }
 +}
++
++
 +void
 +RenderingEngine::setBackground(QRgb background)
 +{
 +  if (foregroundTable_.size() != 256 || background != backgroundColor_)
 +  {
 +    backgroundColor_ = background;
 +    calculateForegroundTable();
 +  }
 +}
++
++
 +void
 +RenderingEngine::calculateForegroundTable()
 +{
 +  foregroundTable_.resize(256);
 +  auto gamma = engine_->gamma();
++
 +  // Yes I know this is horribly slow, but we're only calculating the table once
 +  // and can use it for all rendering if the color and gamma isn't changing.
++
 +  double br = std::pow(qRed(backgroundColor_) / 255.0, gamma);
 +  double bg = std::pow(qGreen(backgroundColor_) / 255.0, gamma);
 +  double bb = std::pow(qBlue(backgroundColor_) / 255.0, gamma);
 +  double invGamma = 1 / gamma;
++
 +  for (int i = 0; i <= 0xFF; i++)
 +  {
 +    double foreAlpha = i * qAlpha(foregroundColor_) / 255.0 / 255.0;
 +    double backAlpha = 1 - foreAlpha;
 +    double r = std::pow(qRed(foregroundColor_) / 255.0, gamma);
 +    double g = std::pow(qGreen(foregroundColor_) / 255.0, gamma);
 +    double b = std::pow(qBlue(foregroundColor_) / 255.0, gamma);
++
 +    r = br * backAlpha + r * foreAlpha;
 +    g = bg * backAlpha + g * foreAlpha;
 +    b = bb * backAlpha + b * foreAlpha;
++
 +    r = std::pow(r, invGamma);
 +    g = std::pow(g, invGamma);
 +    b = std::pow(b, invGamma);
++
 +    foregroundTable_[i]
 +        = qRgba(static_cast<int>(r * 255),
 +                static_cast<int>(g * 255),
 +                static_cast<int>(b * 255),
 +                255);
 +  }
 +}
++
++
 +bool
 +RenderingEngine::convertGlyphToBitmapGlyph(FT_Glyph src,
 +                      FT_Glyph* out)
 +{
 +  if (src->format == FT_GLYPH_FORMAT_BITMAP)
 +  {
 +    *out = src;
 +    return false;
 +  }
 +  if (src->format != FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    *out = NULL;
 +    return false;
 +    // TODO support SVG
 +  }
++
 +  if (src->format == FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    FT_Glyph out2 = src;
 +    auto error = FT_Glyph_To_Bitmap(&out2,
 +                                    engine_->renderMode(),
 +                                    nullptr,
 +                                    false);
 +    if (error)
 +    {
 +      *out = NULL;
 +      return false;
 +    }
 +    *out = out2;
 +    return true;
 +  }
++
 +  *out = NULL;
 +  return false;
 +}
++
++
 +FT_Bitmap
 +RenderingEngine::convertBitmapTo8Bpp(FT_Bitmap* bitmap)
 +{
 +  FT_Bitmap out;
 +  out.buffer = NULL;
 +  auto error = FT_Bitmap_Convert(engine_->ftLibrary(), bitmap, &out, 1);
 +  if (error)
 +  {
 +    // XXX handling?
 +  }
 +  return out;
 +}
++
++
 +void
 +convertLCDToARGB(FT_Bitmap& bitmap,
 +                 QImage& image,
 +                 bool isBGR,
 +                 QVector<QRgb>& colorTable)
 +{
 +  int height = bitmap.rows;
 +  int width = bitmap.width / 3;
 +  int width3 = bitmap.width;
++
 +  unsigned char* srcPtr = bitmap.buffer;
 +  unsigned* dstPtr = reinterpret_cast<unsigned*>(image.bits());
++
 +  int offR = !isBGR ? 0 : 2;
 +  int offG = 1;
 +  int offB = isBGR ? 0 : 2;
 +  for (int i = 0; i < height; i++)
 +  {
 +    for (int j = 0; j < width3; j += 3)
 +    {
 +      unsigned char ar = srcPtr[j + offR];
 +      unsigned char ag = srcPtr[j + offG];
 +      unsigned char ab = srcPtr[j + offB];
 +      unsigned dr = colorTable[ar] & 0xFF;
 +      unsigned dg = colorTable[ag] & 0xFF;
 +      unsigned db = colorTable[ab] & 0xFF;
 +      *dstPtr = (0xFFu << 24) | (dr << 16) | (dg << 8) | db;
 +      dstPtr++;
 +    }
 +    srcPtr += bitmap.pitch;
 +    dstPtr += image.bytesPerLine() / 4 - width; // skip blank area
 +  }
 +}
++
++
 +void
 +convertLCDVToARGB(FT_Bitmap& bitmap,
 +                  QImage& image,
 +                  bool isBGR,
 +                  QVector<QRgb>& colorTable)
 +{
 +  int height = bitmap.rows / 3;
 +  int width = bitmap.width;
 +  int srcPitch = bitmap.pitch;
++
 +  unsigned char* srcPtr = bitmap.buffer;
 +  unsigned* dstPtr = reinterpret_cast<unsigned*>(image.bits());
++
 +  int offR = !isBGR ? 0 : 2 * srcPitch;
 +  int offG = srcPitch;
 +  int offB = isBGR ? 0 : 2 * srcPitch;
 +  for (int i = 0; i < height; i++)
 +  {
 +    for (int j = 0; j < width; j++)
 +    {
 +      unsigned char ar = srcPtr[j + offR];
 +      unsigned char ag = srcPtr[j + offG];
 +      unsigned char ab = srcPtr[j + offB];
 +      unsigned dr = colorTable[ar] & 0xFF;
 +      unsigned dg = colorTable[ag] & 0xFF;
 +      unsigned db = colorTable[ab] & 0xFF;
 +      *dstPtr = (0xFFu << 24) | (dr << 16) | (dg << 8) | db;
 +      dstPtr++;
 +    }
 +    srcPtr += 3ull * srcPitch;                  // move 3 lines
 +    dstPtr += image.bytesPerLine() / 4 - width; // skip blank area
 +  }
 +}
++
++
 +QImage*
 +RenderingEngine::convertBitmapToQImage(FT_Bitmap* src)
 +{
 +  QImage* result = NULL;
++
 +  auto& bmap = *src;
 +  bool ownBitmap = false;
++
 +  int width = INT_MAX, height = INT_MAX;
 +  if (bmap.width < INT_MAX)
 +    width = static_cast<int>(bmap.width);
 +  if (bmap.rows < INT_MAX)
 +    height = static_cast<int>(bmap.rows);
 +  auto format = QImage::Format_Indexed8; // goto crossing init
++
 +  if (bmap.pixel_mode == FT_PIXEL_MODE_GRAY2
 +      || bmap.pixel_mode == FT_PIXEL_MODE_GRAY4)
 +  {
 +    bmap = convertBitmapTo8Bpp(&bmap);
 +    if (!bmap.buffer)
 +      goto cleanup;
 +    ownBitmap = true;
 +  }
++
 +  if (bmap.pixel_mode == FT_PIXEL_MODE_LCD)
 +    width /= 3;
 +  else if (bmap.pixel_mode == FT_PIXEL_MODE_LCD_V)
 +    height /= 3;
++
 +  switch (bmap.pixel_mode)
 +  {
 +  case FT_PIXEL_MODE_MONO:
 +    format = QImage::Format_Mono;
 +    break;
 +  case FT_PIXEL_MODE_GRAY:
 +    format = QImage::Format_Indexed8;
 +    break;
 +  case FT_PIXEL_MODE_BGRA:
 +    // XXX "ARGB" here means BGRA due to endianness - may be problematic
 +    // on big-endian machines
 +    format = QImage::Format_ARGB32_Premultiplied;
 +    break;
 +  case FT_PIXEL_MODE_LCD:
 +  case FT_PIXEL_MODE_LCD_V:
 +    format = QImage::Format_ARGB32;
 +    break;
 +  default:
 +    goto cleanup;
 +  }
++
 +  switch (bmap.pixel_mode)
 +  {
 +  case FT_PIXEL_MODE_MONO:
 +  case FT_PIXEL_MODE_GRAY:
 +  case FT_PIXEL_MODE_BGRA:
 +    {
 +      QImage image(bmap.buffer,
 +                   width, height,
 +                   bmap.pitch,
 +                   format);
 +      if (bmap.pixel_mode == FT_PIXEL_MODE_GRAY)
 +        image.setColorTable(foregroundTable_);
 +      else if (bmap.pixel_mode == FT_PIXEL_MODE_MONO)
 +      {
 +        image.setColorCount(2);
 +        image.setColor(0, static_cast<QRgb>(0)); // transparent
 +        image.setColor(1, foregroundTable_[0xFF]);
 +      }
 +      result = new QImage(image.copy());
 +      // Don't directly use `image` since we're destroying the image
 +    }
 +    break;
 +  case FT_PIXEL_MODE_LCD:;
 +    result = new QImage(width, height, format);
 +    convertLCDToARGB(bmap, *result, engine_->lcdUsesBGR(), foregroundTable_);
 +    break;
 +  case FT_PIXEL_MODE_LCD_V:;
 +    result = new QImage(width, height, format);
 +    convertLCDVToARGB(bmap, *result, engine_->lcdUsesBGR(), foregroundTable_);
 +    break;
 +  }
++
 +cleanup:
 +  if (ownBitmap)
 +    FT_Bitmap_Done(engine_->ftLibrary(), &bmap);
++
 +  return result;
 +}
++
++
 +QImage*
 +RenderingEngine::convertGlyphToQImage(FT_Glyph src,
 +                             QRect* outRect,
 +                             bool inverseRectY)
 +{
 +  FT_BitmapGlyph bitmapGlyph;
 +  bool ownBitmapGlyph
 +    = convertGlyphToBitmapGlyph(src, reinterpret_cast<FT_Glyph*>(&bitmapGlyph));
 +  if (!bitmapGlyph)
 +    return NULL;
++
 +  auto result = convertBitmapToQImage(&bitmapGlyph->bitmap);
++
 +  if (result && outRect)
 +  {
 +    outRect->setLeft(bitmapGlyph->left);
 +    if (inverseRectY)
 +      outRect->setTop(-bitmapGlyph->top);
 +    else
 +      outRect->setTop(bitmapGlyph->top);
 +    if (bitmapGlyph->bitmap.width < INT_MAX)
 +      outRect->setWidth(static_cast<int>(bitmapGlyph->bitmap.width));
 +    else
 +      outRect->setWidth(INT_MAX);
++
 +    if (bitmapGlyph->bitmap.rows < INT_MAX)
 +      outRect->setHeight(static_cast<int>(bitmapGlyph->bitmap.rows));
 +    else
 +      outRect->setHeight(INT_MAX);
 +  }
++
 +  if (ownBitmapGlyph)
 +    FT_Done_Glyph(reinterpret_cast<FT_Glyph>(bitmapGlyph));
++
 +  return result;
 +}
++
++
 +QPoint
 +RenderingEngine::computeGlyphOffset(FT_Glyph glyph, bool inverseY)
 +{
 +  if (glyph->format == FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    FT_BBox cbox;
 +    FT_Outline_Get_CBox(&reinterpret_cast<FT_OutlineGlyph>(glyph)->outline,
 +                        &cbox);
 +    cbox.xMin &= ~63;
 +    cbox.yMin &= ~63;
 +    cbox.xMax = (cbox.xMax + 63) & ~63;
 +    cbox.yMax = (cbox.yMax + 63) & ~63;
 +    if (inverseY)
 +      cbox.yMax = -cbox.yMax;
 +    return { static_cast<int>(cbox.xMin / 64),
 +             static_cast<int>(cbox.yMax / 64) };
 +  }
 +  if (glyph->format == FT_GLYPH_FORMAT_BITMAP)
 +  {
 +    auto bg = reinterpret_cast<FT_BitmapGlyph>(glyph);
 +    if (inverseY)
 +      return { bg->left, -bg->top };
 +    return { bg->left, bg->top };
 +  }
++
 +  return {};
 +}
++
++
 +QImage*
 +RenderingEngine::tryDirectRenderColorLayers(int glyphIndex,
 +                                   QRect* outRect,
 +                                   bool inverseRectY)
 +{
 +  auto& paletteData = engine_->currentFontPaletteData();
 +  auto paletteIndex = engine_->paletteIndex();
 +  auto palette = engine_->currentPalette();
 +  if (palette == NULL
 +      || !engine_->useColorLayer()
 +      || paletteIndex >= paletteData.num_palettes)
 +    return NULL;
++
 +  FT_LayerIterator iter = {};
++
 +  FT_UInt layerGlyphIdx = 0;
 +  FT_UInt layerColorIdx = 0;
++
 +  bool next = FT_Get_Color_Glyph_Layer(engine_->currentFtSize()->face,
 +                                       glyphIndex,
 +                                       &layerGlyphIdx,
 +                                       &layerColorIdx,
 +                                       &iter);
 +  if (!next)
 +    return NULL;
++
 +  // temporarily change lf
 +  auto imageType = engine_->imageType();
 +  auto oldLoadFlags = imageType->flags;
 +  auto loadFlags = oldLoadFlags;
 +  loadFlags &= ~FT_LOAD_COLOR;
 +  loadFlags |= FT_LOAD_RENDER;
++
 +  loadFlags &= ~FT_LOAD_TARGET_(0xF);
 +  loadFlags |= FT_LOAD_TARGET_NORMAL;
 +  imageType->flags = loadFlags;
++
 +  FT_Bitmap bitmap = {};
 +  FT_Bitmap_Init(&bitmap);
++
 +  FT_Vector bitmapOffset = {};
 +  bool failed = false;
++
 +  do
 +  {
 +    FT_Vector slotOffset;
 +    FT_Glyph glyph;
 +    if (FTC_ImageCache_Lookup(engine_->imageCacheManager(),
 +                              imageType,
 +                              layerGlyphIdx,
 +                              &glyph,
 +                              NULL))
 +    {
 +      // XXX Error handling
 +      failed = true;
 +      break;
 +    }
++
 +    if (glyph->format != FT_GLYPH_FORMAT_BITMAP)
 +      continue;
++
 +    auto bitmapGlyph = reinterpret_cast<FT_BitmapGlyph>(glyph);
 +    slotOffset.x = bitmapGlyph->left << 6;
 +    slotOffset.y = bitmapGlyph->top << 6;
++
 +    FT_Color color = {};
++
 +    if (layerColorIdx == 0xFFFF)
 +    {
 +      // TODO: FT_Palette_Get_Foreground_Color: #1134
 +      if (paletteData.palette_flags
 +          && (paletteData.palette_flags[paletteIndex]
 +              & FT_PALETTE_FOR_DARK_BACKGROUND))
 +      {
 +        /* white opaque */
 +        color.blue = 0xFF;
 +        color.green = 0xFF;
 +        color.red = 0xFF;
 +        color.alpha = 0xFF;
 +      }
 +      else
 +      {
 +        /* black opaque */
 +        color.blue = 0x00;
 +        color.green = 0x00;
 +        color.red = 0x00;
 +        color.alpha = 0xFF;
 +      }
 +    }
 +    else if (layerColorIdx < paletteData.num_palette_entries)
 +      color = palette[layerColorIdx];
 +    else
 +      continue;
++
 +    if (FT_Bitmap_Blend(engine_->ftLibrary(),
 +                        &bitmapGlyph->bitmap, slotOffset,
 +                        &bitmap, &bitmapOffset,
 +                        color))
 +    {
 +      // XXX error
 +      failed = true;
 +      break;
 +    }
 +  } while (FT_Get_Color_Glyph_Layer(engine_->currentFtSize()->face,
 +                                    glyphIndex,
 +                                    &layerGlyphIdx,
 +                                    &layerColorIdx,
 +                                    &iter));
++
 +  imageType->flags = oldLoadFlags;
 +  if (failed)
 +  {
 +    FT_Bitmap_Done(engine_->ftLibrary(), &bitmap);
 +    return NULL;
 +  }
++
 +  auto img = convertBitmapToQImage(&bitmap);
 +  if (outRect)
 +  {
 +    outRect->moveLeft(static_cast<int>(bitmapOffset.x >> 6));
 +    if (inverseRectY)
 +      outRect->moveTop(static_cast<int>(-bitmapOffset.y >> 6));
 +    else
 +      outRect->moveTop(static_cast<int>(bitmapOffset.y >> 6));
 +    outRect->setSize(img->size());
 +  }
++
 +  FT_Bitmap_Done(engine_->ftLibrary(), &bitmap);
++
 +  return img;
 +}
++
++
 +// end of rendering.cpp

src/ftinspect/engine/rendering.hpp

 +// rendering.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include <QColor>
 +#include <QImage>
 +#include <freetype/freetype.h>
 +#include <freetype/ftglyph.h>
++
 +class Engine;
 +class RenderingEngine
 +{
 +public:
 +  RenderingEngine(Engine* engine);
++
 +  void setForeground(QRgb foreground);
 +  void setBackground(QRgb background);
 +  void calculateForegroundTable();
++
 +  QRgb foreground() { return foregroundColor_; }
 +  QRgb background() { return backgroundColor_; }
++
 +  // Return `true` if you need to free `out`
 +  // `out` will be set to NULL in cases of error
 +  bool convertGlyphToBitmapGlyph(FT_Glyph src, FT_Glyph* out);
 +  FT_Bitmap convertBitmapTo8Bpp(FT_Bitmap* bitmap);
 +  QImage* convertBitmapToQImage(FT_Bitmap* src);
 +  QImage* convertGlyphToQImage(FT_Glyph src,
 +                               QRect* outRect,
 +                               bool inverseRectY);
 +  QPoint computeGlyphOffset(FT_Glyph glyph, bool inverseY);
++
 +  /*
 +   * Directly render the glyph at the specified index
 +   * to a `QImage`. If you want to perform color-layer
 +   * rendering, call this before trying to load the
 +   * glyph and do normal rendering, If the returning
 +   * value is non-NULL, then there's no need to
 +   * load the glyph the normal way, just draw the `QImage`.
 +   * Will return NULL if not enabled or color layers not available.
 +   */
 +  QImage* tryDirectRenderColorLayers(int glyphIndex,
 +                                     QRect* outRect,
 +                                     bool inverseRectY = false);
++
 +private:
 +  Engine* engine_;
++
 +  QRgb backgroundColor_;
 +  QRgb foregroundColor_;
 +  QVector<QRgb> foregroundTable_;
 +};
++
 +// end of rendering.hpp

src/ftinspect/engine/stringrenderer.cpp

@@ -565,7 +565,8 @@ StringRenderer::renderLine(int x,
      QRect rect;
      QImage* colorLayerImage
 -        = engine_->tryDirectRenderColorLayers(ctx.glyphIndex, &rect, true);
 +      = engine_->renderingEngine()->tryDirectRenderColorLayers(ctx.glyphIndex,
 +                                                               &rect, true);
      if (colorLayerImage)
+     {

src/ftinspect/glyphcomponents/glyphbitmap.cpp

@@ -30,10 +30,12 @@ GlyphBitmap::GlyphBitmap(int glyphIndex,
                           Engine* engine)
+ {
    QRect bRect;
 -  image_ = engine->tryDirectRenderColorLayers(glyphIndex, &bRect, true);
 +  image_ = engine->renderingEngine()->tryDirectRenderColorLayers(glyphIndex,
 +                                                                 &bRect, true);
    if (!image_)
 -    image_ = engine->convertGlyphToQImage(glyph, &bRect, true);
 +    image_ = engine->renderingEngine()->convertGlyphToQImage(glyph, &bRect,
 +                                                             true);
    boundingRect_ = bRect; // QRect to QRectF
+ }

src/ftinspect/glyphcomponents/glyphcontinuous.cpp

@@ -109,7 +109,7 @@ void
  GlyphContinuous::paintEvent(QPaintEvent* event)
+ {
    QPainter painter(this);
 -  painter.fillRect(rect(), engine_->background());
 +  painter.fillRect(rect(), engine_->renderingEngine()->background());
    if (glyphCache_.empty())
      fillCache();
@@ -423,7 +423,9 @@ GlyphContinuous::saveSingleGlyph(FT_Glyph glyph,
      return;
    QRect rect;
 -  QImage* image = engine_->convertGlyphToQImage(glyph, &rect, true);
 +  QImage* image = engine_->renderingEngine()->convertGlyphToQImage(glyph,
 +                                                                   &rect,
 +                                                                   true);
    saveSingleGlyphImage(image, rect, penPos, glyph->advance, gctx);
+ }

src/ftinspect/meson.build

@@ -29,6 +29,7 @@ if qt5_dep.found()
      'engine/fontinfo.cpp',
      'engine/fontinfonamesmapping.cpp',
      'engine/mmgx.cpp',
 +    'engine/rendering.cpp',
      'engine/renderutils.cpp',
      'glyphcomponents/glyphbitmap.cpp',

src/ftinspect/panels/settingpanel.cpp

@@ -369,8 +369,8 @@ SettingPanel::syncSettings()
      antiAliasingComboBox_->currentIndex()
        == AntiAliasingComboBoxModel::AntiAliasing_Light_SubPixel);
 -  engine_->setForeground(foregroundColor_.rgba());
 -  engine_->setBackground(backgroundColor_.rgba());
 +  engine_->renderingEngine()->setForeground(foregroundColor_.rgba());
 +  engine_->renderingEngine()->setBackground(backgroundColor_.rgba());
    mmgxPanel_->syncSettings();
+ }

src/ftinspect/panels/singular.cpp

@@ -87,7 +87,8 @@ SingularTab::drawGlyph()
      currentGlyphPointNumbersItem_ = NULL;
+   }
 -  glyphView_->setBackgroundBrush(QColor(engine_->background()));
 +  glyphView_->setBackgroundBrush(
 +    QColor(engine_->renderingEngine()->background()));
    syncSettings();
    FT_Glyph glyph = engine_->loadGlyph(currentGlyphIndex_);

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][gsoc-2022-chariri-3] [ftinspect] Extract out rendering-related code from `Engine`.
Date:	Tue, 23 Aug 2022 16:02:39 +0000