1 /*
2 * Copyright © 2009,2010 Red Hat, Inc.
3 * Copyright © 2010,2011,2012 Google, Inc.
4 *
5 * This is part of HarfBuzz, a text shaping library.
6 *
7 * Permission is hereby granted, without written agreement and without
8 * license or royalty fees, to use, copy, modify, and distribute this
9 * software and its documentation for any purpose, provided that the
10 * above copyright notice and the following two paragraphs appear in
11 * all copies of this software.
12 *
13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
14 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
15 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
16 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
17 * DAMAGE.
18 *
19 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
20 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
21 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
22 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
23 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
24 *
25 * Red Hat Author(s): Behdad Esfahbod
26 * Google Author(s): Behdad Esfahbod
27 */
28
29 #define HB_SHAPER ot
30 #define hb_ot_shaper_face_data_t hb_ot_layout_t
31 #define hb_ot_shaper_shape_plan_data_t hb_ot_shape_plan_t
32 #include "hb-shaper-impl-private.hh"
33
34 #include "hb-ot-shape-private.hh"
35 #include "hb-ot-shape-complex-private.hh"
36 #include "hb-ot-shape-fallback-private.hh"
37 #include "hb-ot-shape-normalize-private.hh"
38
39 #include "hb-ot-layout-private.hh"
40 #include "hb-unicode-private.hh"
41 #include "hb-set-private.hh"
42
43
44 static hb_tag_t common_features[] = {
45 HB_TAG('c','c','m','p'),
46 HB_TAG('l','o','c','l'),
47 HB_TAG('m','a','r','k'),
48 HB_TAG('m','k','m','k'),
49 HB_TAG('r','l','i','g'),
50 };
51
52
53 static hb_tag_t horizontal_features[] = {
54 HB_TAG('c','a','l','t'),
55 HB_TAG('c','l','i','g'),
56 HB_TAG('c','u','r','s'),
57 HB_TAG('k','e','r','n'),
58 HB_TAG('l','i','g','a'),
59 HB_TAG('r','c','l','t'),
60 };
61
62
63
64 static void
65 hb_ot_shape_collect_features (hb_ot_shape_planner_t *planner,
66 const hb_segment_properties_t *props,
67 const hb_feature_t *user_features,
68 unsigned int num_user_features)
69 {
70 hb_ot_map_builder_t *map = &planner->map;
71
72 map->add_global_bool_feature (HB_TAG('r','v','r','n'));
73 map->add_gsub_pause (nullptr);
74
75 switch (props->direction) {
76 case HB_DIRECTION_LTR:
77 map->add_global_bool_feature (HB_TAG ('l','t','r','a'));
78 map->add_global_bool_feature (HB_TAG ('l','t','r','m'));
79 break;
80 case HB_DIRECTION_RTL:
81 map->add_global_bool_feature (HB_TAG ('r','t','l','a'));
82 map->add_feature (HB_TAG ('r','t','l','m'), 1, F_NONE);
83 break;
84 case HB_DIRECTION_TTB:
85 case HB_DIRECTION_BTT:
86 case HB_DIRECTION_INVALID:
87 default:
88 break;
89 }
90
91 map->add_feature (HB_TAG ('f','r','a','c'), 1, F_NONE);
92 map->add_feature (HB_TAG ('n','u','m','r'), 1, F_NONE);
93 map->add_feature (HB_TAG ('d','n','o','m'), 1, F_NONE);
94
95 if (planner->shaper->collect_features)
96 planner->shaper->collect_features (planner);
97
98 for (unsigned int i = 0; i < ARRAY_LENGTH (common_features); i++)
99 map->add_global_bool_feature (common_features[i]);
100
101 if (HB_DIRECTION_IS_HORIZONTAL (props->direction))
102 for (unsigned int i = 0; i < ARRAY_LENGTH (horizontal_features); i++)
103 map->add_feature (horizontal_features[i], 1, F_GLOBAL |
104 (horizontal_features[i] == HB_TAG('k','e','r','n') ?
105 F_HAS_FALLBACK : F_NONE));
106 else
107 {
108 /* We really want to find a 'vert' feature if there's any in the font, no
109 * matter which script/langsys it is listed (or not) under.
110 * See various bugs referenced from:
111 * https://github.com/behdad/harfbuzz/issues/63 */
112 map->add_feature (HB_TAG ('v','e','r','t'), 1, F_GLOBAL | F_GLOBAL_SEARCH);
113 }
114
115 if (planner->shaper->override_features)
116 planner->shaper->override_features (planner);
117
118 for (unsigned int i = 0; i < num_user_features; i++) {
119 const hb_feature_t *feature = &user_features[i];
120 map->add_feature (feature->tag, feature->value,
121 (feature->start == 0 && feature->end == (unsigned int) -1) ?
122 F_GLOBAL : F_NONE);
123 }
124 }
125
126
127 /*
128 * shaper face data
129 */
130
131 HB_SHAPER_DATA_ENSURE_DEFINE(ot, face)
132
133 hb_ot_shaper_face_data_t *
134 _hb_ot_shaper_face_data_create (hb_face_t *face)
135 {
136 return _hb_ot_layout_create (face);
137 }
138
139 void
140 _hb_ot_shaper_face_data_destroy (hb_ot_shaper_face_data_t *data)
141 {
142 _hb_ot_layout_destroy (data);
143 }
144
145
146 /*
147 * shaper font data
148 */
149
150 HB_SHAPER_DATA_ENSURE_DEFINE(ot, font)
151
152 struct hb_ot_shaper_font_data_t {};
153
154 hb_ot_shaper_font_data_t *
155 _hb_ot_shaper_font_data_create (hb_font_t *font HB_UNUSED)
156 {
157 return (hb_ot_shaper_font_data_t *) HB_SHAPER_DATA_SUCCEEDED;
158 }
159
160 void
161 _hb_ot_shaper_font_data_destroy (hb_ot_shaper_font_data_t *data)
162 {
163 }
164
165
166 /*
167 * shaper shape_plan data
168 */
169
170 hb_ot_shaper_shape_plan_data_t *
171 _hb_ot_shaper_shape_plan_data_create (hb_shape_plan_t *shape_plan,
172 const hb_feature_t *user_features,
173 unsigned int num_user_features,
174 const int *coords,
175 unsigned int num_coords)
176 {
177 hb_ot_shape_plan_t *plan = (hb_ot_shape_plan_t *) calloc (1, sizeof (hb_ot_shape_plan_t));
178 if (unlikely (!plan))
179 return nullptr;
180
181 hb_ot_shape_planner_t planner (shape_plan);
182
183 planner.shaper = hb_ot_shape_complex_categorize (&planner);
184
185 hb_ot_shape_collect_features (&planner, &shape_plan->props,
186 user_features, num_user_features);
187
188 planner.compile (*plan, coords, num_coords);
189
190 if (plan->shaper->data_create) {
191 plan->data = plan->shaper->data_create (plan);
192 if (unlikely (!plan->data))
193 return nullptr;
194 }
195
196 return plan;
197 }
198
199 void
200 _hb_ot_shaper_shape_plan_data_destroy (hb_ot_shaper_shape_plan_data_t *plan)
201 {
202 if (plan->shaper->data_destroy)
203 plan->shaper->data_destroy (const_cast<void *> (plan->data));
204
205 plan->finish ();
206
207 free (plan);
208 }
209
210
211 /*
212 * shaper
213 */
214
215 struct hb_ot_shape_context_t
216 {
217 hb_ot_shape_plan_t *plan;
218 hb_font_t *font;
219 hb_face_t *face;
220 hb_buffer_t *buffer;
221 const hb_feature_t *user_features;
222 unsigned int num_user_features;
223
224 /* Transient stuff */
225 bool fallback_positioning;
226 bool fallback_glyph_classes;
227 hb_direction_t target_direction;
228 };
229
230
231
232 /* Main shaper */
233
234
235 /* Prepare */
236
237 static void
238 hb_set_unicode_props (hb_buffer_t *buffer)
239 {
240 unsigned int count = buffer->len;
241 hb_glyph_info_t *info = buffer->info;
242 for (unsigned int i = 0; i < count; i++)
243 _hb_glyph_info_set_unicode_props (&info[i], buffer);
244 }
245
246 static void
247 hb_insert_dotted_circle (hb_buffer_t *buffer, hb_font_t *font)
248 {
249 if (!(buffer->flags & HB_BUFFER_FLAG_BOT) ||
250 buffer->context_len[0] ||
251 _hb_glyph_info_get_general_category (&buffer->info[0]) !=
252 HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK)
253 return;
254
255 if (!font->has_glyph (0x25CCu))
256 return;
257
258 hb_glyph_info_t dottedcircle = {0};
259 dottedcircle.codepoint = 0x25CCu;
260 _hb_glyph_info_set_unicode_props (&dottedcircle, buffer);
261
262 buffer->clear_output ();
263
264 buffer->idx = 0;
265 hb_glyph_info_t info = dottedcircle;
266 info.cluster = buffer->cur().cluster;
267 info.mask = buffer->cur().mask;
268 buffer->output_info (info);
269 while (buffer->idx < buffer->len && !buffer->in_error)
270 buffer->next_glyph ();
271
272 buffer->swap_buffers ();
273 }
274
275 static void
276 hb_form_clusters (hb_buffer_t *buffer)
277 {
278 if (!(buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_NON_ASCII))
279 return;
280
281 /* Loop duplicated in hb_ensure_native_direction(), and in _hb-coretext.cc */
282 unsigned int base = 0;
283 unsigned int count = buffer->len;
284 hb_glyph_info_t *info = buffer->info;
285 for (unsigned int i = 1; i < count; i++)
286 {
287 if (likely (!HB_UNICODE_GENERAL_CATEGORY_IS_MARK (_hb_glyph_info_get_general_category (&info[i])) &&
288 !_hb_glyph_info_is_joiner (&info[i])))
289 {
290 if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)
291 buffer->merge_clusters (base, i);
292 else
293 buffer->unsafe_to_break (base, i);
294 base = i;
295 }
296 }
297 if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)
298 buffer->merge_clusters (base, count);
299 else
300 buffer->unsafe_to_break (base, count);
301 }
302
303 static void
304 hb_ensure_native_direction (hb_buffer_t *buffer)
305 {
306 hb_direction_t direction = buffer->props.direction;
307
308 /* TODO vertical:
309 * The only BTT vertical script is Ogham, but it's not clear to me whether OpenType
310 * Ogham fonts are supposed to be implemented BTT or not. Need to research that
311 * first. */
312 if ((HB_DIRECTION_IS_HORIZONTAL (direction) && direction != hb_script_get_horizontal_direction (buffer->props.script)) ||
313 (HB_DIRECTION_IS_VERTICAL (direction) && direction != HB_DIRECTION_TTB))
314 {
315 /* Same loop as hb_form_clusters().
316 * Since form_clusters() merged clusters already, we don't merge. */
317 unsigned int base = 0;
318 unsigned int count = buffer->len;
319 hb_glyph_info_t *info = buffer->info;
320 for (unsigned int i = 1; i < count; i++)
321 {
322 if (likely (!HB_UNICODE_GENERAL_CATEGORY_IS_MARK (_hb_glyph_info_get_general_category (&info[i]))))
323 {
324 if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS)
325 buffer->merge_clusters (base, i);
326 buffer->reverse_range (base, i);
327
328 base = i;
329 }
330 }
331 if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS)
332 buffer->merge_clusters (base, count);
333 buffer->reverse_range (base, count);
334
335 buffer->reverse ();
336
337 buffer->props.direction = HB_DIRECTION_REVERSE (buffer->props.direction);
338 }
339 }
340
341
342 /* Substitute */
343
344 static inline void
345 hb_ot_mirror_chars (hb_ot_shape_context_t *c)
346 {
347 if (HB_DIRECTION_IS_FORWARD (c->target_direction))
348 return;
349
350 hb_buffer_t *buffer = c->buffer;
351 hb_unicode_funcs_t *unicode = buffer->unicode;
352 hb_mask_t rtlm_mask = c->plan->rtlm_mask;
353
354 unsigned int count = buffer->len;
355 hb_glyph_info_t *info = buffer->info;
356 for (unsigned int i = 0; i < count; i++) {
357 hb_codepoint_t codepoint = unicode->mirroring (info[i].codepoint);
358 if (likely (codepoint == info[i].codepoint || !c->font->has_glyph (codepoint)))
359 info[i].mask |= rtlm_mask;
360 else
361 info[i].codepoint = codepoint;
362 }
363 }
364
365 static inline void
366 hb_ot_shape_setup_masks_fraction (hb_ot_shape_context_t *c)
367 {
368 if (!(c->buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_NON_ASCII) ||
369 !c->plan->has_frac)
370 return;
371
372 hb_buffer_t *buffer = c->buffer;
373
374 hb_mask_t pre_mask, post_mask;
375 if (HB_DIRECTION_IS_FORWARD (buffer->props.direction))
376 {
377 pre_mask = c->plan->numr_mask | c->plan->frac_mask;
378 post_mask = c->plan->frac_mask | c->plan->dnom_mask;
379 }
380 else
381 {
382 pre_mask = c->plan->frac_mask | c->plan->dnom_mask;
383 post_mask = c->plan->numr_mask | c->plan->frac_mask;
384 }
385
386 unsigned int count = buffer->len;
387 hb_glyph_info_t *info = buffer->info;
388 for (unsigned int i = 0; i < count; i++)
389 {
390 if (info[i].codepoint == 0x2044u) /* FRACTION SLASH */
391 {
392 unsigned int start = i, end = i + 1;
393 while (start &&
394 _hb_glyph_info_get_general_category (&info[start - 1]) ==
395 HB_UNICODE_GENERAL_CATEGORY_DECIMAL_NUMBER)
396 start--;
397 while (end < count &&
398 _hb_glyph_info_get_general_category (&info[end]) ==
399 HB_UNICODE_GENERAL_CATEGORY_DECIMAL_NUMBER)
400 end++;
401
402 buffer->unsafe_to_break (start, end);
403
404 for (unsigned int j = start; j < i; j++)
405 info[j].mask |= pre_mask;
406 info[i].mask |= c->plan->frac_mask;
407 for (unsigned int j = i + 1; j < end; j++)
408 info[j].mask |= post_mask;
409
410 i = end - 1;
411 }
412 }
413 }
414
415 static inline void
416 hb_ot_shape_initialize_masks (hb_ot_shape_context_t *c)
417 {
418 hb_ot_map_t *map = &c->plan->map;
419 hb_buffer_t *buffer = c->buffer;
420
421 hb_mask_t global_mask = map->get_global_mask ();
422 buffer->reset_masks (global_mask);
423 }
424
425 static inline void
426 hb_ot_shape_setup_masks (hb_ot_shape_context_t *c)
427 {
428 hb_ot_map_t *map = &c->plan->map;
429 hb_buffer_t *buffer = c->buffer;
430
431 hb_ot_shape_setup_masks_fraction (c);
432
433 if (c->plan->shaper->setup_masks)
434 c->plan->shaper->setup_masks (c->plan, buffer, c->font);
435
436 for (unsigned int i = 0; i < c->num_user_features; i++)
437 {
438 const hb_feature_t *feature = &c->user_features[i];
439 if (!(feature->start == 0 && feature->end == (unsigned int)-1)) {
440 unsigned int shift;
441 hb_mask_t mask = map->get_mask (feature->tag, &shift);
442 buffer->set_masks (feature->value << shift, mask, feature->start, feature->end);
443 }
444 }
445 }
446
447 static void
448 hb_ot_zero_width_default_ignorables (hb_ot_shape_context_t *c)
449 {
450 hb_buffer_t *buffer = c->buffer;
451
452 if (!(buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_DEFAULT_IGNORABLES) ||
453 (buffer->flags & HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES))
454 return;
455
456 unsigned int count = buffer->len;
457 hb_glyph_info_t *info = buffer->info;
458 hb_glyph_position_t *pos = buffer->pos;
459 unsigned int i = 0;
460 for (i = 0; i < count; i++)
461 if (unlikely (_hb_glyph_info_is_default_ignorable (&info[i])))
462 pos[i].x_advance = pos[i].y_advance = pos[i].x_offset = pos[i].y_offset = 0;
463 }
464
465 static void
466 hb_ot_hide_default_ignorables (hb_ot_shape_context_t *c)
467 {
468 hb_buffer_t *buffer = c->buffer;
469
470 if (!(buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_DEFAULT_IGNORABLES) ||
471 (buffer->flags & HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES))
472 return;
473
474 unsigned int count = buffer->len;
475 hb_glyph_info_t *info = buffer->info;
476 hb_glyph_position_t *pos = buffer->pos;
477 unsigned int i = 0;
478 for (i = 0; i < count; i++)
479 {
480 if (unlikely (_hb_glyph_info_is_default_ignorable (&info[i])))
481 break;
482 }
483
484 /* No default-ignorables found; return. */
485 if (i == count)
486 return;
487
488 hb_codepoint_t space;
489 if (c->font->get_nominal_glyph (' ', &space))
490 {
491 /* Replace default-ignorables with a zero-advance space glyph. */
492 for (/*continue*/; i < count; i++)
493 {
494 if (_hb_glyph_info_is_default_ignorable (&info[i]))
495 info[i].codepoint = space;
496 }
497 }
498 else
499 {
500 /* Merge clusters and delete default-ignorables.
501 * NOTE! We can't use out-buffer as we have positioning data. */
502 unsigned int j = i;
503 for (; i < count; i++)
504 {
505 if (_hb_glyph_info_is_default_ignorable (&info[i]))
506 {
507 /* Merge clusters.
508 * Same logic as buffer->delete_glyph(), but for in-place removal. */
509
510 unsigned int cluster = info[i].cluster;
511 if (i + 1 < count && cluster == info[i + 1].cluster)
512 continue; /* Cluster survives; do nothing. */
513
514 if (j)
515 {
516 /* Merge cluster backward. */
517 if (cluster < info[j - 1].cluster)
518 {
519 unsigned int mask = info[i].mask;
520 unsigned int old_cluster = info[j - 1].cluster;
521 for (unsigned k = j; k && info[k - 1].cluster == old_cluster; k--)
522 buffer->set_cluster (info[k - 1], cluster, mask);
523 }
524 continue;
525 }
526
527 if (i + 1 < count)
528 buffer->merge_clusters (i, i + 2); /* Merge cluster forward. */
529
530 continue;
531 }
532
533 if (j != i)
534 {
535 info[j] = info[i];
536 pos[j] = pos[i];
537 }
538 j++;
539 }
540 buffer->len = j;
541 }
542 }
543
544
545 static inline void
546 hb_ot_map_glyphs_fast (hb_buffer_t *buffer)
547 {
548 /* Normalization process sets up glyph_index(), we just copy it. */
549 unsigned int count = buffer->len;
550 hb_glyph_info_t *info = buffer->info;
551 for (unsigned int i = 0; i < count; i++)
552 info[i].codepoint = info[i].glyph_index();
553
554 buffer->content_type = HB_BUFFER_CONTENT_TYPE_GLYPHS;
555 }
556
557 static inline void
558 hb_synthesize_glyph_classes (hb_ot_shape_context_t *c)
559 {
560 unsigned int count = c->buffer->len;
561 hb_glyph_info_t *info = c->buffer->info;
562 for (unsigned int i = 0; i < count; i++)
563 {
564 hb_ot_layout_glyph_props_flags_t klass;
565
566 /* Never mark default-ignorables as marks.
567 * They won't get in the way of lookups anyway,
568 * but having them as mark will cause them to be skipped
569 * over if the lookup-flag says so, but at least for the
570 * Mongolian variation selectors, looks like Uniscribe
571 * marks them as non-mark. Some Mongolian fonts without
572 * GDEF rely on this. Another notable character that
573 * this applies to is COMBINING GRAPHEME JOINER. */
574 klass = (_hb_glyph_info_get_general_category (&info[i]) !=
575 HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK ||
576 _hb_glyph_info_is_default_ignorable (&info[i])) ?
577 HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH :
578 HB_OT_LAYOUT_GLYPH_PROPS_MARK;
579 _hb_glyph_info_set_glyph_props (&info[i], klass);
580 }
581 }
582
583 static inline void
584 hb_ot_substitute_default (hb_ot_shape_context_t *c)
585 {
586 hb_buffer_t *buffer = c->buffer;
587
588 hb_ot_mirror_chars (c);
589
590 HB_BUFFER_ALLOCATE_VAR (buffer, glyph_index);
591
592 _hb_ot_shape_normalize (c->plan, buffer, c->font);
593
594 hb_ot_shape_setup_masks (c);
595
596 /* This is unfortunate to go here, but necessary... */
597 if (c->fallback_positioning)
598 _hb_ot_shape_fallback_position_recategorize_marks (c->plan, c->font, buffer);
599
600 hb_ot_map_glyphs_fast (buffer);
601
602 HB_BUFFER_DEALLOCATE_VAR (buffer, glyph_index);
603 }
604
605 static inline void
606 hb_ot_substitute_complex (hb_ot_shape_context_t *c)
607 {
608 hb_buffer_t *buffer = c->buffer;
609
610 hb_ot_layout_substitute_start (c->font, buffer);
611
612 if (!hb_ot_layout_has_glyph_classes (c->face))
613 hb_synthesize_glyph_classes (c);
614
615 c->plan->substitute (c->font, buffer);
616
617 return;
618 }
619
620 static inline void
621 hb_ot_substitute (hb_ot_shape_context_t *c)
622 {
623 hb_ot_substitute_default (c);
624
625 _hb_buffer_allocate_gsubgpos_vars (c->buffer);
626
627 hb_ot_substitute_complex (c);
628 }
629
630 /* Position */
631
632 static inline void
633 adjust_mark_offsets (hb_glyph_position_t *pos)
634 {
635 pos->x_offset -= pos->x_advance;
636 pos->y_offset -= pos->y_advance;
637 }
638
639 static inline void
640 zero_mark_width (hb_glyph_position_t *pos)
641 {
642 pos->x_advance = 0;
643 pos->y_advance = 0;
644 }
645
646 static inline void
647 zero_mark_widths_by_gdef (hb_buffer_t *buffer, bool adjust_offsets)
648 {
649 unsigned int count = buffer->len;
650 hb_glyph_info_t *info = buffer->info;
651 for (unsigned int i = 0; i < count; i++)
652 if (_hb_glyph_info_is_mark (&info[i]))
653 {
654 if (adjust_offsets)
655 adjust_mark_offsets (&buffer->pos[i]);
656 zero_mark_width (&buffer->pos[i]);
657 }
658 }
659
660 static inline void
661 hb_ot_position_default (hb_ot_shape_context_t *c)
662 {
663 hb_direction_t direction = c->buffer->props.direction;
664 unsigned int count = c->buffer->len;
665 hb_glyph_info_t *info = c->buffer->info;
666 hb_glyph_position_t *pos = c->buffer->pos;
667
668 if (HB_DIRECTION_IS_HORIZONTAL (direction))
669 {
670 for (unsigned int i = 0; i < count; i++)
671 pos[i].x_advance = c->font->get_glyph_h_advance (info[i].codepoint);
672 /* The nil glyph_h_origin() func returns 0, so no need to apply it. */
673 if (c->font->has_glyph_h_origin_func ())
674 for (unsigned int i = 0; i < count; i++)
675 c->font->subtract_glyph_h_origin (info[i].codepoint,
676 &pos[i].x_offset,
677 &pos[i].y_offset);
678 }
679 else
680 {
681 for (unsigned int i = 0; i < count; i++)
682 {
683 pos[i].y_advance = c->font->get_glyph_v_advance (info[i].codepoint);
684 c->font->subtract_glyph_v_origin (info[i].codepoint,
685 &pos[i].x_offset,
686 &pos[i].y_offset);
687 }
688 }
689 if (c->buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_SPACE_FALLBACK)
690 _hb_ot_shape_fallback_spaces (c->plan, c->font, c->buffer);
691 }
692
693 static inline void
694 hb_ot_position_complex (hb_ot_shape_context_t *c)
695 {
696 unsigned int count = c->buffer->len;
697 hb_glyph_info_t *info = c->buffer->info;
698 hb_glyph_position_t *pos = c->buffer->pos;
699
700 /* If the font has no GPOS, AND, no fallback positioning will
701 * happen, AND, direction is forward, then when zeroing mark
702 * widths, we shift the mark with it, such that the mark
703 * is positioned hanging over the previous glyph. When
704 * direction is backward we don't shift and it will end up
705 * hanging over the next glyph after the final reordering.
706 * If fallback positinoing happens or GPOS is present, we don't
707 * care.
708 */
709 bool adjust_offsets_when_zeroing = c->fallback_positioning &&
710 !c->plan->shaper->fallback_position &&
711 HB_DIRECTION_IS_FORWARD (c->buffer->props.direction);
712
713 /* We change glyph origin to what GPOS expects (horizontal), apply GPOS, change it back. */
714
715 /* The nil glyph_h_origin() func returns 0, so no need to apply it. */
716 if (c->font->has_glyph_h_origin_func ())
717 for (unsigned int i = 0; i < count; i++)
718 c->font->add_glyph_h_origin (info[i].codepoint,
719 &pos[i].x_offset,
720 &pos[i].y_offset);
721
722 hb_ot_layout_position_start (c->font, c->buffer);
723
724 switch (c->plan->shaper->zero_width_marks)
725 {
726 case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY:
727 zero_mark_widths_by_gdef (c->buffer, adjust_offsets_when_zeroing);
728 break;
729
730 default:
731 case HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE:
732 case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE:
733 break;
734 }
735
736 if (likely (!c->fallback_positioning))
737 c->plan->position (c->font, c->buffer);
738
739 switch (c->plan->shaper->zero_width_marks)
740 {
741 case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE:
742 zero_mark_widths_by_gdef (c->buffer, adjust_offsets_when_zeroing);
743 break;
744
745 default:
746 case HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE:
747 case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY:
748 break;
749 }
750
751 /* Finishing off GPOS has to follow a certain order. */
752 hb_ot_layout_position_finish_advances (c->font, c->buffer);
753 hb_ot_zero_width_default_ignorables (c);
754 hb_ot_layout_position_finish_offsets (c->font, c->buffer);
755
756 /* The nil glyph_h_origin() func returns 0, so no need to apply it. */
757 if (c->font->has_glyph_h_origin_func ())
758 for (unsigned int i = 0; i < count; i++)
759 c->font->subtract_glyph_h_origin (info[i].codepoint,
760 &pos[i].x_offset,
761 &pos[i].y_offset);
762 }
763
764 static inline void
765 hb_ot_position (hb_ot_shape_context_t *c)
766 {
767 c->buffer->clear_positions ();
768
769 hb_ot_position_default (c);
770
771 hb_ot_position_complex (c);
772
773 if (c->fallback_positioning && c->plan->shaper->fallback_position)
774 _hb_ot_shape_fallback_position (c->plan, c->font, c->buffer);
775
776 if (HB_DIRECTION_IS_BACKWARD (c->buffer->props.direction))
777 hb_buffer_reverse (c->buffer);
778
779 /* Visual fallback goes here. */
780
781 if (c->fallback_positioning)
782 _hb_ot_shape_fallback_kern (c->plan, c->font, c->buffer);
783
784 _hb_buffer_deallocate_gsubgpos_vars (c->buffer);
785 }
786
787 static inline void
788 hb_propagate_flags (hb_buffer_t *buffer)
789 {
790 /* Propagate cluster-level glyph flags to be the same on all cluster glyphs.
791 * Simplifies using them. */
792
793 if (!(buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_UNSAFE_TO_BREAK))
794 return;
795
796 hb_glyph_info_t *info = buffer->info;
797
798 foreach_cluster (buffer, start, end)
799 {
800 unsigned int mask = 0;
801 for (unsigned int i = start; i < end; i++)
802 if (info[i].mask & HB_GLYPH_FLAG_UNSAFE_TO_BREAK)
803 {
804 mask = HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
805 break;
806 }
807 if (mask)
808 for (unsigned int i = start; i < end; i++)
809 info[i].mask |= mask;
810 }
811 }
812
813 /* Pull it all together! */
814
815 static void
816 hb_ot_shape_internal (hb_ot_shape_context_t *c)
817 {
818 c->buffer->deallocate_var_all ();
819 c->buffer->scratch_flags = HB_BUFFER_SCRATCH_FLAG_DEFAULT;
820 if (likely (!_hb_unsigned_int_mul_overflows (c->buffer->len, HB_BUFFER_MAX_EXPANSION_FACTOR)))
821 {
822 c->buffer->max_len = MAX (c->buffer->len * HB_BUFFER_MAX_EXPANSION_FACTOR,
823 (unsigned) HB_BUFFER_MAX_LEN_MIN);
824 }
825
826 bool disable_otl = c->plan->shaper->disable_otl && c->plan->shaper->disable_otl (c->plan);
827 //c->fallback_substitute = disable_otl || !hb_ot_layout_has_substitution (c->face);
828 c->fallback_positioning = disable_otl || !hb_ot_layout_has_positioning (c->face);
829 c->fallback_glyph_classes = disable_otl || !hb_ot_layout_has_glyph_classes (c->face);
830
831 /* Save the original direction, we use it later. */
832 c->target_direction = c->buffer->props.direction;
833
834 _hb_buffer_allocate_unicode_vars (c->buffer);
835
836 c->buffer->clear_output ();
837
838 hb_ot_shape_initialize_masks (c);
839 hb_set_unicode_props (c->buffer);
840 hb_insert_dotted_circle (c->buffer, c->font);
841
842 hb_form_clusters (c->buffer);
843
844 hb_ensure_native_direction (c->buffer);
845
846 if (c->plan->shaper->preprocess_text)
847 c->plan->shaper->preprocess_text (c->plan, c->buffer, c->font);
848
849 hb_ot_substitute (c);
850 hb_ot_position (c);
851
852 hb_ot_hide_default_ignorables (c);
853
854 if (c->plan->shaper->postprocess_glyphs)
855 c->plan->shaper->postprocess_glyphs (c->plan, c->buffer, c->font);
856
857 hb_propagate_flags (c->buffer);
858
859 _hb_buffer_deallocate_unicode_vars (c->buffer);
860
861 c->buffer->props.direction = c->target_direction;
862
863 c->buffer->max_len = HB_BUFFER_MAX_LEN_DEFAULT;
864 c->buffer->deallocate_var_all ();
865 }
866
867
868 hb_bool_t
869 _hb_ot_shape (hb_shape_plan_t *shape_plan,
870 hb_font_t *font,
871 hb_buffer_t *buffer,
872 const hb_feature_t *features,
873 unsigned int num_features)
874 {
875 hb_ot_shape_context_t c = {HB_SHAPER_DATA_GET (shape_plan), font, font->face, buffer, features, num_features};
876 hb_ot_shape_internal (&c);
877
878 return true;
879 }
880
881
882 /**
883 * hb_ot_shape_plan_collect_lookups:
884 *
885 * Since: 0.9.7
886 **/
887 void
888 hb_ot_shape_plan_collect_lookups (hb_shape_plan_t *shape_plan,
889 hb_tag_t table_tag,
890 hb_set_t *lookup_indexes /* OUT */)
891 {
892 /* XXX Does the first part always succeed? */
893 HB_SHAPER_DATA_GET (shape_plan)->collect_lookups (table_tag, lookup_indexes);
894 }
895
896
897 /* TODO Move this to hb-ot-shape-normalize, make it do decompose, and make it public. */
898 static void
899 add_char (hb_font_t *font,
900 hb_unicode_funcs_t *unicode,
901 hb_bool_t mirror,
902 hb_codepoint_t u,
903 hb_set_t *glyphs)
904 {
905 hb_codepoint_t glyph;
906 if (font->get_nominal_glyph (u, &glyph))
907 glyphs->add (glyph);
908 if (mirror)
909 {
910 hb_codepoint_t m = unicode->mirroring (u);
911 if (m != u && font->get_nominal_glyph (m, &glyph))
912 glyphs->add (glyph);
913 }
914 }
915
916
917 /**
918 * hb_ot_shape_glyphs_closure:
919 *
920 * Since: 0.9.2
921 **/
922 void
923 hb_ot_shape_glyphs_closure (hb_font_t *font,
924 hb_buffer_t *buffer,
925 const hb_feature_t *features,
926 unsigned int num_features,
927 hb_set_t *glyphs)
928 {
929 hb_ot_shape_plan_t plan;
930
931 const char *shapers[] = {"ot", nullptr};
932 hb_shape_plan_t *shape_plan = hb_shape_plan_create_cached (font->face, &buffer->props,
933 features, num_features, shapers);
934
935 bool mirror = hb_script_get_horizontal_direction (buffer->props.script) == HB_DIRECTION_RTL;
936
937 unsigned int count = buffer->len;
938 hb_glyph_info_t *info = buffer->info;
939 for (unsigned int i = 0; i < count; i++)
940 add_char (font, buffer->unicode, mirror, info[i].codepoint, glyphs);
941
942 hb_set_t *lookups = hb_set_create ();
943 hb_ot_shape_plan_collect_lookups (shape_plan, HB_OT_TAG_GSUB, lookups);
944
945 /* And find transitive closure. */
946 hb_set_t *copy = hb_set_create ();
947 do {
948 copy->set (glyphs);
949 for (hb_codepoint_t lookup_index = -1; hb_set_next (lookups, &lookup_index);)
950 hb_ot_layout_lookup_substitute_closure (font->face, lookup_index, glyphs);
951 } while (!copy->is_equal (glyphs));
952 hb_set_destroy (copy);
953
954 hb_set_destroy (lookups);
955
956 hb_shape_plan_destroy (shape_plan);
957 }