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     if (!(cache = calloc(1, sizeof(*cache))))
  48         return NULL;
  49
  50     cache->font = font_ops;
  51     cache->context = context;
  52
  53     opentype_layout_scriptshaping_cache_init(cache);
  54     cache->upem = cache->font->get_font_upem(cache->context);
  55
  56     return cache;
  57 }
  58
  59 void release_scriptshaping_cache(struct scriptshaping_cache *cache)
  60 {
  61     if (!cache)
  62         return;
  63
  64     cache->font->release_font_table(cache->context, cache->gdef.table.context);
  65     cache->font->release_font_table(cache->context, cache->gsub.table.context);
  66     cache->font->release_font_table(cache->context, cache->gpos.table.context);
  67     free(cache);
  68 }
  69
  70 static unsigned int shape_select_script(const struct scriptshaping_cache *cache, DWORD kind, const unsigned int *scripts,
  71         unsigned int *script_index)
  72 {
  73     static const unsigned int fallback_scripts[] =
  74     {
  75         DWRITE_MAKE_OPENTYPE_TAG('D','F','L','T'),
  76         DWRITE_MAKE_OPENTYPE_TAG('d','f','l','t'),
  77         DWRITE_MAKE_OPENTYPE_TAG('l','a','t','n'),
  78         0,
  79     };
  80     unsigned int script;
  81
  82     /* Passed scripts in ascending priority. */
  83     while (scripts && *scripts)
  84     {
  85         if ((script = opentype_layout_find_script(cache, kind, *scripts, script_index)))
  86             return script;
  87
  88         scripts++;
  89     }
  90
  91     /* 'DFLT' -> 'dflt' -> 'latn' */
  92     scripts = fallback_scripts;
  93     while (*scripts)
  94     {
  95         if ((script = opentype_layout_find_script(cache, kind, *scripts, script_index)))
  96             return script;
  97         scripts++;
  98     }
  99
 100     return 0;
 101 }
 102
 103 static DWORD shape_select_language(const struct scriptshaping_cache *cache, DWORD kind, unsigned int script_index,
 104         DWORD language, unsigned int *language_index)
 105 {
 106     /* Specified language -> 'dflt'. */
 107     if ((language = opentype_layout_find_language(cache, kind, language, script_index, language_index)))
 108         return language;
 109
 110     if ((language = opentype_layout_find_language(cache, kind, DWRITE_MAKE_OPENTYPE_TAG('d','f','l','t'),
 111             script_index, language_index)))
 112         return language;
 113
 114     return 0;
 115 }
 116
 117 void shape_add_feature_full(struct shaping_features *features, unsigned int tag, unsigned int flags, unsigned int value)
 118 {
 119     unsigned int i = features->count;
 120
 121     if (!dwrite_array_reserve((void **)&features->features, &features->capacity, features->count + 1,
 122             sizeof(*features->features)))
 123         return;
 124
 125     features->features[i].tag = tag;
 126     features->features[i].flags = flags;
 127     features->features[i].max_value = value;
 128     features->features[i].default_value = flags & FEATURE_GLOBAL ? value : 0;
 129     features->features[i].stage = features->stage;
 130     features->count++;
 131 }
 132
 133 static void shape_add_feature(struct shaping_features *features, unsigned int tag)
 134 {
 135     shape_add_feature_full(features, tag, FEATURE_GLOBAL, 1);
 136 }
 137
 138 void shape_enable_feature(struct shaping_features *features, unsigned int tag,
 139         unsigned int flags)
 140 {
 141     shape_add_feature_full(features, tag, FEATURE_GLOBAL | flags, 1);
 142 }
 143
 144 void shape_start_next_stage(struct shaping_features *features, stage_func func)
 145 {
 146     features->stages[features->stage].func = func;
 147     features->stage++;
 148 }
 149
 150 static int __cdecl features_sorting_compare(const void *a, const void *b)
 151 {
 152     const struct shaping_feature *left = a, *right = b;
 153     return left->tag != right->tag ? (left->tag < right->tag ? -1 : 1) : 0;
 154 };
 155
 156 static void shape_merge_features(struct scriptshaping_context *context, struct shaping_features *features)
 157 {
 158     const DWRITE_TYPOGRAPHIC_FEATURES **user_features = context->user_features.features;
 159     unsigned int i, j;
 160
 161     /* For now only consider global, enabled user features. */
 162     if (user_features && context->user_features.range_lengths)
 163     {
 164         unsigned int flags = context->user_features.range_count == 1 &&
 165                 context->user_features.range_lengths[0] == context->length ? FEATURE_GLOBAL : 0;
 166
 167         for (i = 0; i < context->user_features.range_count; ++i)
 168         {
 169             for (j = 0; j < user_features[i]->featureCount; ++j)
 170                 shape_add_feature_full(features, user_features[i]->features[j].nameTag, flags,
 171                         user_features[i]->features[j].parameter);
 172         }
 173     }
 174
 175     /* Sort and merge duplicates. */
 176     qsort(features->features, features->count, sizeof(*features->features), features_sorting_compare);
 177
 178     for (i = 1, j = 0; i < features->count; ++i)
 179     {
 180         if (features->features[i].tag != features->features[j].tag)
 181             features->features[++j] = features->features[i];
 182         else
 183         {
 184             if (features->features[i].flags & FEATURE_GLOBAL)
 185             {
 186                 features->features[j].flags |= FEATURE_GLOBAL;
 187                 features->features[j].max_value = features->features[i].max_value;
 188                 features->features[j].default_value = features->features[i].default_value;
 189             }
 190             else
 191             {
 192                 if (features->features[j].flags & FEATURE_GLOBAL)
 193                     features->features[j].flags ^= FEATURE_GLOBAL;
 194                 features->features[j].max_value = max(features->features[j].max_value, features->features[i].max_value);
 195             }
 196             features->features[j].flags |= features->features[i].flags & FEATURE_HAS_FALLBACK;
 197             features->features[j].stage = min(features->features[j].stage, features->features[i].stage);
 198         }
 199     }
 200     features->count = j + 1;
 201 }
 202
 203 static void default_shaper_setup_masks(struct scriptshaping_context *context,
 204         const struct shaping_features *features)
 205 {
 206     unsigned int i;
 207
 208     for (i = 0; i < context->glyph_count; ++i)
 209     {
 210         context->u.buffer.glyph_props[i].justification = iswspace(context->glyph_infos[i].codepoint) ?
 211                 SCRIPT_JUSTIFY_BLANK : SCRIPT_JUSTIFY_CHARACTER;
 212     }
 213 }
 214
 215 static const struct shaper default_shaper =
 216 {
 217     .setup_masks = default_shaper_setup_masks
 218 };
 219
 220 static void shape_set_shaper(struct scriptshaping_context *context)
 221 {
 222     switch (context->script)
 223     {
 224         case Script_Arabic:
 225         case Script_Syriac:
 226             context->shaper = &arabic_shaper;
 227             break;
 228         default:
 229             context->shaper = &default_shaper;
 230     }
 231 }
 232
 233 HRESULT shape_get_positions(struct scriptshaping_context *context, const unsigned int *scripts)
 234 {
 235     static const struct shaping_feature common_features[] =
 236     {
 237         { DWRITE_MAKE_OPENTYPE_TAG('a','b','v','m') },
 238         { DWRITE_MAKE_OPENTYPE_TAG('b','l','w','m') },
 239         { DWRITE_MAKE_OPENTYPE_TAG('m','a','r','k'), FEATURE_MANUAL_JOINERS },
 240         { DWRITE_MAKE_OPENTYPE_TAG('m','k','m','k'), FEATURE_MANUAL_JOINERS },
 241     };
 242     static const unsigned int horizontal_features[] =
 243     {
 244         DWRITE_MAKE_OPENTYPE_TAG('c','u','r','s'),
 245         DWRITE_MAKE_OPENTYPE_TAG('d','i','s','t'),
 246         DWRITE_MAKE_OPENTYPE_TAG('k','e','r','n'),
 247     };
 248     struct scriptshaping_cache *cache = context->cache;
 249     unsigned int script_index, language_index, script, i;
 250     struct shaping_features features = { 0 };
 251
 252     shape_set_shaper(context);
 253
 254     for (i = 0; i < ARRAY_SIZE(common_features); ++i)
 255         shape_add_feature_full(&features, common_features[i].tag, FEATURE_GLOBAL | common_features[i].flags, 1);
 256
 257     /* Horizontal features */
 258     if (!context->is_sideways)
 259     {
 260         for (i = 0; i < ARRAY_SIZE(horizontal_features); ++i)
 261             shape_add_feature(&features, horizontal_features[i]);
 262     }
 263
 264     shape_merge_features(context, &features);
 265
 266     /* Resolve script tag to actually supported script. */
 267     if (cache->gpos.table.data)
 268     {
 269         if ((script = shape_select_script(cache, MS_GPOS_TAG, scripts, &script_index)))
 270         {
 271             DWORD language = context->language_tag;
 272
 273             if ((language = shape_select_language(cache, MS_GPOS_TAG, script_index, language, &language_index)))
 274             {
 275                 TRACE("script %s, language %s.\n", debugstr_tag(script), language != ~0u ?
 276                         debugstr_tag(language) : "deflangsys");
 277                 opentype_layout_apply_gpos_features(context, script_index, language_index, &features);
 278             }
 279         }
 280     }
 281
 282     for (i = 0; i < context->glyph_count; ++i)
 283         if (context->u.pos.glyph_props[i].isZeroWidthSpace)
 284             context->advances[i] = 0.0f;
 285
 286     free(features.features);
 287
 288     return S_OK;
 289 }
 290
 291 static unsigned int shape_get_script_lang_index(struct scriptshaping_context *context, const unsigned int *scripts,
 292         unsigned int table, unsigned int *script_index, unsigned int *language_index)
 293 {
 294     unsigned int script;
 295
 296     /* Resolve script tag to actually supported script. */
 297     if ((script = shape_select_script(context->cache, table, scripts, script_index)))
 298     {
 299         unsigned int language = context->language_tag;
 300
 301         if ((language = shape_select_language(context->cache, table, *script_index, language, language_index)))
 302             return script;
 303     }
 304
 305     return 0;
 306 }
 307
 308 HRESULT shape_get_glyphs(struct scriptshaping_context *context, const unsigned int *scripts)
 309 {
 310     static const unsigned int common_features[] =
 311     {
 312         DWRITE_MAKE_OPENTYPE_TAG('c','c','m','p'),
 313         DWRITE_MAKE_OPENTYPE_TAG('l','o','c','l'),
 314         DWRITE_MAKE_OPENTYPE_TAG('r','l','i','g'),
 315     };
 316     static const unsigned int horizontal_features[] =
 317     {
 318         DWRITE_MAKE_OPENTYPE_TAG('c','a','l','t'),
 319         DWRITE_MAKE_OPENTYPE_TAG('c','l','i','g'),
 320         DWRITE_MAKE_OPENTYPE_TAG('l','i','g','a'),
 321         DWRITE_MAKE_OPENTYPE_TAG('r','c','l','t'),
 322     };
 323     unsigned int script_index, language_index;
 324     struct shaping_features features = { 0 };
 325     unsigned int i;
 326
 327     shape_set_shaper(context);
 328
 329     if (!context->is_sideways)
 330     {
 331         if (context->is_rtl)
 332         {
 333             shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('r','t','l','a'), 0);
 334             shape_add_feature_full(&features, DWRITE_MAKE_OPENTYPE_TAG('r','t','l','m'), 0, 1);
 335         }
 336         else
 337         {
 338             shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('l','t','r','a'), 0);
 339             shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('l','t','r','m'), 0);
 340         }
 341     }
 342
 343     if (context->shaper->collect_features)
 344         context->shaper->collect_features(context, &features);
 345
 346     for (i = 0; i < ARRAY_SIZE(common_features); ++i)
 347         shape_add_feature(&features, common_features[i]);
 348
 349     /* Horizontal features */
 350     if (!context->is_sideways)
 351     {
 352         for (i = 0; i < ARRAY_SIZE(horizontal_features); ++i)
 353             shape_add_feature(&features, horizontal_features[i]);
 354     }
 355     else
 356         shape_enable_feature(&features, DWRITE_MAKE_OPENTYPE_TAG('v','e','r','t'), FEATURE_GLOBAL_SEARCH);
 357
 358     shape_merge_features(context, &features);
 359
 360     /* Resolve script tag to actually supported script. */
 361     shape_get_script_lang_index(context, scripts, MS_GSUB_TAG, &script_index, &language_index);
 362     opentype_layout_apply_gsub_features(context, script_index, language_index, &features);
 363
 364     free(features.features);
 365
 366     return (context->glyph_count <= context->u.subst.max_glyph_count) ? S_OK : E_NOT_SUFFICIENT_BUFFER;
 367 }
 368
 369 static int __cdecl tag_array_sorting_compare(const void *a, const void *b)
 370 {
 371     unsigned int left = GET_BE_DWORD(*(unsigned int *)a), right = GET_BE_DWORD(*(unsigned int *)b);
 372     return left != right ? (left < right ? -1 : 1) : 0;
 373 };
 374
 375 HRESULT shape_get_typographic_features(struct scriptshaping_context *context, const unsigned int *scripts,
 376         unsigned int max_tagcount, unsigned int *actual_tagcount, unsigned int *tags)
 377 {
 378     unsigned int i, j, script_index, language_index;
 379     struct tag_array t = { 0 };
 380
 381     /* Collect from both tables, sort and remove duplicates. */
 382
 383     shape_get_script_lang_index(context, scripts, MS_GSUB_TAG, &script_index, &language_index);
 384     opentype_get_typographic_features(&context->cache->gsub, script_index, language_index, &t);
 385
 386     shape_get_script_lang_index(context, scripts, MS_GPOS_TAG, &script_index, &language_index);
 387     opentype_get_typographic_features(&context->cache->gpos, script_index, language_index, &t);
 388
 389     if (t.count == 0)
 390     {
 391         *actual_tagcount = 0;
 392         return S_OK;
 393     }
 394
 395     /* Sort and remove duplicates. */
 396     qsort(t.tags, t.count, sizeof(*t.tags), tag_array_sorting_compare);
 397
 398     for (i = 1, j = 0; i < t.count; ++i)
 399     {
 400         if (t.tags[i] != t.tags[j])
 401             t.tags[++j] = t.tags[i];
 402     }
 403     t.count = j + 1;
 404
 405     if (t.count <= max_tagcount)
 406         memcpy(tags, t.tags, t.count * sizeof(*t.tags));
 407
 408     *actual_tagcount = t.count;
 409
 410     free(t.tags);
 411
 412     return t.count <= max_tagcount ? S_OK : E_NOT_SUFFICIENT_BUFFER;
 413 }
 414
 415 HRESULT shape_check_typographic_feature(struct scriptshaping_context *context, const unsigned int *scripts,
 416         unsigned int tag, unsigned int glyph_count, const UINT16 *glyphs, UINT8 *feature_applies)
 417 {
 418     static const unsigned int tables[] = { MS_GSUB_TAG, MS_GPOS_TAG };
 419     struct shaping_feature feature = { .tag = tag };
 420     unsigned int script_index, language_index;
 421     unsigned int i;
 422
 423     memset(feature_applies, 0, glyph_count * sizeof(*feature_applies));
 424
 425     for (i = 0; i < ARRAY_SIZE(tables); ++i)
 426     {
 427         shape_get_script_lang_index(context, scripts, tables[i], &script_index, &language_index);
 428         context->table = tables[i] == MS_GSUB_TAG ? &context->cache->gsub : &context->cache->gpos;
 429         /* Skip second table if feature applies to all. */
 430         if (opentype_layout_check_feature(context, script_index, language_index, &feature, glyph_count,
 431                 glyphs, feature_applies))
 432         {
 433             break;
 434         }
 435     }
 436
 437     return S_OK;
 438 }