dlls/dwrite/shape.c

   1 /*
   2  *    Glyph shaping support
   3  *
   4  * Copyright 2010 Aric Stewart for CodeWeavers
   5  * Copyright 2014 Nikolay Sivov for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  *
  22  * Shaping features processing, default features, and lookups handling logic are
  23  * derived from HarfBuzz implementation. Consult project documentation for the full
  24  * list of its authors.
  25  */
  26
  27 #define COBJMACROS
  28
  29 #include "dwrite_private.h"
  30 #include "scripts.h"
  31 #include "winternl.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(dwrite);
  36
  37 #ifdef WORDS_BIGENDIAN
  38 #define GET_BE_DWORD(x) (x)
  39 #else
  40 #define GET_BE_DWORD(x) RtlUlongByteSwap(x)
  41 #endif
  42
  43 struct scriptshaping_cache *create_scriptshaping_cache(void *context, const struct shaping_font_ops *font_ops)
  44 {
  45     struct scriptshaping_cache *cache;
  46
  47     cache = heap_alloc_zero(sizeof(*cache));
  48     if (!cache)
  49         return NULL;
  50
  51     cache->font = font_ops;
  52     cache->context = context;
  53
  54     opentype_layout_scriptshaping_cache_init(cache);
  55     cache->upem = cache->font->get_font_upem(cache->context);
  56
  57     return cache;
  58 }
  59
  60 void release_scriptshaping_cache(struct scriptshaping_cache *cache)
  61 {
  62     if (!cache)
  63         return;
  64
  65     cache->font->release_font_table(cache->context, cache->gdef.table.context);
  66     cache->font->release_font_table(cache->context, cache->gsub.table.context);
  67     cache->font->release_font_table(cache->context, cache->gpos.table.context);
  68     heap_free(cache);
  69 }
  70
  71 static unsigned int shape_select_script(const struct scriptshaping_cache *cache, DWORD kind, const DWORD *scripts,
  72         unsigned int *script_index)
  73 {
  74     static const DWORD fallback_scripts[] =
  75     {
  76         DWRITE_MAKE_OPENTYPE_TAG('D','F','L','T'),
  77         DWRITE_MAKE_OPENTYPE_TAG('d','f','l','t'),
  78         DWRITE_MAKE_OPENTYPE_TAG('l','a','t','n'),
  79         0,
  80     };
  81     unsigned int script;
  82
  83     /* Passed scripts in ascending priority. */
  84     while (scripts && *scripts)
  85     {
  86         if ((script = opentype_layout_find_script(cache, kind, *scripts, script_index)))
  87             return script;
  88
  89         scripts++;
  90     }
  91
  92     /* 'DFLT' -> 'dflt' -> 'latn' */
  93     scripts = fallback_scripts;
  94     while (*scripts)
  95     {
  96         if ((script = opentype_layout_find_script(cache, kind, *scripts, script_index)))
  97             return script;
  98         scripts++;
  99     }
 100
 101     return 0;
 102 }
 103
 104 static DWORD shape_select_language(const struct scriptshaping_cache *cache, DWORD kind, unsigned int script_index,
 105         DWORD language, unsigned int *language_index)
 106 {
 107     /* Specified language -> 'dflt'. */
 108     if ((language = opentype_layout_find_language(cache, kind, language, script_index, language_index)))
 109         return language;
 110
 111     if ((language = opentype_layout_find_language(cache, kind, DWRITE_MAKE_OPENTYPE_TAG('d','f','l','t'),
 112             script_index, language_index)))
 113         return language;
 114
 115     return 0;
 116 }
 117
 118 void shape_add_feature_full(struct shaping_features *features, unsigned int tag, unsigned int flags, unsigned int value)
 119 {
 120     unsigned int i = features->count;
 121
 122     if (!dwrite_array_reserve((void **)&features->features, &features->capacity, features->count + 1,
 123             sizeof(*features->features)))
 124         return;
 125
 126     features->features[i].tag = tag;
 127     features->features[i].flags = flags;
 128     features->features[i].max_value = value;
 129     features->features[i].default_value = flags & FEATURE_GLOBAL ? value : 0;
 130     features->features[i].stage = features->stage;
 131     features->count++;
 132 }
 133
 134 static void shape_add_feature(struct shaping_features *features, unsigned int tag)
 135 {
 136     shape_add_feature_full(features, tag, FEATURE_GLOBAL, 1);
 137 }
 138
 139 void shape_enable_feature(struct shaping_features *features, unsigned int tag,
 140         unsigned int flags)
 141 {
 142     shape_add_feature_full(features, tag, FEATURE_GLOBAL | flags, 1);
 143 }
 144
 145 void shape_start_next_stage(struct shaping_features *features, stage_func func)
 146 {
 147     features->stages[features->stage].func = func;
 148     features->stage++;
 149 }
 150
 151 static int features_sorting_compare(const void *a, const void *b)
 152 {
 153     const struct shaping_feature *left = a, *right = b;
 154     return left->tag != right->tag ? (left->tag < right->tag ? -1 : 1) : 0;
 155 };
 156
 157 static void shape_merge_features(struct scriptshaping_context *context, struct shaping_features *features)
 158 {
 159     const DWRITE_TYPOGRAPHIC_FEATURES **user_features = context->user_features.features;
 160     unsigned int i, j;
 161
 162     /* For now only consider global, enabled user features. */
 163     if (user_features && context->user_features.range_lengths)
 164     {
 165         unsigned int flags = context->user_features.range_count == 1 &&
 166                 context->user_features.range_lengths[0] == context->length ? FEATURE_GLOBAL : 0;
 167
 168         for (i = 0; i < context->user_features.range_count; ++i)
 169         {
 170             for (j = 0; j < user_features[i]->featureCount; ++j)
 171                 shape_add_feature_full(features, user_features[i]->features[j].nameTag, flags,
 172                         user_features[i]->features[j].parameter);
 173         }
 174     }
 175
 176     /* Sort and merge duplicates. */
 177     qsort(features->features, features->count, sizeof(*features->features), features_sorting_compare);
 178
 179     for (i = 1, j = 0; i < features->count; ++i)
 180     {
 181         if (features->features[i].tag != features->features[j].tag)
 182             features->features[++j] = features->features[i];
 183         else
 184         {
 185             if (features->features[i].flags & FEATURE_GLOBAL)
 186             {
 187                 features->features[j].flags |= FEATURE_GLOBAL;
 188                 features->features[j].max_value = features->features[i].max_value;
 189                 features->features[j].default_value = features->features[i].default_value;
 190             }
 191             else
 192             {
 193                 if (features->features[j].flags & FEATURE_GLOBAL)
 194                     features->features[j].flags ^= FEATURE_GLOBAL;
 195                 features->features[j].max_value = max(features->features[j].max_value, features->features[i].max_value);
 196             }
 197             features->features[j].flags |= features->features[i].flags & FEATURE_HAS_FALLBACK;
 198             features->features[j].stage = min(features->features[j].stage, features->features[i].stage);
 199         }
 200     }
 201     features->count = j + 1;
 202 }
 203
 204 static const struct shaper null_shaper;
 205
 206 static void shape_set_shaper(struct scriptshaping_context *context)
 207 {
 208     switch (context->script)
 209     {
 210         case Script_Arabic:
 211         case Script_Syriac:
 212             context->shaper = &arabic_shaper;
 213             break;
 214         default:
 215             context->shaper = &null_shaper;
 216     }
 217 }
 218
 219 HRESULT shape_get_positions(struct scriptshaping_context *context, const unsigned int *scripts)
 220 {
 221     static const struct shaping_feature common_features[] =
 222     {
 223         { DWRITE_MAKE_OPENTYPE_TAG('a','b','v','m') },
 224         { DWRITE_MAKE_OPENTYPE_TAG('b','l','w','m') },
 225         { DWRITE_MAKE_OPENTYPE_TAG('m','a','r','k'), FEATURE_MANUAL_JOINERS },
 226         { DWRITE_MAKE_OPENTYPE_TAG('m','k','m','k'), FEATURE_MANUAL_JOINERS },
 227     };
 228     static const unsigned int horizontal_features[] =
 229     {
 230         DWRITE_MAKE_OPENTYPE_TAG('c','u','r','s'),
 231         DWRITE_MAKE_OPENTYPE_TAG('d','i','s','t'),
 232         DWRITE_MAKE_OPENTYPE_TAG('k','e','r','n'),
 233     };
 234     struct scriptshaping_cache *cache = context->cache;
 235     unsigned int script_index, language_index, script, i;
 236     struct shaping_features features = { 0 };
 237
 238     shape_set_shaper(context);
 239
 240     for (i = 0; i < ARRAY_SIZE(common_features); ++i)
 241         shape_add_feature_full(&features, common_features[i].tag, FEATURE_GLOBAL | common_features[i].flags, 1);
 242
 243     /* Horizontal features */
 244     if (!context->is_sideways)
 245     {
 246         for (i = 0; i < ARRAY_SIZE(horizontal_features); ++i)
 247             shape_add_feature(&features, horizontal_features[i]);
 248     }
 249
 250     shape_merge_features(context, &features);
 251
 252     /* Resolve script tag to actually supported script. */
 253     if (cache->gpos.table.data)
 254     {
 255         if ((script = shape_select_script(cache, MS_GPOS_TAG, scripts, &script_index)))
 256         {
 257             DWORD language = context->language_tag;
 258
 259             if ((language = shape_select_language(cache, MS_GPOS_TAG, script_index, language, &language_index)))
 260             {
 261                 TRACE("script %s, language %s.\n", debugstr_tag(script), language != ~0u ?
 262                         debugstr_tag(language) : "deflangsys");
 263                 opentype_layout_apply_gpos_features(context, script_index, language_index, &features);
 264             }
 265         }
 266     }
 267
 268     for (i = 0; i < context->glyph_count; ++i)
 269         if (context->u.pos.glyph_props[i].isZeroWidthSpace)
 270             context->advances[i] = 0.0f;
 271
 272     heap_free(features.features);
 273
 274     return S_OK;
 275 }
 276
 277 static unsigned int shape_get_script_lang_index(struct scriptshaping_context *context, const unsigned int *scripts,
 278         unsigned int table, unsigned int *script_index, unsigned int *language_index)
 279 {
 280     unsigned int script;
 281
 282     /* Resolve script tag to actually supported script. */
 283     if ((script = shape_select_script(context->cache, table, scripts, script_index)))
 284     {
 285         unsigned int language = context->language_tag;
 286
 287         if ((language = shape_select_language(context->cache, table, *script_index, language, language_index)))
 288             return script;
 289     }
 290
 291     return 0;
 292 }
 293
 294 HRESULT shape_get_glyphs(struct scriptshaping_context *context, const unsigned int *scripts)
 295 {
 296     static const unsigned int common_features[] =
 297     {
 298         DWRITE_MAKE_OPENTYPE_TAG('c','c','m','p'),
 299         DWRITE_MAKE_OPENTYPE_TAG('l','o','c','l'),
 300         DWRITE_MAKE_OPENTYPE_TAG('r','l','i','g'),
 301     };
 302     static const unsigned int horizontal_features[] =
 303     {
 304         DWRITE_MAKE_OPENTYPE_TAG('c','a','l','t'),
 305         DWRITE_MAKE_OPENTYPE_TAG('c','l','i','g'),
 306         DWRITE_MAKE_OPENTYPE_TAG('l','i','g','a'),
 307         DWRITE_MAKE_OPENTYPE_TAG('r','c','l','t'),
 308     };
 309     unsigned int script_index, language_index;
 310     struct shaping_features features = { 0 };
 311     unsigned int i;
 312
 313     shape_set_shaper(context);
 314
 315     if (!context->is_sideways)
 316     {
 317         if (context->is_rtl)
 318         {
 319             shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('r','t','l','a'), 0);
 320             shape_add_feature_full(&features, DWRITE_MAKE_OPENTYPE_TAG('r','t','l','m'), 0, 1);
 321         }
 322         else
 323         {
 324             shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('l','t','r','a'), 0);
 325             shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('l','t','r','m'), 0);
 326         }
 327     }
 328
 329     if (context->shaper->collect_features)
 330         context->shaper->collect_features(context, &features);
 331
 332     for (i = 0; i < ARRAY_SIZE(common_features); ++i)
 333         shape_add_feature(&features, common_features[i]);
 334
 335     /* Horizontal features */
 336     if (!context->is_sideways)
 337     {
 338         for (i = 0; i < ARRAY_SIZE(horizontal_features); ++i)
 339             shape_add_feature(&features, horizontal_features[i]);
 340     }
 341     else
 342         shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('v','e','r','t'), FEATURE_GLOBAL_SEARCH);
 343
 344     shape_merge_features(context, &features);
 345
 346     /* Resolve script tag to actually supported script. */
 347     shape_get_script_lang_index(context, scripts, MS_GSUB_TAG, &script_index, &language_index);
 348     opentype_layout_apply_gsub_features(context, script_index, language_index, &features);
 349
 350     heap_free(features.features);
 351
 352     return (context->glyph_count <= context->u.subst.max_glyph_count) ? S_OK : E_NOT_SUFFICIENT_BUFFER;
 353 }
 354
 355 static int tag_array_sorting_compare(const void *a, const void *b)
 356 {
 357     unsigned int left = GET_BE_DWORD(*(unsigned int *)a), right = GET_BE_DWORD(*(unsigned int *)b);
 358     return left != right ? (left < right ? -1 : 1) : 0;
 359 };
 360
 361 HRESULT shape_get_typographic_features(struct scriptshaping_context *context, const unsigned int *scripts,
 362         unsigned int max_tagcount, unsigned int *actual_tagcount, unsigned int *tags)
 363 {
 364     unsigned int i, j, script_index, language_index;
 365     struct tag_array t = { 0 };
 366
 367     /* Collect from both tables, sort and remove duplicates. */
 368
 369     shape_get_script_lang_index(context, scripts, MS_GSUB_TAG, &script_index, &language_index);
 370     opentype_get_typographic_features(&context->cache->gsub, script_index, language_index, &t);
 371
 372     shape_get_script_lang_index(context, scripts, MS_GPOS_TAG, &script_index, &language_index);
 373     opentype_get_typographic_features(&context->cache->gpos, script_index, language_index, &t);
 374
 375     /* Sort and remove duplicates. */
 376     qsort(t.tags, t.count, sizeof(*t.tags), tag_array_sorting_compare);
 377
 378     for (i = 1, j = 0; i < t.count; ++i)
 379     {
 380         if (t.tags[i] != t.tags[j])
 381             t.tags[++j] = t.tags[i];
 382     }
 383     t.count = j + 1;
 384
 385     if (t.count <= max_tagcount)
 386         memcpy(tags, t.tags, t.count * sizeof(*t.tags));
 387
 388     *actual_tagcount = t.count;
 389
 390     heap_free(t.tags);
 391
 392     return t.count <= max_tagcount ? S_OK : E_NOT_SUFFICIENT_BUFFER;
 393 }
 394
 395 HRESULT shape_check_typographic_feature(struct scriptshaping_context *context, const unsigned int *scripts,
 396         unsigned int tag, unsigned int glyph_count, const UINT16 *glyphs, UINT8 *feature_applies)
 397 {
 398     static const unsigned int tables[] = { MS_GSUB_TAG, MS_GPOS_TAG };
 399     struct shaping_feature feature = { .tag = tag };
 400     unsigned int script_index, language_index;
 401     unsigned int i;
 402
 403     memset(feature_applies, 0, glyph_count * sizeof(*feature_applies));
 404
 405     for (i = 0; i < ARRAY_SIZE(tables); ++i)
 406     {
 407         shape_get_script_lang_index(context, scripts, tables[i], &script_index, &language_index);
 408         context->table = tables[i] == MS_GSUB_TAG ? &context->cache->gsub : &context->cache->gpos;
 409         /* Skip second table if feature applies to all. */
 410         if (opentype_layout_check_feature(context, script_index, language_index, &feature, glyph_count,
 411                 glyphs, feature_applies))
 412         {
 413             break;
 414         }
 415     }
 416
 417     return S_OK;
 418 }