src/hb-shape-plan.cc

   1 /*
   2  * Copyright © 2012  Google, Inc.
   3  *
   4  *  This is part of HarfBuzz, a text shaping library.
   5  *
   6  * Permission is hereby granted, without written agreement and without
   7  * license or royalty fees, to use, copy, modify, and distribute this
   8  * software and its documentation for any purpose, provided that the
   9  * above copyright notice and the following two paragraphs appear in
  10  * all copies of this software.
  11  *
  12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  16  * DAMAGE.
  17  *
  18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  23  *
  24  * Google Author(s): Behdad Esfahbod
  25  */
  26
  27 #include "hb-private.hh"
  28 #include "hb-debug.hh"
  29 #include "hb-shape-plan-private.hh"
  30 #include "hb-shaper-private.hh"
  31 #include "hb-font-private.hh"
  32 #include "hb-buffer-private.hh"
  33
  34
  35 static void
  36 hb_shape_plan_plan (hb_shape_plan_t    *shape_plan,
  37                     const hb_feature_t *user_features,
  38                     unsigned int        num_user_features,
  39                     const int          *coords,
  40                     unsigned int        num_coords,
  41                     const char * const *shaper_list)
  42 {
  43   DEBUG_MSG_FUNC (SHAPE_PLAN, shape_plan,
  44                   "num_features=%d num_coords=%d shaper_list=%p",
  45                   num_user_features,
  46                   num_coords,
  47                   shaper_list);
  48
  49   const hb_shaper_pair_t *shapers = _hb_shapers_get ();
  50
  51 #define HB_SHAPER_PLAN(shaper) \
  52         HB_STMT_START { \
  53           if (hb_##shaper##_shaper_face_data_ensure (shape_plan->face_unsafe)) { \
  54             HB_SHAPER_DATA (shaper, shape_plan) = \
  55               HB_SHAPER_DATA_CREATE_FUNC (shaper, shape_plan) (shape_plan, \
  56                                                                user_features, num_user_features, \
  57                                                                coords, num_coords); \
  58             shape_plan->shaper_func = _hb_##shaper##_shape; \
  59             shape_plan->shaper_name = #shaper; \
  60             return; \
  61           } \
  62         } HB_STMT_END
  63
  64   if (likely (!shaper_list)) {
  65     for (unsigned int i = 0; i < HB_SHAPERS_COUNT; i++)
  66       if (0)
  67         ;
  68 #define HB_SHAPER_IMPLEMENT(shaper) \
  69       else if (shapers[i].func == _hb_##shaper##_shape) \
  70         HB_SHAPER_PLAN (shaper);
  71 #include "hb-shaper-list.hh"
  72 #undef HB_SHAPER_IMPLEMENT
  73   } else {
  74     for (; *shaper_list; shaper_list++)
  75       if (0)
  76         ;
  77 #define HB_SHAPER_IMPLEMENT(shaper) \
  78       else if (0 == strcmp (*shaper_list, #shaper)) \
  79         HB_SHAPER_PLAN (shaper);
  80 #include "hb-shaper-list.hh"
  81 #undef HB_SHAPER_IMPLEMENT
  82   }
  83
  84 #undef HB_SHAPER_PLAN
  85 }
  86
  87
  88 /*
  89  * hb_shape_plan_t
  90  */
  91
  92 /**
  93  * hb_shape_plan_create: (Xconstructor)
  94  * @face:
  95  * @props:
  96  * @user_features: (array length=num_user_features):
  97  * @num_user_features:
  98  * @shaper_list: (array zero-terminated=1):
  99  *
 100  *
 101  *
 102  * Return value: (transfer full):
 103  *
 104  * Since: 0.9.7
 105  **/
 106 hb_shape_plan_t *
 107 hb_shape_plan_create (hb_face_t                     *face,
 108                       const hb_segment_properties_t *props,
 109                       const hb_feature_t            *user_features,
 110                       unsigned int                   num_user_features,
 111                       const char * const            *shaper_list)
 112 {
 113   return hb_shape_plan_create2 (face, props,
 114                                 user_features, num_user_features,
 115                                 nullptr, 0,
 116                                 shaper_list);
 117 }
 118
 119 hb_shape_plan_t *
 120 hb_shape_plan_create2 (hb_face_t                     *face,
 121                        const hb_segment_properties_t *props,
 122                        const hb_feature_t            *user_features,
 123                        unsigned int                   num_user_features,
 124                        const int                     *orig_coords,
 125                        unsigned int                   num_coords,
 126                        const char * const            *shaper_list)
 127 {
 128   DEBUG_MSG_FUNC (SHAPE_PLAN, nullptr,
 129                   "face=%p num_features=%d num_coords=%d shaper_list=%p",
 130                   face,
 131                   num_user_features,
 132                   num_coords,
 133                   shaper_list);
 134
 135   hb_shape_plan_t *shape_plan;
 136   hb_feature_t *features = nullptr;
 137   int *coords = nullptr;
 138
 139   if (unlikely (!face))
 140     face = hb_face_get_empty ();
 141   if (unlikely (!props))
 142     return hb_shape_plan_get_empty ();
 143   if (num_user_features && !(features = (hb_feature_t *) calloc (num_user_features, sizeof (hb_feature_t))))
 144     return hb_shape_plan_get_empty ();
 145   if (num_coords && !(coords = (int *) calloc (num_coords, sizeof (int))))
 146   {
 147     free (features);
 148     return hb_shape_plan_get_empty ();
 149   }
 150   if (!(shape_plan = hb_object_create<hb_shape_plan_t> ()))
 151   {
 152     free (coords);
 153     free (features);
 154     return hb_shape_plan_get_empty ();
 155   }
 156
 157   assert (props->direction != HB_DIRECTION_INVALID);
 158
 159   hb_face_make_immutable (face);
 160   shape_plan->default_shaper_list = !shaper_list;
 161   shape_plan->face_unsafe = face;
 162   shape_plan->props = *props;
 163   shape_plan->num_user_features = num_user_features;
 164   shape_plan->user_features = features;
 165   if (num_user_features)
 166     memcpy (features, user_features, num_user_features * sizeof (hb_feature_t));
 167   shape_plan->num_coords = num_coords;
 168   shape_plan->coords = coords;
 169   if (num_coords)
 170     memcpy (coords, orig_coords, num_coords * sizeof (int));
 171
 172   hb_shape_plan_plan (shape_plan,
 173                       user_features, num_user_features,
 174                       coords, num_coords,
 175                       shaper_list);
 176
 177   return shape_plan;
 178 }
 179
 180 /**
 181  * hb_shape_plan_get_empty:
 182  *
 183  *
 184  *
 185  * Return value: (transfer full):
 186  *
 187  * Since: 0.9.7
 188  **/
 189 hb_shape_plan_t *
 190 hb_shape_plan_get_empty (void)
 191 {
 192   static const hb_shape_plan_t _hb_shape_plan_nil = {
 193     HB_OBJECT_HEADER_STATIC,
 194
 195     true, /* default_shaper_list */
 196     nullptr, /* face */
 197     HB_SEGMENT_PROPERTIES_DEFAULT, /* props */
 198
 199     nullptr, /* shaper_func */
 200     nullptr, /* shaper_name */
 201
 202     nullptr, /* user_features */
 203     0,    /* num_user_featurs */
 204
 205     nullptr, /* coords */
 206     0,    /* num_coords */
 207
 208     {
 209 #define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_INVALID,
 210 #include "hb-shaper-list.hh"
 211 #undef HB_SHAPER_IMPLEMENT
 212     }
 213   };
 214
 215   return const_cast<hb_shape_plan_t *> (&_hb_shape_plan_nil);
 216 }
 217
 218 /**
 219  * hb_shape_plan_reference: (skip)
 220  * @shape_plan: a shape plan.
 221  *
 222  *
 223  *
 224  * Return value: (transfer full):
 225  *
 226  * Since: 0.9.7
 227  **/
 228 hb_shape_plan_t *
 229 hb_shape_plan_reference (hb_shape_plan_t *shape_plan)
 230 {
 231   return hb_object_reference (shape_plan);
 232 }
 233
 234 /**
 235  * hb_shape_plan_destroy: (skip)
 236  * @shape_plan: a shape plan.
 237  *
 238  *
 239  *
 240  * Since: 0.9.7
 241  **/
 242 void
 243 hb_shape_plan_destroy (hb_shape_plan_t *shape_plan)
 244 {
 245   if (!hb_object_destroy (shape_plan)) return;
 246
 247 #define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_DESTROY(shaper, shape_plan);
 248 #include "hb-shaper-list.hh"
 249 #undef HB_SHAPER_IMPLEMENT
 250
 251   free (shape_plan->user_features);
 252   free (shape_plan->coords);
 253
 254   free (shape_plan);
 255 }
 256
 257 /**
 258  * hb_shape_plan_set_user_data: (skip)
 259  * @shape_plan: a shape plan.
 260  * @key:
 261  * @data:
 262  * @destroy:
 263  * @replace:
 264  *
 265  *
 266  *
 267  * Return value:
 268  *
 269  * Since: 0.9.7
 270  **/
 271 hb_bool_t
 272 hb_shape_plan_set_user_data (hb_shape_plan_t    *shape_plan,
 273                              hb_user_data_key_t *key,
 274                              void *              data,
 275                              hb_destroy_func_t   destroy,
 276                              hb_bool_t           replace)
 277 {
 278   return hb_object_set_user_data (shape_plan, key, data, destroy, replace);
 279 }
 280
 281 /**
 282  * hb_shape_plan_get_user_data: (skip)
 283  * @shape_plan: a shape plan.
 284  * @key:
 285  *
 286  *
 287  *
 288  * Return value: (transfer none):
 289  *
 290  * Since: 0.9.7
 291  **/
 292 void *
 293 hb_shape_plan_get_user_data (hb_shape_plan_t    *shape_plan,
 294                              hb_user_data_key_t *key)
 295 {
 296   return hb_object_get_user_data (shape_plan, key);
 297 }
 298
 299
 300 /**
 301  * hb_shape_plan_execute:
 302  * @shape_plan: a shape plan.
 303  * @font: a font.
 304  * @buffer: a buffer.
 305  * @features: (array length=num_features):
 306  * @num_features:
 307  *
 308  *
 309  *
 310  * Return value:
 311  *
 312  * Since: 0.9.7
 313  **/
 314 hb_bool_t
 315 hb_shape_plan_execute (hb_shape_plan_t    *shape_plan,
 316                        hb_font_t          *font,
 317                        hb_buffer_t        *buffer,
 318                        const hb_feature_t *features,
 319                        unsigned int        num_features)
 320 {
 321   DEBUG_MSG_FUNC (SHAPE_PLAN, shape_plan,
 322                   "num_features=%d shaper_func=%p, shaper_name=%s",
 323                   num_features,
 324                   shape_plan->shaper_func,
 325                   shape_plan->shaper_name);
 326
 327   if (unlikely (!buffer->len))
 328     return true;
 329
 330   assert (!hb_object_is_inert (buffer));
 331   assert (buffer->content_type == HB_BUFFER_CONTENT_TYPE_UNICODE);
 332
 333   if (unlikely (hb_object_is_inert (shape_plan)))
 334     return false;
 335
 336   assert (shape_plan->face_unsafe == font->face);
 337   assert (hb_segment_properties_equal (&shape_plan->props, &buffer->props));
 338
 339 #define HB_SHAPER_EXECUTE(shaper) \
 340         HB_STMT_START { \
 341           return HB_SHAPER_DATA (shaper, shape_plan) && \
 342                  hb_##shaper##_shaper_font_data_ensure (font) && \
 343                  _hb_##shaper##_shape (shape_plan, font, buffer, features, num_features); \
 344         } HB_STMT_END
 345
 346   if (0)
 347     ;
 348 #define HB_SHAPER_IMPLEMENT(shaper) \
 349   else if (shape_plan->shaper_func == _hb_##shaper##_shape) \
 350     HB_SHAPER_EXECUTE (shaper);
 351 #include "hb-shaper-list.hh"
 352 #undef HB_SHAPER_IMPLEMENT
 353
 354 #undef HB_SHAPER_EXECUTE
 355
 356   return false;
 357 }
 358
 359
 360 /*
 361  * caching
 362  */
 363
 364 #if 0
 365 static unsigned int
 366 hb_shape_plan_hash (const hb_shape_plan_t *shape_plan)
 367 {
 368   return hb_segment_properties_hash (&shape_plan->props) +
 369          shape_plan->default_shaper_list ? 0 : (intptr_t) shape_plan->shaper_func;
 370 }
 371 #endif
 372
 373 /* User-feature caching is currently somewhat dumb:
 374  * it only finds matches where the feature array is identical,
 375  * not cases where the feature lists would be compatible for plan purposes
 376  * but have different ranges, for example.
 377  */
 378 struct hb_shape_plan_proposal_t
 379 {
 380   const hb_segment_properties_t  props;
 381   const char * const            *shaper_list;
 382   const hb_feature_t            *user_features;
 383   unsigned int                   num_user_features;
 384   const int                     *coords;
 385   unsigned int                   num_coords;
 386   hb_shape_func_t               *shaper_func;
 387 };
 388
 389 static inline hb_bool_t
 390 hb_shape_plan_user_features_match (const hb_shape_plan_t          *shape_plan,
 391                                    const hb_shape_plan_proposal_t *proposal)
 392 {
 393   if (proposal->num_user_features != shape_plan->num_user_features)
 394     return false;
 395   for (unsigned int i = 0, n = proposal->num_user_features; i < n; i++)
 396     if (proposal->user_features[i].tag   != shape_plan->user_features[i].tag   ||
 397         proposal->user_features[i].value != shape_plan->user_features[i].value ||
 398         proposal->user_features[i].start != shape_plan->user_features[i].start ||
 399         proposal->user_features[i].end   != shape_plan->user_features[i].end)
 400       return false;
 401   return true;
 402 }
 403
 404 static inline hb_bool_t
 405 hb_shape_plan_coords_match (const hb_shape_plan_t          *shape_plan,
 406                             const hb_shape_plan_proposal_t *proposal)
 407 {
 408   if (proposal->num_coords != shape_plan->num_coords)
 409     return false;
 410   for (unsigned int i = 0, n = proposal->num_coords; i < n; i++)
 411     if (proposal->coords[i] != shape_plan->coords[i])
 412       return false;
 413   return true;
 414 }
 415
 416 static hb_bool_t
 417 hb_shape_plan_matches (const hb_shape_plan_t          *shape_plan,
 418                        const hb_shape_plan_proposal_t *proposal)
 419 {
 420   return hb_segment_properties_equal (&shape_plan->props, &proposal->props) &&
 421          hb_shape_plan_user_features_match (shape_plan, proposal) &&
 422          hb_shape_plan_coords_match (shape_plan, proposal) &&
 423          ((shape_plan->default_shaper_list && !proposal->shaper_list) ||
 424           (shape_plan->shaper_func == proposal->shaper_func));
 425 }
 426
 427 static inline hb_bool_t
 428 hb_non_global_user_features_present (const hb_feature_t *user_features,
 429                                      unsigned int        num_user_features)
 430 {
 431   while (num_user_features) {
 432     if (user_features->start != 0 || user_features->end != (unsigned int) -1)
 433       return true;
 434     num_user_features--;
 435     user_features++;
 436   }
 437   return false;
 438 }
 439
 440 static inline hb_bool_t
 441 hb_coords_present (const int *coords,
 442                    unsigned int num_coords)
 443 {
 444   return num_coords != 0;
 445 }
 446
 447 /**
 448  * hb_shape_plan_create_cached:
 449  * @face:
 450  * @props:
 451  * @user_features: (array length=num_user_features):
 452  * @num_user_features:
 453  * @shaper_list: (array zero-terminated=1):
 454  *
 455  *
 456  *
 457  * Return value: (transfer full):
 458  *
 459  * Since: 0.9.7
 460  **/
 461 hb_shape_plan_t *
 462 hb_shape_plan_create_cached (hb_face_t                     *face,
 463                              const hb_segment_properties_t *props,
 464                              const hb_feature_t            *user_features,
 465                              unsigned int                   num_user_features,
 466                              const char * const            *shaper_list)
 467 {
 468   return hb_shape_plan_create_cached2 (face, props,
 469                                        user_features, num_user_features,
 470                                        nullptr, 0,
 471                                        shaper_list);
 472 }
 473
 474 hb_shape_plan_t *
 475 hb_shape_plan_create_cached2 (hb_face_t                     *face,
 476                               const hb_segment_properties_t *props,
 477                               const hb_feature_t            *user_features,
 478                               unsigned int                   num_user_features,
 479                               const int                     *coords,
 480                               unsigned int                   num_coords,
 481                               const char * const            *shaper_list)
 482 {
 483   DEBUG_MSG_FUNC (SHAPE_PLAN, nullptr,
 484                   "face=%p num_features=%d shaper_list=%p",
 485                   face,
 486                   num_user_features,
 487                   shaper_list);
 488
 489   hb_shape_plan_proposal_t proposal = {
 490     *props,
 491     shaper_list,
 492     user_features,
 493     num_user_features,
 494     nullptr
 495   };
 496
 497   if (shaper_list) {
 498     /* Choose shaper.  Adapted from hb_shape_plan_plan().
 499      * Must choose shaper exactly the same way as that function. */
 500     for (const char * const *shaper_item = shaper_list; *shaper_item; shaper_item++)
 501       if (0)
 502         ;
 503 #define HB_SHAPER_IMPLEMENT(shaper) \
 504       else if (0 == strcmp (*shaper_item, #shaper) && \
 505                hb_##shaper##_shaper_face_data_ensure (face)) \
 506       { \
 507         proposal.shaper_func = _hb_##shaper##_shape; \
 508         break; \
 509       }
 510 #include "hb-shaper-list.hh"
 511 #undef HB_SHAPER_IMPLEMENT
 512
 513     if (unlikely (!proposal.shaper_func))
 514       return hb_shape_plan_get_empty ();
 515   }
 516
 517
 518 retry:
 519   hb_face_t::plan_node_t *cached_plan_nodes = (hb_face_t::plan_node_t *) hb_atomic_ptr_get (&face->shape_plans);
 520
 521   /* Don't look for plan in the cache if there were variation coordinates XXX Fix me. */
 522   if (!hb_coords_present (coords, num_coords))
 523     for (hb_face_t::plan_node_t *node = cached_plan_nodes; node; node = node->next)
 524       if (hb_shape_plan_matches (node->shape_plan, &proposal))
 525       {
 526         DEBUG_MSG_FUNC (SHAPE_PLAN, node->shape_plan, "fulfilled from cache");
 527         return hb_shape_plan_reference (node->shape_plan);
 528       }
 529
 530   /* Not found. */
 531   hb_shape_plan_t *shape_plan = hb_shape_plan_create2 (face, props,
 532                                                        user_features, num_user_features,
 533                                                        coords, num_coords,
 534                                                        shaper_list);
 535
 536   /* Don't add to the cache if face is inert. */
 537   if (unlikely (hb_object_is_inert (face)))
 538     return shape_plan;
 539
 540   /* Don't add the plan to the cache if there were user features with non-global ranges */
 541   if (hb_non_global_user_features_present (user_features, num_user_features))
 542     return shape_plan;
 543   /* Don't add the plan to the cache if there were variation coordinates XXX Fix me. */
 544   if (hb_coords_present (coords, num_coords))
 545     return shape_plan;
 546
 547   hb_face_t::plan_node_t *node = (hb_face_t::plan_node_t *) calloc (1, sizeof (hb_face_t::plan_node_t));
 548   if (unlikely (!node))
 549     return shape_plan;
 550
 551   node->shape_plan = shape_plan;
 552   node->next = cached_plan_nodes;
 553
 554   if (!hb_atomic_ptr_cmpexch (&face->shape_plans, cached_plan_nodes, node)) {
 555     hb_shape_plan_destroy (shape_plan);
 556     free (node);
 557     goto retry;
 558   }
 559   DEBUG_MSG_FUNC (SHAPE_PLAN, shape_plan, "inserted into cache");
 560
 561   return hb_shape_plan_reference (shape_plan);
 562 }
 563
 564 /**
 565  * hb_shape_plan_get_shaper:
 566  * @shape_plan: a shape plan.
 567  *
 568  *
 569  *
 570  * Return value: (transfer none):
 571  *
 572  * Since: 0.9.7
 573  **/
 574 const char *
 575 hb_shape_plan_get_shaper (hb_shape_plan_t *shape_plan)
 576 {
 577   return shape_plan->shaper_name;
 578 }