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-glyf-table.hh"
35 #include "hb-ot-head-table.hh"
36 #include "hb-ot-hhea-table.hh"
37 #include "hb-ot-hmtx-table.hh"
38
39
40 struct hb_ot_face_metrics_accelerator_t
41 {
42 unsigned int num_metrics;
43 unsigned int num_advances;
44 unsigned int default_advance;
45 const OT::_mtx *table;
46 hb_blob_t *blob;
47
48 inline void init (hb_face_t *face,
49 hb_tag_t _hea_tag, hb_tag_t _mtx_tag,
50 unsigned int default_advance_)
51 {
52 this->default_advance = default_advance_;
53 this->num_metrics = face->get_num_glyphs ();
54
55 hb_blob_t *_hea_blob = OT::Sanitizer<OT::_hea>::sanitize (face->reference_table (_hea_tag));
56 const OT::_hea *_hea = OT::Sanitizer<OT::_hea>::lock_instance (_hea_blob);
57 this->num_advances = _hea->numberOfLongMetrics;
58 hb_blob_destroy (_hea_blob);
59
60 this->blob = OT::Sanitizer<OT::_mtx>::sanitize (face->reference_table (_mtx_tag));
61 if (unlikely (!this->num_advances ||
62 2 * (this->num_advances + this->num_metrics) > hb_blob_get_length (this->blob)))
63 {
64 this->num_metrics = this->num_advances = 0;
65 hb_blob_destroy (this->blob);
66 this->blob = hb_blob_get_empty ();
67 }
68 this->table = OT::Sanitizer<OT::_mtx>::lock_instance (this->blob);
69 }
70
71 inline void fini (void)
72 {
73 hb_blob_destroy (this->blob);
74 }
75
76 inline unsigned int get_advance (hb_codepoint_t glyph) const
77 {
78 if (unlikely (glyph >= this->num_metrics))
79 {
80 /* If this->num_metrics is zero, it means we don't have the metrics table
81 * for this direction: return default advance. Otherwise, it means that the
82 * glyph index is out of bound: return zero. */
83 if (this->num_metrics)
84 return 0;
85 else
86 return this->default_advance;
87 }
88
89 if (glyph >= this->num_advances)
90 glyph = this->num_advances - 1;
91
92 return this->table->longMetric[glyph].advance;
93 }
94 };
95
96 struct hb_ot_face_glyf_accelerator_t
97 {
98 bool short_offset;
99 unsigned int num_glyphs;
100 const OT::loca *loca;
101 const OT::glyf *glyf;
102 hb_blob_t *loca_blob;
103 hb_blob_t *glyf_blob;
104 unsigned int glyf_len;
105
106 inline void init (hb_face_t *face)
107 {
108 hb_blob_t *head_blob = OT::Sanitizer<OT::head>::sanitize (face->reference_table (HB_OT_TAG_head));
109 const OT::head *head = OT::Sanitizer<OT::head>::lock_instance (head_blob);
110 if ((unsigned int) head->indexToLocFormat > 1 || head->glyphDataFormat != 0)
111 {
112 /* Unknown format. Leave num_glyphs=0, that takes care of disabling us. */
113 hb_blob_destroy (head_blob);
114 return;
115 }
116 this->short_offset = 0 == head->indexToLocFormat;
117 hb_blob_destroy (head_blob);
118
119 this->loca_blob = OT::Sanitizer<OT::loca>::sanitize (face->reference_table (HB_OT_TAG_loca));
120 this->loca = OT::Sanitizer<OT::loca>::lock_instance (this->loca_blob);
121 this->glyf_blob = OT::Sanitizer<OT::glyf>::sanitize (face->reference_table (HB_OT_TAG_glyf));
122 this->glyf = OT::Sanitizer<OT::glyf>::lock_instance (this->glyf_blob);
123
124 this->num_glyphs = MAX (1u, hb_blob_get_length (this->loca_blob) / (this->short_offset ? 2 : 4)) - 1;
125 this->glyf_len = hb_blob_get_length (this->glyf_blob);
126 }
127
128 inline void fini (void)
129 {
130 hb_blob_destroy (this->loca_blob);
131 hb_blob_destroy (this->glyf_blob);
132 }
133
134 inline bool get_extents (hb_codepoint_t glyph,
135 hb_glyph_extents_t *extents) const
136 {
137 if (unlikely (glyph >= this->num_glyphs))
138 return false;
139
140 unsigned int start_offset, end_offset;
141 if (this->short_offset)
142 {
143 start_offset = 2 * this->loca->u.shortsZ[glyph];
144 end_offset = 2 * this->loca->u.shortsZ[glyph + 1];
145 }
146 else
147 {
148 start_offset = this->loca->u.longsZ[glyph];
149 end_offset = this->loca->u.longsZ[glyph + 1];
150 }
151
152 if (start_offset > end_offset || end_offset > this->glyf_len)
153 return false;
154
155 if (end_offset - start_offset < OT::glyfGlyphHeader::static_size)
156 return true; /* Empty glyph; zero extents. */
157
158 const OT::glyfGlyphHeader &glyph_header = OT::StructAtOffset<OT::glyfGlyphHeader> (this->glyf, start_offset);
159
160 extents->x_bearing = MIN (glyph_header.xMin, glyph_header.xMax);
161 extents->y_bearing = MAX (glyph_header.yMin, glyph_header.yMax);
162 extents->width = MAX (glyph_header.xMin, glyph_header.xMax) - extents->x_bearing;
163 extents->height = MIN (glyph_header.yMin, glyph_header.yMax) - extents->y_bearing;
164
165 return true;
166 }
167 };
168
169 struct hb_ot_face_cmap_accelerator_t
170 {
171 const OT::CmapSubtable *table;
172 const OT::CmapSubtable *uvs_table;
173 hb_blob_t *blob;
174
175 inline void init (hb_face_t *face)
176 {
177 this->blob = OT::Sanitizer<OT::cmap>::sanitize (face->reference_table (HB_OT_TAG_cmap));
178 const OT::cmap *cmap = OT::Sanitizer<OT::cmap>::lock_instance (this->blob);
179 const OT::CmapSubtable *subtable = NULL;
180 const OT::CmapSubtable *subtable_uvs = NULL;
181
182 /* 32-bit subtables. */
183 if (!subtable) subtable = cmap->find_subtable (3, 10);
184 if (!subtable) subtable = cmap->find_subtable (0, 6);
185 if (!subtable) subtable = cmap->find_subtable (0, 4);
186 /* 16-bit subtables. */
187 if (!subtable) subtable = cmap->find_subtable (3, 1);
188 if (!subtable) subtable = cmap->find_subtable (0, 3);
189 if (!subtable) subtable = cmap->find_subtable (0, 2);
190 if (!subtable) subtable = cmap->find_subtable (0, 1);
191 if (!subtable) subtable = cmap->find_subtable (0, 0);
192 if (!subtable) subtable = cmap->find_subtable (3, 0);
193 /* Meh. */
194 if (!subtable) subtable = &OT::Null(OT::CmapSubtable);
195
196 /* UVS subtable. */
197 if (!subtable_uvs) subtable_uvs = cmap->find_subtable (0, 5);
198 /* Meh. */
199 if (!subtable_uvs) subtable_uvs = &OT::Null(OT::CmapSubtable);
200
201 this->table = subtable;
202 this->uvs_table = subtable_uvs;
203 }
204
205 inline void fini (void)
206 {
207 hb_blob_destroy (this->blob);
208 }
209
210 inline bool get_glyph (hb_codepoint_t unicode,
211 hb_codepoint_t variation_selector,
212 hb_codepoint_t *glyph) const
213 {
214 if (unlikely (variation_selector))
215 {
216 switch (this->uvs_table->get_glyph_variant (unicode,
217 variation_selector,
218 glyph))
219 {
220 case OT::GLYPH_VARIANT_NOT_FOUND: return false;
221 case OT::GLYPH_VARIANT_FOUND: return true;
222 case OT::GLYPH_VARIANT_USE_DEFAULT: break;
223 }
224 }
225
226 return this->table->get_glyph (unicode, glyph);
227 }
228 };
229
230
231 struct hb_ot_font_t
232 {
233 hb_ot_face_cmap_accelerator_t cmap;
234 hb_ot_face_metrics_accelerator_t h_metrics;
235 hb_ot_face_metrics_accelerator_t v_metrics;
236 hb_ot_face_glyf_accelerator_t glyf;
237 };
238
239
240 static hb_ot_font_t *
241 _hb_ot_font_create (hb_face_t *face)
242 {
243 hb_ot_font_t *ot_font = (hb_ot_font_t *) calloc (1, sizeof (hb_ot_font_t));
244
245 if (unlikely (!ot_font))
246 return NULL;
247
248 unsigned int upem = face->get_upem ();
249
250 ot_font->cmap.init (face);
251 ot_font->h_metrics.init (face, HB_OT_TAG_hhea, HB_OT_TAG_hmtx, upem>>1);
252 ot_font->v_metrics.init (face, HB_OT_TAG_vhea, HB_OT_TAG_vmtx, upem); /* TODO Can we do this lazily? */
253 ot_font->glyf.init (face);
254
255 return ot_font;
256 }
257
258 static void
259 _hb_ot_font_destroy (hb_ot_font_t *ot_font)
260 {
261 ot_font->cmap.fini ();
262 ot_font->h_metrics.fini ();
263 ot_font->v_metrics.fini ();
264 ot_font->glyf.fini ();
265
266 free (ot_font);
267 }
268
269
270 static hb_bool_t
271 hb_ot_get_glyph (hb_font_t *font HB_UNUSED,
272 void *font_data,
273 hb_codepoint_t unicode,
274 hb_codepoint_t variation_selector,
275 hb_codepoint_t *glyph,
276 void *user_data HB_UNUSED)
277
278 {
279 const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
280 return ot_font->cmap.get_glyph (unicode, variation_selector, glyph);
281 }
282
283 static hb_position_t
284 hb_ot_get_glyph_h_advance (hb_font_t *font HB_UNUSED,
285 void *font_data,
286 hb_codepoint_t glyph,
287 void *user_data HB_UNUSED)
288 {
289 const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
290 return font->em_scale_x (ot_font->h_metrics.get_advance (glyph));
291 }
292
293 static hb_position_t
294 hb_ot_get_glyph_v_advance (hb_font_t *font HB_UNUSED,
295 void *font_data,
296 hb_codepoint_t glyph,
297 void *user_data HB_UNUSED)
298 {
299 const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
300 return font->em_scale_y (-(int) ot_font->v_metrics.get_advance (glyph));
301 }
302
303 static hb_bool_t
304 hb_ot_get_glyph_h_origin (hb_font_t *font HB_UNUSED,
305 void *font_data HB_UNUSED,
306 hb_codepoint_t glyph HB_UNUSED,
307 hb_position_t *x HB_UNUSED,
308 hb_position_t *y HB_UNUSED,
309 void *user_data HB_UNUSED)
310 {
311 /* We always work in the horizontal coordinates. */
312 return true;
313 }
314
315 static hb_bool_t
316 hb_ot_get_glyph_v_origin (hb_font_t *font HB_UNUSED,
317 void *font_data,
318 hb_codepoint_t glyph,
319 hb_position_t *x,
320 hb_position_t *y,
321 void *user_data HB_UNUSED)
322 {
323 /* TODO */
324 return false;
325 }
326
327 static hb_position_t
328 hb_ot_get_glyph_h_kerning (hb_font_t *font,
329 void *font_data,
330 hb_codepoint_t left_glyph,
331 hb_codepoint_t right_glyph,
332 void *user_data HB_UNUSED)
333 {
334 /* TODO */
335 return 0;
336 }
337
338 static hb_position_t
339 hb_ot_get_glyph_v_kerning (hb_font_t *font HB_UNUSED,
340 void *font_data HB_UNUSED,
341 hb_codepoint_t top_glyph HB_UNUSED,
342 hb_codepoint_t bottom_glyph HB_UNUSED,
343 void *user_data HB_UNUSED)
344 {
345 /* OpenType doesn't have vertical-kerning other than GPOS. */
346 return 0;
347 }
348
349 static hb_bool_t
350 hb_ot_get_glyph_extents (hb_font_t *font HB_UNUSED,
351 void *font_data,
352 hb_codepoint_t glyph,
353 hb_glyph_extents_t *extents,
354 void *user_data HB_UNUSED)
355 {
356 const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
357 bool ret = ot_font->glyf.get_extents (glyph, extents);
358 extents->x_bearing = font->em_scale_x (extents->x_bearing);
359 extents->y_bearing = font->em_scale_y (extents->y_bearing);
360 extents->width = font->em_scale_x (extents->width);
361 extents->height = font->em_scale_y (extents->height);
362 return ret;
363 }
364
365 static hb_bool_t
366 hb_ot_get_glyph_contour_point (hb_font_t *font HB_UNUSED,
367 void *font_data,
368 hb_codepoint_t glyph,
369 unsigned int point_index,
370 hb_position_t *x,
371 hb_position_t *y,
372 void *user_data HB_UNUSED)
373 {
374 /* TODO */
375 return false;
376 }
377
378 static hb_bool_t
379 hb_ot_get_glyph_name (hb_font_t *font HB_UNUSED,
380 void *font_data,
381 hb_codepoint_t glyph,
382 char *name, unsigned int size,
383 void *user_data HB_UNUSED)
384 {
385 /* TODO */
386 return false;
387 }
388
389 static hb_bool_t
390 hb_ot_get_glyph_from_name (hb_font_t *font HB_UNUSED,
391 void *font_data,
392 const char *name, int len, /* -1 means nul-terminated */
393 hb_codepoint_t *glyph,
394 void *user_data HB_UNUSED)
395 {
396 /* TODO */
397 return false;
398 }
399
400
401 static hb_font_funcs_t *
402 _hb_ot_get_font_funcs (void)
403 {
404 static const hb_font_funcs_t ot_ffuncs = {
405 HB_OBJECT_HEADER_STATIC,
406
407 true, /* immutable */
408
409 {
410 #define HB_FONT_FUNC_IMPLEMENT(name) hb_ot_get_##name,
411 HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
412 #undef HB_FONT_FUNC_IMPLEMENT
413 }
414 };
415
416 return const_cast<hb_font_funcs_t *> (&ot_ffuncs);
417 }
418
419
420 /**
421 * Since: 0.9.28
422 **/
423 void
424 hb_ot_font_set_funcs (hb_font_t *font)
425 {
426 hb_ot_font_t *ot_font = _hb_ot_font_create (font->face);
427 if (unlikely (!ot_font))
428 return;
429
430 hb_font_set_funcs (font,
431 _hb_ot_get_font_funcs (),
432 ot_font,
433 (hb_destroy_func_t) _hb_ot_font_destroy);
434 }