From 623f059b0756d70bc517d9aa5ca55df27415da01 Mon Sep 17 00:00:00 2001 From: Nikolay Sivov Date: Fri, 1 Feb 2019 13:48:09 +0300 Subject: [PATCH] dwrite: Implement single adjustment, GPOS lookup 1. Signed-off-by: Nikolay Sivov Signed-off-by: Alexandre Julliard --- dlls/dwrite/analyzer.c | 4 + dlls/dwrite/dwrite_private.h | 2 + dlls/dwrite/opentype.c | 305 +++++++++++++++++++++++++++++++++++ 3 files changed, 311 insertions(+) diff --git a/dlls/dwrite/analyzer.c b/dlls/dwrite/analyzer.c index 7f15c912790..1fc8f98d16c 100644 --- a/dlls/dwrite/analyzer.c +++ b/dlls/dwrite/analyzer.c @@ -1316,7 +1316,9 @@ static HRESULT WINAPI dwritetextanalyzer_GetGlyphPlacements(IDWriteTextAnalyzer2 context.u.pos.glyphs = glyphs; context.u.pos.glyph_props = glyph_props; context.glyph_count = glyph_count; + context.emsize = emSize; context.advances = advances; + context.offsets = offsets; context.language_tag = get_opentype_language(locale); hr = shape_get_positions(&context, scriptprops->scripttags, scriptprops->ops->gpos_features); @@ -1378,7 +1380,9 @@ static HRESULT WINAPI dwritetextanalyzer_GetGdiCompatibleGlyphPlacements(IDWrite context.u.pos.glyphs = glyphs; context.u.pos.glyph_props = glyph_props; context.glyph_count = glyph_count; + context.emsize = emSize * ppdip; context.advances = advances; + context.offsets = offsets; context.language_tag = get_opentype_language(locale); hr = shape_get_positions(&context, scriptprops->scripttags, scriptprops->ops->gpos_features); diff --git a/dlls/dwrite/dwrite_private.h b/dlls/dwrite/dwrite_private.h index 5a6cd4b16b5..355a8265634 100644 --- a/dlls/dwrite/dwrite_private.h +++ b/dlls/dwrite/dwrite_private.h @@ -393,7 +393,9 @@ struct scriptshaping_context } u; unsigned int glyph_count; + float emsize; float *advances; + DWRITE_GLYPH_OFFSET *offsets; }; struct shaping_font_ops diff --git a/dlls/dwrite/opentype.c b/dlls/dwrite/opentype.c index 8cc74638b00..8cc45e4c108 100644 --- a/dlls/dwrite/opentype.c +++ b/dlls/dwrite/opentype.c @@ -489,6 +489,18 @@ enum gpos_lookup_type GPOS_LOOKUP_EXTENSION_POSITION = 9, }; +enum gpos_value_format +{ + GPOS_VALUE_X_PLACEMENT = 0x1, + GPOS_VALUE_Y_PLACEMENT = 0x2, + GPOS_VALUE_X_ADVANCE = 0x4, + GPOS_VALUE_Y_ADVANCE = 0x8, + GPOS_VALUE_X_PLACEMENT_DEVICE = 0x10, + GPOS_VALUE_Y_PLACEMENT_DEVICE = 0x20, + GPOS_VALUE_X_ADVANCE_DEVICE = 0x40, + GPOS_VALUE_Y_ADVANCE_DEVICE = 0x80, +}; + enum OPENTYPE_PLATFORM_ID { OPENTYPE_PLATFORM_UNICODE = 0, @@ -526,6 +538,54 @@ struct ot_lookup_table WORD subtable[1]; }; +#define GLYPH_NOT_COVERED ((unsigned int)~0u) + +struct ot_coverage_format1 +{ + WORD format; + WORD glyph_count; + WORD glyphs[1]; +}; + +struct ot_coverage_range +{ + WORD start_glyph; + WORD end_glyph; + WORD startcoverage_index; +}; + +struct ot_coverage_format2 +{ + WORD format; + WORD range_count; + struct ot_coverage_range ranges[1]; +}; + +struct ot_gpos_device_table +{ + WORD start_size; + WORD end_size; + WORD format; + WORD values[1]; +}; + +struct ot_gpos_singlepos_format1 +{ + WORD format; + WORD coverage; + WORD value_format; + WORD value[1]; +}; + +struct ot_gpos_singlepos_format2 +{ + WORD format; + WORD coverage; + WORD value_format; + WORD value_count; + WORD values[1]; +}; + typedef struct { WORD SubstFormat; WORD Coverage; @@ -2635,6 +2695,201 @@ static unsigned int opentype_layout_get_glyph_class(const struct dwrite_fonttabl return glyph_class; } +struct coverage_compare_format1_context +{ + UINT16 glyph; + const UINT16 *table_base; + unsigned int *coverage_index; +}; + +static int coverage_compare_format1(const void *left, const void *right) +{ + const struct coverage_compare_format1_context *context = left; + UINT16 glyph = GET_BE_WORD(*(UINT16 *)right); + int ret; + + ret = context->glyph - glyph; + if (!ret) + *context->coverage_index = (UINT16 *)right - context->table_base; + + return ret; +} + +static int coverage_compare_format2(const void *g, const void *r) +{ + const struct ot_coverage_range *range = r; + UINT16 glyph = *(UINT16 *)g; + + if (glyph < GET_BE_WORD(range->start_glyph)) + return -1; + else if (glyph > GET_BE_WORD(range->end_glyph)) + return 1; + else + return 0; +} + +static unsigned int opentype_layout_is_glyph_covered(const struct dwrite_fonttable *table, DWORD coverage, + UINT16 glyph) +{ + WORD format = table_read_be_word(table, coverage), count; + + count = table_read_be_word(table, coverage + 2); + + if (format == 1) + { + const struct ot_coverage_format1 *format1 = table_read_ensure(table, coverage, + FIELD_OFFSET(struct ot_coverage_format1, glyphs[count])); + struct coverage_compare_format1_context context; + unsigned int coverage_index = GLYPH_NOT_COVERED; + + if (format1) + { + context.glyph = glyph; + context.table_base = format1->glyphs; + context.coverage_index = &coverage_index; + + bsearch(&context, format1->glyphs, count, sizeof(glyph), coverage_compare_format1); + } + + return coverage_index; + } + else if (format == 2) + { + const struct ot_coverage_format2 *format2 = table_read_ensure(table, coverage, + FIELD_OFFSET(struct ot_coverage_format2, ranges[count])); + if (format2) + { + const struct ot_coverage_range *range = bsearch(&glyph, format2->ranges, count, + sizeof(struct ot_coverage_range), coverage_compare_format2); + return range && glyph <= GET_BE_WORD(range->end_glyph) ? + GET_BE_WORD(range->startcoverage_index) + glyph - GET_BE_WORD(range->start_glyph) : + GLYPH_NOT_COVERED; + } + } + else + WARN("Unknown coverage format %u.\n", format); + + return -1; +} + +static inline unsigned int dwrite_popcount(unsigned int x) +{ +#ifdef HAVE___BUILTIN_POPCOUNT + return __builtin_popcount(x); +#else + x -= x >> 1 & 0x55555555; + x = (x & 0x33333333) + (x >> 2 & 0x33333333); + return ((x + (x >> 4)) & 0x0f0f0f0f) * 0x01010101 >> 24; +#endif +} + +static float opentype_scale_gpos_be_value(WORD value, float emsize, UINT16 upem) +{ + return (short)GET_BE_WORD(value) * emsize / upem; +} + +static int opentype_layout_gpos_get_dev_value(const struct scriptshaping_context *context, unsigned int offset) +{ + const struct scriptshaping_cache *cache = context->cache; + unsigned int start_size, end_size, format, value_word; + unsigned int index, ppem, mask; + int value; + + if (!offset) + return 0; + + start_size = table_read_be_word(&cache->gpos.table, offset); + end_size = table_read_be_word(&cache->gpos.table, offset + FIELD_OFFSET(struct ot_gpos_device_table, end_size)); + + ppem = context->emsize; + if (ppem < start_size || ppem > end_size) + return 0; + + format = table_read_be_word(&cache->gpos.table, offset + FIELD_OFFSET(struct ot_gpos_device_table, format)); + + if (format < 1 || format > 3) + return 0; + + index = ppem - start_size; + + value_word = table_read_be_word(&cache->gpos.table, offset + + FIELD_OFFSET(struct ot_gpos_device_table, values[index >> (4 - format)])); + mask = 0xffff >> (16 - (1 << format)); + + value = (value_word >> ((index % (4 - format)) * (1 << format))) & mask; + + if ((unsigned int)value >= ((mask + 1) >> 1)) + value -= mask + 1; + + return value; +} + +static void opentype_layout_apply_gpos_value(struct scriptshaping_context *context, unsigned int table_offset, + WORD value_format, const WORD *values, unsigned int glyph) +{ + const struct scriptshaping_cache *cache = context->cache; + DWRITE_GLYPH_OFFSET *offset = &context->offsets[glyph]; + float *advance = &context->advances[glyph]; + + if (!value_format) + return; + + if (value_format & GPOS_VALUE_X_PLACEMENT) + { + offset->advanceOffset += opentype_scale_gpos_be_value(*values, context->emsize, cache->upem); + values++; + } + if (value_format & GPOS_VALUE_Y_PLACEMENT) + { + offset->ascenderOffset += opentype_scale_gpos_be_value(*values, context->emsize, cache->upem); + values++; + } + if (value_format & GPOS_VALUE_X_ADVANCE) + { + *advance += opentype_scale_gpos_be_value(*values, context->emsize, cache->upem); + values++; + } + if (value_format & GPOS_VALUE_Y_ADVANCE) + { + values++; + } + if (value_format & GPOS_VALUE_X_PLACEMENT_DEVICE) + { + offset->advanceOffset += opentype_layout_gpos_get_dev_value(context, table_offset + GET_BE_WORD(*values)); + values++; + } + if (value_format & GPOS_VALUE_Y_PLACEMENT_DEVICE) + { + offset->ascenderOffset += opentype_layout_gpos_get_dev_value(context, table_offset + GET_BE_WORD(*values)); + values++; + } + if (value_format & GPOS_VALUE_X_ADVANCE_DEVICE) + { + *advance += opentype_layout_gpos_get_dev_value(context, table_offset + GET_BE_WORD(*values)); + values++; + } + if (value_format & GPOS_VALUE_Y_ADVANCE_DEVICE) + { + values++; + } +} + +static unsigned int opentype_layout_get_gpos_subtable(const struct scriptshaping_cache *cache, + unsigned int lookup_offset, unsigned int subtable) +{ + WORD lookup_type = table_read_be_word(&cache->gpos.table, lookup_offset); + unsigned int subtable_offset = table_read_be_word(&cache->gpos.table, lookup_offset + + FIELD_OFFSET(struct ot_lookup_table, subtable[subtable])); + if (lookup_type == GPOS_LOOKUP_EXTENSION_POSITION) + { + const struct ot_gpos_extensionpos_format1 *format1 = table_read_ensure(&cache->gpos.table, + lookup_offset + subtable_offset, sizeof(*format1)); + subtable_offset += GET_BE_DWORD(format1->extension_offset); + } + + return lookup_offset + subtable_offset; +} + struct lookup { unsigned int offset; @@ -2677,6 +2932,56 @@ static BOOL glyph_iterator_match(const struct glyph_iterator *iter) static BOOL opentype_layout_apply_gpos_single_adjustment(struct scriptshaping_context *context, struct glyph_iterator *iter, const struct lookup *lookup) { + struct scriptshaping_cache *cache = context->cache; + WORD format, value_format, value_len, coverage; + unsigned int i; + + for (i = 0; i < lookup->subtable_count; ++i) + { + unsigned int subtable_offset = opentype_layout_get_gpos_subtable(cache, lookup->offset, i); + unsigned int coverage_index; + + format = table_read_be_word(&cache->gpos.table, subtable_offset); + + coverage = table_read_be_word(&cache->gpos.table, subtable_offset + + FIELD_OFFSET(struct ot_gpos_singlepos_format1, coverage)); + value_format = table_read_be_word(&cache->gpos.table, subtable_offset + + FIELD_OFFSET(struct ot_gpos_singlepos_format1, value_format)); + value_len = dwrite_popcount(value_format); + + if (format == 1) + { + const struct ot_gpos_singlepos_format1 *format1 = table_read_ensure(&cache->gpos.table, subtable_offset, + FIELD_OFFSET(struct ot_gpos_singlepos_format1, value[value_len])); + + coverage_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset + coverage, + context->u.pos.glyphs[iter->pos]); + if (coverage_index == GLYPH_NOT_COVERED) + continue; + + opentype_layout_apply_gpos_value(context, subtable_offset, value_format, format1->value, iter->pos); + break; + } + else if (format == 2) + { + WORD value_count = table_read_be_word(&cache->gpos.table, subtable_offset + + FIELD_OFFSET(struct ot_gpos_singlepos_format2, value_count)); + const struct ot_gpos_singlepos_format2 *format2 = table_read_ensure(&cache->gpos.table, subtable_offset, + FIELD_OFFSET(struct ot_gpos_singlepos_format2, values) + value_count * value_len * sizeof(WORD)); + + coverage_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset + coverage, + context->u.pos.glyphs[iter->pos]); + if (coverage_index == GLYPH_NOT_COVERED || coverage_index >= value_count) + continue; + + opentype_layout_apply_gpos_value(context, subtable_offset, value_format, + &format2->values[coverage_index * value_len], iter->pos); + break; + } + else + WARN("Unknown single adjustment format %u.\n", format); + } + return FALSE; }