HarfBuzzShaper::HarfBuzzRun::HarfBuzzRun(unsigned numCharacters, TextDirection direction, hb_buffer_t* harfbuzzBuffer)
: m_numCharacters(numCharacters)
, m_direction(direction)
{
m_numGlyphs = hb_buffer_get_length(harfbuzzBuffer);
m_glyphs.resize(m_numGlyphs);
m_advances.resize(m_numGlyphs);
m_offsets.resize(m_numGlyphs);
m_glyphToCharacterIndex.resize(m_numGlyphs);
m_logClusters.resize(m_numCharacters);
hb_glyph_info_t* infos = hb_buffer_get_glyph_infos(harfbuzzBuffer, 0);
for (unsigned i = 0; i < m_numGlyphs; ++i)
m_glyphToCharacterIndex[i] = infos[i].cluster;
// Fill logical clusters
unsigned index = 0;
while (index < m_numGlyphs) {
unsigned nextIndex = index + 1;
while (nextIndex < m_numGlyphs && infos[index].cluster == infos[nextIndex].cluster)
++nextIndex;
if (rtl()) {
int nextCluster = nextIndex < m_numGlyphs ? infos[nextIndex].cluster : -1;
for (int j = infos[index].cluster; j > nextCluster; --j)
m_logClusters[j] = index;
} else {
unsigned nextCluster = nextIndex < m_numGlyphs ? infos[nextIndex].cluster : m_numCharacters;
for (unsigned j = infos[index].cluster; j < nextCluster; ++j)
m_logClusters[j] = index;
}
index = nextIndex;
}
}
void
getGlyphPositions(XeTeXLayoutEngine engine, FloatPoint positions[])
{
int glyphCount = hb_buffer_get_length(engine->hbBuffer);
hb_glyph_position_t *hbPositions = hb_buffer_get_glyph_positions(engine->hbBuffer, NULL);
float x = 0, y = 0;
if (engine->font->getLayoutDirVertical()) {
for (int i = 0; i < glyphCount; i++) {
positions[i].x = -engine->font->unitsToPoints(x + hbPositions[i].y_offset); /* negative is forwards */
positions[i].y = engine->font->unitsToPoints(y - hbPositions[i].x_offset);
x += hbPositions[i].y_advance;
y += hbPositions[i].x_advance;
}
positions[glyphCount].x = -engine->font->unitsToPoints(x);
positions[glyphCount].y = engine->font->unitsToPoints(y);
} else {
for (int i = 0; i < glyphCount; i++) {
positions[i].x = engine->font->unitsToPoints(x + hbPositions[i].x_offset);
positions[i].y = -engine->font->unitsToPoints(y + hbPositions[i].y_offset); /* negative is upwards */
x += hbPositions[i].x_advance;
y += hbPositions[i].y_advance;
}
positions[glyphCount].x = engine->font->unitsToPoints(x);
positions[glyphCount].y = -engine->font->unitsToPoints(y);
}
if (engine->extend != 1.0 || engine->slant != 0.0)
for (int i = 0; i <= glyphCount; ++i)
positions[i].x = positions[i].x * engine->extend - positions[i].y * engine->slant;
}
void HarfBuzzShaper::HarfBuzzRun::applyShapeResult(hb_buffer_t* harfBuzzBuffer)
{
m_numGlyphs = hb_buffer_get_length(harfBuzzBuffer);
m_glyphs.resize(m_numGlyphs);
m_advances.resize(m_numGlyphs);
m_glyphToCharacterIndexes.resize(m_numGlyphs);
m_offsets.resize(m_numGlyphs);
}
void
getGlyphs(XeTeXLayoutEngine engine, uint32_t glyphs[])
{
int glyphCount = hb_buffer_get_length(engine->hbBuffer);
hb_glyph_info_t *hbGlyphs = hb_buffer_get_glyph_infos(engine->hbBuffer, NULL);
for (int i = 0; i < glyphCount; i++)
glyphs[i] = hbGlyphs[i].codepoint;
}
void HarfBuzzShaper::HarfBuzzRun::applyShapeResult(hb_buffer_t* harfbuzzBuffer)
{
m_numGlyphs = hb_buffer_get_length(harfbuzzBuffer);
m_glyphs.resize(m_numGlyphs);
m_advances.resize(m_numGlyphs);
m_glyphToCharacterIndexes.resize(m_numGlyphs);
m_offsets.resize(m_numGlyphs);
hb_glyph_info_t* infos = hb_buffer_get_glyph_infos(harfbuzzBuffer, 0);
for (unsigned i = 0; i < m_numGlyphs; ++i)
m_glyphToCharacterIndexes[i] = infos[i].cluster;
}
void
getGlyphAdvances(XeTeXLayoutEngine engine, float advances[])
{
int glyphCount = hb_buffer_get_length(engine->hbBuffer);
hb_glyph_position_t *hbPositions = hb_buffer_get_glyph_positions(engine->hbBuffer, NULL);
for (int i = 0; i < glyphCount; i++) {
if (engine->font->getLayoutDirVertical())
advances[i] = engine->font->unitsToPoints(hbPositions[i].y_advance);
else
advances[i] = engine->font->unitsToPoints(hbPositions[i].x_advance);
}
}
SkScalar SkShaper::shape(SkTextBlobBuilder* builder,
const SkPaint& srcPaint,
const char* utf8text,
size_t textBytes,
SkPoint point) const {
SkPaint paint(srcPaint);
paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
paint.setTypeface(fImpl->fTypeface);
SkASSERT(builder);
hb_buffer_t* buffer = fImpl->fBuffer.get();
hb_buffer_add_utf8(buffer, utf8text, -1, 0, -1);
hb_buffer_guess_segment_properties(buffer);
hb_shape(fImpl->fHarfBuzzFont.get(), buffer, nullptr, 0);
unsigned len = hb_buffer_get_length(buffer);
if (len == 0) {
hb_buffer_clear_contents(buffer);
return 0;
}
hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer, NULL);
hb_glyph_position_t* pos =
hb_buffer_get_glyph_positions(buffer, NULL);
auto runBuffer = builder->allocRunPos(paint, len);
double x = point.x();
double y = point.y();
double textSizeY = paint.getTextSize() / (double)FONT_SIZE_SCALE;
double textSizeX = textSizeY * paint.getTextScaleX();
for (unsigned i = 0; i < len; i++) {
runBuffer.glyphs[i] = info[i].codepoint;
reinterpret_cast<SkPoint*>(runBuffer.pos)[i] =
SkPoint::Make(x + pos[i].x_offset * textSizeX,
y - pos[i].y_offset * textSizeY);
x += pos[i].x_advance * textSizeX;
y += pos[i].y_advance * textSizeY;
}
hb_buffer_clear_contents(buffer);
return (SkScalar)x;
}
// Input: characters, font?
// Output: glyphs, positions, char indices
// Returns: number of glyphs
le_int32 LayoutEngine::layoutChars(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft,
float x, float y, LEErrorCode &success)
{
if (LE_FAILURE(success)) {
return 0;
}
if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
success = LE_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
this->x = x;
this->y = y;
hb_buffer_set_length (fHbBuffer, 0);
hb_buffer_set_direction (fHbBuffer, rightToLeft ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
hb_buffer_add_utf16 (fHbBuffer, chars, max, offset, count);
hb_shape (fHbFont, fHbBuffer, NULL, 0);
return hb_buffer_get_length (fHbBuffer);
}
le_int32 LayoutEngine::getGlyphCount() const
{
return hb_buffer_get_length (fHbBuffer);
}
static void
text_to_glyphs (cairo_t *cr,
const gchar *text,
cairo_glyph_t **glyphs,
int *num_glyphs)
{
PangoAttribute *fallback_attr;
PangoAttrList *attr_list;
PangoContext *context;
PangoDirection base_dir;
GList *items;
GList *visual_items;
FT_Face ft_face;
hb_font_t *hb_font;
gdouble x = 0, y = 0;
gint i;
gdouble x_scale, y_scale;
*num_glyphs = 0;
*glyphs = NULL;
base_dir = pango_find_base_dir (text, -1);
cairo_scaled_font_t *cr_font = cairo_get_scaled_font (cr);
ft_face = cairo_ft_scaled_font_lock_face (cr_font);
hb_font = hb_ft_font_create (ft_face, NULL);
cairo_surface_t *target = cairo_get_target (cr);
cairo_surface_get_device_scale (target, &x_scale, &y_scale);
/* We abuse pango itemazation to split text into script and direction
* runs, since we use our fonts directly no through pango, we don't
* bother changing the default font, but we disable font fallback as
* pango will split runs at font change */
context = pango_cairo_create_context (cr);
attr_list = pango_attr_list_new ();
fallback_attr = pango_attr_fallback_new (FALSE);
pango_attr_list_insert (attr_list, fallback_attr);
items = pango_itemize_with_base_dir (context, base_dir,
text, 0, strlen (text),
attr_list, NULL);
g_object_unref (context);
pango_attr_list_unref (attr_list);
/* reorder the items in the visual order */
visual_items = pango_reorder_items (items);
while (visual_items) {
PangoItem *item;
PangoAnalysis analysis;
hb_buffer_t *hb_buffer;
hb_glyph_info_t *hb_glyphs;
hb_glyph_position_t *hb_positions;
gint n;
item = visual_items->data;
analysis = item->analysis;
hb_buffer = hb_buffer_create ();
hb_buffer_add_utf8 (hb_buffer, text, -1, item->offset, item->length);
hb_buffer_set_script (hb_buffer, hb_glib_script_to_script (analysis.script));
hb_buffer_set_language (hb_buffer, hb_language_from_string (pango_language_to_string (analysis.language), -1));
hb_buffer_set_direction (hb_buffer, analysis.level % 2 ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
hb_shape (hb_font, hb_buffer, NULL, 0);
n = hb_buffer_get_length (hb_buffer);
hb_glyphs = hb_buffer_get_glyph_infos (hb_buffer, NULL);
hb_positions = hb_buffer_get_glyph_positions (hb_buffer, NULL);
*glyphs = g_renew (cairo_glyph_t, *glyphs, *num_glyphs + n);
for (i = 0; i < n; i++) {
(*glyphs)[*num_glyphs + i].index = hb_glyphs[i].codepoint;
(*glyphs)[*num_glyphs + i].x = x + (hb_positions[i].x_offset / (64. * x_scale));
(*glyphs)[*num_glyphs + i].y = y - (hb_positions[i].y_offset / (64. * y_scale));
x += (hb_positions[i].x_advance / (64. * x_scale));
y -= (hb_positions[i].y_advance / (64. * y_scale));
}
*num_glyphs += n;
hb_buffer_destroy (hb_buffer);
visual_items = visual_items->next;
}
g_list_free_full (visual_items, (GDestroyNotify) pango_item_free);
g_list_free_full (items, (GDestroyNotify) pango_item_free);
hb_font_destroy (hb_font);
cairo_ft_scaled_font_unlock_face (cr_font);
}
static void shape_text(text_line & line,
text_itemizer & itemizer,
std::map<unsigned,double> & width_map,
face_manager_freetype & font_manager,
double scale_factor)
{
unsigned start = line.first_char();
unsigned end = line.last_char();
std::size_t length = end - start;
if (!length) return;
std::list<text_item> const& list = itemizer.itemize(start, end);
line.reserve(length);
auto hb_buffer_deleter = [](hb_buffer_t * buffer) { hb_buffer_destroy(buffer);};
const std::unique_ptr<hb_buffer_t, decltype(hb_buffer_deleter)> buffer(hb_buffer_create(),hb_buffer_deleter);
hb_buffer_pre_allocate(buffer.get(), safe_cast<int>(length));
mapnik::value_unicode_string const& text = itemizer.text();
for (auto const& text_item : list)
{
face_set_ptr face_set = font_manager.get_face_set(text_item.format_->face_name, text_item.format_->fontset);
double size = text_item.format_->text_size * scale_factor;
face_set->set_unscaled_character_sizes();
std::size_t num_faces = face_set->size();
std::size_t pos = 0;
font_feature_settings const& ff_settings = text_item.format_->ff_settings;
int ff_count = safe_cast<int>(ff_settings.count());
for (auto const& face : *face_set)
{
++pos;
hb_buffer_clear_contents(buffer.get());
hb_buffer_add_utf16(buffer.get(), uchar_to_utf16(text.getBuffer()), text.length(), text_item.start, static_cast<int>(text_item.end - text_item.start));
hb_buffer_set_direction(buffer.get(), (text_item.dir == UBIDI_RTL)?HB_DIRECTION_RTL:HB_DIRECTION_LTR);
hb_buffer_set_script(buffer.get(), _icu_script_to_script(text_item.script));
hb_font_t *font(hb_ft_font_create(face->get_face(), nullptr));
// https://github.com/mapnik/test-data-visual/pull/25
#if HB_VERSION_MAJOR > 0
#if HB_VERSION_ATLEAST(1, 0 , 5)
hb_ft_font_set_load_flags(font,FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING);
#endif
#endif
hb_shape(font, buffer.get(), ff_settings.get_features(), ff_count);
hb_font_destroy(font);
unsigned num_glyphs = hb_buffer_get_length(buffer.get());
hb_glyph_info_t *glyphs = hb_buffer_get_glyph_infos(buffer.get(), nullptr);
hb_glyph_position_t *positions = hb_buffer_get_glyph_positions(buffer.get(), nullptr);
bool font_has_all_glyphs = true;
// Check if all glyphs are valid.
for (unsigned i=0; i<num_glyphs; ++i)
{
if (!glyphs[i].codepoint)
{
font_has_all_glyphs = false;
break;
}
}
if (!font_has_all_glyphs && (pos < num_faces))
{
//Try next font in fontset
continue;
}
double max_glyph_height = 0;
for (unsigned i=0; i<num_glyphs; ++i)
{
auto const& gpos = positions[i];
auto const& glyph = glyphs[i];
unsigned char_index = glyph.cluster;
glyph_info g(glyph.codepoint,char_index,text_item.format_);
if (face->glyph_dimensions(g))
{
g.face = face;
g.scale_multiplier = size / face->get_face()->units_per_EM;
//Overwrite default advance with better value provided by HarfBuzz
g.unscaled_advance = gpos.x_advance;
g.offset.set(gpos.x_offset * g.scale_multiplier, gpos.y_offset * g.scale_multiplier);
double tmp_height = g.height();
if (tmp_height > max_glyph_height) max_glyph_height = tmp_height;
width_map[char_index] += g.advance();
line.add_glyph(std::move(g), scale_factor);
}
}
line.update_max_char_height(max_glyph_height);
break; //When we reach this point the current font had all glyphs.
}
}
}
LineLayout* VirtualFont::createLineLayout(const TextLine &line, boost::iterator_range<vector<TextRun>::const_iterator> range)
{
auto layout = new LineLayout(this, line.langHint, line.overallDirection);
int averageCount = 0;
map<hb_codepoint_t, Cluster> clusterMap;
auto buffer = hb_buffer_create();
for (auto &run : range)
{
clusterMap.clear();
for (auto &font : getFontSet(run.language))
{
if (font->reload())
{
layout->maxHeight = std::max(layout->maxHeight, font->metrics.height);
layout->maxAscent = std::max(layout->maxAscent, font->metrics.ascent);
layout->maxDescent = std::max(layout->maxDescent, font->metrics.descent);
layout->maxLineThickness = std::max(layout->maxLineThickness, font->metrics.lineThickness);
layout->maxUnderlineOffset = std::max(layout->maxUnderlineOffset, font->metrics.underlineOffset);
layout->averageStrikethroughOffset += font->metrics.strikethroughOffset;
averageCount++;
run.apply(line.text, buffer);
hb_shape(font->hbFont, buffer, nullptr, 0);
auto glyphCount = hb_buffer_get_length(buffer);
auto glyphInfos = hb_buffer_get_glyph_infos(buffer, nullptr);
auto glyphPositions = hb_buffer_get_glyph_positions(buffer, nullptr);
bool hasMissingGlyphs = false;
for (int i = 0; i < glyphCount; i++)
{
auto codepoint = glyphInfos[i].codepoint;
auto cluster = glyphInfos[i].cluster;
auto it = clusterMap.find(cluster);
bool clusterFound = (it != clusterMap.end());
if (codepoint)
{
if (clusterFound && (it->second.font != font))
{
continue; // CLUSTER FOUND, WITH ANOTHER FONT (E.G. SPACE)
}
else
{
auto offset = Vec2f(glyphPositions[i].x_offset, -glyphPositions[i].y_offset) * font->scale;
float advance = glyphPositions[i].x_advance * font->scale.x;
if (!properties.useMipmap)
{
offset.x = snap(offset.x);
offset.y = snap(offset.y);
advance = snap(advance);
}
if (clusterFound)
{
it->second.addShape(codepoint, offset, advance);
}
else
{
clusterMap.insert(make_pair(cluster, Cluster(font, run.tag, codepoint, offset, advance)));
}
}
}
else if (!clusterFound)
{
hasMissingGlyphs = true;
}
}
if (!hasMissingGlyphs)
{
break; // NO NEED TO PROCEED TO THE NEXT FONT IN THE LIST
}
}
}
if (run.direction == HB_DIRECTION_RTL)
{
for (auto it = clusterMap.rbegin(); it != clusterMap.rend(); ++it)
{
layout->addCluster(it->second);
}
}
else
{
for (auto it = clusterMap.begin(); it != clusterMap.end(); ++it)
{
layout->addCluster(it->second);
}
}
}
layout->averageStrikethroughOffset /= averageCount;
hb_buffer_destroy(buffer);
return layout;
}
/* set harfbuzz text buffer */
hb_buffer_add_utf32(
buf,
(const uint32_t *) span->text,
(unsigned int) span->len,
0,
(unsigned int) span->len);
// hb_buffer_guess_segment_properties(buf);
/* run harfbuzz shaper */
hb_shape(hb_font, buf, NULL, 0);
/* get harfbuzz result values */
dword glyph_count = hb_buffer_get_length(buf);
if (glyph_count < 1) {
hb_buffer_destroy(buf);
_libaroma_text_lock(0);
return NULL;
}
hb_glyph_info_t * glyph_info =
hb_buffer_get_glyph_infos(buf, &glyph_count);
hb_glyph_position_t * glyph_pos =
hb_buffer_get_glyph_positions(buf, &glyph_count);
/* prepare return memory */
_LIBAROMA_TEXTSHAPEDP shaped =
(_LIBAROMA_TEXTSHAPEDP) malloc(sizeof(_LIBAROMA_TEXTSHAPED));
shaped->coln = glyph_count;
/**
* raqm_get_glyphs:
* @rq: a #raqm_t.
* @length: (out): output array length.
*
* Gets the final result of Raqm layout process, an array of #raqm_glyph_t
* containing the glyph indices in the font, their positions and other possible
* information.
*
* Return value: (transfer none):
* An array of #raqm_glyph_t, or %NULL in case of error. This is owned by @rq
* and must not be freed.
*
* Since: 0.1
*/
raqm_glyph_t *
raqm_get_glyphs (raqm_t *rq,
size_t *length)
{
size_t count = 0;
if (!rq || !rq->runs || !length)
{
if (length)
*length = 0;
return NULL;
}
for (raqm_run_t *run = rq->runs; run != NULL; run = run->next)
count += hb_buffer_get_length (run->buffer);
*length = count;
if (rq->glyphs)
free (rq->glyphs);
rq->glyphs = malloc (sizeof (raqm_glyph_t) * count);
if (!rq->glyphs)
{
*length = 0;
return NULL;
}
RAQM_TEST ("Glyph information:\n");
count = 0;
for (raqm_run_t *run = rq->runs; run != NULL; run = run->next)
{
size_t len;
hb_glyph_info_t *info;
hb_glyph_position_t *position;
len = hb_buffer_get_length (run->buffer);
info = hb_buffer_get_glyph_infos (run->buffer, NULL);
position = hb_buffer_get_glyph_positions (run->buffer, NULL);
for (size_t i = 0; i < len; i++)
{
rq->glyphs[count + i].index = info[i].codepoint;
rq->glyphs[count + i].cluster = info[i].cluster;
rq->glyphs[count + i].x_advance = position[i].x_advance;
rq->glyphs[count + i].y_advance = position[i].y_advance;
rq->glyphs[count + i].x_offset = position[i].x_offset;
rq->glyphs[count + i].y_offset = position[i].y_offset;
RAQM_TEST ("glyph [%d]\tx_offset: %d\ty_offset: %d\tx_advance: %d\n",
rq->glyphs[count + i].index, rq->glyphs[count + i].x_offset,
rq->glyphs[count + i].y_offset, rq->glyphs[count + i].x_advance);
}
count += len;
}
if (rq->flags & RAQM_FLAG_UTF8)
{
#ifdef RAQM_TESTING
RAQM_TEST ("\nUTF-32 clusters:");
for (size_t i = 0; i < count; i++)
RAQM_TEST (" %02d", rq->glyphs[i].cluster);
RAQM_TEST ("\n");
#endif
for (size_t i = 0; i < count; i++)
rq->glyphs[i].cluster = _raqm_u32_to_u8_index (rq,
rq->glyphs[i].cluster);
#ifdef RAQM_TESTING
RAQM_TEST ("UTF-8 clusters: ");
for (size_t i = 0; i < count; i++)
RAQM_TEST (" %02d", rq->glyphs[i].cluster);
RAQM_TEST ("\n");
#endif
}
return rq->glyphs;
}
}
static void
test_buffer_contents (fixture_t *fixture, gconstpointer user_data)
{
hb_buffer_t *b = fixture->buffer;
unsigned int i, len, len2;
buffer_type_t buffer_type = GPOINTER_TO_INT (user_data);
hb_glyph_info_t *glyphs;
if (buffer_type == BUFFER_EMPTY) {
g_assert_cmpint (hb_buffer_get_length (b), ==, 0);
return;
}
len = hb_buffer_get_length (b);
hb_buffer_get_glyph_infos (b, NULL); /* test NULL */
glyphs = hb_buffer_get_glyph_infos (b, &len2);
g_assert_cmpint (len, ==, len2);
g_assert_cmpint (len, ==, 5);
for (i = 0; i < len; i++) {
g_assert_cmphex (glyphs[i].mask, ==, 0);
g_assert_cmphex (glyphs[i].var1.u32, ==, 0);
g_assert_cmphex (glyphs[i].var2.u32, ==, 0);
}
for (i = 0; i < len; i++) {
unsigned int cluster;
cluster = 1+i;
if (i >= 2) {
void Java_org_iisc_mile_indictext_android_EditIndicText_drawIndicText(
JNIEnv* env, jobject thiz, jstring unicodeText, jint xStart,
jint yBaseLine, jint charHeight, jobject lock) {
FT_Library ft_library;
FT_Face ft_face;
hb_font_t *font;
hb_buffer_t *buffer;
int glyph_count;
hb_glyph_info_t *glyph_info;
hb_glyph_position_t *glyph_pos;
hb_bool_t fail;
FT_UInt glyph_index;
FT_GlyphSlot slot;
FT_Error error;
char* fontFilePath;
jboolean iscopy;
const jchar *text;
int num_chars, i;
int pen_x;
int glyphPosX, glyphPosY;
fontFilePath =
"/sdcard/Android/data/org.iisc.mile.indictext.android/Lohit-Kannada.ttf";
text = (*env)->GetStringChars(env, unicodeText, &iscopy);
num_chars = (*env)->GetStringLength(env, unicodeText);
error = FT_Init_FreeType(&ft_library); /* initialize library */
if (error) {
__android_log_print(6, "drawIndicText",
"Error initializing FreeType library\n");
return;
}
__android_log_print(2, "drawIndicText",
"Successfully initialized FreeType library\n");
error = FT_New_Face(ft_library, fontFilePath, 0, &ft_face); /* create face object */
if (error == FT_Err_Unknown_File_Format) {
__android_log_print(6, "drawIndicText",
"The font file could be opened and read, but it appears that its font format is unsupported");
return;
} else if (error) {
__android_log_print(6, "drawIndicText",
"The font file could not be opened or read, or it might be broken");
return;
}
__android_log_print(2, "drawIndicText",
"Successfully created font-face object\n");
font = hb_ft_font_create(ft_face, NULL);
error = FT_Set_Pixel_Sizes(ft_face, 0, charHeight); /* set character size */
/* error handling omitted */
__android_log_print(2, "drawIndicText",
"Successfully set character size to %d\n", charHeight);
__android_log_print(2, "drawIndicText", "Text being rendered = %s\n", text);
slot = ft_face->glyph;
pen_x = xStart;
/* Create a buffer for harfbuzz to use */
buffer = hb_buffer_create();
//hb_buffer_set_unicode_funcs(buffer, hb_icu_get_unicode_funcs());
//alternatively you can use hb_buffer_set_unicode_funcs(buffer, hb_glib_get_unicode_funcs());
//hb_buffer_set_direction(buffer, HB_DIRECTION_LTR); /* or LTR */
hb_buffer_set_script(buffer, HB_SCRIPT_KANNADA); /* see hb-unicode.h */
//hb_buffer_set_language(buffer, hb_language_from_string("ka"));
/* Layout the text */
hb_buffer_add_utf16(buffer, text, num_chars, 0, num_chars);
__android_log_print(2, "drawIndicText", "Before HarfBuzz shape()\n");
hb_shape(font, buffer, NULL, 0);
__android_log_print(2, "drawIndicText", "After HarfBuzz shape()\n");
glyph_count = hb_buffer_get_length(buffer);
glyph_info = hb_buffer_get_glyph_infos(buffer, 0);
glyph_pos = hb_buffer_get_glyph_positions(buffer, 0);
for (i = 0; i < glyph_count; i++) {
glyph_index = glyph_info[i].codepoint;
__android_log_print(2, "drawIndicText", "Glyph%d = %x", i, glyph_index);
error = FT_Load_Glyph(ft_face, glyph_index, FT_LOAD_DEFAULT);
if (error) {
continue; /* ignore errors */
}
/* convert to an anti-aliased bitmap */
error = FT_Render_Glyph(ft_face->glyph, FT_RENDER_MODE_NORMAL);
if (error) {
continue;
}
/* now, draw to our target surface (convert position) */
draw_bitmap(&slot->bitmap, pen_x + slot->bitmap_left,
yBaseLine - slot->bitmap_top, env, thiz, lock);
//glyphPosX = pen_x + glyph_pos[i].x_offset;
//glyphPosY = yBaseLine - glyph_pos[i].y_offset;
//draw_bitmap(&slot->bitmap, glyphPosX, glyphPosY, env, thiz, lock);
/* increment pen position */
pen_x += slot->advance.x >> 6;
//pen_x += glyph_pos[i].x_advance / 64;
__android_log_print(2, "drawIndicText",
"\tx_offset = %d\ty_offset = %d\tx_advance = %d\ty_advance = %d\n",
glyph_pos[i].x_offset / 64, glyph_pos[i].y_offset / 64,
glyph_pos[i].x_advance / 64, glyph_pos[i].y_advance / 64);
__android_log_print(2, "drawIndicText",
"\tbitmap_left = %d\tbitmap_top = %d\tadvance.x = %d\tadvance.y = %d\n",
slot->bitmap_left, slot->bitmap_top, slot->advance.x >> 6,
slot->advance.y >> 6);
}
hb_buffer_destroy(buffer);
(*env)->ReleaseStringChars(env, unicodeText, text);
hb_font_destroy(font);
FT_Done_Face(ft_face);
FT_Done_FreeType(ft_library);
return;
}
JNIEXPORT jboolean JNICALL Java_sun_font_SunLayoutEngine_shape
(JNIEnv *env, jclass cls,
jobject font2D,
jobject fontStrike,
jfloat ptSize,
jfloatArray matrix,
jlong pFace,
jlong pNativeFont,
jboolean aat,
jcharArray text,
jobject gvdata,
jint script,
jint offset,
jint limit,
jint baseIndex,
jobject startPt,
jint flags,
jint slot) {
hb_buffer_t *buffer;
hb_face_t* hbface;
hb_font_t* hbfont;
jchar *chars;
jsize len;
int glyphCount;
hb_glyph_info_t *glyphInfo;
hb_glyph_position_t *glyphPos;
hb_direction_t direction = HB_DIRECTION_LTR;
hb_feature_t *features = NULL;
int featureCount = 0;
char* kern = (flags & TYPO_KERN) ? "kern" : "-kern";
char* liga = (flags & TYPO_LIGA) ? "liga" : "-liga";
jboolean ret;
unsigned int buflen;
JDKFontInfo *jdkFontInfo =
createJDKFontInfo(env, font2D, fontStrike, ptSize,
pNativeFont, matrix, aat);
if (!jdkFontInfo) {
return JNI_FALSE;
}
jdkFontInfo->env = env; // this is valid only for the life of this JNI call.
jdkFontInfo->font2D = font2D;
jdkFontInfo->fontStrike = fontStrike;
hbface = (hb_face_t*) jlong_to_ptr(pFace);
hbfont = hb_jdk_font_create(hbface, jdkFontInfo, NULL);
buffer = hb_buffer_create();
hb_buffer_set_script(buffer, getHBScriptCode(script));
hb_buffer_set_language(buffer,
hb_ot_tag_to_language(HB_OT_TAG_DEFAULT_LANGUAGE));
if ((flags & TYPO_RTL) != 0) {
direction = HB_DIRECTION_RTL;
}
hb_buffer_set_direction(buffer, direction);
hb_buffer_set_cluster_level(buffer,
HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS);
chars = (*env)->GetCharArrayElements(env, text, NULL);
if ((*env)->ExceptionCheck(env)) {
hb_buffer_destroy(buffer);
hb_font_destroy(hbfont);
free((void*)jdkFontInfo);
return JNI_FALSE;
}
len = (*env)->GetArrayLength(env, text);
hb_buffer_add_utf16(buffer, chars, len, offset, limit-offset);
features = calloc(2, sizeof(hb_feature_t));
if (features) {
hb_feature_from_string(kern, -1, &features[featureCount++]);
hb_feature_from_string(liga, -1, &features[featureCount++]);
}
hb_shape_full(hbfont, buffer, features, featureCount, 0);
glyphCount = hb_buffer_get_length(buffer);
glyphInfo = hb_buffer_get_glyph_infos(buffer, 0);
glyphPos = hb_buffer_get_glyph_positions(buffer, &buflen);
ret = storeGVData(env, gvdata, slot, baseIndex, offset, startPt,
limit - offset, glyphCount, glyphInfo, glyphPos,
jdkFontInfo->devScale);
hb_buffer_destroy (buffer);
hb_font_destroy(hbfont);
free((void*)jdkFontInfo);
if (features != NULL) free(features);
(*env)->ReleaseCharArrayElements(env, text, chars, JNI_ABORT);
return ret;
}
const char*
af_shaper_get_cluster( const char* p,
AF_StyleMetrics metrics,
void* buf_,
unsigned int* count )
{
AF_StyleClass style_class;
const hb_feature_t* feature;
FT_Int upem;
const char* q;
int len;
hb_buffer_t* buf = (hb_buffer_t*)buf_;
hb_font_t* font;
hb_codepoint_t dummy;
upem = (FT_Int)metrics->globals->face->units_per_EM;
style_class = metrics->style_class;
feature = features[style_class->coverage];
font = metrics->globals->hb_font;
/* we shape at a size of units per EM; this means font units */
hb_font_set_scale( font, upem, upem );
while ( *p == ' ' )
p++;
/* count bytes up to next space (or end of buffer) */
q = p;
while ( !( *q == ' ' || *q == '\0' ) )
GET_UTF8_CHAR( dummy, q );
len = (int)( q - p );
/* feed character(s) to the HarfBuzz buffer */
hb_buffer_clear_contents( buf );
hb_buffer_add_utf8( buf, p, len, 0, len );
/* we let HarfBuzz guess the script and writing direction */
hb_buffer_guess_segment_properties( buf );
/* shape buffer, which means conversion from character codes to */
/* glyph indices, possibly applying a feature */
hb_shape( font, buf, feature, feature ? 1 : 0 );
if ( feature )
{
hb_buffer_t* hb_buf = metrics->globals->hb_buf;
unsigned int gcount;
hb_glyph_info_t* ginfo;
unsigned int hb_gcount;
hb_glyph_info_t* hb_ginfo;
/* we have to check whether applying a feature does actually change */
/* glyph indices; otherwise the affected glyph or glyphs aren't */
/* available at all in the feature */
hb_buffer_clear_contents( hb_buf );
hb_buffer_add_utf8( hb_buf, p, len, 0, len );
hb_buffer_guess_segment_properties( hb_buf );
hb_shape( font, hb_buf, NULL, 0 );
ginfo = hb_buffer_get_glyph_infos( buf, &gcount );
hb_ginfo = hb_buffer_get_glyph_infos( hb_buf, &hb_gcount );
if ( gcount == hb_gcount )
{
unsigned int i;
for (i = 0; i < gcount; i++ )
if ( ginfo[i].codepoint != hb_ginfo[i].codepoint )
break;
if ( i == gcount )
{
/* both buffers have identical glyph indices */
hb_buffer_clear_contents( buf );
}
}
}
*count = hb_buffer_get_length( buf );
#ifdef FT_DEBUG_LEVEL_TRACE
if ( feature && *count > 1 )
FT_TRACE1(( "af_shaper_get_cluster:"
" input character mapped to multiple glyphs\n" ));
#endif
return q;
}
int main (int argc, char** argv)
{
if (argc != 2)
{
std::cerr << "Usage: " << argv[0] << " <num-iter>" << std::endl;
return EXIT_FAILURE;
}
const unsigned NUM_ITER = atoi(argv[1]);
// open first face in the font
FT_Library ft_library = 0;
FT_Error error = FT_Init_FreeType(&ft_library);
if (error) throw std::runtime_error("Failed to initialize FreeType2 library");
FT_Face ft_face[NUM_EXAMPLES];
FT_New_Face(ft_library, "fonts/DejaVuSerif.ttf", 0, &ft_face[ENGLISH]);
FT_New_Face(ft_library, "fonts/amiri-0.104/amiri-regular.ttf", 0, &ft_face[ARABIC]);
FT_New_Face(ft_library, "fonts/fireflysung-1.3.0/fireflysung.ttf", 0, &ft_face[CHINESE]);
// Get our harfbuzz font structs
hb_font_t *hb_ft_font[NUM_EXAMPLES];
hb_ft_font[ENGLISH] = hb_ft_font_create(ft_face[ENGLISH], NULL);
hb_ft_font[ARABIC] = hb_ft_font_create(ft_face[ARABIC] , NULL);
hb_ft_font[CHINESE] = hb_ft_font_create(ft_face[CHINESE], NULL);
{
std::cerr << "Starting ICU shaping:" << std::endl;
progress_timer timer1(std::clog,"ICU shaping done");
UErrorCode err = U_ZERO_ERROR;
for (unsigned i = 0; i < NUM_ITER; ++i)
{
for (unsigned j = 0; j < NUM_EXAMPLES; ++j)
{
UnicodeString text = UnicodeString::fromUTF8(texts[j]);
int32_t length = text.length();
UnicodeString reordered;
UnicodeString shaped;
UBiDi *bidi = ubidi_openSized(length, 0, &err);
ubidi_setPara(bidi, text.getBuffer(), length, UBIDI_DEFAULT_LTR, 0, &err);
ubidi_writeReordered(bidi, reordered.getBuffer(length),
length, UBIDI_DO_MIRRORING, &err);
ubidi_close(bidi);
reordered.releaseBuffer(length);
u_shapeArabic(reordered.getBuffer(), length,
shaped.getBuffer(length), length,
U_SHAPE_LETTERS_SHAPE | U_SHAPE_LENGTH_FIXED_SPACES_NEAR |
U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, &err);
shaped.releaseBuffer(length);
if (U_SUCCESS(err))
{
U_NAMESPACE_QUALIFIER StringCharacterIterator iter(shaped);
for (iter.setToStart(); iter.hasNext();)
{
UChar ch = iter.nextPostInc();
int32_t glyph_index = FT_Get_Char_Index(ft_face[j], ch);
if (i == 0)
{
std::cerr << glyph_index << ":";
}
}
if (i == 0) std::cerr << std::endl;
}
}
}
}
{
const char **shaper_list = hb_shape_list_shapers();
for ( ;*shaper_list; shaper_list++)
{
std::cerr << *shaper_list << std::endl;
}
std::cerr << "Starting Harfbuzz shaping" << std::endl;
progress_timer timer2(std::clog,"Harfbuzz shaping done");
const char* const shapers[] = { /*"ot",*/"fallback" };
hb_buffer_t *buffer(hb_buffer_create());
for (unsigned i = 0; i < NUM_ITER; ++i)
{
for (unsigned j = 0; j < NUM_EXAMPLES; ++j)
{
UnicodeString text = UnicodeString::fromUTF8(texts[j]);
int32_t length = text.length();
hb_buffer_clear_contents(buffer);
//hb_buffer_set_unicode_funcs(buffer.get(), hb_icu_get_unicode_funcs());
hb_buffer_pre_allocate(buffer, length);
hb_buffer_add_utf16(buffer, text.getBuffer(), text.length(), 0, length);
hb_buffer_set_direction(buffer, text_directions[j]);
hb_buffer_set_script(buffer, scripts[j]);
hb_buffer_set_language(buffer,hb_language_from_string(languages[j], std::strlen(languages[j])));
//hb_shape(hb_ft_font[j], buffer.get(), 0, 0);
hb_shape_full(hb_ft_font[j], buffer, 0, 0, shapers);
unsigned num_glyphs = hb_buffer_get_length(buffer);
hb_glyph_info_t *glyphs = hb_buffer_get_glyph_infos(buffer, NULL);
//hb_glyph_position_t *positions = hb_buffer_get_glyph_positions(buffer.get(), NULL);
for (unsigned k=0; k<num_glyphs; ++k)
{
int32_t glyph_index = glyphs[k].codepoint;
if (i == 0)
{
std::cerr << glyph_index << ":";
}
}
if (i == 0) std::cerr << std::endl;
}
}
hb_buffer_destroy(buffer);
}
// cleanup
for (int j=0; j < NUM_EXAMPLES; ++j)
{
hb_font_destroy(hb_ft_font[j]);
}
FT_Done_FreeType(ft_library);
return EXIT_SUCCESS;
}
void drawIndicText(JNIEnv *env, jobject thiz, jstring unicodeText, jint xStart,
jint yBaseLine, jint charHeight, jobject lock, jstring fontPath, jint language) {
FT_Library ft_library;
FT_Face ft_face;
hb_font_t *font;
hb_buffer_t *buffer;
int glyph_count;
hb_glyph_info_t *glyph_info;
hb_glyph_position_t *glyph_pos;
hb_bool_t fail;
FT_UInt glyph_index;
FT_GlyphSlot slot;
FT_Error error;
jboolean iscopy;
const jchar *text;
int num_chars, i;
int pen_x;
int glyphPosX, glyphPosY;
const char *fontFilePath = (*env)->GetStringUTFChars(env, fontPath, NULL);
text = (*env)->GetStringChars(env, unicodeText, &iscopy);
num_chars = (*env)->GetStringLength(env, unicodeText);
/* initialize library */
error = FT_Init_FreeType(&ft_library);
if (error) {
__android_log_print(6, "drawIndicText",
"Error initializing FreeType library\n");
return;
}
// __android_log_print(2, "drawIndicText",
// "Successfully initialized FreeType library\n");
error = FT_New_Face(ft_library, fontFilePath, 0, &ft_face); /* create face object */
if (error == FT_Err_Unknown_File_Format) {
__android_log_print(6, "drawIndicText",
"The font file could be opened and read, but it appears that its font format is unsupported %s ",
fontFilePath);
return;
} else if (error) {
__android_log_print(6, "drawIndicText",
"The font file could not be opened or read, or it might be broken");
return;
}
// __android_log_print(2, "drawIndicText",
// "Successfully created font-face object\n");
font = hb_ft_font_create(ft_face, NULL);
error = FT_Set_Pixel_Sizes(ft_face, 0, charHeight); /* set character size */
slot = ft_face->glyph;
pen_x = xStart;
/* Create a buffer for harfbuzz to use */
buffer = hb_buffer_create();
hb_buffer_set_script(buffer, scripts[language]);
/* Layout the text */
hb_buffer_add_utf16(buffer, text, num_chars, 0, num_chars);
// __android_log_print(2, "drawIndicText", "Before HarfBuzz shape()\n");
hb_shape(font, buffer, NULL, 0);
// __android_log_print(2, "drawIndicText", "After HarfBuzz shape()\n");
glyph_count = hb_buffer_get_length(buffer);
glyph_info = hb_buffer_get_glyph_infos(buffer, 0);
glyph_pos = hb_buffer_get_glyph_positions(buffer, 0);
for (i = 0; i < glyph_count; i++) {
glyph_index = glyph_info[i].codepoint;
// __android_log_print(2, "drawIndicText", "Glyph%d = %x", i, glyph_index);
error = FT_Load_Glyph(ft_face, glyph_index, FT_LOAD_DEFAULT);
if (error) {
/* ignore errors */
continue;
}
/* convert to an anti-aliased bitmap */
error = FT_Render_Glyph(ft_face->glyph, FT_RENDER_MODE_NORMAL);
if (error) {
continue;
}
/* now, draw to our target surface (convert position) */
draw_bitmap(&slot->bitmap, pen_x + slot->bitmap_left,
yBaseLine - slot->bitmap_top, env, thiz, lock);
/* increment pen position */
pen_x += slot->advance.x >> 6;
}
hb_buffer_destroy(buffer);
(*env)->ReleaseStringChars(env, unicodeText, text);
(*env)->ReleaseStringUTFChars(env, fontPath, fontFilePath);
hb_font_destroy(font);
FT_Done_Face(ft_face);
FT_Done_FreeType(ft_library);
return;
}
bool HarfBuzzShaper::extractShapeResults(hb_buffer_t* harfBuzzBuffer,
ShapeResult* shapeResult,
bool& fontCycleQueued, const HolesQueueItem& currentQueueItem,
const SimpleFontData* currentFont,
UScriptCode currentRunScript,
bool isLastResort)
{
enum ClusterResult {
Shaped,
NotDef,
Unknown
};
ClusterResult currentClusterResult = Unknown;
ClusterResult previousClusterResult = Unknown;
unsigned previousCluster = 0;
unsigned currentCluster = 0;
// Find first notdef glyph in harfBuzzBuffer.
unsigned numGlyphs = hb_buffer_get_length(harfBuzzBuffer);
hb_glyph_info_t* glyphInfo = hb_buffer_get_glyph_infos(harfBuzzBuffer, 0);
unsigned lastChangePosition = 0;
if (!numGlyphs) {
DLOG(ERROR) << "HarfBuzz returned empty glyph buffer after shaping.";
return false;
}
for (unsigned glyphIndex = 0; glyphIndex <= numGlyphs; ++glyphIndex) {
// Iterating by clusters, check for when the state switches from shaped
// to non-shaped and vice versa. Taking into account the edge cases of
// beginning of the run and end of the run.
previousCluster = currentCluster;
currentCluster = glyphInfo[glyphIndex].cluster;
if (glyphIndex < numGlyphs) {
// Still the same cluster, merge shaping status.
if (previousCluster == currentCluster && glyphIndex != 0) {
if (glyphInfo[glyphIndex].codepoint == 0) {
currentClusterResult = NotDef;
} else {
// We can only call the current cluster fully shapped, if
// all characters that are part of it are shaped, so update
// currentClusterResult to Shaped only if the previous
// characters have been shaped, too.
currentClusterResult = currentClusterResult == Shaped ? Shaped : NotDef;
}
continue;
}
// We've moved to a new cluster.
previousClusterResult = currentClusterResult;
currentClusterResult = glyphInfo[glyphIndex].codepoint == 0 ? NotDef : Shaped;
} else {
// The code below operates on the "flanks"/changes between NotDef
// and Shaped. In order to keep the code below from explictly
// dealing with character indices and run end, we explicitly
// terminate the cluster/run here by setting the result value to the
// opposite of what it was, leading to atChange turning true.
previousClusterResult = currentClusterResult;
currentClusterResult = currentClusterResult == NotDef ? Shaped : NotDef;
}
bool atChange = (previousClusterResult != currentClusterResult) && previousClusterResult != Unknown;
if (!atChange)
continue;
// Compute the range indices of consecutive shaped or .notdef glyphs.
// Cluster information for RTL runs becomes reversed, e.g. character 0
// has cluster index 5 in a run of 6 characters.
unsigned numCharacters = 0;
unsigned numGlyphsToInsert = 0;
unsigned startIndex = 0;
if (HB_DIRECTION_IS_FORWARD(hb_buffer_get_direction(harfBuzzBuffer))) {
startIndex = glyphInfo[lastChangePosition].cluster;
if (glyphIndex == numGlyphs) {
numCharacters = currentQueueItem.m_startIndex + currentQueueItem.m_numCharacters - glyphInfo[lastChangePosition].cluster;
numGlyphsToInsert = numGlyphs - lastChangePosition;
} else {
numCharacters = glyphInfo[glyphIndex].cluster - glyphInfo[lastChangePosition].cluster;
numGlyphsToInsert = glyphIndex - lastChangePosition;
}
} else {
// Direction Backwards
startIndex = glyphInfo[glyphIndex - 1].cluster;
if (lastChangePosition == 0) {
numCharacters = currentQueueItem.m_startIndex + currentQueueItem.m_numCharacters - glyphInfo[glyphIndex - 1].cluster;
} else {
numCharacters = glyphInfo[lastChangePosition - 1].cluster - glyphInfo[glyphIndex - 1].cluster;
}
numGlyphsToInsert = glyphIndex - lastChangePosition;
}
if (currentClusterResult == Shaped && !isLastResort) {
// Now it's clear that we need to continue processing.
if (!fontCycleQueued) {
appendToHolesQueue(HolesQueueNextFont, 0, 0);
fontCycleQueued = true;
}
// Here we need to put character positions.
ASSERT(numCharacters);
appendToHolesQueue(HolesQueueRange, startIndex, numCharacters);
}
// If numCharacters is 0, that means we hit a NotDef before shaping the
// whole grapheme. We do not append it here. For the next glyph we
// encounter, atChange will be true, and the characters corresponding to
// the grapheme will be added to the TODO queue again, attempting to
// shape the whole grapheme with the next font.
// When we're getting here with the last resort font, we have no other
// choice than adding boxes to the ShapeResult.
if ((currentClusterResult == NotDef && numCharacters) || isLastResort) {
hb_direction_t direction = TextDirectionToHBDirection(
m_textRun.direction(),
m_font->getFontDescription().orientation(), currentFont);
// Here we need to specify glyph positions.
ShapeResult::RunInfo* run = new ShapeResult::RunInfo(currentFont,
direction, ICUScriptToHBScript(currentRunScript),
startIndex, numGlyphsToInsert, numCharacters);
shapeResult->insertRun(adoptPtr(run), lastChangePosition,
numGlyphsToInsert,
harfBuzzBuffer);
}
lastChangePosition = glyphIndex;
}
return true;
}
int
layoutChars(XeTeXLayoutEngine engine, uint16_t chars[], int32_t offset, int32_t count, int32_t max,
bool rightToLeft)
{
bool res;
hb_script_t script = HB_SCRIPT_INVALID;
hb_direction_t direction = HB_DIRECTION_LTR;
hb_segment_properties_t segment_props;
hb_shape_plan_t *shape_plan;
hb_font_t* hbFont = engine->font->getHbFont();
hb_face_t* hbFace = hb_font_get_face(hbFont);
if (engine->font->getLayoutDirVertical())
direction = HB_DIRECTION_TTB;
else if (rightToLeft)
direction = HB_DIRECTION_RTL;
script = hb_ot_tag_to_script (engine->script);
if (hbUnicodeFuncs == NULL)
hbUnicodeFuncs = _get_unicode_funcs();
hb_buffer_reset(engine->hbBuffer);
hb_buffer_set_unicode_funcs(engine->hbBuffer, hbUnicodeFuncs);
hb_buffer_add_utf16(engine->hbBuffer, chars, max, offset, count);
hb_buffer_set_direction(engine->hbBuffer, direction);
hb_buffer_set_script(engine->hbBuffer, script);
hb_buffer_set_language(engine->hbBuffer, engine->language);
hb_buffer_guess_segment_properties(engine->hbBuffer);
hb_buffer_get_segment_properties(engine->hbBuffer, &segment_props);
if (engine->ShaperList == NULL) {
// HarfBuzz gives graphite2 shaper a priority, so that for hybrid
// Graphite/OpenType fonts, Graphite will be used. However, pre-0.9999
// XeTeX preferred OpenType over Graphite, so we are doing the same
// here for sake of backward compatibility.
engine->ShaperList = (char**) xcalloc(4, sizeof(char*));
engine->ShaperList[0] = (char*) "ot";
engine->ShaperList[1] = (char*) "graphite2";
engine->ShaperList[2] = (char*) "fallback";
engine->ShaperList[3] = NULL;
}
shape_plan = hb_shape_plan_create_cached(hbFace, &segment_props, engine->features, engine->nFeatures, engine->ShaperList);
res = hb_shape_plan_execute(shape_plan, hbFont, engine->hbBuffer, engine->features, engine->nFeatures);
if (res) {
engine->shaper = strdup(hb_shape_plan_get_shaper(shape_plan));
hb_buffer_set_content_type(engine->hbBuffer, HB_BUFFER_CONTENT_TYPE_GLYPHS);
} else {
// all selected shapers failed, retrying with default
// we don't use _cached here as the cached plain will always fail.
hb_shape_plan_destroy(shape_plan);
shape_plan = hb_shape_plan_create(hbFace, &segment_props, engine->features, engine->nFeatures, NULL);
res = hb_shape_plan_execute(shape_plan, hbFont, engine->hbBuffer, engine->features, engine->nFeatures);
if (res) {
engine->shaper = strdup(hb_shape_plan_get_shaper(shape_plan));
hb_buffer_set_content_type(engine->hbBuffer, HB_BUFFER_CONTENT_TYPE_GLYPHS);
} else {
fprintf(stderr, "\nERROR: all shapers failed\n");
exit(3);
}
}
hb_shape_plan_destroy(shape_plan);
int glyphCount = hb_buffer_get_length(engine->hbBuffer);
#ifdef DEBUG
char buf[1024];
unsigned int consumed;
printf ("shaper: %s\n", engine->shaper);
hb_buffer_serialize_flags_t flags = HB_BUFFER_SERIALIZE_FLAGS_DEFAULT;
hb_buffer_serialize_format_t format = HB_BUFFER_SERIALIZE_FORMAT_JSON;
hb_buffer_serialize_glyphs (engine->hbBuffer, 0, glyphCount, buf, sizeof(buf), &consumed, hbFont, format, flags);
if (consumed)
printf ("buffer glyphs: %s\n", buf);
#endif
return glyphCount;
}
