/*
* Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
*
* This is part of HarfBuzz, an OpenType Layout engine library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*/
#include "harfbuzz-shaper.h"
#include "harfbuzz-shaper-private.h"
#include "harfbuzz-stream-private.h"
#include <assert.h>
#include <stdio.h>
#define HB_MIN(a, b) ((a) < (b) ? (a) : (b))
#define HB_MAX(a, b) ((a) > (b) ? (a) : (b))
// --------------------------------------------------------------------------------------------------------------------------------------------
//
// Basic processing
//
// --------------------------------------------------------------------------------------------------------------------------------------------
static inline void positionCluster(HB_ShaperItem *item, int gfrom, int glast)
{
int nmarks = glast - gfrom;
assert(nmarks > 0);
HB_Glyph *glyphs = item->glyphs;
HB_GlyphAttributes *attributes = item->attributes;
HB_GlyphMetrics baseMetrics;
item->font->klass->getGlyphMetrics(item->font, glyphs[gfrom], &baseMetrics);
if (item->item.script == HB_Script_Hebrew
&& (-baseMetrics.y) > baseMetrics.height)
// we need to attach below the baseline, because of the hebrew iud.
baseMetrics.height = -baseMetrics.y;
// qDebug("---> positionCluster: cluster from %d to %d", gfrom, glast);
// qDebug("baseInfo: %f/%f (%f/%f) off=%f/%f", baseInfo.x, baseInfo.y, baseInfo.width, baseInfo.height, baseInfo.xoff, baseInfo.yoff);
HB_Fixed size = item->font->klass->getFontMetric(item->font, HB_FontAscent) / 10;
HB_Fixed offsetBase = HB_FIXED_CONSTANT(1) + (size - HB_FIXED_CONSTANT(4)) / 4;
if (size > HB_FIXED_CONSTANT(4))
offsetBase += HB_FIXED_CONSTANT(4);
else
offsetBase += size;
offsetBase = -offsetBase;
//qreal offsetBase = (size - 4) / 4 + qMin<qreal>(size, 4) + 1;
// qDebug("offset = %f", offsetBase);
bool rightToLeft = item->item.bidiLevel % 2;
int i;
unsigned char lastCmb = 0;
HB_GlyphMetrics attachmentRect;
memset(&attachmentRect, 0, sizeof(attachmentRect));
for(i = 1; i <= nmarks; i++) {
HB_Glyph mark = glyphs[gfrom+i];
HB_GlyphMetrics markMetrics;
item->font->klass->getGlyphMetrics(item->font, mark, &markMetrics);
HB_FixedPoint p;
p.x = p.y = 0;
// qDebug("markInfo: %f/%f (%f/%f) off=%f/%f", markInfo.x, markInfo.y, markInfo.width, markInfo.height, markInfo.xoff, markInfo.yoff);
HB_Fixed offset = offsetBase;
unsigned char cmb = attributes[gfrom+i].combiningClass;
// ### maybe the whole position determination should move down to heuristicSetGlyphAttributes. Would save some
// bits in the glyphAttributes structure.
if (cmb < 200) {
// fixed position classes. We approximate by mapping to one of the others.
// currently I added only the ones for arabic, hebrew, lao and thai.
// for Lao and Thai marks with class 0, see below (heuristicSetGlyphAttributes)
// add a bit more offset to arabic, a bit hacky
if (cmb >= 27 && cmb <= 36 && offset < 3)
offset +=1;
// below
if ((cmb >= 10 && cmb <= 18) ||
cmb == 20 || cmb == 22 ||
cmb == 29 || cmb == 32)
cmb = HB_Combining_Below;
// above
else if (cmb == 23 || cmb == 27 || cmb == 28 ||
cmb == 30 || cmb == 31 || (cmb >= 33 && cmb <= 36))
cmb = HB_Combining_Above;
//below-right
else if (cmb == 9 || cmb == 103 || cmb == 118)
cmb = HB_Combining_BelowRight;
// above-right
else if (cmb == 24 || cmb == 107 || cmb == 122)
cmb = HB_Combining_AboveRight;
else if (cmb == 25)
cmb = HB_Combining_AboveLeft;
// fixed:
// 19 21
}
// combining marks of different class don't interact. Reset the rectangle.
if (cmb != lastCmb) {
//qDebug("resetting rect");
attachmentRect = baseMetrics;
}
switch(cmb) {
case HB_Combining_DoubleBelow:
// ### wrong in rtl context!
case HB_Combining_BelowLeft:
p.y += offset;
case HB_Combining_BelowLeftAttached:
p.x += attachmentRect.x - markMetrics.x;
p.y += (attachmentRect.y + attachmentRect.height) - markMetrics.y;
break;
case HB_Combining_Below:
p.y += offset;
case HB_Combining_BelowAttached:
p.x += attachmentRect.x - markMetrics.x;
p.y += (attachmentRect.y + attachmentRect.height) - markMetrics.y;
p.x += (attachmentRect.width - markMetrics.width) / 2;
break;
case HB_Combining_BelowRight:
p.y += offset;
case HB_Combining_BelowRightAttached:
p.x += attachmentRect.x + attachmentRect.width - markMetrics.width - markMetrics.x;
p.y += attachmentRect.y + attachmentRect.height - markMetrics.y;
break;
case HB_Combining_Left:
p.x -= offset;
case HB_Combining_LeftAttached:
break;
case HB_Combining_Right:
p.x += offset;
case HB_Combining_RightAttached:
break;
case HB_Combining_DoubleAbove:
// ### wrong in RTL context!
case HB_Combining_AboveLeft:
p.y -= offset;
case HB_Combining_AboveLeftAttached:
p.x += attachmentRect.x - markMetrics.x;
p.y += attachmentRect.y - markMetrics.y - markMetrics.height;
break;
case HB_Combining_Above:
p.y -= offset;
case HB_Combining_AboveAttached:
p.x += attachmentRect.x - markMetrics.x;
p.y += attachmentRect.y - markMetrics.y - markMetrics.height;
p.x += (attachmentRect.width - markMetrics.width) / 2;
break;
case HB_Combining_AboveRight:
p.y -= offset;
case HB_Combining_AboveRightAttached:
p.x += attachmentRect.x + attachmentRect.width - markMetrics.x - markMetrics.width;
p.y += attachmentRect.y - markMetrics.y - markMetrics.height;
break;
case HB_Combining_IotaSubscript:
default:
break;
}
// qDebug("char=%x combiningClass = %d offset=%f/%f", mark, cmb, p.x(), p.y());
markMetrics.x += p.x;
markMetrics.y += p.y;
HB_GlyphMetrics unitedAttachmentRect = attachmentRect;
unitedAttachmentRect.x = HB_MIN(attachmentRect.x, markMetrics.x);
unitedAttachmentRect.y = HB_MIN(attachmentRect.y, markMetrics.y);
unitedAttachmentRect.width = HB_MAX(attachmentRect.x + attachmentRect.width, markMetrics.x + markMetrics.width) - unitedAttachmentRect.x;
unitedAttachmentRect.height = HB_MAX(attachmentRect.y + attachmentRect.height, markMetrics.y + markMetrics.height) - unitedAttachmentRect.y;
attachmentRect = unitedAttachmentRect;
lastCmb = cmb;
if (rightToLeft) {
item->offsets[gfrom+i].x = p.x;
item->offsets[gfrom+i].y = p.y;
} else {
item->offsets[gfrom+i].x = p.x - baseMetrics.xOffset;
item->offsets[gfrom+i].y = p.y - baseMetrics.yOffset;
}
item->advances[gfrom+i] = 0;
}
}
void HB_HeuristicPosition(HB_ShaperItem *item)
{
HB_GetGlyphAdvances(item);
HB_GlyphAttributes *attributes = item->attributes;
int cEnd = -1;
int i = item->num_glyphs;
while (i--) {
if (cEnd == -1 && attributes[i].mark) {
cEnd = i;
} else if (cEnd != -1 && !attributes[i].mark) {
positionCluster(item, i, cEnd);
cEnd = -1;
}
}
}
// set the glyph attributes heuristically. Assumes a 1 to 1 relationship between chars and glyphs
// and no reordering.
// also computes logClusters heuristically
void HB_HeuristicSetGlyphAttributes(HB_ShaperItem *item)
{
const HB_UChar16 *uc = item->string + item->item.pos;
hb_uint32 length = item->item.length;
// ### zeroWidth and justification are missing here!!!!!
assert(item->num_glyphs <= length);
// qDebug("QScriptEngine::heuristicSetGlyphAttributes, num_glyphs=%d", item->num_glyphs);
HB_GlyphAttributes *attributes = item->attributes;
unsigned short *logClusters = item->log_clusters;
hb_uint32 glyph_pos = 0;
hb_uint32 i;
for (i = 0; i < length; i++) {
if (HB_IsHighSurrogate(uc[i]) && i < length - 1
&& HB_IsLowSurrogate(uc[i + 1])) {
logClusters[i] = glyph_pos;
logClusters[++i] = glyph_pos;
} else {
logClusters[i] = glyph_pos;
}
++glyph_pos;
}
assert(glyph_pos == item->num_glyphs);
// first char in a run is never (treated as) a mark
int cStart = 0;
const bool symbolFont = item->face->isSymbolFont;
attributes[0].mark = false;
attributes[0].clusterStart = true;
attributes[0].dontPrint = (!symbolFont && uc[0] == 0x00ad) || HB_IsControlChar(uc[0]);
int pos = 0;
HB_CharCategory lastCat;
int dummy;
HB_GetUnicodeCharProperties(uc[0], &lastCat, &dummy);
for (i = 1; i < length; ++i) {
if (logClusters[i] == pos)
// same glyph
continue;
++pos;
while (pos < logClusters[i]) {
attributes[pos] = attributes[pos-1];
++pos;
}
// hide soft-hyphens by default
if ((!symbolFont && uc[i] == 0x00ad) || HB_IsControlChar(uc[i]))
attributes[pos].dontPrint = true;
HB_CharCategory cat;
int cmb;
HB_GetUnicodeCharProperties(uc[i], &cat, &cmb);
if (cat != HB_Mark_NonSpacing) {
attributes[pos].mark = false;
attributes[pos].clusterStart = true;
attributes[pos].combiningClass = 0;
cStart = logClusters[i];
} else {
if (cmb == 0) {
// Fix 0 combining classes
if ((uc[pos] & 0xff00) == 0x0e00) {
// thai or lao
if (uc[pos] == 0xe31 ||
uc[pos] == 0xe34 ||
uc[pos] == 0xe35 ||
uc[pos] == 0xe36 ||
uc[pos] == 0xe37 ||
uc[pos] == 0xe47 ||
uc[pos] == 0xe4c ||
uc[pos] == 0xe4d ||
uc[pos] == 0xe4e) {
cmb = HB_Combining_AboveRight;
} else if (uc[pos] == 0xeb1 ||
uc[pos] == 0xeb4 ||
uc[pos] == 0xeb5 ||
uc[pos] == 0xeb6 ||
uc[pos] == 0xeb7 ||
uc[pos] == 0xebb ||
uc[pos] == 0xecc ||
uc[pos] == 0xecd) {
cmb = HB_Combining_Above;
} else if (uc[pos] == 0xebc) {
cmb = HB_Combining_Below;
}
}
}
attributes[pos].mark = true;
attributes[pos].clusterStart = false;
attributes[pos].combiningClass = cmb;
logClusters[i] = cStart;
}
// one gets an inter character justification point if the current char is not a non spacing mark.
// as then the current char belongs to the last one and one gets a space justification point
// after the space char.
if (lastCat == HB_Separator_Space)
attributes[pos-1].justification = HB_Space;
else if (cat != HB_Mark_NonSpacing)
attributes[pos-1].justification = HB_Character;
else
attributes[pos-1].justification = HB_NoJustification;
lastCat = cat;
}
pos = logClusters[length-1];
if (lastCat == HB_Separator_Space)
attributes[pos].justification = HB_Space;
else
attributes[pos].justification = HB_Character;
}
#ifndef NO_OPENTYPE
static const HB_OpenTypeFeature basic_features[] = {
{ HB_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty },
{ HB_MAKE_TAG('l', 'i', 'g', 'a'), CcmpProperty },
{ HB_MAKE_TAG('c', 'l', 'i', 'g'), CcmpProperty },
{0, 0}
};
#endif
HB_Bool HB_ConvertStringToGlyphIndices(HB_ShaperItem *shaper_item)
{
if (shaper_item->glyphIndicesPresent) {
shaper_item->num_glyphs = shaper_item->initialGlyphCount;
shaper_item->glyphIndicesPresent = false;
return true;
}
return shaper_item->font->klass
->convertStringToGlyphIndices(shaper_item->font,
shaper_item->string + shaper_item->item.pos, shaper_item->item.length,
shaper_item->glyphs, &shaper_item->num_glyphs,
shaper_item->item.bidiLevel % 2);
}
HB_Bool HB_BasicShape(HB_ShaperItem *shaper_item)
{
#ifndef NO_OPENTYPE
const int availableGlyphs = shaper_item->num_glyphs;
#endif
if (!HB_ConvertStringToGlyphIndices(shaper_item))
return false;
HB_HeuristicSetGlyphAttributes(shaper_item);
#ifndef NO_OPENTYPE
if (HB_SelectScript(shaper_item, basic_features)) {
HB_OpenTypeShape(shaper_item, /*properties*/0);
return HB_OpenTypePosition(shaper_item, availableGlyphs, /*doLogClusters*/true);
}
#endif
HB_HeuristicPosition(shaper_item);
return true;
}
const HB_ScriptEngine HB_ScriptEngines[] = {
// Common
{ HB_BasicShape},
// Greek
{ HB_GreekShape},
// Cyrillic
{ HB_BasicShape},
// Armenian
{ HB_BasicShape},
// Hebrew
{ HB_HebrewShape},
// Arabic
{ HB_ArabicShape},
// Syriac
{ HB_ArabicShape},
// Thaana
{ HB_BasicShape},
// Devanagari
{ HB_IndicShape},
// Bengali
{ HB_IndicShape},
// Gurmukhi
{ HB_IndicShape},
// Gujarati
{ HB_IndicShape},
// Oriya
{ HB_IndicShape},
// Tamil
{ HB_IndicShape},
// Telugu
{ HB_IndicShape},
// Kannada
{ HB_IndicShape},
// Malayalam
{ HB_IndicShape},
// Sinhala
{ HB_IndicShape},
// Thai
{ HB_BasicShape},
// Lao
{ HB_BasicShape},
// Tibetan
{ HB_TibetanShape},
// Myanmar
{ HB_MyanmarShape},
// Georgian
{ HB_BasicShape},
// Hangul
{ HB_HangulShape},
// Ogham
{ HB_BasicShape},
// Runic
{ HB_BasicShape},
// Khmer
{ HB_KhmerShape},
// N'Ko
{ HB_ArabicShape}
};
static inline char *tag_to_string(HB_UInt tag)
{
static char string[5];
string[0] = (tag >> 24)&0xff;
string[1] = (tag >> 16)&0xff;
string[2] = (tag >> 8)&0xff;
string[3] = tag&0xff;
string[4] = 0;
return string;
}
#ifdef OT_DEBUG
static void dump_string(HB_Buffer buffer)
{
for (uint i = 0; i < buffer->in_length; ++i) {
qDebug(" %x: cluster=%d", buffer->in_string[i].gindex, buffer->in_string[i].cluster);
}
}
#define DEBUG printf
#else
#define DEBUG if (1) ; else printf
#endif
#if 0
#define DefaultLangSys 0xffff
#define DefaultScript HB_MAKE_TAG('D', 'F', 'L', 'T')
#endif
enum {
RequiresGsub = 1,
RequiresGpos = 2
};
struct OTScripts {
unsigned int tag;
int flags;
};
static const OTScripts ot_scripts [] = {
// Common
{ HB_MAKE_TAG('l', 'a', 't', 'n'), 0 },
// Greek
{ HB_MAKE_TAG('g', 'r', 'e', 'k'), 0 },
// Cyrillic
{ HB_MAKE_TAG('c', 'y', 'r', 'l'), 0 },
// Armenian
{ HB_MAKE_TAG('a', 'r', 'm', 'n'), 0 },
// Hebrew
{ HB_MAKE_TAG('h', 'e', 'b', 'r'), 1 },
// Arabic
{ HB_MAKE_TAG('a', 'r', 'a', 'b'), 1 },
// Syriac
{ HB_MAKE_TAG('s', 'y', 'r', 'c'), 1 },
// Thaana
{ HB_MAKE_TAG('t', 'h', 'a', 'a'), 1 },
// Devanagari
{ HB_MAKE_TAG('d', 'e', 'v', 'a'), 1 },
// Bengali
{ HB_MAKE_TAG('b', 'e', 'n', 'g'), 1 },
// Gurmukhi
{ HB_MAKE_TAG('g', 'u', 'r', 'u'), 1 },
// Gujarati
{ HB_MAKE_TAG('g', 'u', 'j', 'r'), 1 },
// Oriya
{ HB_MAKE_TAG('o', 'r', 'y', 'a'), 1 },
// Tamil
{ HB_MAKE_TAG('t', 'a', 'm', 'l'), 1 },
// Telugu
{ HB_MAKE_TAG('t', 'e', 'l', 'u'), 1 },
// Kannada
{ HB_MAKE_TAG('k', 'n', 'd', 'a'), 1 },
// Malayalam
{ HB_MAKE_TAG('m', 'l', 'y', 'm'), 1 },
// Sinhala
{ HB_MAKE_TAG('s', 'i', 'n', 'h'), 1 },
// Thai
{ HB_MAKE_TAG('t', 'h', 'a', 'i'), 1 },
// Lao
{ HB_MAKE_TAG('l', 'a', 'o', ' '), 1 },
// Tibetan
{ HB_MAKE_TAG('t', 'i', 'b', 't'), 1 },
// Myanmar
{ HB_MAKE_TAG('m', 'y', 'm', 'r'), 1 },
// Georgian
{ HB_MAKE_TAG('g', 'e', 'o', 'r'), 0 },
// Hangul
{ HB_MAKE_TAG('h', 'a', 'n', 'g'), 1 },
// Ogham
{ HB_MAKE_TAG('o', 'g', 'a', 'm'), 0 },
// Runic
{ HB_MAKE_TAG('r', 'u', 'n', 'r'), 0 },
// Khmer
{ HB_MAKE_TAG('k', 'h', 'm', 'r'), 1 },
// N'Ko
{ HB_MAKE_TAG('n', 'k', 'o', ' '), 1 }
};
enum { NumOTScripts = sizeof(ot_scripts)/sizeof(OTScripts) };
static HB_Bool checkScript(HB_Face face, int script)
{
assert(script < HB_ScriptCount);
if (!face->gsub && !face->gpos)
return false;
unsigned int tag = ot_scripts[script].tag;
int requirements = ot_scripts[script].flags;
if (requirements & RequiresGsub) {
if (!face->gsub)
return false;
HB_UShort script_index;
HB_Error error = HB_GSUB_Select_Script(face->gsub, tag, &script_index);
if (error) {
DEBUG("could not select script %d in GSub table: %d", (int)script, error);
error = HB_GSUB_Select_Script(face->gsub, HB_MAKE_TAG('D', 'F', 'L', 'T'), &script_index);
if (error)
return false;
}
}
if (requirements & RequiresGpos) {
if (!face->gpos)
return false;
HB_UShort script_index;
HB_Error error = HB_GPOS_Select_Script(face->gpos, script, &script_index);
if (error) {
DEBUG("could not select script in gpos table: %d", error);
error = HB_GPOS_Select_Script(face->gpos, HB_MAKE_TAG('D', 'F', 'L', 'T'), &script_index);
if (error)
return false;
}
}
return true;
}
static HB_Stream getTableStream(void *font, HB_GetFontTableFunc tableFunc, HB_Tag tag)
{
HB_Error error;
HB_UInt length = 0;
HB_Stream stream = 0;
if (!font)
return 0;
error = tableFunc(font, tag, 0, &length);
if (error)
return 0;
stream = (HB_Stream)malloc(sizeof(HB_StreamRec));
if (!stream)
return 0;
stream->base = (HB_Byte*)malloc(length);
if (!stream->base) {
free(stream);
return 0;
}
error = tableFunc(font, tag, stream->base, &length);
if (error) {
_hb_close_stream(stream);
return 0;
}
stream->size = length;
stream->pos = 0;
stream->cursor = NULL;
return stream;
}
HB_Face HB_NewFace(void *font, HB_GetFontTableFunc tableFunc)
{
HB_Face face = (HB_Face )malloc(sizeof(HB_FaceRec));
if (!face)
return 0;
face->isSymbolFont = false;
face->gdef = 0;
face->gpos = 0;
face->gsub = 0;
face->current_script = HB_ScriptCount;
face->current_flags = HB_ShaperFlag_Default;
face->has_opentype_kerning = false;
face->tmpAttributes = 0;
face->tmpLogClusters = 0;
face->glyphs_substituted = false;
face->buffer = 0;
HB_Error error = HB_Err_Ok;
HB_Stream stream;
HB_Stream gdefStream;
gdefStream = getTableStream(font, tableFunc, TTAG_GDEF);
error = HB_Err_Not_Covered;
if (!gdefStream || (error = HB_Load_GDEF_Table(gdefStream, &face->gdef))) {
//DEBUG("error loading gdef table: %d", error);
face->gdef = 0;
}
//DEBUG() << "trying to load gsub table";
stream = getTableStream(font, tableFunc, TTAG_GSUB);
error = HB_Err_Not_Covered;
if (!stream || (error = HB_Load_GSUB_Table(stream, &face->gsub, face->gdef, gdefStream))) {
face->gsub = 0;
if (error != HB_Err_Not_Covered) {
//DEBUG("error loading gsub table: %d", error);
} else {
//DEBUG("face doesn't have a gsub table");
}
}
_hb_close_stream(stream);
stream = getTableStream(font, tableFunc, TTAG_GPOS);
error = HB_Err_Not_Covered;
if (!stream || (error = HB_Load_GPOS_Table(stream, &face->gpos, face->gdef, gdefStream))) {
face->gpos = 0;
DEBUG("error loading gpos table: %d", error);
}
_hb_close_stream(stream);
_hb_close_stream(gdefStream);
for (unsigned int i = 0; i < HB_ScriptCount; ++i)
face->supported_scripts[i] = checkScript(face, i);
if (HB_Buffer_new(&face->buffer) != HB_Err_Ok) {
HB_FreeFace(face);
return 0;
}
return face;
}
void HB_FreeFace(HB_Face face)
{
if (!face)
return;
if (face->gpos)
HB_Done_GPOS_Table(face->gpos);
if (face->gsub)
HB_Done_GSUB_Table(face->gsub);
if (face->gdef)
HB_Done_GDEF_Table(face->gdef);
if (face->buffer)
HB_Buffer_free(face->buffer);
if (face->tmpAttributes)
free(face->tmpAttributes);
if (face->tmpLogClusters)
free(face->tmpLogClusters);
free(face);
}
HB_Bool HB_SelectScript(HB_ShaperItem *shaper_item, const HB_OpenTypeFeature *features)
{
HB_Script script = shaper_item->item.script;
if (!shaper_item->face->supported_scripts[script])
return false;
HB_Face face = shaper_item->face;
if (face->current_script == script && face->current_flags == shaper_item->shaperFlags)
return true;
face->current_script = script;
face->current_flags = shaper_item->shaperFlags;
assert(script < HB_ScriptCount);
// find script in our list of supported scripts.
unsigned int tag = ot_scripts[script].tag;
if (face->gsub && features) {
#ifdef OT_DEBUG
{
HB_FeatureList featurelist = face->gsub->FeatureList;
int numfeatures = featurelist.FeatureCount;
DEBUG("gsub table has %d features", numfeatures);
for (int i = 0; i < numfeatures; i++) {
HB_FeatureRecord *r = featurelist.FeatureRecord + i;
DEBUG(" feature '%s'", tag_to_string(r->FeatureTag));
}
}
#endif
HB_GSUB_Clear_Features(face->gsub);
HB_UShort script_index;
HB_Error error = HB_GSUB_Select_Script(face->gsub, tag, &script_index);
if (!error) {
DEBUG("script %s has script index %d", tag_to_string(script), script_index);
while (features->tag) {
HB_UShort feature_index;
error = HB_GSUB_Select_Feature(face->gsub, features->tag, script_index, 0xffff, &feature_index);
if (!error) {
DEBUG(" adding feature %s", tag_to_string(features->tag));
HB_GSUB_Add_Feature(face->gsub, feature_index, features->property);
}
++features;
}
}
}
// reset
face->has_opentype_kerning = false;
if (face->gpos) {
HB_GPOS_Clear_Features(face->gpos);
HB_UShort script_index;
HB_Error error = HB_GPOS_Select_Script(face->gpos, tag, &script_index);
if (!error) {
#ifdef OT_DEBUG
{
HB_FeatureList featurelist = face->gpos->FeatureList;
int numfeatures = featurelist.FeatureCount;
DEBUG("gpos table has %d features", numfeatures);
for(int i = 0; i < numfeatures; i++) {
HB_FeatureRecord *r = featurelist.FeatureRecord + i;
HB_UShort feature_index;
HB_GPOS_Select_Feature(face->gpos, r->FeatureTag, script_index, 0xffff, &feature_index);
DEBUG(" feature '%s'", tag_to_string(r->FeatureTag));
}
}
#endif
HB_UInt *feature_tag_list_buffer;
error = HB_GPOS_Query_Features(face->gpos, script_index, 0xffff, &feature_tag_list_buffer);
if (!error) {
HB_UInt *feature_tag_list = feature_tag_list_buffer;
while (*feature_tag_list) {
HB_UShort feature_index;
if (*feature_tag_list == HB_MAKE_TAG('k', 'e', 'r', 'n')) {
if (face->current_flags & HB_ShaperFlag_NoKerning) {
++feature_tag_list;
continue;
}
face->has_opentype_kerning = true;
}
error = HB_GPOS_Select_Feature(face->gpos, *feature_tag_list, script_index, 0xffff, &feature_index);
if (!error)
HB_GPOS_Add_Feature(face->gpos, feature_index, PositioningProperties);
++feature_tag_list;
}
FREE(feature_tag_list_buffer);
}
}
}
return true;
}
HB_Bool HB_OpenTypeShape(HB_ShaperItem *item, const hb_uint32 *properties)
{
HB_GlyphAttributes *tmpAttributes;
unsigned int *tmpLogClusters;
HB_Face face = item->face;
face->length = item->num_glyphs;
HB_Buffer_clear(face->buffer);
tmpAttributes = (HB_GlyphAttributes *) realloc(face->tmpAttributes, face->length*sizeof(HB_GlyphAttributes));
if (!tmpAttributes)
return false;
face->tmpAttributes = tmpAttributes;
tmpLogClusters = (unsigned int *) realloc(face->tmpLogClusters, face->length*sizeof(unsigned int));
if (!tmpLogClusters)
return false;
face->tmpLogClusters = tmpLogClusters;
for (int i = 0; i < face->length; ++i) {
HB_Buffer_add_glyph(face->buffer, item->glyphs[i], properties ? properties[i] : 0, i);
face->tmpAttributes[i] = item->attributes[i];
face->tmpLogClusters[i] = item->log_clusters[i];
}
#ifdef OT_DEBUG
DEBUG("-----------------------------------------");
// DEBUG("log clusters before shaping:");
// for (int j = 0; j < length; j++)
// DEBUG(" log[%d] = %d", j, item->log_clusters[j]);
DEBUG("original glyphs: %p", item->glyphs);
for (int i = 0; i < length; ++i)
DEBUG(" glyph=%4x", hb_buffer->in_string[i].gindex);
// dump_string(hb_buffer);
#endif
face->glyphs_substituted = false;
if (face->gsub) {
unsigned int error = HB_GSUB_Apply_String(face->gsub, face->buffer);
if (error && error != HB_Err_Not_Covered)
return false;
face->glyphs_substituted = (error != HB_Err_Not_Covered);
}
#ifdef OT_DEBUG
// DEBUG("log clusters before shaping:");
// for (int j = 0; j < length; j++)
// DEBUG(" log[%d] = %d", j, item->log_clusters[j]);
DEBUG("shaped glyphs:");
for (int i = 0; i < length; ++i)
DEBUG(" glyph=%4x", hb_buffer->in_string[i].gindex);
DEBUG("-----------------------------------------");
// dump_string(hb_buffer);
#endif
return true;
}
HB_Bool HB_OpenTypePosition(HB_ShaperItem *item, int availableGlyphs, HB_Bool doLogClusters)
{
HB_Face face = item->face;
bool glyphs_positioned = false;
if (face->gpos) {
if (face->buffer->positions)
memset(face->buffer->positions, 0, face->buffer->in_length*sizeof(HB_PositionRec));
// #### check that passing "false,false" is correct
glyphs_positioned = HB_GPOS_Apply_String(item->font, face->gpos, face->current_flags, face->buffer, false, false) != HB_Err_Not_Covered;
}
if (!face->glyphs_substituted && !glyphs_positioned) {
HB_GetGlyphAdvances(item);
return true; // nothing to do for us
}
// make sure we have enough space to write everything back
if (availableGlyphs < (int)face->buffer->in_length) {
item->num_glyphs = face->buffer->in_length;
return false;
}
HB_Glyph *glyphs = item->glyphs;
HB_GlyphAttributes *attributes = item->attributes;
for (unsigned int i = 0; i < face->buffer->in_length; ++i) {
glyphs[i] = face->buffer->in_string[i].gindex;
attributes[i] = face->tmpAttributes[face->buffer->in_string[i].cluster];
if (i && face->buffer->in_string[i].cluster == face->buffer->in_string[i-1].cluster)
attributes[i].clusterStart = false;
}
item->num_glyphs = face->buffer->in_length;
if (doLogClusters && face->glyphs_substituted) {
// we can't do this for indic, as we pass the stuf in syllables and it's easier to do it in the shaper.
unsigned short *logClusters = item->log_clusters;
int clusterStart = 0;
int oldCi = 0;
// #### the reconstruction of the logclusters currently does not work if the original string
// contains surrogate pairs
for (unsigned int i = 0; i < face->buffer->in_length; ++i) {
int ci = face->buffer->in_string[i].cluster;
// DEBUG(" ci[%d] = %d mark=%d, cmb=%d, cs=%d",
// i, ci, glyphAttributes[i].mark, glyphAttributes[i].combiningClass, glyphAttributes[i].clusterStart);
if (!attributes[i].mark && attributes[i].clusterStart && ci != oldCi) {
for (int j = oldCi; j < ci; j++)
logClusters[j] = clusterStart;
clusterStart = i;
oldCi = ci;
}
}
for (int j = oldCi; j < face->length; j++)
logClusters[j] = clusterStart;
}
// calulate the advances for the shaped glyphs
// DEBUG("unpositioned: ");
// positioning code:
if (glyphs_positioned) {
HB_GetGlyphAdvances(item);
HB_Position positions = face->buffer->positions;
HB_Fixed *advances = item->advances;
// DEBUG("positioned glyphs:");
for (unsigned int i = 0; i < face->buffer->in_length; i++) {
// DEBUG(" %d:\t orig advance: (%d/%d)\tadv=(%d/%d)\tpos=(%d/%d)\tback=%d\tnew_advance=%d", i,
// glyphs[i].advance.x.toInt(), glyphs[i].advance.y.toInt(),
// (int)(positions[i].x_advance >> 6), (int)(positions[i].y_advance >> 6),
// (int)(positions[i].x_pos >> 6), (int)(positions[i].y_pos >> 6),
// positions[i].back, positions[i].new_advance);
HB_Fixed adjustment = positions[i].x_advance;
if (!(face->current_flags & HB_ShaperFlag_UseDesignMetrics))
adjustment = HB_FIXED_ROUND(adjustment);
if (positions[i].new_advance) {
; //advances[i] = adjustment;
} else {
advances[i] += adjustment;
}
int back = 0;
HB_FixedPoint *offsets = item->offsets;
offsets[i].x = positions[i].x_pos;
offsets[i].y = positions[i].y_pos;
while (positions[i - back].back) {
back += positions[i - back].back;
offsets[i].x += positions[i - back].x_pos;
offsets[i].y += positions[i - back].y_pos;
}
offsets[i].y = -offsets[i].y;
if (item->item.bidiLevel % 2) {
// ### may need to go back multiple glyphs like in ltr
back = positions[i].back;
while (back--)
offsets[i].x -= advances[i-back];
} else {
back = 0;
while (positions[i - back].back) {
back += positions[i - back].back;
offsets[i].x -= advances[i-back];
}
}
// DEBUG(" ->\tadv=%d\tpos=(%d/%d)",
// glyphs[i].advance.x.toInt(), glyphs[i].offset.x.toInt(), glyphs[i].offset.y.toInt());
}
item->kerning_applied = face->has_opentype_kerning;
} else {
HB_HeuristicPosition(item);
}
#ifdef OT_DEBUG
if (doLogClusters) {
DEBUG("log clusters after shaping:");
for (int j = 0; j < length; j++)
DEBUG(" log[%d] = %d", j, item->log_clusters[j]);
}
DEBUG("final glyphs:");
for (int i = 0; i < (int)hb_buffer->in_length; ++i)
DEBUG(" glyph=%4x char_index=%d mark: %d cmp: %d, clusterStart: %d advance=%d/%d offset=%d/%d",
glyphs[i].glyph, hb_buffer->in_string[i].cluster, glyphs[i].attributes.mark,
glyphs[i].attributes.combiningClass, glyphs[i].attributes.clusterStart,
glyphs[i].advance.x.toInt(), glyphs[i].advance.y.toInt(),
glyphs[i].offset.x.toInt(), glyphs[i].offset.y.toInt());
DEBUG("-----------------------------------------");
#endif
return true;
}
HB_Bool HB_ShapeItem(HB_ShaperItem *shaper_item)
{
HB_Bool result = false;
if (shaper_item->num_glyphs < shaper_item->item.length) {
shaper_item->num_glyphs = shaper_item->item.length;
return false;
}
assert(shaper_item->item.script < HB_ScriptCount);
result = HB_ScriptEngines[shaper_item->item.script].shape(shaper_item);
shaper_item->glyphIndicesPresent = false;
return result;
}
