src/hb-ot-font.cc

   1 /*
   2  * Copyright © 2011,2014  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, Roozbeh Pournader
  25  */
  26
  27 #include "hb-private.hh"
  28
  29 #include "hb-ot.h"
  30
  31 #include "hb-font-private.hh"
  32
  33 #include "hb-ot-cmap-table.hh"
  34 #include "hb-ot-cbdt-table.hh"
  35 #include "hb-ot-glyf-table.hh"
  36 #include "hb-ot-head-table.hh"
  37 #include "hb-ot-hhea-table.hh"
  38 #include "hb-ot-hmtx-table.hh"
  39 #include "hb-ot-os2-table.hh"
  40 #include "hb-ot-var-hvar-table.hh"
  41 //#include "hb-ot-post-table.hh"
  42
  43
  44 struct hb_ot_face_metrics_accelerator_t
  45 {
  46   unsigned int num_metrics;
  47   unsigned int num_advances;
  48   unsigned int default_advance;
  49   unsigned short ascender;
  50   unsigned short descender;
  51   unsigned short line_gap;
  52   bool has_font_extents;
  53
  54   const OT::hmtxvmtx *table;
  55   hb_blob_t *blob;
  56
  57   const OT::HVARVVAR *var;
  58   hb_blob_t *var_blob;
  59
  60   inline void init (hb_face_t *face,
  61                     hb_tag_t _hea_tag,
  62                     hb_tag_t _mtx_tag,
  63                     hb_tag_t _var_tag,
  64                     hb_tag_t os2_tag,
  65                     unsigned int default_advance = 0)
  66   {
  67     this->default_advance = default_advance ? default_advance : face->get_upem ();
  68
  69     bool got_font_extents = false;
  70     if (os2_tag)
  71     {
  72       hb_blob_t *os2_blob = OT::Sanitizer<OT::os2>::sanitize (face->reference_table (os2_tag));
  73       const OT::os2 *os2 = OT::Sanitizer<OT::os2>::lock_instance (os2_blob);
  74 #define USE_TYPO_METRICS (1u<<7)
  75       if (0 != (os2->fsSelection & USE_TYPO_METRICS))
  76       {
  77         this->ascender = os2->sTypoAscender;
  78         this->descender = os2->sTypoDescender;
  79         this->line_gap = os2->sTypoLineGap;
  80         got_font_extents = (this->ascender | this->descender) != 0;
  81       }
  82       hb_blob_destroy (os2_blob);
  83     }
  84
  85     hb_blob_t *_hea_blob = OT::Sanitizer<OT::_hea>::sanitize (face->reference_table (_hea_tag));
  86     const OT::_hea *_hea = OT::Sanitizer<OT::_hea>::lock_instance (_hea_blob);
  87     this->num_advances = _hea->numberOfLongMetrics;
  88     if (!got_font_extents)
  89     {
  90       this->ascender = _hea->ascender;
  91       this->descender = _hea->descender;
  92       this->line_gap = _hea->lineGap;
  93       got_font_extents = (this->ascender | this->descender) != 0;
  94     }
  95     hb_blob_destroy (_hea_blob);
  96
  97     this->has_font_extents = got_font_extents;
  98
  99     this->blob = OT::Sanitizer<OT::hmtxvmtx>::sanitize (face->reference_table (_mtx_tag));
 100
 101     /* Cap num_metrics() and num_advances() based on table length. */
 102     unsigned int len = hb_blob_get_length (this->blob);
 103     if (unlikely (this->num_advances * 4 > len))
 104       this->num_advances = len / 4;
 105     this->num_metrics = this->num_advances + (len - 4 * this->num_advances) / 2;
 106
 107     /* We MUST set num_metrics to zero if num_advances is zero.
 108      * Our get_advance() depends on that. */
 109     if (unlikely (!this->num_advances))
 110     {
 111       this->num_metrics = this->num_advances = 0;
 112       hb_blob_destroy (this->blob);
 113       this->blob = hb_blob_get_empty ();
 114     }
 115     this->table = OT::Sanitizer<OT::hmtxvmtx>::lock_instance (this->blob);
 116
 117     this->var_blob = OT::Sanitizer<OT::HVARVVAR>::sanitize (face->reference_table (_var_tag));
 118     this->var = OT::Sanitizer<OT::HVARVVAR>::lock_instance (this->var_blob);
 119   }
 120
 121   inline void fini (void)
 122   {
 123     hb_blob_destroy (this->blob);
 124     hb_blob_destroy (this->var_blob);
 125   }
 126
 127   inline unsigned int get_advance (hb_codepoint_t  glyph,
 128                                    hb_font_t      *font) const
 129   {
 130     if (unlikely (glyph >= this->num_metrics))
 131     {
 132       /* If this->num_metrics is zero, it means we don't have the metrics table
 133        * for this direction: return default advance.  Otherwise, it means that the
 134        * glyph index is out of bound: return zero. */
 135       if (this->num_metrics)
 136         return 0;
 137       else
 138         return this->default_advance;
 139     }
 140
 141     return this->table->longMetric[MIN (glyph, this->num_advances - 1)].advance
 142          + this->var->get_advance_var (glyph, font->coords, font->num_coords); // TODO Optimize?!
 143   }
 144 };
 145
 146 struct hb_ot_face_glyf_accelerator_t
 147 {
 148   bool short_offset;
 149   unsigned int num_glyphs;
 150   const OT::loca *loca;
 151   const OT::glyf *glyf;
 152   hb_blob_t *loca_blob;
 153   hb_blob_t *glyf_blob;
 154   unsigned int glyf_len;
 155
 156   inline void init (hb_face_t *face)
 157   {
 158     hb_blob_t *head_blob = OT::Sanitizer<OT::head>::sanitize (face->reference_table (HB_OT_TAG_head));
 159     const OT::head *head = OT::Sanitizer<OT::head>::lock_instance (head_blob);
 160     if ((unsigned int) head->indexToLocFormat > 1 || head->glyphDataFormat != 0)
 161     {
 162       /* Unknown format.  Leave num_glyphs=0, that takes care of disabling us. */
 163       hb_blob_destroy (head_blob);
 164       return;
 165     }
 166     this->short_offset = 0 == head->indexToLocFormat;
 167     hb_blob_destroy (head_blob);
 168
 169     this->loca_blob = OT::Sanitizer<OT::loca>::sanitize (face->reference_table (HB_OT_TAG_loca));
 170     this->loca = OT::Sanitizer<OT::loca>::lock_instance (this->loca_blob);
 171     this->glyf_blob = OT::Sanitizer<OT::glyf>::sanitize (face->reference_table (HB_OT_TAG_glyf));
 172     this->glyf = OT::Sanitizer<OT::glyf>::lock_instance (this->glyf_blob);
 173
 174     this->num_glyphs = MAX (1u, hb_blob_get_length (this->loca_blob) / (this->short_offset ? 2 : 4)) - 1;
 175     this->glyf_len = hb_blob_get_length (this->glyf_blob);
 176   }
 177
 178   inline void fini (void)
 179   {
 180     hb_blob_destroy (this->loca_blob);
 181     hb_blob_destroy (this->glyf_blob);
 182   }
 183
 184   inline bool get_extents (hb_codepoint_t glyph,
 185                            hb_glyph_extents_t *extents) const
 186   {
 187     if (unlikely (glyph >= this->num_glyphs))
 188       return false;
 189
 190     unsigned int start_offset, end_offset;
 191     if (this->short_offset)
 192     {
 193       start_offset = 2 * this->loca->u.shortsZ[glyph];
 194       end_offset   = 2 * this->loca->u.shortsZ[glyph + 1];
 195     }
 196     else
 197     {
 198       start_offset = this->loca->u.longsZ[glyph];
 199       end_offset   = this->loca->u.longsZ[glyph + 1];
 200     }
 201
 202     if (start_offset > end_offset || end_offset > this->glyf_len)
 203       return false;
 204
 205     if (end_offset - start_offset < OT::glyfGlyphHeader::static_size)
 206       return true; /* Empty glyph; zero extents. */
 207
 208     const OT::glyfGlyphHeader &glyph_header = OT::StructAtOffset<OT::glyfGlyphHeader> (this->glyf, start_offset);
 209
 210     extents->x_bearing = MIN (glyph_header.xMin, glyph_header.xMax);
 211     extents->y_bearing = MAX (glyph_header.yMin, glyph_header.yMax);
 212     extents->width     = MAX (glyph_header.xMin, glyph_header.xMax) - extents->x_bearing;
 213     extents->height    = MIN (glyph_header.yMin, glyph_header.yMax) - extents->y_bearing;
 214
 215     return true;
 216   }
 217 };
 218
 219 struct hb_ot_face_cbdt_accelerator_t
 220 {
 221   hb_blob_t *cblc_blob;
 222   hb_blob_t *cbdt_blob;
 223   const OT::CBLC *cblc;
 224   const OT::CBDT *cbdt;
 225
 226   unsigned int cbdt_len;
 227   float upem;
 228
 229   inline void init (hb_face_t *face)
 230   {
 231     upem = face->get_upem();
 232
 233     cblc_blob = OT::Sanitizer<OT::CBLC>::sanitize (face->reference_table (HB_OT_TAG_CBLC));
 234     cbdt_blob = OT::Sanitizer<OT::CBDT>::sanitize (face->reference_table (HB_OT_TAG_CBDT));
 235     cbdt_len = hb_blob_get_length (cbdt_blob);
 236
 237     if (hb_blob_get_length (cblc_blob) == 0) {
 238       cblc = NULL;
 239       cbdt = NULL;
 240       return;  /* Not a bitmap font. */
 241     }
 242     cblc = OT::Sanitizer<OT::CBLC>::lock_instance (cblc_blob);
 243     cbdt = OT::Sanitizer<OT::CBDT>::lock_instance (cbdt_blob);
 244
 245   }
 246
 247   inline void fini (void)
 248   {
 249     hb_blob_destroy (this->cblc_blob);
 250     hb_blob_destroy (this->cbdt_blob);
 251   }
 252
 253   inline bool get_extents (hb_codepoint_t glyph, hb_glyph_extents_t *extents) const
 254   {
 255     unsigned int x_ppem = upem, y_ppem = upem; /* TODO Use font ppem if available. */
 256
 257     if (cblc == NULL)
 258       return false;  // Not a color bitmap font.
 259
 260     const OT::IndexSubtableRecord *subtable_record = this->cblc->find_table(glyph, &x_ppem, &y_ppem);
 261     if (subtable_record == NULL)
 262       return false;
 263
 264     if (subtable_record->get_extents (extents))
 265       return true;
 266
 267     unsigned int image_offset = 0, image_length = 0, image_format = 0;
 268     if (!subtable_record->get_image_data (glyph, &image_offset, &image_length, &image_format))
 269       return false;
 270
 271     {
 272       /* TODO Move the following into CBDT struct when adding more formats. */
 273
 274       if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length))
 275         return false;
 276
 277       switch (image_format)
 278       {
 279         case 17: {
 280           if (unlikely (image_length < OT::GlyphBitmapDataFormat17::min_size))
 281             return false;
 282
 283           const OT::GlyphBitmapDataFormat17& glyphFormat17 =
 284               OT::StructAtOffset<OT::GlyphBitmapDataFormat17> (this->cbdt, image_offset);
 285           glyphFormat17.glyphMetrics.get_extents (extents);
 286         }
 287         break;
 288         default:
 289           // TODO: Support other image formats.
 290           return false;
 291       }
 292     }
 293
 294     /* Convert to the font units. */
 295     extents->x_bearing *= upem / (float) x_ppem;
 296     extents->y_bearing *= upem / (float) y_ppem;
 297     extents->width *= upem / (float) x_ppem;
 298     extents->height *= upem / (float) y_ppem;
 299
 300     return true;
 301   }
 302 };
 303
 304 typedef bool (*hb_cmap_get_glyph_func_t) (const void *obj,
 305                                           hb_codepoint_t codepoint,
 306                                           hb_codepoint_t *glyph);
 307
 308 template <typename Type>
 309 static inline bool get_glyph_from (const void *obj,
 310                                    hb_codepoint_t codepoint,
 311                                    hb_codepoint_t *glyph)
 312 {
 313   const Type *typed_obj = (const Type *) obj;
 314   return typed_obj->get_glyph (codepoint, glyph);
 315 }
 316
 317 template <typename Type>
 318 static inline bool get_glyph_from_symbol (const void *obj,
 319                                           hb_codepoint_t codepoint,
 320                                           hb_codepoint_t *glyph)
 321 {
 322   const Type *typed_obj = (const Type *) obj;
 323   if (likely (typed_obj->get_glyph (codepoint, glyph)))
 324     return true;
 325
 326   if (codepoint <= 0x00FFu)
 327   {
 328     /* For symbol-encoded OpenType fonts, we duplicate the
 329      * U+F000..F0FF range at U+0000..U+00FF.  That's what
 330      * Windows seems to do, and that's hinted about at:
 331      * http://www.microsoft.com/typography/otspec/recom.htm
 332      * under "Non-Standard (Symbol) Fonts". */
 333     return typed_obj->get_glyph (0xF000u + codepoint, glyph);
 334   }
 335
 336   return false;
 337 }
 338
 339 struct hb_ot_face_cmap_accelerator_t
 340 {
 341   hb_cmap_get_glyph_func_t get_glyph_func;
 342   const void *get_glyph_data;
 343   OT::CmapSubtableFormat4::accelerator_t format4_accel;
 344
 345   const OT::CmapSubtableFormat14 *uvs_table;
 346   hb_blob_t *blob;
 347
 348   inline void init (hb_face_t *face)
 349   {
 350     this->blob = OT::Sanitizer<OT::cmap>::sanitize (face->reference_table (HB_OT_TAG_cmap));
 351     const OT::cmap *cmap = OT::Sanitizer<OT::cmap>::lock_instance (this->blob);
 352     const OT::CmapSubtable *subtable = NULL;
 353     const OT::CmapSubtableFormat14 *subtable_uvs = NULL;
 354
 355     bool symbol = false;
 356     /* 32-bit subtables. */
 357     if (!subtable) subtable = cmap->find_subtable (3, 10);
 358     if (!subtable) subtable = cmap->find_subtable (0, 6);
 359     if (!subtable) subtable = cmap->find_subtable (0, 4);
 360     /* 16-bit subtables. */
 361     if (!subtable) subtable = cmap->find_subtable (3, 1);
 362     if (!subtable) subtable = cmap->find_subtable (0, 3);
 363     if (!subtable) subtable = cmap->find_subtable (0, 2);
 364     if (!subtable) subtable = cmap->find_subtable (0, 1);
 365     if (!subtable) subtable = cmap->find_subtable (0, 0);
 366     if (!subtable)
 367     {
 368       subtable = cmap->find_subtable (3, 0);
 369       if (subtable) symbol = true;
 370     }
 371     /* Meh. */
 372     if (!subtable) subtable = &OT::Null(OT::CmapSubtable);
 373
 374     /* UVS subtable. */
 375     if (!subtable_uvs)
 376     {
 377       const OT::CmapSubtable *st = cmap->find_subtable (0, 5);
 378       if (st && st->u.format == 14)
 379         subtable_uvs = &st->u.format14;
 380     }
 381     /* Meh. */
 382     if (!subtable_uvs) subtable_uvs = &OT::Null(OT::CmapSubtableFormat14);
 383
 384     this->uvs_table = subtable_uvs;
 385
 386     this->get_glyph_data = subtable;
 387     if (unlikely (symbol))
 388       this->get_glyph_func = get_glyph_from_symbol<OT::CmapSubtable>;
 389     else
 390       switch (subtable->u.format) {
 391       /* Accelerate format 4 and format 12. */
 392       default: this->get_glyph_func = get_glyph_from<OT::CmapSubtable>;         break;
 393       case 12: this->get_glyph_func = get_glyph_from<OT::CmapSubtableFormat12>; break;
 394       case  4:
 395         {
 396           this->format4_accel.init (&subtable->u.format4);
 397           this->get_glyph_data = &this->format4_accel;
 398           this->get_glyph_func = this->format4_accel.get_glyph_func;
 399         }
 400         break;
 401       }
 402   }
 403
 404   inline void fini (void)
 405   {
 406     hb_blob_destroy (this->blob);
 407   }
 408
 409   inline bool get_nominal_glyph (hb_codepoint_t  unicode,
 410                                  hb_codepoint_t *glyph) const
 411   {
 412     return this->get_glyph_func (this->get_glyph_data, unicode, glyph);
 413   }
 414
 415   inline bool get_variation_glyph (hb_codepoint_t  unicode,
 416                                    hb_codepoint_t  variation_selector,
 417                                    hb_codepoint_t *glyph) const
 418   {
 419     switch (this->uvs_table->get_glyph_variant (unicode,
 420                                                 variation_selector,
 421                                                 glyph))
 422     {
 423       case OT::GLYPH_VARIANT_NOT_FOUND:         return false;
 424       case OT::GLYPH_VARIANT_FOUND:             return true;
 425       case OT::GLYPH_VARIANT_USE_DEFAULT:       break;
 426     }
 427
 428     return get_nominal_glyph (unicode, glyph);
 429   }
 430 };
 431
 432 struct hb_ot_font_t
 433 {
 434   hb_ot_face_cmap_accelerator_t cmap;
 435   hb_ot_face_metrics_accelerator_t h_metrics;
 436   hb_ot_face_metrics_accelerator_t v_metrics;
 437   OT::hb_lazy_loader_t<hb_ot_face_glyf_accelerator_t> glyf;
 438   OT::hb_lazy_loader_t<hb_ot_face_cbdt_accelerator_t> cbdt;
 439 };
 440
 441
 442 static hb_ot_font_t *
 443 _hb_ot_font_create (hb_face_t *face)
 444 {
 445   hb_ot_font_t *ot_font = (hb_ot_font_t *) calloc (1, sizeof (hb_ot_font_t));
 446
 447   if (unlikely (!ot_font))
 448     return NULL;
 449
 450   ot_font->cmap.init (face);
 451   ot_font->h_metrics.init (face, HB_OT_TAG_hhea, HB_OT_TAG_hmtx, HB_OT_TAG_HVAR, HB_OT_TAG_os2);
 452   ot_font->v_metrics.init (face, HB_OT_TAG_vhea, HB_OT_TAG_vmtx, HB_OT_TAG_VVAR, HB_TAG_NONE,
 453                            ot_font->h_metrics.ascender - ot_font->h_metrics.descender); /* TODO Can we do this lazily? */
 454   ot_font->glyf.init (face);
 455   ot_font->cbdt.init (face);
 456
 457   return ot_font;
 458 }
 459
 460 static void
 461 _hb_ot_font_destroy (hb_ot_font_t *ot_font)
 462 {
 463   ot_font->cmap.fini ();
 464   ot_font->h_metrics.fini ();
 465   ot_font->v_metrics.fini ();
 466   ot_font->glyf.fini ();
 467   ot_font->cbdt.fini ();
 468
 469   free (ot_font);
 470 }
 471
 472
 473 static hb_bool_t
 474 hb_ot_get_nominal_glyph (hb_font_t *font HB_UNUSED,
 475                          void *font_data,
 476                          hb_codepoint_t unicode,
 477                          hb_codepoint_t *glyph,
 478                          void *user_data HB_UNUSED)
 479
 480 {
 481   const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
 482   return ot_font->cmap.get_nominal_glyph (unicode, glyph);
 483 }
 484
 485 static hb_bool_t
 486 hb_ot_get_variation_glyph (hb_font_t *font HB_UNUSED,
 487                            void *font_data,
 488                            hb_codepoint_t unicode,
 489                            hb_codepoint_t variation_selector,
 490                            hb_codepoint_t *glyph,
 491                            void *user_data HB_UNUSED)
 492 {
 493   const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
 494   return ot_font->cmap.get_variation_glyph (unicode, variation_selector, glyph);
 495 }
 496
 497 static hb_position_t
 498 hb_ot_get_glyph_h_advance (hb_font_t *font,
 499                            void *font_data,
 500                            hb_codepoint_t glyph,
 501                            void *user_data HB_UNUSED)
 502 {
 503   const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
 504   return font->em_scale_x (ot_font->h_metrics.get_advance (glyph, font));
 505 }
 506
 507 static hb_position_t
 508 hb_ot_get_glyph_v_advance (hb_font_t *font,
 509                            void *font_data,
 510                            hb_codepoint_t glyph,
 511                            void *user_data HB_UNUSED)
 512 {
 513   const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
 514   return font->em_scale_y (-(int) ot_font->v_metrics.get_advance (glyph, font));
 515 }
 516
 517 static hb_bool_t
 518 hb_ot_get_glyph_extents (hb_font_t *font HB_UNUSED,
 519                          void *font_data,
 520                          hb_codepoint_t glyph,
 521                          hb_glyph_extents_t *extents,
 522                          void *user_data HB_UNUSED)
 523 {
 524   const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
 525   bool ret = ot_font->glyf->get_extents (glyph, extents);
 526   if (!ret)
 527     ret = ot_font->cbdt->get_extents (glyph, extents);
 528   // TODO Hook up side-bearings variations.
 529   extents->x_bearing = font->em_scale_x (extents->x_bearing);
 530   extents->y_bearing = font->em_scale_y (extents->y_bearing);
 531   extents->width     = font->em_scale_x (extents->width);
 532   extents->height    = font->em_scale_y (extents->height);
 533   return ret;
 534 }
 535
 536 static hb_bool_t
 537 hb_ot_get_font_h_extents (hb_font_t *font HB_UNUSED,
 538                           void *font_data,
 539                           hb_font_extents_t *metrics,
 540                           void *user_data HB_UNUSED)
 541 {
 542   const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
 543   metrics->ascender = font->em_scale_y (ot_font->h_metrics.ascender);
 544   metrics->descender = font->em_scale_y (ot_font->h_metrics.descender);
 545   metrics->line_gap = font->em_scale_y (ot_font->h_metrics.line_gap);
 546   // TODO Hook up variations.
 547   return ot_font->h_metrics.has_font_extents;
 548 }
 549
 550 static hb_bool_t
 551 hb_ot_get_font_v_extents (hb_font_t *font HB_UNUSED,
 552                           void *font_data,
 553                           hb_font_extents_t *metrics,
 554                           void *user_data HB_UNUSED)
 555 {
 556   const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
 557   metrics->ascender = font->em_scale_x (ot_font->v_metrics.ascender);
 558   metrics->descender = font->em_scale_x (ot_font->v_metrics.descender);
 559   metrics->line_gap = font->em_scale_x (ot_font->v_metrics.line_gap);
 560   // TODO Hook up variations.
 561   return ot_font->v_metrics.has_font_extents;
 562 }
 563
 564 static hb_font_funcs_t *static_ot_funcs = NULL;
 565
 566 #ifdef HB_USE_ATEXIT
 567 static
 568 void free_static_ot_funcs (void)
 569 {
 570   hb_font_funcs_destroy (static_ot_funcs);
 571 }
 572 #endif
 573
 574 static hb_font_funcs_t *
 575 _hb_ot_get_font_funcs (void)
 576 {
 577 retry:
 578   hb_font_funcs_t *funcs = (hb_font_funcs_t *) hb_atomic_ptr_get (&static_ot_funcs);
 579
 580   if (unlikely (!funcs))
 581   {
 582     funcs = hb_font_funcs_create ();
 583
 584     hb_font_funcs_set_font_h_extents_func (funcs, hb_ot_get_font_h_extents, NULL, NULL);
 585     hb_font_funcs_set_font_v_extents_func (funcs, hb_ot_get_font_v_extents, NULL, NULL);
 586     hb_font_funcs_set_nominal_glyph_func (funcs, hb_ot_get_nominal_glyph, NULL, NULL);
 587     hb_font_funcs_set_variation_glyph_func (funcs, hb_ot_get_variation_glyph, NULL, NULL);
 588     hb_font_funcs_set_glyph_h_advance_func (funcs, hb_ot_get_glyph_h_advance, NULL, NULL);
 589     hb_font_funcs_set_glyph_v_advance_func (funcs, hb_ot_get_glyph_v_advance, NULL, NULL);
 590     //hb_font_funcs_set_glyph_h_origin_func (funcs, hb_ot_get_glyph_h_origin, NULL, NULL);
 591     //hb_font_funcs_set_glyph_v_origin_func (funcs, hb_ot_get_glyph_v_origin, NULL, NULL);
 592     //hb_font_funcs_set_glyph_h_kerning_func (funcs, hb_ot_get_glyph_h_kerning, NULL, NULL); TODO
 593     //hb_font_funcs_set_glyph_v_kerning_func (funcs, hb_ot_get_glyph_v_kerning, NULL, NULL);
 594     hb_font_funcs_set_glyph_extents_func (funcs, hb_ot_get_glyph_extents, NULL, NULL);
 595     //hb_font_funcs_set_glyph_contour_point_func (funcs, hb_ot_get_glyph_contour_point, NULL, NULL); TODO
 596     //hb_font_funcs_set_glyph_name_func (funcs, hb_ot_get_glyph_name, NULL, NULL); TODO
 597     //hb_font_funcs_set_glyph_from_name_func (funcs, hb_ot_get_glyph_from_name, NULL, NULL); TODO
 598
 599     hb_font_funcs_make_immutable (funcs);
 600
 601     if (!hb_atomic_ptr_cmpexch (&static_ot_funcs, NULL, funcs)) {
 602       hb_font_funcs_destroy (funcs);
 603       goto retry;
 604     }
 605
 606 #ifdef HB_USE_ATEXIT
 607     atexit (free_static_ot_funcs); /* First person registers atexit() callback. */
 608 #endif
 609   };
 610
 611   return funcs;
 612 }
 613
 614
 615 /**
 616  * hb_ot_font_set_funcs:
 617  *
 618  * Since: 0.9.28
 619  **/
 620 void
 621 hb_ot_font_set_funcs (hb_font_t *font)
 622 {
 623   hb_ot_font_t *ot_font = _hb_ot_font_create (font->face);
 624   if (unlikely (!ot_font))
 625     return;
 626
 627   hb_font_set_funcs (font,
 628                      _hb_ot_get_font_funcs (),
 629                      ot_font,
 630                      (hb_destroy_func_t) _hb_ot_font_destroy);
 631 }