src/hb-ot-shape.cc

   1 /*
   2  * Copyright © 2009,2010  Red Hat, Inc.
   3  * Copyright © 2010,2011,2012  Google, Inc.
   4  *
   5  *  This is part of HarfBuzz, a text shaping library.
   6  *
   7  * Permission is hereby granted, without written agreement and without
   8  * license or royalty fees, to use, copy, modify, and distribute this
   9  * software and its documentation for any purpose, provided that the
  10  * above copyright notice and the following two paragraphs appear in
  11  * all copies of this software.
  12  *
  13  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  14  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  15  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  16  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  17  * DAMAGE.
  18  *
  19  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  20  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  21  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  22  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  23  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  24  *
  25  * Red Hat Author(s): Behdad Esfahbod
  26  * Google Author(s): Behdad Esfahbod
  27  */
  28
  29 #define HB_SHAPER ot
  30 #define hb_ot_shaper_face_data_t hb_ot_layout_t
  31 #define hb_ot_shaper_shape_plan_data_t hb_ot_shape_plan_t
  32 #include "hb-shaper-impl-private.hh"
  33
  34 #include "hb-ot-shape-private.hh"
  35 #include "hb-ot-shape-complex-private.hh"
  36 #include "hb-ot-shape-fallback-private.hh"
  37 #include "hb-ot-shape-normalize-private.hh"
  38
  39 #include "hb-ot-layout-private.hh"
  40 #include "hb-set-private.hh"
  41
  42
  43 static hb_tag_t common_features[] = {
  44   HB_TAG('c','c','m','p'),
  45   HB_TAG('l','i','g','a'),
  46   HB_TAG('l','o','c','l'),
  47   HB_TAG('m','a','r','k'),
  48   HB_TAG('m','k','m','k'),
  49   HB_TAG('r','l','i','g'),
  50 };
  51
  52
  53 static hb_tag_t horizontal_features[] = {
  54   HB_TAG('c','a','l','t'),
  55   HB_TAG('c','l','i','g'),
  56   HB_TAG('c','u','r','s'),
  57   HB_TAG('k','e','r','n'),
  58   HB_TAG('r','c','l','t'),
  59 };
  60
  61 /* Note:
  62  * Technically speaking, vrt2 and vert are mutually exclusive.
  63  * According to the spec, valt and vpal are also mutually exclusive.
  64  * But we apply them all for now.
  65  */
  66 static hb_tag_t vertical_features[] = {
  67   HB_TAG('v','a','l','t'),
  68   HB_TAG('v','e','r','t'),
  69   HB_TAG('v','k','r','n'),
  70   HB_TAG('v','p','a','l'),
  71   HB_TAG('v','r','t','2'),
  72 };
  73
  74
  75
  76 static void
  77 hb_ot_shape_collect_features (hb_ot_shape_planner_t          *planner,
  78                               const hb_segment_properties_t  *props,
  79                               const hb_feature_t             *user_features,
  80                               unsigned int                    num_user_features)
  81 {
  82   hb_ot_map_builder_t *map = &planner->map;
  83
  84   switch (props->direction) {
  85     case HB_DIRECTION_LTR:
  86       map->add_bool_feature (HB_TAG ('l','t','r','a'));
  87       map->add_bool_feature (HB_TAG ('l','t','r','m'));
  88       break;
  89     case HB_DIRECTION_RTL:
  90       map->add_bool_feature (HB_TAG ('r','t','l','a'));
  91       map->add_bool_feature (HB_TAG ('r','t','l','m'), false);
  92       break;
  93     case HB_DIRECTION_TTB:
  94     case HB_DIRECTION_BTT:
  95     case HB_DIRECTION_INVALID:
  96     default:
  97       break;
  98   }
  99
 100 #define ADD_FEATURES(array) \
 101   HB_STMT_START { \
 102     for (unsigned int i = 0; i < ARRAY_LENGTH (array); i++) \
 103       map->add_bool_feature (array[i]); \
 104   } HB_STMT_END
 105
 106   if (planner->shaper->collect_features)
 107     planner->shaper->collect_features (planner);
 108
 109   ADD_FEATURES (common_features);
 110
 111   if (HB_DIRECTION_IS_HORIZONTAL (props->direction))
 112     ADD_FEATURES (horizontal_features);
 113   else
 114     ADD_FEATURES (vertical_features);
 115
 116   if (planner->shaper->override_features)
 117     planner->shaper->override_features (planner);
 118
 119 #undef ADD_FEATURES
 120
 121   for (unsigned int i = 0; i < num_user_features; i++) {
 122     const hb_feature_t *feature = &user_features[i];
 123     map->add_feature (feature->tag, feature->value, (feature->start == 0 && feature->end == (unsigned int) -1));
 124   }
 125 }
 126
 127
 128 /*
 129  * shaper face data
 130  */
 131
 132 hb_ot_shaper_face_data_t *
 133 _hb_ot_shaper_face_data_create (hb_face_t *face)
 134 {
 135   return _hb_ot_layout_create (face);
 136 }
 137
 138 void
 139 _hb_ot_shaper_face_data_destroy (hb_ot_shaper_face_data_t *data)
 140 {
 141   _hb_ot_layout_destroy (data);
 142 }
 143
 144
 145 /*
 146  * shaper font data
 147  */
 148
 149 struct hb_ot_shaper_font_data_t {};
 150
 151 hb_ot_shaper_font_data_t *
 152 _hb_ot_shaper_font_data_create (hb_font_t *font)
 153 {
 154   return (hb_ot_shaper_font_data_t *) HB_SHAPER_DATA_SUCCEEDED;
 155 }
 156
 157 void
 158 _hb_ot_shaper_font_data_destroy (hb_ot_shaper_font_data_t *data)
 159 {
 160 }
 161
 162
 163 /*
 164  * shaper shape_plan data
 165  */
 166
 167 hb_ot_shaper_shape_plan_data_t *
 168 _hb_ot_shaper_shape_plan_data_create (hb_shape_plan_t    *shape_plan,
 169                                       const hb_feature_t *user_features,
 170                                       unsigned int        num_user_features)
 171 {
 172   hb_ot_shape_plan_t *plan = (hb_ot_shape_plan_t *) calloc (1, sizeof (hb_ot_shape_plan_t));
 173   if (unlikely (!plan))
 174     return NULL;
 175
 176   hb_ot_shape_planner_t planner (shape_plan);
 177
 178   planner.shaper = hb_ot_shape_complex_categorize (&shape_plan->props);
 179
 180   hb_ot_shape_collect_features (&planner, &shape_plan->props, user_features, num_user_features);
 181
 182   planner.compile (*plan);
 183
 184   if (plan->shaper->data_create) {
 185     plan->data = plan->shaper->data_create (plan);
 186     if (unlikely (!plan->data))
 187       return NULL;
 188   }
 189
 190   return plan;
 191 }
 192
 193 void
 194 _hb_ot_shaper_shape_plan_data_destroy (hb_ot_shaper_shape_plan_data_t *plan)
 195 {
 196   if (plan->shaper->data_destroy)
 197     plan->shaper->data_destroy (const_cast<void *> (plan->data));
 198
 199   plan->finish ();
 200
 201   free (plan);
 202 }
 203
 204
 205 /*
 206  * shaper
 207  */
 208
 209 struct hb_ot_shape_context_t
 210 {
 211   hb_ot_shape_plan_t *plan;
 212   hb_font_t *font;
 213   hb_face_t *face;
 214   hb_buffer_t  *buffer;
 215   const hb_feature_t *user_features;
 216   unsigned int        num_user_features;
 217
 218   /* Transient stuff */
 219   hb_direction_t target_direction;
 220 };
 221
 222
 223
 224 /* Main shaper */
 225
 226
 227 /* Prepare */
 228
 229 static void
 230 hb_set_unicode_props (hb_buffer_t *buffer)
 231 {
 232   unsigned int count = buffer->len;
 233   for (unsigned int i = 0; i < count; i++)
 234     _hb_glyph_info_set_unicode_props (&buffer->info[i], buffer->unicode);
 235 }
 236
 237 static void
 238 hb_form_clusters (hb_buffer_t *buffer)
 239 {
 240   unsigned int count = buffer->len;
 241   for (unsigned int i = 1; i < count; i++)
 242     if (FLAG (_hb_glyph_info_get_general_category (&buffer->info[i])) &
 243         (FLAG (HB_UNICODE_GENERAL_CATEGORY_SPACING_MARK) |
 244          FLAG (HB_UNICODE_GENERAL_CATEGORY_ENCLOSING_MARK) |
 245          FLAG (HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK)))
 246       buffer->merge_clusters (i - 1, i + 1);
 247 }
 248
 249 static void
 250 hb_ensure_native_direction (hb_buffer_t *buffer)
 251 {
 252   hb_direction_t direction = buffer->props.direction;
 253
 254   /* TODO vertical:
 255    * The only BTT vertical script is Ogham, but it's not clear to me whether OpenType
 256    * Ogham fonts are supposed to be implemented BTT or not.  Need to research that
 257    * first. */
 258   if ((HB_DIRECTION_IS_HORIZONTAL (direction) && direction != hb_script_get_horizontal_direction (buffer->props.script)) ||
 259       (HB_DIRECTION_IS_VERTICAL   (direction) && direction != HB_DIRECTION_TTB))
 260   {
 261     hb_buffer_reverse_clusters (buffer);
 262     buffer->props.direction = HB_DIRECTION_REVERSE (buffer->props.direction);
 263   }
 264 }
 265
 266
 267 /* Substitute */
 268
 269 static inline void
 270 hb_ot_mirror_chars (hb_ot_shape_context_t *c)
 271 {
 272   if (HB_DIRECTION_IS_FORWARD (c->target_direction))
 273     return;
 274
 275   hb_unicode_funcs_t *unicode = c->buffer->unicode;
 276   hb_mask_t rtlm_mask = c->plan->map.get_1_mask (HB_TAG ('r','t','l','m'));
 277
 278   unsigned int count = c->buffer->len;
 279   for (unsigned int i = 0; i < count; i++) {
 280     hb_codepoint_t codepoint = unicode->mirroring (c->buffer->info[i].codepoint);
 281     if (likely (codepoint == c->buffer->info[i].codepoint))
 282       c->buffer->info[i].mask |= rtlm_mask;
 283     else
 284       c->buffer->info[i].codepoint = codepoint;
 285   }
 286 }
 287
 288 static inline void
 289 hb_ot_shape_setup_masks (hb_ot_shape_context_t *c)
 290 {
 291   hb_ot_map_t *map = &c->plan->map;
 292
 293   hb_mask_t global_mask = map->get_global_mask ();
 294   c->buffer->reset_masks (global_mask);
 295
 296   if (c->plan->shaper->setup_masks)
 297     c->plan->shaper->setup_masks (c->plan, c->buffer, c->font);
 298
 299   for (unsigned int i = 0; i < c->num_user_features; i++)
 300   {
 301     const hb_feature_t *feature = &c->user_features[i];
 302     if (!(feature->start == 0 && feature->end == (unsigned int)-1)) {
 303       unsigned int shift;
 304       hb_mask_t mask = map->get_mask (feature->tag, &shift);
 305       c->buffer->set_masks (feature->value << shift, mask, feature->start, feature->end);
 306     }
 307   }
 308 }
 309
 310 static inline void
 311 hb_ot_map_glyphs_fast (hb_buffer_t  *buffer)
 312 {
 313   /* Normalization process sets up glyph_index(), we just copy it. */
 314   unsigned int count = buffer->len;
 315   for (unsigned int i = 0; i < count; i++)
 316     buffer->info[i].codepoint = buffer->info[i].glyph_index();
 317 }
 318
 319 static inline void
 320 hb_ot_substitute_default (hb_ot_shape_context_t *c)
 321 {
 322   if (c->plan->shaper->preprocess_text)
 323     c->plan->shaper->preprocess_text (c->plan, c->buffer, c->font);
 324
 325   hb_ot_mirror_chars (c);
 326
 327   HB_BUFFER_ALLOCATE_VAR (c->buffer, glyph_index);
 328
 329   _hb_ot_shape_normalize (c->font, c->buffer,
 330                           c->plan->shaper->normalization_preference ?
 331                           c->plan->shaper->normalization_preference (c->plan) :
 332                           HB_OT_SHAPE_NORMALIZATION_MODE_DEFAULT);
 333
 334   hb_ot_shape_setup_masks (c);
 335
 336   hb_ot_map_glyphs_fast (c->buffer);
 337
 338   HB_BUFFER_DEALLOCATE_VAR (c->buffer, glyph_index);
 339 }
 340
 341 static inline void
 342 hb_synthesize_glyph_classes (hb_ot_shape_context_t *c)
 343 {
 344   unsigned int count = c->buffer->len;
 345   for (unsigned int i = 0; i < count; i++)
 346     c->buffer->info[i].glyph_props() = _hb_glyph_info_get_general_category (&c->buffer->info[i]) == HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK ?
 347                                        HB_OT_LAYOUT_GLYPH_CLASS_MARK :
 348                                        HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH;
 349 }
 350
 351
 352 static inline void
 353 hb_ot_substitute_complex (hb_ot_shape_context_t *c)
 354 {
 355   hb_ot_layout_substitute_start (c->font, c->buffer);
 356
 357   if (!hb_ot_layout_has_glyph_classes (c->face))
 358     hb_synthesize_glyph_classes (c);
 359
 360   if (hb_ot_layout_has_substitution (c->face))
 361     c->plan->substitute (c->font, c->buffer);
 362
 363   hb_ot_layout_substitute_finish (c->font, c->buffer);
 364
 365   return;
 366 }
 367
 368 static inline void
 369 hb_ot_substitute (hb_ot_shape_context_t *c)
 370 {
 371   hb_ot_substitute_default (c);
 372   hb_ot_substitute_complex (c);
 373 }
 374
 375 /* Position */
 376
 377 static inline void
 378 hb_ot_position_default (hb_ot_shape_context_t *c)
 379 {
 380   hb_ot_layout_position_start (c->font, c->buffer);
 381
 382   unsigned int count = c->buffer->len;
 383   for (unsigned int i = 0; i < count; i++) {
 384     c->font->get_glyph_advance_for_direction (c->buffer->info[i].codepoint,
 385                                               c->buffer->props.direction,
 386                                               &c->buffer->pos[i].x_advance,
 387                                               &c->buffer->pos[i].y_advance);
 388     c->font->subtract_glyph_origin_for_direction (c->buffer->info[i].codepoint,
 389                                                   c->buffer->props.direction,
 390                                                   &c->buffer->pos[i].x_offset,
 391                                                   &c->buffer->pos[i].y_offset);
 392   }
 393 }
 394
 395 static inline bool
 396 hb_ot_position_complex (hb_ot_shape_context_t *c)
 397 {
 398   bool ret = false;
 399
 400   if (hb_ot_layout_has_positioning (c->face))
 401   {
 402     /* Change glyph origin to what GPOS expects, apply GPOS, change it back. */
 403
 404     unsigned int count = c->buffer->len;
 405     for (unsigned int i = 0; i < count; i++) {
 406       c->font->add_glyph_origin_for_direction (c->buffer->info[i].codepoint,
 407                                                HB_DIRECTION_LTR,
 408                                                &c->buffer->pos[i].x_offset,
 409                                                &c->buffer->pos[i].y_offset);
 410     }
 411
 412     c->plan->position (c->font, c->buffer);
 413
 414     for (unsigned int i = 0; i < count; i++) {
 415       c->font->subtract_glyph_origin_for_direction (c->buffer->info[i].codepoint,
 416                                                     HB_DIRECTION_LTR,
 417                                                     &c->buffer->pos[i].x_offset,
 418                                                     &c->buffer->pos[i].y_offset);
 419     }
 420
 421     ret = true;
 422   }
 423
 424   hb_ot_layout_position_finish (c->font, c->buffer, c->plan->shaper->zero_width_attached_marks);
 425
 426   return ret;
 427 }
 428
 429 static inline void
 430 hb_ot_position_complex_fallback (hb_ot_shape_context_t *c)
 431 {
 432   _hb_ot_shape_fallback_position (c->plan, c->font, c->buffer);
 433 }
 434
 435 static inline void
 436 hb_ot_truetype_kern (hb_ot_shape_context_t *c)
 437 {
 438   /* TODO Check for kern=0 */
 439   unsigned int count = c->buffer->len;
 440   for (unsigned int i = 1; i < count; i++) {
 441     hb_position_t x_kern, y_kern, kern1, kern2;
 442     c->font->get_glyph_kerning_for_direction (c->buffer->info[i - 1].codepoint, c->buffer->info[i].codepoint,
 443                                               c->buffer->props.direction,
 444                                               &x_kern, &y_kern);
 445
 446     kern1 = x_kern >> 1;
 447     kern2 = x_kern - kern1;
 448     c->buffer->pos[i - 1].x_advance += kern1;
 449     c->buffer->pos[i].x_advance += kern2;
 450     c->buffer->pos[i].x_offset += kern2;
 451
 452     kern1 = y_kern >> 1;
 453     kern2 = y_kern - kern1;
 454     c->buffer->pos[i - 1].y_advance += kern1;
 455     c->buffer->pos[i].y_advance += kern2;
 456     c->buffer->pos[i].y_offset += kern2;
 457   }
 458 }
 459
 460 static inline void
 461 hb_position_complex_fallback_visual (hb_ot_shape_context_t *c)
 462 {
 463   hb_ot_truetype_kern (c);
 464 }
 465
 466 static inline void
 467 hb_ot_position (hb_ot_shape_context_t *c)
 468 {
 469   hb_ot_position_default (c);
 470
 471   hb_bool_t fallback = !hb_ot_position_complex (c);
 472
 473   if (fallback)
 474     hb_ot_position_complex_fallback (c);
 475
 476   if (HB_DIRECTION_IS_BACKWARD (c->buffer->props.direction))
 477     hb_buffer_reverse (c->buffer);
 478
 479   if (fallback)
 480     hb_position_complex_fallback_visual (c);
 481 }
 482
 483
 484 /* Post-process */
 485
 486 static void
 487 hb_ot_hide_zerowidth (hb_ot_shape_context_t *c)
 488 {
 489   hb_codepoint_t space;
 490   if (!c->font->get_glyph (' ', 0, &space))
 491     return; /* No point! */
 492
 493   unsigned int count = c->buffer->len;
 494   for (unsigned int i = 0; i < count; i++)
 495     if (unlikely (!is_a_ligature (c->buffer->info[i]) &&
 496                   _hb_glyph_info_is_zero_width (&c->buffer->info[i]))) {
 497       c->buffer->info[i].codepoint = space;
 498       c->buffer->pos[i].x_advance = 0;
 499       c->buffer->pos[i].y_advance = 0;
 500     }
 501 }
 502
 503
 504 /* Pull it all together! */
 505
 506 static void
 507 hb_ot_shape_internal (hb_ot_shape_context_t *c)
 508 {
 509   c->buffer->deallocate_var_all ();
 510
 511   /* Save the original direction, we use it later. */
 512   c->target_direction = c->buffer->props.direction;
 513
 514   HB_BUFFER_ALLOCATE_VAR (c->buffer, unicode_props0);
 515   HB_BUFFER_ALLOCATE_VAR (c->buffer, unicode_props1);
 516
 517   c->buffer->clear_output ();
 518
 519   hb_set_unicode_props (c->buffer);
 520   hb_form_clusters (c->buffer);
 521
 522   hb_ensure_native_direction (c->buffer);
 523
 524   hb_ot_substitute (c);
 525   hb_ot_position (c);
 526
 527   hb_ot_hide_zerowidth (c);
 528
 529   HB_BUFFER_DEALLOCATE_VAR (c->buffer, unicode_props1);
 530   HB_BUFFER_DEALLOCATE_VAR (c->buffer, unicode_props0);
 531
 532   c->buffer->props.direction = c->target_direction;
 533
 534   c->buffer->deallocate_var_all ();
 535 }
 536
 537
 538 hb_bool_t
 539 _hb_ot_shape (hb_shape_plan_t    *shape_plan,
 540               hb_font_t          *font,
 541               hb_buffer_t        *buffer,
 542               const hb_feature_t *features,
 543               unsigned int        num_features)
 544 {
 545   hb_ot_shape_context_t c = {HB_SHAPER_DATA_GET (shape_plan), font, font->face, buffer, features, num_features};
 546   hb_ot_shape_internal (&c);
 547
 548   return true;
 549 }
 550
 551
 552
 553 static inline void
 554 hb_ot_map_glyphs_dumb (hb_font_t    *font,
 555                        hb_buffer_t  *buffer)
 556 {
 557   unsigned int count = buffer->len;
 558   for (unsigned int i = 0; i < count; i++)
 559     font->get_glyph (buffer->cur().codepoint, 0, &buffer->cur().codepoint);
 560 }
 561
 562 void
 563 hb_ot_shape_glyphs_closure (hb_font_t          *font,
 564                             hb_buffer_t        *buffer,
 565                             const hb_feature_t *features,
 566                             unsigned int        num_features,
 567                             hb_set_t           *glyphs)
 568 {
 569   hb_ot_shape_plan_t plan;
 570
 571   buffer->guess_properties ();
 572
 573   /* TODO cache / ensure correct backend, etc. */
 574   hb_shape_plan_t *shape_plan = hb_shape_plan_create (font->face, &buffer->props, features, num_features, NULL);
 575
 576   /* TODO: normalization? have shapers do closure()? */
 577   /* TODO: Deal with mirrored chars? */
 578   hb_ot_map_glyphs_dumb (font, buffer);
 579
 580   /* Seed it.  It's user's responsibility to have cleard glyphs
 581    * if that's what they desire. */
 582   unsigned int count = buffer->len;
 583   for (unsigned int i = 0; i < count; i++)
 584     glyphs->add (buffer->info[i].codepoint);
 585
 586   /* And find transitive closure. */
 587   hb_set_t copy;
 588   copy.init ();
 589
 590   do {
 591     copy.set (glyphs);
 592     HB_SHAPER_DATA_GET (shape_plan)->substitute_closure (font->face, glyphs);
 593   } while (!copy.equal (glyphs));
 594
 595   hb_shape_plan_destroy (shape_plan);
 596 }