/****************************************************************************

**

** 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);