Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include <qmath.h>
#include "qtextureglyphcache_p.h"
#include "private/qfontengine_p.h"
#include "private/qnumeric_p.h"
#include <QtGui/qpainterpath.h>
QT_BEGIN_NAMESPACE
// #define CACHE_DEBUG
// out-of-line to avoid vtable duplication, breaking e.g. RTTI
QTextureGlyphCache::~QTextureGlyphCache()
{
}
int QTextureGlyphCache::calculateSubPixelPositionCount(glyph_t glyph) const
{
// Test 12 different subpixel positions since it factors into 3*4 so it gives
// the coverage we need.
const int NumSubpixelPositions = 12;
QImage images[NumSubpixelPositions];
int numImages = 0;
for (int i = 0; i < NumSubpixelPositions; ++i) {
QImage img = textureMapForGlyph(glyph, QFixedPoint(QFixed::fromReal(i / 12.0), 0));
if (numImages == 0) {
QPainterPath path;
QFixedPoint point;
m_current_fontengine->addGlyphsToPath(&glyph, &point, 1, &path, QTextItem::RenderFlags());
// Glyph is space, return 0 to indicate that we need to keep trying
if (path.isEmpty())
break;
images[numImages++] = std::move(img);
} else {
bool found = false;
for (int j = 0; j < numImages; ++j) {
if (images[j] == img) {
found = true;
break;
}
}
if (!found)
images[numImages++] = std::move(img);
}
}
return numImages;
}
bool QTextureGlyphCache::populate(QFontEngine *fontEngine,
qsizetype numGlyphs,
const glyph_t *glyphs,
const QFixedPoint *positions,
QPainter::RenderHints renderHints,
bool includeGlyphCacheScale)
{
#ifdef CACHE_DEBUG
printf("Populating with %lld glyphs\n", static_cast<long long>(numGlyphs));
qDebug() << " -> current transformation: " << m_transform;
#endif
m_current_fontengine = fontEngine;
const int padding = glyphPadding();
const int paddingDoubled = padding * 2;
bool supportsSubPixelPositions = fontEngine->supportsSubPixelPositions();
bool verticalSubPixelPositions = fontEngine->supportsVerticalSubPixelPositions()
&& (renderHints & QPainter::VerticalSubpixelPositioning) != 0;
if (fontEngine->m_subPixelPositionCount == 0) {
if (!supportsSubPixelPositions) {
fontEngine->m_subPixelPositionCount = 1;
} else {
qsizetype i = 0;
while (fontEngine->m_subPixelPositionCount == 0 && i < numGlyphs)
fontEngine->m_subPixelPositionCount = calculateSubPixelPositionCount(glyphs[i++]);
}
}
if (m_cx == 0 && m_cy == 0) {
m_cx = padding;
m_cy = padding;
}
qreal glyphCacheScaleX = transform().m11();
qreal glyphCacheScaleY = transform().m22();
QHash<GlyphAndSubPixelPosition, Coord> listItemCoordinates;
int rowHeight = 0;
// check each glyph for its metrics and get the required rowHeight.
for (qsizetype i = 0; i < numGlyphs; ++i) {
const glyph_t glyph = glyphs[i];
QFixedPoint subPixelPosition;
if (supportsSubPixelPositions) {
QFixedPoint pos = positions != nullptr ? positions[i] : QFixedPoint();
if (includeGlyphCacheScale) {
pos = QFixedPoint(QFixed::fromReal(pos.x.toReal() * glyphCacheScaleX),
QFixed::fromReal(pos.y.toReal() * glyphCacheScaleY));
}
subPixelPosition = fontEngine->subPixelPositionFor(pos);
if (!verticalSubPixelPositions)
subPixelPosition.y = 0;
}
if (coords.contains(GlyphAndSubPixelPosition(glyph, subPixelPosition)))
continue;
if (listItemCoordinates.contains(GlyphAndSubPixelPosition(glyph, subPixelPosition)))
continue;
glyph_metrics_t metrics = fontEngine->alphaMapBoundingBox(glyph, subPixelPosition, m_transform, m_format);
#ifdef CACHE_DEBUG
printf("(%4x): w=%.2f, h=%.2f, xoff=%.2f, yoff=%.2f, x=%.2f, y=%.2f\n",
glyph,
metrics.width.toReal(),
metrics.height.toReal(),
metrics.xoff.toReal(),
metrics.yoff.toReal(),
metrics.x.toReal(),
metrics.y.toReal());
#endif
GlyphAndSubPixelPosition key(glyph, subPixelPosition);
int glyph_width = metrics.width.ceil().toInt();
int glyph_height = metrics.height.ceil().toInt();
if (glyph_height == 0 || glyph_width == 0) {
// Avoid multiple calls to boundingBox() for non-printable characters
Coord c = { 0, 0, 0, 0, 0, 0 };
coords.insert(key, c);
continue;
}
// align to 8-bit boundary
if (m_format == QFontEngine::Format_Mono)
glyph_width = (glyph_width+7)&~7;
Coord c = { 0, 0, // will be filled in later
glyph_width,
glyph_height, // texture coords
metrics.x.truncate(),
-metrics.y.truncate() }; // baseline for horizontal scripts
listItemCoordinates.insert(key, c);
rowHeight = qMax(rowHeight, glyph_height);
}
if (listItemCoordinates.isEmpty())
return true;
rowHeight += paddingDoubled;
if (m_w == 0) {
if (fontEngine->maxCharWidth() <= QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH)
m_w = QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH;
else
m_w = qNextPowerOfTwo(qCeil(fontEngine->maxCharWidth()) - 1);
}
// now actually use the coords and paint the wanted glyps into cache.
QHash<GlyphAndSubPixelPosition, Coord>::iterator iter = listItemCoordinates.begin();
int requiredWidth = m_w;
while (iter != listItemCoordinates.end()) {
Coord c = iter.value();
m_currentRowHeight = qMax(m_currentRowHeight, c.h);
if (m_cx + c.w + padding > requiredWidth) {
int new_width = requiredWidth*2;
while (new_width < m_cx + c.w + padding)
new_width *= 2;
if (new_width <= maxTextureWidth()) {
requiredWidth = new_width;
} else {
// no room on the current line, start new glyph strip
m_cx = padding;
m_cy += m_currentRowHeight + paddingDoubled;
m_currentRowHeight = c.h; // New row
}
}
if (maxTextureHeight() > 0 && m_cy + c.h + padding > maxTextureHeight()) {
// We can't make a cache of the required size, so we bail out
return false;
}
c.x = m_cx;
c.y = m_cy;
coords.insert(iter.key(), c);
m_pendingGlyphs.insert(iter.key(), c);
m_cx += c.w + paddingDoubled;
++iter;
}
return true;
}
void QTextureGlyphCache::fillInPendingGlyphs()
{
if (!hasPendingGlyphs())
return;
int requiredHeight = m_h;
int requiredWidth = m_w; // Use a minimum size to avoid a lot of initial reallocations
const int padding = glyphPadding();
{
QHash<GlyphAndSubPixelPosition, Coord>::iterator iter = m_pendingGlyphs.begin();
while (iter != m_pendingGlyphs.end()) {
Coord c = iter.value();
requiredHeight = qMax(requiredHeight, c.y + c.h + padding);
requiredWidth = qMax(requiredWidth, c.x + c.w + padding);
++iter;
}
}
if (isNull() || requiredHeight > m_h || requiredWidth > m_w) {
if (isNull())
createCache(qNextPowerOfTwo(requiredWidth - 1), qNextPowerOfTwo(requiredHeight - 1));
else
resizeCache(qNextPowerOfTwo(requiredWidth - 1), qNextPowerOfTwo(requiredHeight - 1));
}
beginFillTexture();
{
QHash<GlyphAndSubPixelPosition, Coord>::iterator iter = m_pendingGlyphs.begin();
while (iter != m_pendingGlyphs.end()) {
GlyphAndSubPixelPosition key = iter.key();
fillTexture(iter.value(), key.glyph, key.subPixelPosition);
++iter;
}
}
endFillTexture();
m_pendingGlyphs.clear();
}
QImage QTextureGlyphCache::textureMapForGlyph(glyph_t g, const QFixedPoint &subPixelPosition) const
{
switch (m_format) {
case QFontEngine::Format_A32:
return m_current_fontengine->alphaRGBMapForGlyph(g, subPixelPosition, m_transform);
case QFontEngine::Format_ARGB:
return m_current_fontengine->bitmapForGlyph(g, subPixelPosition, m_transform, color());
default:
return m_current_fontengine->alphaMapForGlyph(g, subPixelPosition, m_transform);
}
}
/************************************************************************
* QImageTextureGlyphCache
*/
// out-of-line to avoid vtable duplication, breaking e.g. RTTI
QImageTextureGlyphCache::~QImageTextureGlyphCache()
{
}
void QImageTextureGlyphCache::resizeTextureData(int width, int height)
{
m_image = m_image.copy(0, 0, width, height);
// Regions not part of the copy are initialized to 0, and that is just what
// we need.
}
void QImageTextureGlyphCache::createTextureData(int width, int height)
{
switch (m_format) {
case QFontEngine::Format_Mono:
m_image = QImage(width, height, QImage::Format_Mono);
break;
case QFontEngine::Format_A8:
m_image = QImage(width, height, QImage::Format_Alpha8);
break;
case QFontEngine::Format_A32:
m_image = QImage(width, height, QImage::Format_RGB32);
break;
case QFontEngine::Format_ARGB:
m_image = QImage(width, height, QImage::Format_ARGB32_Premultiplied);
break;
default:
Q_UNREACHABLE();
}
// Regions not touched by the glyphs must be initialized to 0. (such
// locations may in fact be sampled with styled (shifted) text materials)
// When resizing, the QImage copy() does this implicitly but the initial
// contents must be zeroed out explicitly here.
m_image.fill(0);
}
void QImageTextureGlyphCache::fillTexture(const Coord &c,
glyph_t g,
const QFixedPoint &subPixelPosition)
{
QImage mask = textureMapForGlyph(g, subPixelPosition);
if (mask.isNull())
return;
#ifdef CACHE_DEBUG
printf("fillTexture of %dx%d at %d,%d in the cache of %dx%d\n", c.w, c.h, c.x, c.y, m_image.width(), m_image.height());
if (mask.width() > c.w || mask.height() > c.h) {
printf(" ERROR; mask is bigger than reserved space! %dx%d instead of %dx%d\n", mask.width(), mask.height(), c.w,c.h);
return;
}
#endif
if (m_format == QFontEngine::Format_A32
|| m_format == QFontEngine::Format_ARGB) {
QImage ref(m_image.bits() + (c.x * 4 + c.y * m_image.bytesPerLine()),
qMin(mask.width(), c.w), qMin(mask.height(), c.h), m_image.bytesPerLine(),
m_image.format());
QPainter p(&ref);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.fillRect(0, 0, c.w, c.h, QColor(0,0,0,0)); // TODO optimize this
p.drawImage(0, 0, mask);
p.end();
} else if (m_format == QFontEngine::Format_Mono) {
if (mask.depth() > 1) {
// TODO optimize this
mask.convertTo(QImage::Format_Alpha8);
mask.reinterpretAsFormat(QImage::Format_Grayscale8);
mask.invertPixels();
mask.convertTo(QImage::Format_Mono, Qt::ThresholdDither);
}
int mw = qMin(mask.width(), c.w);
int mh = qMin(mask.height(), c.h);
uchar *d = m_image.bits();
qsizetype dbpl = m_image.bytesPerLine();
for (int y = 0; y < c.h; ++y) {
uchar *dest = d + (c.y + y) *dbpl + c.x/8;
if (y < mh) {
const uchar *src = mask.constScanLine(y);
for (int x = 0; x < c.w/8; ++x) {
if (x < (mw+7)/8)
dest[x] = src[x];
else
dest[x] = 0;
}
} else {
for (int x = 0; x < c.w/8; ++x)
dest[x] = 0;
}
}
} else { // A8
int mw = qMin(mask.width(), c.w);
int mh = qMin(mask.height(), c.h);
uchar *d = m_image.bits();
qsizetype dbpl = m_image.bytesPerLine();
if (mask.depth() == 1) {
for (int y = 0; y < c.h; ++y) {
uchar *dest = d + (c.y + y) *dbpl + c.x;
if (y < mh) {
const uchar *src = mask.constScanLine(y);
for (int x = 0; x < c.w; ++x) {
if (x < mw)
dest[x] = (src[x >> 3] & (1 << (7 - (x & 7)))) > 0 ? 255 : 0;
}
}
}
} else if (mask.depth() == 8) {
for (int y = 0; y < c.h; ++y) {
uchar *dest = d + (c.y + y) *dbpl + c.x;
if (y < mh) {
const uchar *src = mask.constScanLine(y);
for (int x = 0; x < c.w; ++x) {
if (x < mw)
dest[x] = src[x];
}
}
}
}
}
#ifdef CACHE_DEBUG
// QPainter p(&m_image);
// p.drawLine(
int margin = m_current_fontengine ? m_current_fontengine->glyphMargin(m_format) : 0;
QPoint base(c.x + margin, c.y + margin + c.baseLineY-1);
if (m_image.rect().contains(base))
m_image.setPixel(base, 255);
m_image.save(QString::fromLatin1("cache-%1.png").arg(qint64(this)));
#endif
}
QT_END_NAMESPACE