--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/makeqpf/qpf2.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,767 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpf2.h"
+
+#include <math.h>
+#include <private/qfontengine_p.h>
+#include <QFile>
+#include <qendian.h>
+
+QT_BEGIN_NAMESPACE
+
+#include "../../src/gui/text/qpfutil.cpp"
+
+int QPF::debugVerbosity = 0;
+
+// ### copied from qfontdatabase.cpp
+
+// see the Unicode subset bitfields in the MSDN docs
+static int requiredUnicodeBits[QFontDatabase::WritingSystemsCount][2] = {
+ // Any,
+ { 127, 127 },
+ // Latin,
+ { 0, 127 },
+ // Greek,
+ { 7, 127 },
+ // Cyrillic,
+ { 9, 127 },
+ // Armenian,
+ { 10, 127 },
+ // Hebrew,
+ { 11, 127 },
+ // Arabic,
+ { 13, 127 },
+ // Syriac,
+ { 71, 127 },
+ //Thaana,
+ { 72, 127 },
+ //Devanagari,
+ { 15, 127 },
+ //Bengali,
+ { 16, 127 },
+ //Gurmukhi,
+ { 17, 127 },
+ //Gujarati,
+ { 18, 127 },
+ //Oriya,
+ { 19, 127 },
+ //Tamil,
+ { 20, 127 },
+ //Telugu,
+ { 21, 127 },
+ //Kannada,
+ { 22, 127 },
+ //Malayalam,
+ { 23, 127 },
+ //Sinhala,
+ { 73, 127 },
+ //Thai,
+ { 24, 127 },
+ //Lao,
+ { 25, 127 },
+ //Tibetan,
+ { 70, 127 },
+ //Myanmar,
+ { 74, 127 },
+ // Georgian,
+ { 26, 127 },
+ // Khmer,
+ { 80, 127 },
+ // SimplifiedChinese,
+ { 126, 127 },
+ // TraditionalChinese,
+ { 126, 127 },
+ // Japanese,
+ { 126, 127 },
+ // Korean,
+ { 56, 127 },
+ // Vietnamese,
+ { 0, 127 }, // same as latin1
+ // Other,
+ { 126, 127 }
+};
+
+#define SimplifiedChineseCsbBit 18
+#define TraditionalChineseCsbBit 20
+#define JapaneseCsbBit 17
+#define KoreanCsbBit 21
+
+static QList<QFontDatabase::WritingSystem> determineWritingSystemsFromTrueTypeBits(quint32 unicodeRange[4], quint32 codePageRange[2])
+{
+ QList<QFontDatabase::WritingSystem> writingSystems;
+ bool hasScript = false;
+
+ int i;
+ for(i = 0; i < QFontDatabase::WritingSystemsCount; i++) {
+ int bit = requiredUnicodeBits[i][0];
+ int index = bit/32;
+ int flag = 1 << (bit&31);
+ if (bit != 126 && unicodeRange[index] & flag) {
+ bit = requiredUnicodeBits[i][1];
+ index = bit/32;
+
+ flag = 1 << (bit&31);
+ if (bit == 127 || unicodeRange[index] & flag) {
+ writingSystems.append(QFontDatabase::WritingSystem(i));
+ hasScript = true;
+ // qDebug("font %s: index=%d, flag=%8x supports script %d", familyName.latin1(), index, flag, i);
+ }
+ }
+ }
+ if(codePageRange[0] & (1 << SimplifiedChineseCsbBit)) {
+ writingSystems.append(QFontDatabase::SimplifiedChinese);
+ hasScript = true;
+ //qDebug("font %s supports Simplified Chinese", familyName.latin1());
+ }
+ if(codePageRange[0] & (1 << TraditionalChineseCsbBit)) {
+ writingSystems.append(QFontDatabase::TraditionalChinese);
+ hasScript = true;
+ //qDebug("font %s supports Traditional Chinese", familyName.latin1());
+ }
+ if(codePageRange[0] & (1 << JapaneseCsbBit)) {
+ writingSystems.append(QFontDatabase::Japanese);
+ hasScript = true;
+ //qDebug("font %s supports Japanese", familyName.latin1());
+ }
+ if(codePageRange[0] & (1 << KoreanCsbBit)) {
+ writingSystems.append(QFontDatabase::Korean);
+ hasScript = true;
+ //qDebug("font %s supports Korean", familyName.latin1());
+ }
+ if (!hasScript)
+ writingSystems.append(QFontDatabase::Symbol);
+
+ return writingSystems;
+}
+
+static QByteArray getWritingSystems(QFontEngine *fontEngine)
+{
+ QByteArray os2Table = fontEngine->getSfntTable(MAKE_TAG('O', 'S', '/', '2'));
+ if (os2Table.isEmpty())
+ return QByteArray();
+
+ const uchar *data = reinterpret_cast<const uchar *>(os2Table.constData());
+
+ quint32 unicodeRange[4] = {
+ qFromBigEndian<quint32>(data + 42),
+ qFromBigEndian<quint32>(data + 46),
+ qFromBigEndian<quint32>(data + 50),
+ qFromBigEndian<quint32>(data + 54)
+ };
+ quint32 codePageRange[2] = { qFromBigEndian<quint32>(data + 78), qFromBigEndian<quint32>(data + 82) };
+ QList<QFontDatabase::WritingSystem> systems = determineWritingSystemsFromTrueTypeBits(unicodeRange, codePageRange);
+
+ QByteArray bitField((QFontDatabase::WritingSystemsCount + 7) / 8, 0);
+
+ for (int i = 0; i < systems.count(); ++i) {
+ int bitPos = systems.at(i);
+ bitField[bitPos / 8] = bitField.at(bitPos / 8) | (1 << (bitPos % 8));
+ }
+
+ return bitField;
+}
+
+static QString stringify(const QByteArray &bits)
+{
+ QString result;
+ for (int i = 0; i < bits.count(); ++i) {
+ uchar currentByte = bits.at(i);
+ for (int j = 0; j < 8; ++j) {
+ if (currentByte & 1)
+ result += '1';
+ else
+ result += '0';
+ currentByte >>= 1;
+ }
+ }
+ return result;
+}
+
+static void dumpWritingSystems(const QByteArray &bits)
+{
+ QStringList writingSystems;
+
+ QString bitString = stringify(bits);
+ for (int i = 0; i < qMin(int(QFontDatabase::WritingSystemsCount), bitString.length()); ++i) {
+ if (bitString.at(i) == QLatin1Char('1'))
+ writingSystems << QFontDatabase::writingSystemName(QFontDatabase::WritingSystem(i));
+ }
+
+ qDebug() << "Supported writing systems:" << writingSystems;
+}
+
+static const char *headerTagNames[QFontEngineQPF::NumTags] = {
+ "FontName",
+ "FileName",
+ "FileIndex",
+ "FontRevision",
+ "FreeText",
+ "Ascent",
+ "Descent",
+ "Leading",
+ "XHeight",
+ "AverageCharWidth",
+ "MaxCharWidth",
+ "LineThickness",
+ "MinLeftBearing",
+ "MinRightBearing",
+ "UnderlinePosition",
+ "GlyphFormat",
+ "PixelSize",
+ "Weight",
+ "Style",
+ "EndOfHeader",
+ "WritingSystems"
+};
+
+QString QPF::fileNameForFont(const QFont &f)
+{
+ QString fileName = f.family().toLower() + "_" + QString::number(f.pixelSize())
+ + "_" + QString::number(f.weight())
+ + (f.italic() ? "_italic" : "")
+ + ".qpf2";
+ fileName.replace(QLatin1Char(' '), QLatin1Char('_'));
+ return fileName;
+}
+
+QByteArray QPF::generate(const QFont &font, int options, const QList<CharacterRange> &ranges, QString *originalFontFile)
+{
+ QTextEngine engine("Test", font);
+ engine.itemize();
+ engine.shape(0);
+ QFontEngine *fontEngine = engine.fontEngine(engine.layoutData->items[0]);
+ if (fontEngine->type() == QFontEngine::Multi)
+ fontEngine = static_cast<QFontEngineMulti *>(fontEngine)->engine(0);
+
+ if (originalFontFile)
+ *originalFontFile = QFile::decodeName(fontEngine->faceId().filename);
+
+ return generate(fontEngine, options, ranges);
+}
+
+QByteArray QPF::generate(QFontEngine *fontEngine, int options, const QList<CharacterRange> &ranges)
+{
+ QPF font;
+
+ font.options = options;
+ font.addHeader(fontEngine);
+ if (options & IncludeCMap)
+ font.addCMap(fontEngine);
+ font.addGlyphs(fontEngine, ranges);
+
+ return font.qpf;
+}
+
+void QPF::addHeader(QFontEngine *fontEngine)
+{
+ QFontEngineQPF::Header *header = reinterpret_cast<QFontEngineQPF::Header *>(addBytes(sizeof(QFontEngineQPF::Header)));
+
+ header->magic[0] = 'Q';
+ header->magic[1] = 'P';
+ header->magic[2] = 'F';
+ header->magic[3] = '2';
+ if (options & RenderGlyphs)
+ header->lock = 0xffffffff;
+ else
+ header->lock = 0;
+ header->majorVersion = QFontEngineQPF::CurrentMajorVersion;
+ header->minorVersion = QFontEngineQPF::CurrentMinorVersion;
+ header->dataSize = 0;
+ int oldSize = qpf.size();
+
+ addTaggedString(QFontEngineQPF::Tag_FontName, fontEngine->fontDef.family.toUtf8());
+
+ QFontEngine::FaceId face = fontEngine->faceId();
+ addTaggedString(QFontEngineQPF::Tag_FileName, face.filename);
+ addTaggedUInt32(QFontEngineQPF::Tag_FileIndex, face.index);
+
+ {
+ const QByteArray head = fontEngine->getSfntTable(MAKE_TAG('h', 'e', 'a', 'd'));
+ const quint32 revision = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(head.constData()) + 4);
+ addTaggedUInt32(QFontEngineQPF::Tag_FontRevision, revision);
+ }
+
+ addTaggedQFixed(QFontEngineQPF::Tag_Ascent, fontEngine->ascent());
+ addTaggedQFixed(QFontEngineQPF::Tag_Descent, fontEngine->descent());
+ addTaggedQFixed(QFontEngineQPF::Tag_Leading, fontEngine->leading());
+ addTaggedQFixed(QFontEngineQPF::Tag_XHeight, fontEngine->xHeight());
+ addTaggedQFixed(QFontEngineQPF::Tag_AverageCharWidth, fontEngine->averageCharWidth());
+ addTaggedQFixed(QFontEngineQPF::Tag_MaxCharWidth, QFixed::fromReal(fontEngine->maxCharWidth()));
+ addTaggedQFixed(QFontEngineQPF::Tag_LineThickness, fontEngine->lineThickness());
+ addTaggedQFixed(QFontEngineQPF::Tag_MinLeftBearing, QFixed::fromReal(fontEngine->minLeftBearing()));
+ addTaggedQFixed(QFontEngineQPF::Tag_MinRightBearing, QFixed::fromReal(fontEngine->minRightBearing()));
+ addTaggedQFixed(QFontEngineQPF::Tag_UnderlinePosition, fontEngine->underlinePosition());
+ addTaggedUInt8(QFontEngineQPF::Tag_PixelSize, fontEngine->fontDef.pixelSize);
+ addTaggedUInt8(QFontEngineQPF::Tag_Weight, fontEngine->fontDef.weight);
+ addTaggedUInt8(QFontEngineQPF::Tag_Style, fontEngine->fontDef.style);
+
+ QByteArray writingSystemBitField = getWritingSystems(fontEngine);
+ if (!writingSystemBitField.isEmpty())
+ addTaggedString(QFontEngineQPF::Tag_WritingSystems, writingSystemBitField);
+
+ addTaggedUInt8(QFontEngineQPF::Tag_GlyphFormat, QFontEngineQPF::AlphamapGlyphs);
+
+ addTaggedString(QFontEngineQPF::Tag_EndOfHeader, QByteArray());
+ align4();
+ header = reinterpret_cast<QFontEngineQPF::Header *>(qpf.data());
+ header->dataSize = qToBigEndian<quint16>(qpf.size() - oldSize);
+}
+
+static uchar *appendBytes(QByteArray &array, int size)
+{
+ int oldSize = array.size();
+ array.resize(array.size() + size);
+ return reinterpret_cast<uchar *>(array.data() + oldSize);
+}
+
+#define APPEND(type, value) \
+ qToBigEndian<type>(value, appendBytes(cmap, sizeof(type)))
+
+struct CMapSegment
+{
+ int start; // codepoints
+ int end;
+ int startGlyphIndex;
+};
+
+static QByteArray generateTrueTypeCMap(QFontEngine *fe)
+{
+ QByteArray cmap;
+ const int glyphCount = fe->glyphCount();
+ if (!glyphCount)
+ return cmap;
+
+ // cmap header
+ APPEND(quint16, 0); // table version number
+ APPEND(quint16, 1); // number of tables
+
+ // encoding record
+ APPEND(quint16, 3); // platform-id
+ APPEND(quint16, 10); // encoding-id (ucs-4)
+ const int cmapOffset = cmap.size() + sizeof(quint32);
+ APPEND(quint32, cmapOffset); // offset to sub-table
+
+ APPEND(quint16, 4); // subtable format
+ const int cmapTableLengthOffset = cmap.size();
+ APPEND(quint16, 0); // length in bytes, will fill in later
+ APPEND(quint16, 0); // language field
+
+ QList<CMapSegment> segments;
+ CMapSegment currentSegment;
+ currentSegment.start = 0xffff;
+ currentSegment.end = 0;
+ currentSegment.startGlyphIndex = 0;
+ quint32 previousGlyphIndex = 0xfffffffe;
+ bool inSegment = false;
+
+ QGlyphLayoutArray<10> layout;
+ for (uint uc = 0; uc < 0x10000; ++uc) {
+ QChar ch(uc);
+ int nglyphs = 10;
+
+ bool validGlyph = fe->stringToCMap(&ch, 1, &layout, &nglyphs, /*flags*/ 0)
+ && nglyphs == 1 && layout.glyphs[0];
+
+ // leaving a segment?
+ if (inSegment && (!validGlyph || layout.glyphs[0] != previousGlyphIndex + 1)) {
+ Q_ASSERT(currentSegment.start != 0xffff);
+ // store the current segment
+ currentSegment.end = uc - 1;
+ segments.append(currentSegment);
+ currentSegment.start = 0xffff;
+ inSegment = false;
+ }
+ // entering a new segment?
+ if (validGlyph && (!inSegment || layout.glyphs[0] != previousGlyphIndex + 1)) {
+ currentSegment.start = uc;
+ currentSegment.startGlyphIndex = layout.glyphs[0];
+ inSegment = true;
+ }
+
+ if (validGlyph)
+ previousGlyphIndex = layout.glyphs[0];
+ else
+ previousGlyphIndex = 0xfffffffe;
+ }
+
+ currentSegment.start = 0xffff;
+ currentSegment.end = 0xffff;
+ currentSegment.startGlyphIndex = 0;
+ segments.append(currentSegment);
+
+ if (QPF::debugVerbosity > 3)
+ qDebug() << "segments:" << segments.count();
+
+ Q_ASSERT(!inSegment);
+
+ const quint16 entrySelector = int(log2(segments.count()));
+ const quint16 searchRange = 2 * (1 << entrySelector);
+ const quint16 rangeShift = segments.count() * 2 - searchRange;
+
+ if (QPF::debugVerbosity > 3)
+ qDebug() << "entrySelector" << entrySelector << "searchRange" << searchRange
+ << "rangeShift" << rangeShift;
+
+ APPEND(quint16, segments.count() * 2); // segCountX2
+ APPEND(quint16, searchRange);
+ APPEND(quint16, entrySelector);
+ APPEND(quint16, rangeShift);
+
+ // end character codes
+ for (int i = 0; i < segments.count(); ++i)
+ APPEND(quint16, segments.at(i).end);
+
+ APPEND(quint16, 0); // pad
+
+ // start character codes
+ for (int i = 0; i < segments.count(); ++i)
+ APPEND(quint16, segments.at(i).start);
+
+ // id deltas
+ for (int i = 0; i < segments.count(); ++i)
+ APPEND(quint16, segments.at(i).startGlyphIndex - segments.at(i).start);
+
+ // id range offsets
+ for (int i = 0; i < segments.count(); ++i)
+ APPEND(quint16, 0);
+
+ uchar *lengthPtr = reinterpret_cast<uchar *>(cmap.data()) + cmapTableLengthOffset;
+ qToBigEndian<quint16>(cmap.size() - cmapOffset, lengthPtr);
+
+ return cmap;
+}
+
+void QPF::addCMap(QFontEngine *fontEngine)
+{
+ QByteArray cmapTable = fontEngine->getSfntTable(MAKE_TAG('c', 'm', 'a', 'p'));
+ if (cmapTable.isEmpty())
+ cmapTable = generateTrueTypeCMap(fontEngine);
+ addBlock(QFontEngineQPF::CMapBlock, cmapTable);
+}
+
+void QPF::addGlyphs(QFontEngine *fe, const QList<CharacterRange> &ranges)
+{
+ const quint16 glyphCount = fe->glyphCount();
+
+ QByteArray gmap;
+ gmap.resize(glyphCount * sizeof(quint32));
+ gmap.fill(char(0xff));
+ //qDebug() << "glyphCount" << glyphCount;
+
+ QByteArray glyphs;
+ if (options & RenderGlyphs) {
+ // this is only a rough estimation
+ glyphs.reserve(glyphCount
+ * (sizeof(QFontEngineQPF::Glyph)
+ + qRound(fe->maxCharWidth() * (fe->ascent() + fe->descent()).toReal())));
+
+ QGlyphLayoutArray<10> layout;
+
+ foreach (CharacterRange range, ranges) {
+ if (debugVerbosity > 2)
+ qDebug() << "rendering range from" << range.start << "to" << range.end;
+ for (uint uc = range.start; uc < range.end; ++uc) {
+ QChar ch(uc);
+ int nglyphs = 10;
+ if (!fe->stringToCMap(&ch, 1, &layout, &nglyphs, /*flags*/ 0))
+ continue;
+
+ if (nglyphs != 1)
+ continue;
+
+ const quint32 glyphIndex = layout.glyphs[0];
+
+ if (!glyphIndex)
+ continue;
+
+ Q_ASSERT(glyphIndex < glyphCount);
+
+ QImage img = fe->alphaMapForGlyph(glyphIndex).convertToFormat(QImage::Format_Indexed8);
+ glyph_metrics_t metrics = fe->boundingBox(glyphIndex);
+
+ const quint32 oldSize = glyphs.size();
+ glyphs.resize(glyphs.size() + sizeof(QFontEngineQPF::Glyph) + img.numBytes());
+ uchar *data = reinterpret_cast<uchar *>(glyphs.data() + oldSize);
+
+ uchar *gmapPtr = reinterpret_cast<uchar *>(gmap.data() + glyphIndex * sizeof(quint32));
+ qToBigEndian(oldSize, gmapPtr);
+
+ QFontEngineQPF::Glyph *glyph = reinterpret_cast<QFontEngineQPF::Glyph *>(data);
+ glyph->width = img.width();
+ glyph->height = img.height();
+ glyph->bytesPerLine = img.bytesPerLine();
+ glyph->x = qRound(metrics.x);
+ glyph->y = qRound(metrics.y);
+ glyph->advance = qRound(metrics.xoff);
+ data += sizeof(QFontEngineQPF::Glyph);
+
+ if (debugVerbosity && uc >= 'A' && uc <= 'z' || debugVerbosity > 1) {
+ qDebug() << "adding glyph with index" << glyphIndex << " uc =" << char(uc) << ":\n"
+ << " glyph->x =" << glyph->x << "rounded from" << metrics.x << "\n"
+ << " glyph->y =" << glyph->y << "rounded from" << metrics.y << "\n"
+ << " width =" << glyph->width << "height =" << glyph->height
+ << " advance =" << glyph->advance << "rounded from" << metrics.xoff
+ ;
+ }
+
+ qMemCopy(data, img.bits(), img.numBytes());
+ }
+ }
+ }
+
+ addBlock(QFontEngineQPF::GMapBlock, gmap);
+ addBlock(QFontEngineQPF::GlyphBlock, glyphs);
+}
+
+void QPF::addBlock(QFontEngineQPF::BlockTag tag, const QByteArray &blockData)
+{
+ addUInt16(tag);
+ addUInt16(0); // padding
+ const int padSize = ((blockData.size() + 3) / 4) * 4 - blockData.size();
+ addUInt32(blockData.size() + padSize);
+ addByteArray(blockData);
+ for (int i = 0; i < padSize; ++i)
+ addUInt8(0);
+}
+
+#define ADD_TAGGED_DATA(tag, qtype, type, value) \
+ addUInt16(tag); \
+ addUInt16(sizeof(qtype)); \
+ add##type(value)
+
+void QPF::addTaggedString(QFontEngineQPF::HeaderTag tag, const QByteArray &string)
+{
+ addUInt16(tag);
+ addUInt16(string.length());
+ addByteArray(string);
+}
+
+void QPF::addTaggedQFixed(QFontEngineQPF::HeaderTag tag, QFixed value)
+{
+ ADD_TAGGED_DATA(tag, quint32, UInt32, value.value());
+}
+
+void QPF::addTaggedUInt8(QFontEngineQPF::HeaderTag tag, quint8 value)
+{
+ ADD_TAGGED_DATA(tag, quint8, UInt8, value);
+}
+
+void QPF::addTaggedInt8(QFontEngineQPF::HeaderTag tag, qint8 value)
+{
+ ADD_TAGGED_DATA(tag, qint8, Int8, value);
+}
+
+void QPF::addTaggedUInt16(QFontEngineQPF::HeaderTag tag, quint16 value)
+{
+ ADD_TAGGED_DATA(tag, quint16, UInt16, value);
+}
+
+void QPF::addTaggedUInt32(QFontEngineQPF::HeaderTag tag, quint32 value)
+{
+ ADD_TAGGED_DATA(tag, quint32, UInt32, value);
+}
+
+void QPF::dump(const QByteArray &qpf)
+{
+ QPF font;
+ font.qpf = qpf;
+
+ const uchar *data = reinterpret_cast<const uchar *>(qpf.constData());
+ const uchar *endPtr = reinterpret_cast<const uchar *>(qpf.constData() + qpf.size());
+ data = font.dumpHeader(data);
+
+ const quint32 *gmap = 0;
+ quint32 glyphCount = 0;
+
+ while (data < endPtr) {
+ const QFontEngineQPF::Block *block = reinterpret_cast<const QFontEngineQPF::Block *>(data);
+ quint32 tag = qFromBigEndian(block->tag);
+ quint32 blockSize = qFromBigEndian(block->dataSize);
+ qDebug() << "Block: Tag =" << qFromBigEndian(block->tag) << "; Size =" << blockSize << "; Offset =" << hex << data - reinterpret_cast<const uchar *>(qpf.constData());
+ data += sizeof(QFontEngineQPF::Block);
+
+ if (debugVerbosity) {
+ if (tag == QFontEngineQPF::GMapBlock) {
+ gmap = reinterpret_cast<const quint32 *>(data);
+ glyphCount = blockSize / 4;
+ font.dumpGMapBlock(gmap, glyphCount);
+ } else if (tag == QFontEngineQPF::GlyphBlock
+ && gmap && debugVerbosity > 1) {
+ font.dumpGlyphBlock(gmap, glyphCount, data, data + blockSize);
+ }
+ }
+
+ data += blockSize;
+ }
+}
+
+const uchar *QPF::dumpHeader(const uchar *data)
+{
+ const QFontEngineQPF::Header *header = reinterpret_cast<const QFontEngineQPF::Header *>(data);
+ qDebug() << "Header:";
+ qDebug() << "magic ="
+ << header->magic[0]
+ << header->magic[1]
+ << header->magic[2]
+ << header->magic[3];
+ qDebug() << "lock =" << qFromBigEndian(header->lock);
+ qDebug() << "majorVersion =" << header->majorVersion;
+ qDebug() << "minorVersion =" << header->minorVersion;
+ qDebug() << "dataSize =" << qFromBigEndian(header->dataSize);
+
+ data += sizeof(QFontEngineQPF::Header);
+
+ const uchar *endPtr = data + qFromBigEndian(header->dataSize);
+
+ while (data && data < endPtr) {
+ data = dumpHeaderTag(data);
+ }
+
+ return endPtr;
+}
+
+const uchar *QPF::dumpHeaderTag(const uchar *data)
+{
+ const QFontEngineQPF::Tag *tagPtr = reinterpret_cast<const QFontEngineQPF::Tag *>(data);
+ quint16 tag = qFromBigEndian(tagPtr->tag);
+ quint16 size = qFromBigEndian(tagPtr->size);
+
+ qDebug() << "Tag =" << tag << headerTagNames[tag];
+ qDebug() << "Size =" << size;
+
+ if (tag == QFontEngineQPF::Tag_EndOfHeader)
+ return 0;
+
+ data += sizeof(QFontEngineQPF::Tag);
+
+ Q_ASSERT(tag < QFontEngineQPF::NumTags);
+
+ switch (tagTypes[tag]) {
+ case QFontEngineQPF::StringType:
+ qDebug() << "Payload =" << QString::fromUtf8(QByteArray(reinterpret_cast<const char *>(data), size));
+ break;
+ case QFontEngineQPF::FixedType:
+ Q_ASSERT(size == sizeof(quint32));
+ qDebug() << "Payload =" << QFixed::fromFixed(qFromBigEndian<quint32>(data)).toReal();
+ break;
+ case QFontEngineQPF::UInt8Type:
+ Q_ASSERT(size == sizeof(quint8));
+ qDebug() << "Payload =" << *data;
+ break;
+ case QFontEngineQPF::UInt32Type:
+ Q_ASSERT(size == sizeof(quint32));
+ qDebug() << "Payload =" << qFromBigEndian<quint32>(data);
+ break;
+ case QFontEngineQPF::BitFieldType: {
+ QByteArray bits(reinterpret_cast<const char *>(data), size);
+ qDebug() << "Payload =" << stringify(bits);
+ if (QPF::debugVerbosity > 2 && tag == QFontEngineQPF::Tag_WritingSystems)
+ dumpWritingSystems(bits);
+ } break;
+ }
+
+ data += size;
+ return data;
+}
+
+void QPF::dumpGMapBlock(const quint32 *gmap, int glyphCount)
+{
+ qDebug() << "glyphCount =" << glyphCount;
+ int renderedGlyphs = 0;
+ for (int i = 0; i < glyphCount; ++i) {
+ if (gmap[i] != 0xffffffff) {
+ const quint32 glyphPos = qFromBigEndian(gmap[i]);
+ qDebug("gmap[%d] = 0x%x / %u", i, glyphPos, glyphPos);
+ ++renderedGlyphs;
+ }
+ }
+ qDebug() << "Glyphs rendered:" << renderedGlyphs << "; Glyphs missing from the font:" << glyphCount - renderedGlyphs;
+}
+
+void QPF::dumpGlyphBlock(const quint32 *gmap, int glyphCount, const uchar *data, const uchar *endPtr)
+{
+ // glyphPos -> glyphIndex
+ QMap<quint32, quint32> reverseGlyphMap;
+ for (int i = 0; i < glyphCount; ++i) {
+ if (gmap[i] == 0xffffffff)
+ continue;
+ const quint32 glyphPos = qFromBigEndian(gmap[i]);
+ reverseGlyphMap[glyphPos] = i;
+ }
+
+ const uchar *glyphBlockBegin = data;
+ while (data < endPtr) {
+ const QFontEngineQPF::Glyph *g = reinterpret_cast<const QFontEngineQPF::Glyph *>(data);
+
+ const quint64 glyphOffset = data - glyphBlockBegin;
+ const quint32 glyphIndex = reverseGlyphMap.value(glyphOffset, 0xffffffff);
+
+ if (glyphIndex == 0xffffffff)
+ qDebug() << "############: Glyph present in glyph block is not listed in glyph map!";
+ qDebug("glyph at offset 0x%x glyphIndex = %u", quint32(glyphOffset), glyphIndex);
+ qDebug() << " width =" << g->width << "height =" << g->height << "x =" << g->x << "y =" << g->y;
+ qDebug() << " advance =" << g->advance << "bytesPerLine =" << g->bytesPerLine;
+
+ data += sizeof(*g);
+ if (glyphIndex == 0xffffffff || debugVerbosity > 4) {
+ dumpGlyph(data, g);
+ }
+
+ data += g->height * g->bytesPerLine;
+ }
+}
+
+void QPF::dumpGlyph(const uchar *data, const QFontEngineQPF::Glyph *glyph)
+{
+ fprintf(stderr, "---- glyph data:\n");
+ const char *alphas = " .o#";
+ for (int y = 0; y < glyph->height; ++y) {
+ for (int x = 0; x < glyph->width; ++x) {
+ const uchar value = data[y * glyph->bytesPerLine + x];
+ fprintf(stderr, "%c", alphas[value >> 6]);
+ }
+ fprintf(stderr, "\n");
+ }
+ fprintf(stderr, "----\n");
+}
+
+QT_END_NAMESPACE