/*

 *******************************************************************************

 *

 *   Copyright (C) 1999-2003, International Business Machines

 *   Corporation and others.  All Rights Reserved.

 *

 *******************************************************************************

 *   file name:  PortableFontInstance.cpp

 *

 *   created on: 11/22/1999

 *   created by: Eric R. Mader

 */

#include <stdio.h>

#include "layout/LETypes.h"

#include "layout/LEFontInstance.h"

#include "layout/LESwaps.h"

#include "PortableFontInstance.h"

#include "sfnt.h"

#include <string.h>

//

// Finds the high bit by binary searching

// through the bits in n.

//

le_int8 PortableFontInstance::highBit(le_int32 value)

{

    if (value <= 0) {

        return -32;

    }

    le_uint8 bit = 0;

    if (value >= 1 << 16) {

        value >>= 16;

        bit += 16;

    }

    if (value >= 1 << 8) {

        value >>= 8;

        bit += 8;

    }

    if (value >= 1 << 4) {

        value >>= 4;

        bit += 4;

    }

    if (value >= 1 << 2) {

        value >>= 2;

        bit += 2;

    }

    if (value >= 1 << 1) {

        value >>= 1;

        bit += 1;

    }

    return bit;

}

PortableFontInstance::PortableFontInstance(char *fileName, float pointSize, LEErrorCode &status)

    : fFile(NULL), fUnitsPerEM(0), fPointSize(pointSize), fAscent(0), fDescent(0), fLeading(0),

      fDirectory(NULL), fCMAPMapper(NULL), fHMTXTable(NULL), fNumGlyphs(0), fNumLongHorMetrics(0)

{

    if (LE_FAILURE(status)) {

        return;

    }

    // open the font file

    fFile = fopen(fileName, "rb");

    if (fFile == NULL) {

        status = LE_FONT_FILE_NOT_FOUND_ERROR;

        return;

    }

    // read in the directory

    SFNTDirectory tempDir;

    fread(&tempDir, sizeof tempDir, 1, fFile);

    le_int32 dirSize = sizeof tempDir + ((SWAPW(tempDir.numTables) - ANY_NUMBER) * sizeof(DirectoryEntry));

    const LETag headTag = LE_HEAD_TABLE_TAG;

    const LETag hheaTag = LE_HHEA_TABLE_TAG;

    const HEADTable *headTable = NULL;

    const HHEATable *hheaTable = NULL;

    le_uint16 numTables = 0;

    fDirectory = (const SFNTDirectory *) LE_NEW_ARRAY(char, dirSize);

    if (fDirectory == NULL) {

        status = LE_MEMORY_ALLOCATION_ERROR;

        goto error_exit;

    }

    fseek(fFile, 0L, SEEK_SET);

    fread((void *) fDirectory, sizeof(char), dirSize, fFile);

    //

    // We calculate these numbers 'cause some fonts

    // have bogus values for them in the directory header.

    //

    numTables = SWAPW(fDirectory->numTables);

    fDirPower = 1 << highBit(numTables);

    fDirExtra = numTables - fDirPower;

    // read unitsPerEm from 'head' table

    headTable = (const HEADTable *) readFontTable(headTag);

    if (headTable == NULL) {

        status = LE_MISSING_FONT_TABLE_ERROR;

        goto error_exit;

    }

    fUnitsPerEM = SWAPW(headTable->unitsPerEm);

    deleteTable(headTable);

    hheaTable = (HHEATable *) readFontTable(hheaTag);

    if (hheaTable == NULL) {

        status = LE_MISSING_FONT_TABLE_ERROR;

        goto error_exit;

    }

    fAscent  = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->ascent));

    fDescent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->descent));

    fLeading = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->lineGap));

    fNumLongHorMetrics = SWAPW(hheaTable->numOfLongHorMetrics);

    deleteTable((void *) hheaTable);

    fCMAPMapper = findUnicodeMapper();

    if (fCMAPMapper == NULL) {

        status = LE_MISSING_FONT_TABLE_ERROR;

        goto error_exit;

    }

    return;

error_exit:

    fclose(fFile);

    fFile = NULL;

    return;

}

PortableFontInstance::~PortableFontInstance()

{

    if (fFile != NULL) {

        fclose(fFile);

        deleteTable(fHMTXTable);

        delete fCMAPMapper;

        LE_DELETE_ARRAY(fDirectory);

    }

};

void PortableFontInstance::deleteTable(const void *table) const

{

    LE_DELETE_ARRAY(table);

}

const DirectoryEntry *PortableFontInstance::findTable(LETag tag) const

{

    if (fDirectory != NULL) {

        le_uint16 table = 0;

        le_uint16 probe = fDirPower;

        if (SWAPL(fDirectory->tableDirectory[fDirExtra].tag) <= tag) {

            table = fDirExtra;

        }

        while (probe > (1 << 0)) {

            probe >>= 1;

            if (SWAPL(fDirectory->tableDirectory[table + probe].tag) <= tag) {

                table += probe;

            }

        }

        if (SWAPL(fDirectory->tableDirectory[table].tag) == tag) {

            return &fDirectory->tableDirectory[table];

        }

    }

    return NULL;

}

const void *PortableFontInstance::readTable(LETag tag, le_uint32 *length) const

{

    const DirectoryEntry *entry = findTable(tag);

    if (entry == NULL) {

        *length = 0;

        return NULL;

    }

    *length = SWAPL(entry->length);

    void *table = LE_NEW_ARRAY(char, *length);

    if (table != NULL) {

        fseek(fFile, SWAPL(entry->offset), SEEK_SET);

        fread(table, sizeof(char), *length, fFile);

    }

    return table;

}

const void *PortableFontInstance::getFontTable(LETag tableTag) const

{

    return FontTableCache::find(tableTag);

}

const void *PortableFontInstance::readFontTable(LETag tableTag) const

{

    le_uint32 len;

    return readTable(tableTag, &len);

}

CMAPMapper *PortableFontInstance::findUnicodeMapper()

{

    LETag cmapTag = LE_CMAP_TABLE_TAG;

    const CMAPTable *cmap = (CMAPTable *) readFontTable(cmapTag);

    if (cmap == NULL) {

        return NULL;

    }

    return CMAPMapper::createUnicodeMapper(cmap);

}

void PortableFontInstance::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const

{

    TTGlyphID ttGlyph = (TTGlyphID) LE_GET_GLYPH(glyph);

    if (fHMTXTable == NULL) {

        LETag maxpTag = LE_MAXP_TABLE_TAG;

        LETag hmtxTag = LE_HMTX_TABLE_TAG;

        const MAXPTable *maxpTable = (MAXPTable *) readFontTable(maxpTag);

        PortableFontInstance *realThis = (PortableFontInstance *) this;

        if (maxpTable != NULL) {

            realThis->fNumGlyphs = SWAPW(maxpTable->numGlyphs);

            deleteTable(maxpTable);

        }

        realThis->fHMTXTable = (const HMTXTable *) readFontTable(hmtxTag);

    }

    le_uint16 index = ttGlyph;

    if (ttGlyph >= fNumGlyphs || fHMTXTable == NULL) {

        advance.fX = advance.fY = 0;

        return;

    }

    if (ttGlyph >= fNumLongHorMetrics) {

        index = fNumLongHorMetrics - 1;

    }

    advance.fX = xUnitsToPoints(SWAPW(fHMTXTable->hMetrics[index].advanceWidth));

    advance.fY = 0;

}

le_bool PortableFontInstance::getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const

{

    return FALSE;

}