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.hh" 28 #include "hb-shape-plan.hh" 29 #include "hb-shaper.hh" 30 #include "hb-font.hh" 31 #include "hb-buffer.hh" 32 33 34 /** 35 * SECTION:hb-shape-plan 36 * @title: hb-shape-plan 37 * @short_description: Object representing a shaping plan 38 * @include: hb.h 39 * 40 * Shape plans are not used for shaping directly, but can be access to query 41 * certain information about how shaping will perform given a set of input 42 * parameters (script, language, direction, features, etc.) 43 * Most client would not need to deal with shape plans directly. 44 **/ 45 46 47 /* 48 * hb_shape_plan_key_t 49 */ 50 51 bool 52 hb_shape_plan_key_t::init (bool copy, 53 hb_face_t *face, 54 const hb_segment_properties_t *props, 55 const hb_feature_t *user_features, 56 unsigned int num_user_features, 57 const int *coords, 58 unsigned int num_coords, 59 const char * const *shaper_list) 60 { 61 hb_feature_t *features = nullptr; 62 if (copy && num_user_features && !(features = (hb_feature_t *) calloc (num_user_features, sizeof (hb_feature_t)))) 63 goto bail; 64 65 this->props = *props; 66 this->num_user_features = num_user_features; 67 this->user_features = copy ? features : user_features; 68 if (copy && num_user_features) 69 { 70 memcpy (features, user_features, num_user_features * sizeof (hb_feature_t)); 71 /* Make start/end uniform to easier catch bugs. */ 72 for (unsigned int i = 0; i < num_user_features; i++) 73 { 74 if (features[0].start != HB_FEATURE_GLOBAL_START) 75 features[0].start = 1; 76 if (features[0].end != HB_FEATURE_GLOBAL_END) 77 features[0].end = 2; 78 } 79 } 80 this->shaper_func = nullptr; 81 this->shaper_name = nullptr; 82 this->ot.init (face, coords, num_coords); 83 84 /* 85 * Choose shaper. 86 */ 87 88 #define HB_SHAPER_PLAN(shaper) \ 89 HB_STMT_START { \ 90 if (face->data.shaper) \ 91 { \ 92 this->shaper_func = _hb_##shaper##_shape; \ 93 this->shaper_name = #shaper; \ 94 return true; \ 95 } \ 96 } HB_STMT_END 97 98 if (unlikely (shaper_list)) 99 { 100 for (; *shaper_list; shaper_list++) 101 if (false) 102 ; 103 #define HB_SHAPER_IMPLEMENT(shaper) \ 104 else if (0 == strcmp (*shaper_list, #shaper)) \ 105 HB_SHAPER_PLAN (shaper); 106 #include "hb-shaper-list.hh" 107 #undef HB_SHAPER_IMPLEMENT 108 } 109 else 110 { 111 const hb_shaper_entry_t *shapers = _hb_shapers_get (); 112 for (unsigned int i = 0; i < HB_SHAPERS_COUNT; i++) 113 if (false) 114 ; 115 #define HB_SHAPER_IMPLEMENT(shaper) \ 116 else if (shapers[i].func == _hb_##shaper##_shape) \ 117 HB_SHAPER_PLAN (shaper); 118 #include "hb-shaper-list.hh" 119 #undef HB_SHAPER_IMPLEMENT 120 } 121 #undef HB_SHAPER_PLAN 122 123 bail: 124 ::free (features); 125 return false; 126 } 127 128 bool 129 hb_shape_plan_key_t::user_features_match (const hb_shape_plan_key_t *other) 130 { 131 if (this->num_user_features != other->num_user_features) 132 return false; 133 for (unsigned int i = 0; i < num_user_features; i++) 134 { 135 if (this->user_features[i].tag != other->user_features[i].tag || 136 this->user_features[i].value != other->user_features[i].value || 137 (this->user_features[i].start == HB_FEATURE_GLOBAL_START && 138 this->user_features[i].end == HB_FEATURE_GLOBAL_END) != 139 (other->user_features[i].start == HB_FEATURE_GLOBAL_START && 140 other->user_features[i].end == HB_FEATURE_GLOBAL_END)) 141 return false; 142 } 143 return true; 144 } 145 146 bool 147 hb_shape_plan_key_t::equal (const hb_shape_plan_key_t *other) 148 { 149 return hb_segment_properties_equal (&this->props, &other->props) && 150 this->user_features_match (other) && 151 this->ot.equal (&other->ot) && 152 this->shaper_func == other->shaper_func; 153 } 154 155 156 /* 157 * hb_shape_plan_t 158 */ 159 160 161 /** 162 * hb_shape_plan_create: (Xconstructor) 163 * @face: 164 * @props: 165 * @user_features: (array length=num_user_features): 166 * @num_user_features: 167 * @shaper_list: (array zero-terminated=1): 168 * 169 * 170 * 171 * Return value: (transfer full): 172 * 173 * Since: 0.9.7 174 **/ 175 hb_shape_plan_t * 176 hb_shape_plan_create (hb_face_t *face, 177 const hb_segment_properties_t *props, 178 const hb_feature_t *user_features, 179 unsigned int num_user_features, 180 const char * const *shaper_list) 181 { 182 return hb_shape_plan_create2 (face, props, 183 user_features, num_user_features, 184 nullptr, 0, 185 shaper_list); 186 } 187 188 hb_shape_plan_t * 189 hb_shape_plan_create2 (hb_face_t *face, 190 const hb_segment_properties_t *props, 191 const hb_feature_t *user_features, 192 unsigned int num_user_features, 193 const int *coords, 194 unsigned int num_coords, 195 const char * const *shaper_list) 196 { 197 DEBUG_MSG_FUNC (SHAPE_PLAN, nullptr, 198 "face=%p num_features=%d num_coords=%d shaper_list=%p", 199 face, 200 num_user_features, 201 num_coords, 202 shaper_list); 203 204 assert (props->direction != HB_DIRECTION_INVALID); 205 206 hb_shape_plan_t *shape_plan; 207 208 if (unlikely (!props)) 209 goto bail; 210 if (!(shape_plan = hb_object_create<hb_shape_plan_t> ())) 211 goto bail; 212 213 if (unlikely (!face)) 214 face = hb_face_get_empty (); 215 hb_face_make_immutable (face); 216 shape_plan->face_unsafe = face; 217 218 if (unlikely (!shape_plan->key.init (true, 219 face, 220 props, 221 user_features, 222 num_user_features, 223 coords, 224 num_coords, 225 shaper_list))) 226 goto bail2; 227 if (unlikely (!shape_plan->ot.init0 (face, &shape_plan->key))) 228 goto bail3; 229 230 return shape_plan; 231 232 bail3: 233 shape_plan->key.free (); 234 bail2: 235 free (shape_plan); 236 bail: 237 return hb_shape_plan_get_empty (); 238 } 239 240 /** 241 * hb_shape_plan_get_empty: 242 * 243 * 244 * 245 * Return value: (transfer full): 246 * 247 * Since: 0.9.7 248 **/ 249 hb_shape_plan_t * 250 hb_shape_plan_get_empty () 251 { 252 return const_cast<hb_shape_plan_t *> (&Null(hb_shape_plan_t)); 253 } 254 255 /** 256 * hb_shape_plan_reference: (skip) 257 * @shape_plan: a shape plan. 258 * 259 * 260 * 261 * Return value: (transfer full): 262 * 263 * Since: 0.9.7 264 **/ 265 hb_shape_plan_t * 266 hb_shape_plan_reference (hb_shape_plan_t *shape_plan) 267 { 268 return hb_object_reference (shape_plan); 269 } 270 271 /** 272 * hb_shape_plan_destroy: (skip) 273 * @shape_plan: a shape plan. 274 * 275 * 276 * 277 * Since: 0.9.7 278 **/ 279 void 280 hb_shape_plan_destroy (hb_shape_plan_t *shape_plan) 281 { 282 if (!hb_object_destroy (shape_plan)) return; 283 284 shape_plan->ot.fini (); 285 shape_plan->key.free (); 286 free (shape_plan); 287 } 288 289 /** 290 * hb_shape_plan_set_user_data: (skip) 291 * @shape_plan: a shape plan. 292 * @key: 293 * @data: 294 * @destroy: 295 * @replace: 296 * 297 * 298 * 299 * Return value: 300 * 301 * Since: 0.9.7 302 **/ 303 hb_bool_t 304 hb_shape_plan_set_user_data (hb_shape_plan_t *shape_plan, 305 hb_user_data_key_t *key, 306 void * data, 307 hb_destroy_func_t destroy, 308 hb_bool_t replace) 309 { 310 return hb_object_set_user_data (shape_plan, key, data, destroy, replace); 311 } 312 313 /** 314 * hb_shape_plan_get_user_data: (skip) 315 * @shape_plan: a shape plan. 316 * @key: 317 * 318 * 319 * 320 * Return value: (transfer none): 321 * 322 * Since: 0.9.7 323 **/ 324 void * 325 hb_shape_plan_get_user_data (hb_shape_plan_t *shape_plan, 326 hb_user_data_key_t *key) 327 { 328 return hb_object_get_user_data (shape_plan, key); 329 } 330 331 /** 332 * hb_shape_plan_get_shaper: 333 * @shape_plan: a shape plan. 334 * 335 * 336 * 337 * Return value: (transfer none): 338 * 339 * Since: 0.9.7 340 **/ 341 const char * 342 hb_shape_plan_get_shaper (hb_shape_plan_t *shape_plan) 343 { 344 return shape_plan->key.shaper_name; 345 } 346 347 348 /** 349 * hb_shape_plan_execute: 350 * @shape_plan: a shape plan. 351 * @font: a font. 352 * @buffer: a buffer. 353 * @features: (array length=num_features): 354 * @num_features: 355 * 356 * 357 * 358 * Return value: 359 * 360 * Since: 0.9.7 361 **/ 362 hb_bool_t 363 hb_shape_plan_execute (hb_shape_plan_t *shape_plan, 364 hb_font_t *font, 365 hb_buffer_t *buffer, 366 const hb_feature_t *features, 367 unsigned int num_features) 368 { 369 DEBUG_MSG_FUNC (SHAPE_PLAN, shape_plan, 370 "num_features=%d shaper_func=%p, shaper_name=%s", 371 num_features, 372 shape_plan->key.shaper_func, 373 shape_plan->key.shaper_name); 374 375 if (unlikely (!buffer->len)) 376 return true; 377 378 assert (!hb_object_is_immutable (buffer)); 379 assert (buffer->content_type == HB_BUFFER_CONTENT_TYPE_UNICODE); 380 381 if (unlikely (hb_object_is_inert (shape_plan))) 382 return false; 383 384 assert (shape_plan->face_unsafe == font->face); 385 assert (hb_segment_properties_equal (&shape_plan->key.props, &buffer->props)); 386 387 #define HB_SHAPER_EXECUTE(shaper) \ 388 HB_STMT_START { \ 389 return font->data.shaper && \ 390 _hb_##shaper##_shape (shape_plan, font, buffer, features, num_features); \ 391 } HB_STMT_END 392 393 if (false) 394 ; 395 #define HB_SHAPER_IMPLEMENT(shaper) \ 396 else if (shape_plan->key.shaper_func == _hb_##shaper##_shape) \ 397 HB_SHAPER_EXECUTE (shaper); 398 #include "hb-shaper-list.hh" 399 #undef HB_SHAPER_IMPLEMENT 400 401 #undef HB_SHAPER_EXECUTE 402 403 return false; 404 } 405 406 407 /* 408 * Caching 409 */ 410 411 /** 412 * hb_shape_plan_create_cached: 413 * @face: 414 * @props: 415 * @user_features: (array length=num_user_features): 416 * @num_user_features: 417 * @shaper_list: (array zero-terminated=1): 418 * 419 * 420 * 421 * Return value: (transfer full): 422 * 423 * Since: 0.9.7 424 **/ 425 hb_shape_plan_t * 426 hb_shape_plan_create_cached (hb_face_t *face, 427 const hb_segment_properties_t *props, 428 const hb_feature_t *user_features, 429 unsigned int num_user_features, 430 const char * const *shaper_list) 431 { 432 return hb_shape_plan_create_cached2 (face, props, 433 user_features, num_user_features, 434 nullptr, 0, 435 shaper_list); 436 } 437 438 hb_shape_plan_t * 439 hb_shape_plan_create_cached2 (hb_face_t *face, 440 const hb_segment_properties_t *props, 441 const hb_feature_t *user_features, 442 unsigned int num_user_features, 443 const int *coords, 444 unsigned int num_coords, 445 const char * const *shaper_list) 446 { 447 DEBUG_MSG_FUNC (SHAPE_PLAN, nullptr, 448 "face=%p num_features=%d shaper_list=%p", 449 face, 450 num_user_features, 451 shaper_list); 452 453 retry: 454 hb_face_t::plan_node_t *cached_plan_nodes = face->shape_plans; 455 456 bool dont_cache = hb_object_is_inert (face); 457 458 if (likely (!dont_cache)) 459 { 460 hb_shape_plan_key_t key; 461 if (!key.init (false, 462 face, 463 props, 464 user_features, 465 num_user_features, 466 coords, 467 num_coords, 468 shaper_list)) 469 return hb_shape_plan_get_empty (); 470 471 for (hb_face_t::plan_node_t *node = cached_plan_nodes; node; node = node->next) 472 if (node->shape_plan->key.equal (&key)) 473 { 474 DEBUG_MSG_FUNC (SHAPE_PLAN, node->shape_plan, "fulfilled from cache"); 475 return hb_shape_plan_reference (node->shape_plan); 476 } 477 } 478 479 hb_shape_plan_t *shape_plan = hb_shape_plan_create2 (face, props, 480 user_features, num_user_features, 481 coords, num_coords, 482 shaper_list); 483 484 if (unlikely (dont_cache)) 485 return shape_plan; 486 487 hb_face_t::plan_node_t *node = (hb_face_t::plan_node_t *) calloc (1, sizeof (hb_face_t::plan_node_t)); 488 if (unlikely (!node)) 489 return shape_plan; 490 491 node->shape_plan = shape_plan; 492 node->next = cached_plan_nodes; 493 494 if (unlikely (!face->shape_plans.cmpexch (cached_plan_nodes, node))) 495 { 496 hb_shape_plan_destroy (shape_plan); 497 free (node); 498 goto retry; 499 } 500 DEBUG_MSG_FUNC (SHAPE_PLAN, shape_plan, "inserted into cache"); 501 502 return hb_shape_plan_reference (shape_plan); 503 } 504
