src/hb-ot-shape-complex-hangul.cc

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