1 /* 2 * Copyright 2013 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-ot-shape-complex-private.hh" 28 29 30 /* Hangul shaper */ 31 32 33 /* Same order as the feature array below */ 34 enum { 35 _JMO, 36 37 LJMO, 38 VJMO, 39 TJMO, 40 41 FIRST_HANGUL_FEATURE = LJMO, 42 HANGUL_FEATURE_COUNT = TJMO + 1 43 }; 44 45 static const hb_tag_t hangul_features[HANGUL_FEATURE_COUNT] = 46 { 47 HB_TAG_NONE, 48 HB_TAG('l','j','m','o'), 49 HB_TAG('v','j','m','o'), 50 HB_TAG('t','j','m','o') 51 }; 52 53 static void 54 collect_features_hangul (hb_ot_shape_planner_t *plan) 55 { 56 hb_ot_map_builder_t *map = &plan->map; 57 58 for (unsigned int i = FIRST_HANGUL_FEATURE; i < HANGUL_FEATURE_COUNT; i++) 59 map->add_feature (hangul_features[i], 1, F_NONE); 60 } 61 62 static void 63 override_features_hangul (hb_ot_shape_planner_t *plan) 64 { 65 /* Uniscribe does not apply 'calt' for Hangul, and certain fonts 66 * (Noto Sans CJK, Source Sans Han, etc) apply all of jamo lookups 67 * in calt, which is not desirable. */ 68 plan->map.add_feature (HB_TAG('c','a','l','t'), 0, F_GLOBAL); 69 } 70 71 struct hangul_shape_plan_t 72 { 73 ASSERT_POD (); 74 75 hb_mask_t mask_array[HANGUL_FEATURE_COUNT]; 76 }; 77 78 static void * 79 data_create_hangul (const hb_ot_shape_plan_t *plan) 80 { 81 hangul_shape_plan_t *hangul_plan = (hangul_shape_plan_t *) calloc (1, sizeof (hangul_shape_plan_t)); 82 if (unlikely (!hangul_plan)) 83 return NULL; 84 85 for (unsigned int i = 0; i < HANGUL_FEATURE_COUNT; i++) 86 hangul_plan->mask_array[i] = plan->map.get_1_mask (hangul_features[i]); 87 88 return hangul_plan; 89 } 90 91 static void 92 data_destroy_hangul (void *data) 93 { 94 free (data); 95 } 96 97 /* Constants for algorithmic hangul syllable [de]composition. */ 98 #define LBase 0x1100u 99 #define VBase 0x1161u 100 #define TBase 0x11A7u 101 #define LCount 19u 102 #define VCount 21u 103 #define TCount 28u 104 #define SBase 0xAC00u 105 #define NCount (VCount * TCount) 106 #define SCount (LCount * NCount) 107 108 #define isCombiningL(u) (hb_in_range ((u), LBase, LBase+LCount-1)) 109 #define isCombiningV(u) (hb_in_range ((u), VBase, VBase+VCount-1)) 110 #define isCombiningT(u) (hb_in_range ((u), TBase+1, TBase+TCount-1)) 111 #define isCombinedS(u) (hb_in_range ((u), SBase, SBase+SCount-1)) 112 113 #define isL(u) (hb_in_ranges ((u), 0x1100u, 0x115Fu, 0xA960u, 0xA97Cu)) 114 #define isV(u) (hb_in_ranges ((u), 0x1160u, 0x11A7u, 0xD7B0u, 0xD7C6u)) 115 #define isT(u) (hb_in_ranges ((u), 0x11A8u, 0x11FFu, 0xD7CBu, 0xD7FBu)) 116 117 #define isHangulTone(u) (hb_in_range ((u), 0x302Eu, 0x302Fu)) 118 119 /* buffer var allocations */ 120 #define hangul_shaping_feature() complex_var_u8_0() /* hangul jamo shaping feature */ 121 122 static bool 123 is_zero_width_char (hb_font_t *font, 124 hb_codepoint_t unicode) 125 { 126 hb_codepoint_t glyph; 127 return hb_font_get_glyph (font, unicode, 0, &glyph) && hb_font_get_glyph_h_advance (font, glyph) == 0; 128 } 129 130 static void 131 preprocess_text_hangul (const hb_ot_shape_plan_t *plan, 132 hb_buffer_t *buffer, 133 hb_font_t *font) 134 { 135 HB_BUFFER_ALLOCATE_VAR (buffer, hangul_shaping_feature); 136 137 /* Hangul syllables come in two shapes: LV, and LVT. Of those: 138 * 139 * - LV can be precomposed, or decomposed. Lets call those 140 * <LV> and <L,V>, 141 * - LVT can be fully precomposed, partically precomposed, or 142 * fully decomposed. Ie. <LVT>, <LV,T>, or <L,V,T>. 143 * 144 * The composition / decomposition is mechanical. However, not 145 * all <L,V> sequences compose, and not all <LV,T> sequences 146 * compose. 147 * 148 * Here are the specifics: 149 * 150 * - <L>: U+1100..115F, U+A960..A97F 151 * - <V>: U+1160..11A7, U+D7B0..D7C7 152 * - <T>: U+11A8..11FF, U+D7CB..D7FB 153 * 154 * - Only the <L,V> sequences for the 11xx ranges combine. 155 * - Only <LV,T> sequences for T in U+11A8..11C3 combine. 156 * 157 * Here is what we want to accomplish in this shaper: 158 * 159 * - If the whole syllable can be precomposed, do that, 160 * - Otherwise, fully decompose and apply ljmo/vjmo/tjmo features. 161 * - If a valid syllable is followed by a Hangul tone mark, reorder the tone 162 * mark to precede the whole syllable - unless it is a zero-width glyph, in 163 * which case we leave it untouched, assuming it's designed to overstrike. 164 * 165 * That is, of the different possible syllables: 166 * 167 * <L> 168 * <L,V> 169 * <L,V,T> 170 * <LV> 171 * <LVT> 172 * <LV, T> 173 * 174 * - <L> needs no work. 175 * 176 * - <LV> and <LVT> can stay the way they are if the font supports them, otherwise we 177 * should fully decompose them if font supports. 178 * 179 * - <L,V> and <L,V,T> we should compose if the whole thing can be composed. 180 * 181 * - <LV,T> we should compose if the whole thing can be composed, otherwise we should 182 * decompose. 183 */ 184 185 buffer->clear_output (); 186 unsigned int start = 0, end = 0; /* Extent of most recently seen syllable; 187 * valid only if start < end 188 */ 189 unsigned int count = buffer->len; 190 191 for (buffer->idx = 0; buffer->idx < count && !buffer->in_error;) 192 { 193 hb_codepoint_t u = buffer->cur().codepoint; 194 195 if (isHangulTone (u)) 196 { 197 /* 198 * We could cache the width of the tone marks and the existence of dotted-circle, 199 * but the use of the Hangul tone mark characters seems to be rare enough that 200 * I didn't bother for now. 201 */ 202 if (start < end && end == buffer->out_len) 203 { 204 /* Tone mark follows a valid syllable; move it in front, unless it's zero width. */ 205 buffer->next_glyph (); 206 if (!is_zero_width_char (font, u)) 207 { 208 buffer->merge_out_clusters (start, end + 1); 209 hb_glyph_info_t *info = buffer->out_info; 210 hb_glyph_info_t tone = info[end]; 211 memmove (&info[start + 1], &info[start], (end - start) * sizeof (hb_glyph_info_t)); 212 info[start] = tone; 213 } 214 } 215 else 216 { 217 /* No valid syllable as base for tone mark; try to insert dotted circle. */ 218 if (font->has_glyph (0x25CCu)) 219 { 220 hb_codepoint_t chars[2]; 221 if (!is_zero_width_char (font, u)) { 222 chars[0] = u; 223 chars[1] = 0x25CCu; 224 } else { 225 chars[0] = 0x25CCu; 226 chars[1] = u; 227 } 228 buffer->replace_glyphs (1, 2, chars); 229 } 230 else 231 { 232 /* No dotted circle available in the font; just leave tone mark untouched. */ 233 buffer->next_glyph (); 234 } 235 } 236 start = end = buffer->out_len; 237 continue; 238 } 239 240 start = buffer->out_len; /* Remember current position as a potential syllable start; 241 * will only be used if we set end to a later position. 242 */ 243 244 if (isL (u) && buffer->idx + 1 < count) 245 { 246 hb_codepoint_t l = u; 247 hb_codepoint_t v = buffer->cur(+1).codepoint; 248 if (isV (v)) 249 { 250 /* Have <L,V> or <L,V,T>. */ 251 hb_codepoint_t t = 0; 252 unsigned int tindex = 0; 253 if (buffer->idx + 2 < count) 254 { 255 t = buffer->cur(+2).codepoint; 256 if (isT (t)) 257 tindex = t - TBase; /* Only used if isCombiningT (t); otherwise invalid. */ 258 else 259 t = 0; /* The next character was not a trailing jamo. */ 260 } 261 262 /* We've got a syllable <L,V,T?>; see if it can potentially be composed. */ 263 if (isCombiningL (l) && isCombiningV (v) && (t == 0 || isCombiningT (t))) 264 { 265 /* Try to compose; if this succeeds, end is set to start+1. */ 266 hb_codepoint_t s = SBase + (l - LBase) * NCount + (v - VBase) * TCount + tindex; 267 if (font->has_glyph (s)) 268 { 269 buffer->replace_glyphs (t ? 3 : 2, 1, &s); 270 if (unlikely (buffer->in_error)) 271 return; 272 end = start + 1; 273 continue; 274 } 275 } 276 277 /* We didn't compose, either because it's an Old Hangul syllable without a 278 * precomposed character in Unicode, or because the font didn't support the 279 * necessary precomposed glyph. 280 * Set jamo features on the individual glyphs, and advance past them. 281 */ 282 buffer->cur().hangul_shaping_feature() = LJMO; 283 buffer->next_glyph (); 284 buffer->cur().hangul_shaping_feature() = VJMO; 285 buffer->next_glyph (); 286 if (t) 287 { 288 buffer->cur().hangul_shaping_feature() = TJMO; 289 buffer->next_glyph (); 290 end = start + 3; 291 } 292 else 293 end = start + 2; 294 if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES) 295 buffer->merge_out_clusters (start, end); 296 continue; 297 } 298 } 299 300 else if (isCombinedS (u)) 301 { 302 /* Have <LV>, <LVT>, or <LV,T> */ 303 hb_codepoint_t s = u; 304 bool has_glyph = font->has_glyph (s); 305 unsigned int lindex = (s - SBase) / NCount; 306 unsigned int nindex = (s - SBase) % NCount; 307 unsigned int vindex = nindex / TCount; 308 unsigned int tindex = nindex % TCount; 309 310 if (!tindex && 311 buffer->idx + 1 < count && 312 isCombiningT (buffer->cur(+1).codepoint)) 313 { 314 /* <LV,T>, try to combine. */ 315 unsigned int new_tindex = buffer->cur(+1).codepoint - TBase; 316 hb_codepoint_t new_s = s + new_tindex; 317 if (font->has_glyph (new_s)) 318 { 319 buffer->replace_glyphs (2, 1, &new_s); 320 if (unlikely (buffer->in_error)) 321 return; 322 end = start + 1; 323 continue; 324 } 325 } 326 327 /* Otherwise, decompose if font doesn't support <LV> or <LVT>, 328 * or if having non-combining <LV,T>. Note that we already handled 329 * combining <LV,T> above. */ 330 if (!has_glyph || 331 (!tindex && 332 buffer->idx + 1 < count && 333 isT (buffer->cur(+1).codepoint))) 334 { 335 hb_codepoint_t decomposed[3] = {LBase + lindex, 336 VBase + vindex, 337 TBase + tindex}; 338 if (font->has_glyph (decomposed[0]) && 339 font->has_glyph (decomposed[1]) && 340 (!tindex || font->has_glyph (decomposed[2]))) 341 { 342 unsigned int s_len = tindex ? 3 : 2; 343 buffer->replace_glyphs (1, s_len, decomposed); 344 if (unlikely (buffer->in_error)) 345 return; 346 347 /* We decomposed S: apply jamo features to the individual glyphs 348 * that are now in buffer->out_info. 349 */ 350 hb_glyph_info_t *info = buffer->out_info; 351 352 /* If we decomposed an LV because of a non-combining T following, 353 * we want to include this T in the syllable. 354 */ 355 if (has_glyph && !tindex) 356 { 357 buffer->next_glyph (); 358 s_len++; 359 } 360 end = start + s_len; 361 362 unsigned int i = start; 363 info[i++].hangul_shaping_feature() = LJMO; 364 info[i++].hangul_shaping_feature() = VJMO; 365 if (i < end) 366 info[i++].hangul_shaping_feature() = TJMO; 367 if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES) 368 buffer->merge_out_clusters (start, end); 369 continue; 370 } 371 } 372 373 if (has_glyph) 374 { 375 /* We didn't decompose the S, so just advance past it. */ 376 end = start + 1; 377 buffer->next_glyph (); 378 continue; 379 } 380 } 381 382 /* Didn't find a recognizable syllable, so we leave end <= start; 383 * this will prevent tone-mark reordering happening. 384 */ 385 buffer->next_glyph (); 386 } 387 buffer->swap_buffers (); 388 } 389 390 static void 391 setup_masks_hangul (const hb_ot_shape_plan_t *plan, 392 hb_buffer_t *buffer, 393 hb_font_t *font HB_UNUSED) 394 { 395 const hangul_shape_plan_t *hangul_plan = (const hangul_shape_plan_t *) plan->data; 396 397 if (likely (hangul_plan)) 398 { 399 unsigned int count = buffer->len; 400 hb_glyph_info_t *info = buffer->info; 401 for (unsigned int i = 0; i < count; i++, info++) 402 info->mask |= hangul_plan->mask_array[info->hangul_shaping_feature()]; 403 } 404 405 HB_BUFFER_DEALLOCATE_VAR (buffer, hangul_shaping_feature); 406 } 407 408 409 const hb_ot_complex_shaper_t _hb_ot_complex_shaper_hangul = 410 { 411 "hangul", 412 collect_features_hangul, 413 override_features_hangul, 414 data_create_hangul, 415 data_destroy_hangul, 416 preprocess_text_hangul, 417 NULL, /* postprocess_glyphs */ 418 HB_OT_SHAPE_NORMALIZATION_MODE_NONE, 419 NULL, /* decompose */ 420 NULL, /* compose */ 421 setup_masks_hangul, 422 NULL, /* disable_otl */ 423 HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE, 424 false, /* fallback_position */ 425 }; 426
