src/hb-font.cc

   1 /*
   2  * Copyright © 2009  Red Hat, 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  * Red Hat Author(s): Behdad Esfahbod
  25  */
  26
  27 #include "hb-private.hh"
  28
  29 #include "hb-font-private.hh"
  30 #include "hb-blob-private.hh"
  31 #include "hb-open-file-private.hh"
  32
  33 #include "hb-ot-layout-private.hh"
  34
  35 #include <string.h>
  36
  37 HB_BEGIN_DECLS
  38
  39
  40 /*
  41  * hb_font_funcs_t
  42  */
  43
  44 static hb_codepoint_t
  45 hb_font_get_glyph_nil (hb_font_t *font HB_UNUSED,
  46                        const void *user_data HB_UNUSED,
  47                        hb_codepoint_t unicode HB_UNUSED,
  48                        hb_codepoint_t variation_selector HB_UNUSED)
  49 { return 0; }
  50
  51 static void
  52 hb_font_get_glyph_advance_nil (hb_font_t *font HB_UNUSED,
  53                                const void *user_data HB_UNUSED,
  54                                hb_codepoint_t glyph HB_UNUSED,
  55                                hb_position_t *x_advance HB_UNUSED,
  56                                hb_position_t *y_advance HB_UNUSED)
  57 { }
  58
  59 static void
  60 hb_font_get_glyph_extents_nil (hb_font_t *font HB_UNUSED,
  61                                const void *user_data HB_UNUSED,
  62                                hb_codepoint_t glyph HB_UNUSED,
  63                                hb_glyph_extents_t *extents HB_UNUSED)
  64 { }
  65
  66 static hb_bool_t
  67 hb_font_get_contour_point_nil (hb_font_t *font HB_UNUSED,
  68                                const void *user_data HB_UNUSED,
  69                                unsigned int point_index HB_UNUSED,
  70                                hb_codepoint_t glyph HB_UNUSED,
  71                                hb_position_t *x HB_UNUSED,
  72                                hb_position_t *y HB_UNUSED)
  73 { return false; }
  74
  75 static hb_position_t
  76 hb_font_get_kerning_nil (hb_font_t *font HB_UNUSED,
  77                          const void *user_data HB_UNUSED,
  78                          hb_codepoint_t first_glyph HB_UNUSED,
  79                          hb_codepoint_t second_glyph HB_UNUSED)
  80 { return 0; }
  81
  82 hb_font_funcs_t _hb_font_funcs_nil = {
  83   HB_OBJECT_HEADER_STATIC,
  84
  85   TRUE,  /* immutable */
  86   {
  87     hb_font_get_glyph_nil,
  88     hb_font_get_glyph_advance_nil,
  89     hb_font_get_glyph_extents_nil,
  90     hb_font_get_contour_point_nil,
  91     hb_font_get_kerning_nil
  92   }
  93 };
  94
  95 hb_font_funcs_t *
  96 hb_font_funcs_create (void)
  97 {
  98   hb_font_funcs_t *ffuncs;
  99
 100   if (!(ffuncs = hb_object_create<hb_font_funcs_t> ()))
 101     return &_hb_font_funcs_nil;
 102
 103   ffuncs->v = _hb_font_funcs_nil.v;
 104
 105   return ffuncs;
 106 }
 107
 108 hb_font_funcs_t *
 109 hb_font_funcs_reference (hb_font_funcs_t *ffuncs)
 110 {
 111   return hb_object_reference (ffuncs);
 112 }
 113
 114 void
 115 hb_font_funcs_destroy (hb_font_funcs_t *ffuncs)
 116 {
 117   if (!hb_object_destroy (ffuncs)) return;
 118
 119   free (ffuncs);
 120 }
 121
 122 hb_bool_t
 123 hb_font_funcs_set_user_data (hb_font_funcs_t    *ffuncs,
 124                              hb_user_data_key_t *key,
 125                              void *              data,
 126                              hb_destroy_func_t   destroy)
 127 {
 128   return hb_object_set_user_data (ffuncs, key, data, destroy);
 129 }
 130
 131 void *
 132 hb_font_funcs_get_user_data (hb_font_funcs_t    *ffuncs,
 133                              hb_user_data_key_t *key)
 134 {
 135   return hb_object_get_user_data (ffuncs, key);
 136 }
 137
 138
 139 void
 140 hb_font_funcs_make_immutable (hb_font_funcs_t *ffuncs)
 141 {
 142   if (hb_object_is_inert (ffuncs))
 143     return;
 144
 145   ffuncs->immutable = TRUE;
 146 }
 147
 148 hb_bool_t
 149 hb_font_funcs_is_immutable (hb_font_funcs_t *ffuncs)
 150 {
 151   return ffuncs->immutable;
 152 }
 153
 154
 155 void
 156 hb_font_funcs_set_glyph_func (hb_font_funcs_t *ffuncs,
 157                               hb_font_get_glyph_func_t glyph_func)
 158 {
 159   if (ffuncs->immutable)
 160     return;
 161
 162   ffuncs->v.get_glyph = glyph_func ? glyph_func : hb_font_get_glyph_nil;
 163 }
 164
 165 void
 166 hb_font_funcs_set_glyph_advance_func (hb_font_funcs_t *ffuncs,
 167                                       hb_font_get_glyph_advance_func_t glyph_advance_func)
 168 {
 169   if (ffuncs->immutable)
 170     return;
 171
 172   ffuncs->v.get_glyph_advance = glyph_advance_func ? glyph_advance_func : hb_font_get_glyph_advance_nil;
 173 }
 174
 175 void
 176 hb_font_funcs_set_glyph_extents_func (hb_font_funcs_t *ffuncs,
 177                                       hb_font_get_glyph_extents_func_t glyph_extents_func)
 178 {
 179   if (ffuncs->immutable)
 180     return;
 181
 182   ffuncs->v.get_glyph_extents = glyph_extents_func ? glyph_extents_func : hb_font_get_glyph_extents_nil;
 183 }
 184
 185 void
 186 hb_font_funcs_set_contour_point_func (hb_font_funcs_t *ffuncs,
 187                                       hb_font_get_contour_point_func_t contour_point_func)
 188 {
 189   if (ffuncs->immutable)
 190     return;
 191
 192   ffuncs->v.get_contour_point = contour_point_func ? contour_point_func : hb_font_get_contour_point_nil;
 193 }
 194
 195 void
 196 hb_font_funcs_set_kerning_func (hb_font_funcs_t *ffuncs,
 197                                 hb_font_get_kerning_func_t kerning_func)
 198 {
 199   if (ffuncs->immutable)
 200     return;
 201
 202   ffuncs->v.get_kerning = kerning_func ? kerning_func : hb_font_get_kerning_nil;
 203 }
 204
 205
 206 hb_font_get_glyph_func_t
 207 hb_font_funcs_get_glyph_func (hb_font_funcs_t *ffuncs)
 208 {
 209   return ffuncs->v.get_glyph;
 210 }
 211
 212 hb_font_get_glyph_advance_func_t
 213 hb_font_funcs_get_glyph_advance_func (hb_font_funcs_t *ffuncs)
 214 {
 215   return ffuncs->v.get_glyph_advance;
 216 }
 217
 218 hb_font_get_glyph_extents_func_t
 219 hb_font_funcs_get_glyph_extents_func (hb_font_funcs_t *ffuncs)
 220 {
 221   return ffuncs->v.get_glyph_extents;
 222 }
 223
 224 hb_font_get_contour_point_func_t
 225 hb_font_funcs_get_contour_point_func (hb_font_funcs_t *ffuncs)
 226 {
 227   return ffuncs->v.get_contour_point;
 228 }
 229
 230 hb_font_get_kerning_func_t
 231 hb_font_funcs_get_kerning_func (hb_font_funcs_t *ffuncs)
 232 {
 233   return ffuncs->v.get_kerning;
 234 }
 235
 236
 237
 238 hb_codepoint_t
 239 hb_font_get_glyph (hb_font_t *font,
 240                    hb_codepoint_t unicode, hb_codepoint_t variation_selector)
 241 {
 242   return font->klass->v.get_glyph (font, font->user_data,
 243                                    unicode, variation_selector);
 244 }
 245
 246 void
 247 hb_font_get_glyph_advance (hb_font_t *font,
 248                            hb_codepoint_t glyph,
 249                            hb_position_t *x_advance, hb_position_t *y_advance)
 250 {
 251   *x_advance = *y_advance = 0;
 252   return font->klass->v.get_glyph_advance (font, font->user_data,
 253                                            glyph, x_advance, y_advance);
 254 }
 255
 256 void
 257 hb_font_get_glyph_extents (hb_font_t *font,
 258                            hb_codepoint_t glyph, hb_glyph_extents_t *extents)
 259 {
 260   memset (extents, 0, sizeof (*extents));
 261   return font->klass->v.get_glyph_extents (font, font->user_data,
 262                                            glyph, extents);
 263 }
 264
 265 hb_bool_t
 266 hb_font_get_contour_point (hb_font_t *font,
 267                            unsigned int point_index,
 268                            hb_codepoint_t glyph, hb_position_t *x, hb_position_t *y)
 269 {
 270   *x = 0; *y = 0;
 271   return font->klass->v.get_contour_point (font, font->user_data,
 272                                            point_index,
 273                                            glyph, x, y);
 274 }
 275
 276 hb_position_t
 277 hb_font_get_kerning (hb_font_t *font,
 278                      hb_codepoint_t first_glyph, hb_codepoint_t second_glyph)
 279 {
 280   return font->klass->v.get_kerning (font, font->user_data,
 281                                      first_glyph, second_glyph);
 282 }
 283
 284
 285 /*
 286  * hb_face_t
 287  */
 288
 289 static hb_face_t _hb_face_nil = {
 290   HB_OBJECT_HEADER_STATIC,
 291
 292   NULL, /* get_table */
 293   NULL, /* user_data */
 294   NULL, /* destroy */
 295
 296   NULL, /* head_blob */
 297   NULL, /* head_table */
 298
 299   NULL  /* ot_layout */
 300 };
 301
 302
 303 hb_face_t *
 304 hb_face_create_for_tables (hb_get_table_func_t  get_table,
 305                            void                *user_data,
 306                            hb_destroy_func_t    destroy)
 307 {
 308   hb_face_t *face;
 309
 310   if (!get_table || !(face = hb_object_create<hb_face_t> ())) {
 311     if (destroy)
 312       destroy (user_data);
 313     return &_hb_face_nil;
 314   }
 315
 316   face->get_table = get_table;
 317   face->user_data = user_data;
 318   face->destroy = destroy;
 319
 320   face->ot_layout = _hb_ot_layout_new (face);
 321
 322   face->head_blob = Sanitizer<head>::sanitize (hb_face_reference_table (face, HB_OT_TAG_head));
 323   face->head_table = Sanitizer<head>::lock_instance (face->head_blob);
 324
 325   return face;
 326 }
 327
 328
 329 typedef struct _hb_face_for_data_closure_t {
 330   hb_blob_t *blob;
 331   unsigned int  index;
 332 } hb_face_for_data_closure_t;
 333
 334 static hb_face_for_data_closure_t *
 335 _hb_face_for_data_closure_create (hb_blob_t *blob, unsigned int index)
 336 {
 337   hb_face_for_data_closure_t *closure;
 338
 339   closure = (hb_face_for_data_closure_t *) malloc (sizeof (hb_face_for_data_closure_t));
 340   if (unlikely (!closure))
 341     return NULL;
 342
 343   closure->blob = blob;
 344   closure->index = index;
 345
 346   return closure;
 347 }
 348
 349 static void
 350 _hb_face_for_data_closure_destroy (hb_face_for_data_closure_t *closure)
 351 {
 352   hb_blob_destroy (closure->blob);
 353   free (closure);
 354 }
 355
 356 static hb_blob_t *
 357 _hb_face_for_data_get_table (hb_tag_t tag, void *user_data)
 358 {
 359   hb_face_for_data_closure_t *data = (hb_face_for_data_closure_t *) user_data;
 360
 361   const OpenTypeFontFile &ot_file = *Sanitizer<OpenTypeFontFile>::lock_instance (data->blob);
 362   const OpenTypeFontFace &ot_face = ot_file.get_face (data->index);
 363
 364   const OpenTypeTable &table = ot_face.get_table_by_tag (tag);
 365
 366   hb_blob_t *blob = hb_blob_create_sub_blob (data->blob, table.offset, table.length);
 367
 368   hb_blob_unlock (data->blob);
 369
 370   return blob;
 371 }
 372
 373 hb_face_t *
 374 hb_face_create_for_data (hb_blob_t    *blob,
 375                          unsigned int  index)
 376 {
 377   if (unlikely (!blob || hb_object_is_inert (blob)))
 378     return &_hb_face_nil;
 379
 380   hb_face_for_data_closure_t *closure = _hb_face_for_data_closure_create (Sanitizer<OpenTypeFontFile>::sanitize (hb_blob_reference (blob)), index);
 381
 382   if (unlikely (!closure))
 383     return &_hb_face_nil;
 384
 385   return hb_face_create_for_tables (_hb_face_for_data_get_table,
 386                                     closure,
 387                                     (hb_destroy_func_t) _hb_face_for_data_closure_destroy);
 388 }
 389
 390
 391 hb_face_t *
 392 hb_face_reference (hb_face_t *face)
 393 {
 394   return hb_object_reference (face);
 395 }
 396
 397 void
 398 hb_face_destroy (hb_face_t *face)
 399 {
 400   if (!hb_object_destroy (face)) return;
 401
 402   _hb_ot_layout_free (face->ot_layout);
 403
 404   hb_blob_unlock (face->head_blob);
 405   hb_blob_destroy (face->head_blob);
 406
 407   if (face->destroy)
 408     face->destroy (face->user_data);
 409
 410   free (face);
 411 }
 412
 413 hb_bool_t
 414 hb_face_set_user_data (hb_face_t          *face,
 415                        hb_user_data_key_t *key,
 416                        void *              data,
 417                        hb_destroy_func_t   destroy)
 418 {
 419   return hb_object_set_user_data (face, key, data, destroy);
 420 }
 421
 422 void *
 423 hb_face_get_user_data (hb_face_t          *face,
 424                        hb_user_data_key_t *key)
 425 {
 426   return hb_object_get_user_data (face, key);
 427 }
 428
 429
 430 hb_blob_t *
 431 hb_face_reference_table (hb_face_t *face,
 432                          hb_tag_t   tag)
 433 {
 434   hb_blob_t *blob;
 435
 436   if (unlikely (!face || !face->get_table))
 437     return &_hb_blob_nil;
 438
 439   blob = face->get_table (tag, face->user_data);
 440   if (unlikely (!blob))
 441     blob = hb_blob_get_empty();
 442
 443   return blob;
 444 }
 445
 446 unsigned int
 447 hb_face_get_upem (hb_face_t *face)
 448 {
 449   return (face->head_table ? face->head_table : &Null(head))->get_upem ();
 450 }
 451
 452
 453 /*
 454  * hb_font_t
 455  */
 456
 457 static hb_font_t _hb_font_nil = {
 458   HB_OBJECT_HEADER_STATIC,
 459
 460   &_hb_face_nil,
 461
 462   0, /* x_scale */
 463   0, /* y_scale */
 464
 465   0, /* x_ppem */
 466   0, /* y_ppem */
 467
 468   NULL, /* klass */
 469   NULL, /* user_data */
 470   NULL  /* destroy */
 471 };
 472
 473 hb_font_t *
 474 hb_font_create (hb_face_t *face)
 475 {
 476   hb_font_t *font;
 477
 478   if (unlikely (!face))
 479     face = &_hb_face_nil;
 480   if (unlikely (hb_object_is_inert (face)))
 481     return &_hb_font_nil;
 482   if (!(font = hb_object_create<hb_font_t> ()))
 483     return &_hb_font_nil;
 484
 485   font->face = hb_face_reference (face);
 486   font->klass = &_hb_font_funcs_nil;
 487
 488   return font;
 489 }
 490
 491 hb_font_t *
 492 hb_font_reference (hb_font_t *font)
 493 {
 494   return hb_object_reference (font);
 495 }
 496
 497 void
 498 hb_font_destroy (hb_font_t *font)
 499 {
 500   if (!hb_object_destroy (font)) return;
 501
 502   hb_face_destroy (font->face);
 503   hb_font_funcs_destroy (font->klass);
 504   if (font->destroy)
 505     font->destroy (font->user_data);
 506
 507   free (font);
 508 }
 509
 510 hb_bool_t
 511 hb_font_set_user_data (hb_font_t          *font,
 512                        hb_user_data_key_t *key,
 513                        void *              data,
 514                        hb_destroy_func_t   destroy)
 515 {
 516   return hb_object_set_user_data (font, key, data, destroy);
 517 }
 518
 519 void *
 520 hb_font_get_user_data (hb_font_t          *font,
 521                        hb_user_data_key_t *key)
 522 {
 523   return hb_object_get_user_data (font, key);
 524 }
 525
 526
 527 hb_face_t *
 528 hb_font_get_face (hb_font_t *font)
 529 {
 530   return font->face;
 531 }
 532
 533
 534 void
 535 hb_font_set_funcs (hb_font_t         *font,
 536                    hb_font_funcs_t   *klass,
 537                    void              *user_data,
 538                    hb_destroy_func_t  destroy)
 539 {
 540   if (hb_object_is_inert (font))
 541     return;
 542
 543   if (font->destroy)
 544     font->destroy (font->user_data);
 545
 546   if (!klass)
 547     klass = &_hb_font_funcs_nil;
 548
 549   hb_font_funcs_reference (klass);
 550   hb_font_funcs_destroy (font->klass);
 551   font->klass = klass;
 552   font->user_data = user_data;
 553   font->destroy = destroy;
 554 }
 555
 556 void
 557 hb_font_unset_funcs (hb_font_t          *font,
 558                      hb_font_funcs_t   **klass,
 559                      void              **user_data,
 560                      hb_destroy_func_t  *destroy)
 561 {
 562   /* None of the input arguments can be NULL. */
 563
 564   *klass = font->klass;
 565   *user_data = font->user_data;
 566   *destroy = font->destroy;
 567
 568   if (hb_object_is_inert (font))
 569     return;
 570
 571   font->klass = NULL;
 572   font->user_data = NULL;
 573   font->destroy = NULL;
 574 }
 575
 576 void
 577 hb_font_set_scale (hb_font_t *font,
 578                    int x_scale,
 579                    int y_scale)
 580 {
 581   if (hb_object_is_inert (font))
 582     return;
 583
 584   font->x_scale = x_scale;
 585   font->y_scale = y_scale;
 586 }
 587
 588 void
 589 hb_font_get_scale (hb_font_t *font,
 590                    int *x_scale,
 591                    int *y_scale)
 592 {
 593   if (x_scale) *x_scale = font->x_scale;
 594   if (y_scale) *y_scale = font->y_scale;
 595 }
 596
 597 void
 598 hb_font_set_ppem (hb_font_t *font,
 599                   unsigned int x_ppem,
 600                   unsigned int y_ppem)
 601 {
 602   if (hb_object_is_inert (font))
 603     return;
 604
 605   font->x_ppem = x_ppem;
 606   font->y_ppem = y_ppem;
 607 }
 608
 609 void
 610 hb_font_get_ppem (hb_font_t *font,
 611                   unsigned int *x_ppem,
 612                   unsigned int *y_ppem)
 613 {
 614   if (x_ppem) *x_ppem = font->x_ppem;
 615   if (y_ppem) *y_ppem = font->y_ppem;
 616 }
 617
 618
 619 HB_END_DECLS