src/hb-ot-cff1-table.cc

   1 /*
   2  * Copyright © 2018 Adobe 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  * Adobe Author(s): Michiharu Ariza
  25  */
  26
  27 #include "hb.hh"
  28
  29 #ifndef HB_NO_CFF
  30
  31 #include "hb-draw.hh"
  32 #include "hb-algs.hh"
  33 #include "hb-ot-cff1-table.hh"
  34 #include "hb-cff1-interp-cs.hh"
  35
  36 using namespace CFF;
  37
  38 struct sid_to_gid_t
  39 {
  40   uint16_t  sid;
  41   uint8_t   gid;
  42
  43   int cmp (uint16_t a) const
  44   {
  45     if (a == sid) return 0;
  46     return (a < sid) ? -1 : 1;
  47   }
  48 };
  49
  50 /* SID to code */
  51 static const uint8_t standard_encoding_to_code [] =
  52 {
  53     0,   32,   33,   34,   35,   36,   37,   38,  39,   40,   41,   42,   43,   44,   45,   46,
  54    47,   48,   49,   50,   51,   52,   53,   54,  55,   56,   57,   58,   59,   60,   61,   62,
  55    63,   64,   65,   66,   67,   68,   69,   70,  71,   72,   73,   74,   75,   76,   77,   78,
  56    79,   80,   81,   82,   83,   84,   85,   86,  87,   88,   89,   90,   91,   92,   93,   94,
  57    95,   96,   97,   98,   99,  100,  101,  102, 103,  104,  105,  106,  107,  108,  109,  110,
  58   111,  112,  113,  114,  115,  116,  117,  118, 119,  120,  121,  122,  123,  124,  125,  126,
  59   161,  162,  163,  164,  165,  166,  167,  168, 169,  170,  171,  172,  173,  174,  175,  177,
  60   178,  179,  180,  182,  183,  184,  185,  186, 187,  188,  189,  191,  193,  194,  195,  196,
  61   197,  198,  199,  200,  202,  203,  205,  206, 207,  208,  225,  227,  232,  233,  234,  235,
  62   241,  245,  248,  249,  250,  251
  63 };
  64
  65 /* SID to code */
  66 static const uint8_t expert_encoding_to_code [] =
  67 {
  68     0,   32,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   44,   45,   46,
  69     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   58,   59,    0,    0,    0,
  70     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  71     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  72     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  73     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  74     0,    0,    0,   47,    0,    0,    0,    0,    0,    0,    0,    0,    0,   87,   88,    0,
  75     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  76     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  77     0,    0,    0,    0,    0,    0,  201,    0,    0,    0,    0,  189,    0,    0,  188,    0,
  78     0,    0,    0,  190,  202,    0,    0,    0,    0,  203,    0,    0,    0,    0,    0,    0,
  79     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  80     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  81     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  82     0,    0,    0,    0,    0,   33,   34,   36,   37,   38,   39,   40,   41,   42,   43,   48,
  83    49,   50,   51,   52,   53,   54,   55,   56,   57,   60,   61,   62,   63,   65,   66,   67,
  84    68,   69,   73,   76,   77,   78,   79,   82,   83,   84,   86,   89,   90,   91,   93,   94,
  85    95,   96,   97,   98,   99,  100,  101,  102,  103,  104,  105,  106,  107,  108,  109,  110,
  86   111,  112,  113,  114,  115,  116,  117,  118,  119,  120,  121,  122,  123,  124,  125,  126,
  87   161,  162,  163,  166,  167,  168,  169,  170,  172,  175,  178,  179,  182,  183,  184,  191,
  88   192,  193,  194,  195,  196,  197,  200,  204,  205,  206,  207,  208,  209,  210,  211,  212,
  89   213,  214,  215,  216,  217,  218,  219,  220,  221,  222,  223,  224,  225,  226,  227,  228,
  90   229,  230,  231,  232,  233,  234,  235,  236,  237,  238,  239,  240,  241,  242,  243,  244,
  91   245,  246,  247,  248,  249,  250,  251,  252,  253,  254,  255
  92 };
  93
  94 /* glyph ID to SID */
  95 static const uint16_t expert_charset_to_sid [] =
  96 {
  97     0,    1,  229,  230,  231,  232,  233,  234,  235,  236,  237,  238,   13,   14,   15,   99,
  98   239,  240,  241,  242,  243,  244,  245,  246,  247,  248,   27,   28,  249,  250,  251,  252,
  99   253,  254,  255,  256,  257,  258,  259,  260,  261,  262,  263,  264,  265,  266,  109,  110,
 100   267,  268,  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,
 101   283,  284,  285,  286,  287,  288,  289,  290,  291,  292,  293,  294,  295,  296,  297,  298,
 102   299,  300,  301,  302,  303,  304,  305,  306,  307,  308,  309,  310,  311,  312,  313,  314,
 103   315,  316,  317,  318,  158,  155,  163,  319,  320,  321,  322,  323,  324,  325,  326,  150,
 104   164,  169,  327,  328,  329,  330,  331,  332,  333,  334,  335,  336,  337,  338,  339,  340,
 105   341,  342,  343,  344,  345,  346,  347,  348,  349,  350,  351,  352,  353,  354,  355,  356,
 106   357,  358,  359,  360,  361,  362,  363,  364,  365,  366,  367,  368,  369,  370,  371,  372,
 107   373,  374,  375,  376,  377,  378
 108 };
 109
 110 /* glyph ID to SID */
 111 static const uint16_t expert_subset_charset_to_sid [] =
 112 {
 113     0,    1,  231,  232,  235,  236,  237,  238,   13,   14,   15,   99,  239,  240,  241,  242,
 114   243,  244,  245,  246,  247,  248,   27,   28,  249,  250,  251,  253,  254,  255,  256,  257,
 115   258,  259,  260,  261,  262,  263,  264,  265,  266,  109,  110,  267,  268,  269,  270,  272,
 116   300,  301,  302,  305,  314,  315,  158,  155,  163,  320,  321,  322,  323,  324,  325,  326,
 117   150,  164,  169,  327,  328,  329,  330,  331,  332,  333,  334,  335,  336,  337,  338,  339,
 118   340,  341,  342,  343,  344,  345,  346
 119 };
 120
 121 /* SID to glyph ID */
 122 static const sid_to_gid_t expert_charset_sid_to_gid [] =
 123 {
 124     { 1, 1 },     { 13, 12 },   { 14, 13 },   { 15, 14 },
 125     { 27, 26 },   { 28, 27 },   { 99, 15 },   { 109, 46 },
 126     { 110, 47 },  { 150, 111 }, { 155, 101 }, { 158, 100 },
 127     { 163, 102 }, { 164, 112 }, { 169, 113 }, { 229, 2 },
 128     { 230, 3 },   { 231, 4 },   { 232, 5 },   { 233, 6 },
 129     { 234, 7 },   { 235, 8 },   { 236, 9 },   { 237, 10 },
 130     { 238, 11 },  { 239, 16 },  { 240, 17 },  { 241, 18 },
 131     { 242, 19 },  { 243, 20 },  { 244, 21 },  { 245, 22 },
 132     { 246, 23 },  { 247, 24 },  { 248, 25 },  { 249, 28 },
 133     { 250, 29 },  { 251, 30 },  { 252, 31 },  { 253, 32 },
 134     { 254, 33 },  { 255, 34 },  { 256, 35 },  { 257, 36 },
 135     { 258, 37 },  { 259, 38 },  { 260, 39 },  { 261, 40 },
 136     { 262, 41 },  { 263, 42 },  { 264, 43 },  { 265, 44 },
 137     { 266, 45 },  { 267, 48 },  { 268, 49 },  { 269, 50 },
 138     { 270, 51 },  { 271, 52 },  { 272, 53 },  { 273, 54 },
 139     { 274, 55 },  { 275, 56 },  { 276, 57 },  { 277, 58 },
 140     { 278, 59 },  { 279, 60 },  { 280, 61 },  { 281, 62 },
 141     { 282, 63 },  { 283, 64 },  { 284, 65 },  { 285, 66 },
 142     { 286, 67 },  { 287, 68 },  { 288, 69 },  { 289, 70 },
 143     { 290, 71 },  { 291, 72 },  { 292, 73 },  { 293, 74 },
 144     { 294, 75 },  { 295, 76 },  { 296, 77 },  { 297, 78 },
 145     { 298, 79 },  { 299, 80 },  { 300, 81 },  { 301, 82 },
 146     { 302, 83 },  { 303, 84 },  { 304, 85 },  { 305, 86 },
 147     { 306, 87 },  { 307, 88 },  { 308, 89 },  { 309, 90 },
 148     { 310, 91 },  { 311, 92 },  { 312, 93 },  { 313, 94 },
 149     { 314, 95 },  { 315, 96 },  { 316, 97 },  { 317, 98 },
 150     { 318, 99 },  { 319, 103 }, { 320, 104 }, { 321, 105 },
 151     { 322, 106 }, { 323, 107 }, { 324, 108 }, { 325, 109 },
 152     { 326, 110 }, { 327, 114 }, { 328, 115 }, { 329, 116 },
 153     { 330, 117 }, { 331, 118 }, { 332, 119 }, { 333, 120 },
 154     { 334, 121 }, { 335, 122 }, { 336, 123 }, { 337, 124 },
 155     { 338, 125 }, { 339, 126 }, { 340, 127 }, { 341, 128 },
 156     { 342, 129 }, { 343, 130 }, { 344, 131 }, { 345, 132 },
 157     { 346, 133 }, { 347, 134 }, { 348, 135 }, { 349, 136 },
 158     { 350, 137 }, { 351, 138 }, { 352, 139 }, { 353, 140 },
 159     { 354, 141 }, { 355, 142 }, { 356, 143 }, { 357, 144 },
 160     { 358, 145 }, { 359, 146 }, { 360, 147 }, { 361, 148 },
 161     { 362, 149 }, { 363, 150 }, { 364, 151 }, { 365, 152 },
 162     { 366, 153 }, { 367, 154 }, { 368, 155 }, { 369, 156 },
 163     { 370, 157 }, { 371, 158 }, { 372, 159 }, { 373, 160 },
 164     { 374, 161 }, { 375, 162 }, { 376, 163 }, { 377, 164 },
 165     { 378, 165 }
 166 };
 167
 168 /* SID to glyph ID */
 169 static const sid_to_gid_t expert_subset_charset_sid_to_gid [] =
 170 {
 171   { 1, 1 },       { 13, 8 },      { 14, 9 },      { 15, 10 },
 172   { 27, 22 },     { 28, 23 },     { 99, 11 },     { 109, 41 },
 173   { 110, 42 },    { 150, 64 },    { 155, 55 },    { 158, 54 },
 174   { 163, 56 },    { 164, 65 },    { 169, 66 },    { 231, 2 },
 175   { 232, 3 },     { 235, 4 },     { 236, 5 },     { 237, 6 },
 176   { 238, 7 },     { 239, 12 },    { 240, 13 },    { 241, 14 },
 177   { 242, 15 },    { 243, 16 },    { 244, 17 },    { 245, 18 },
 178   { 246, 19 },    { 247, 20 },    { 248, 21 },    { 249, 24 },
 179   { 250, 25 },    { 251, 26 },    { 253, 27 },    { 254, 28 },
 180   { 255, 29 },    { 256, 30 },    { 257, 31 },    { 258, 32 },
 181   { 259, 33 },    { 260, 34 },    { 261, 35 },    { 262, 36 },
 182   { 263, 37 },    { 264, 38 },    { 265, 39 },    { 266, 40 },
 183   { 267, 43 },    { 268, 44 },    { 269, 45 },    { 270, 46 },
 184   { 272, 47 },    { 300, 48 },    { 301, 49 },    { 302, 50 },
 185   { 305, 51 },    { 314, 52 },    { 315, 53 },    { 320, 57 },
 186   { 321, 58 },    { 322, 59 },    { 323, 60 },    { 324, 61 },
 187   { 325, 62 },    { 326, 63 },    { 327, 67 },    { 328, 68 },
 188   { 329, 69 },    { 330, 70 },    { 331, 71 },    { 332, 72 },
 189   { 333, 73 },    { 334, 74 },    { 335, 75 },    { 336, 76 },
 190   { 337, 77 },    { 338, 78 },    { 339, 79 },    { 340, 80 },
 191   { 341, 81 },    { 342, 82 },    { 343, 83 },    { 344, 84 },
 192   { 345, 85 },    { 346, 86 }
 193 };
 194
 195 /* code to SID */
 196 static const uint8_t standard_encoding_to_sid [] =
 197 {
 198     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 199     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 200     1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,   12,   13,   14,   15,   16,
 201     17,  18,   19,   20,   21,   22,   23,   24,   25,   26,   27,   28,   29,   30,   31,   32,
 202     33,  34,   35,   36,   37,   38,   39,   40,   41,   42,   43,   44,   45,   46,   47,   48,
 203     49,  50,   51,   52,   53,   54,   55,   56,   57,   58,   59,   60,   61,   62,   63,   64,
 204     65,  66,   67,   68,   69,   70,   71,   72,   73,   74,   75,   76,   77,   78,   79,   80,
 205     81,  82,   83,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,    0,
 206     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 207     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 208     0,   96,   97,   98,   99,  100,  101,  102,  103,  104,  105,  106,  107,  108,  109,  110,
 209     0,  111,  112,  113,  114,    0,  115,  116,  117,  118,  119,  120,  121,  122,    0,  123,
 210     0,  124,  125,  126,  127,  128,  129,  130,  131,    0,  132,  133,    0,  134,  135,  136,
 211   137,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 212     0,   138,   0,  139,    0,    0,    0,    0,  140,  141,  142,  143,    0,    0,    0,    0,
 213     0,   144,   0,    0,    0,  145,    0,    0,  146,  147,  148,  149,    0,    0,    0,    0
 214 };
 215
 216 hb_codepoint_t OT::cff1::lookup_standard_encoding_for_code (hb_codepoint_t sid)
 217 {
 218   if (sid < ARRAY_LENGTH (standard_encoding_to_code))
 219     return (hb_codepoint_t)standard_encoding_to_code[sid];
 220   else
 221     return 0;
 222 }
 223
 224 hb_codepoint_t OT::cff1::lookup_expert_encoding_for_code (hb_codepoint_t sid)
 225 {
 226   if (sid < ARRAY_LENGTH (expert_encoding_to_code))
 227     return (hb_codepoint_t)expert_encoding_to_code[sid];
 228   else
 229     return 0;
 230 }
 231
 232 hb_codepoint_t OT::cff1::lookup_expert_charset_for_sid (hb_codepoint_t glyph)
 233 {
 234   if (glyph < ARRAY_LENGTH (expert_charset_to_sid))
 235     return (hb_codepoint_t)expert_charset_to_sid[glyph];
 236   else
 237     return 0;
 238 }
 239
 240 hb_codepoint_t OT::cff1::lookup_expert_subset_charset_for_sid (hb_codepoint_t glyph)
 241 {
 242   if (glyph < ARRAY_LENGTH (expert_subset_charset_to_sid))
 243     return (hb_codepoint_t)expert_subset_charset_to_sid[glyph];
 244   else
 245     return 0;
 246 }
 247
 248 hb_codepoint_t OT::cff1::lookup_expert_charset_for_glyph (hb_codepoint_t sid)
 249 {
 250   const auto *pair = hb_sorted_array (expert_charset_sid_to_gid).bsearch (sid);
 251   return pair ? pair->gid : 0;
 252 }
 253
 254 hb_codepoint_t OT::cff1::lookup_expert_subset_charset_for_glyph (hb_codepoint_t sid)
 255 {
 256   const auto *pair = hb_sorted_array (expert_subset_charset_sid_to_gid).bsearch (sid);
 257   return pair ? pair->gid : 0;
 258 }
 259
 260 hb_codepoint_t OT::cff1::lookup_standard_encoding_for_sid (hb_codepoint_t code)
 261 {
 262   if (code < ARRAY_LENGTH (standard_encoding_to_sid))
 263     return (hb_codepoint_t)standard_encoding_to_sid[code];
 264   else
 265     return CFF_UNDEF_SID;
 266 }
 267
 268 struct bounds_t
 269 {
 270   void init ()
 271   {
 272     min.set_int (INT_MAX, INT_MAX);
 273     max.set_int (INT_MIN, INT_MIN);
 274   }
 275
 276   void update (const point_t &pt)
 277   {
 278     if (pt.x < min.x) min.x = pt.x;
 279     if (pt.x > max.x) max.x = pt.x;
 280     if (pt.y < min.y) min.y = pt.y;
 281     if (pt.y > max.y) max.y = pt.y;
 282   }
 283
 284   void merge (const bounds_t &b)
 285   {
 286     if (empty ())
 287       *this = b;
 288     else if (!b.empty ())
 289     {
 290       if (b.min.x < min.x) min.x = b.min.x;
 291       if (b.max.x > max.x) max.x = b.max.x;
 292       if (b.min.y < min.y) min.y = b.min.y;
 293       if (b.max.y > max.y) max.y = b.max.y;
 294     }
 295   }
 296
 297   void offset (const point_t &delta)
 298   {
 299     if (!empty ())
 300     {
 301       min.move (delta);
 302       max.move (delta);
 303     }
 304   }
 305
 306   bool empty () const { return (min.x >= max.x) || (min.y >= max.y); }
 307
 308   point_t min;
 309   point_t max;
 310 };
 311
 312 struct cff1_extents_param_t
 313 {
 314   cff1_extents_param_t (const OT::cff1::accelerator_t *_cff) : cff (_cff)
 315   {
 316     bounds.init ();
 317   }
 318
 319   void start_path   ()       { path_open = true; }
 320   void end_path     ()       { path_open = false; }
 321   bool is_path_open () const { return path_open; }
 322
 323   bool path_open = false;
 324   bounds_t bounds;
 325
 326   const OT::cff1::accelerator_t *cff;
 327 };
 328
 329 struct cff1_path_procs_extents_t : path_procs_t<cff1_path_procs_extents_t, cff1_cs_interp_env_t, cff1_extents_param_t>
 330 {
 331   static void moveto (cff1_cs_interp_env_t &env, cff1_extents_param_t& param, const point_t &pt)
 332   {
 333     param.end_path ();
 334     env.moveto (pt);
 335   }
 336
 337   static void line (cff1_cs_interp_env_t &env, cff1_extents_param_t& param, const point_t &pt1)
 338   {
 339     if (!param.is_path_open ())
 340     {
 341       param.start_path ();
 342       param.bounds.update (env.get_pt ());
 343     }
 344     env.moveto (pt1);
 345     param.bounds.update (env.get_pt ());
 346   }
 347
 348   static void curve (cff1_cs_interp_env_t &env, cff1_extents_param_t& param, const point_t &pt1, const point_t &pt2, const point_t &pt3)
 349   {
 350     if (!param.is_path_open ())
 351     {
 352       param.start_path ();
 353       param.bounds.update (env.get_pt ());
 354     }
 355     /* include control points */
 356     param.bounds.update (pt1);
 357     param.bounds.update (pt2);
 358     env.moveto (pt3);
 359     param.bounds.update (env.get_pt ());
 360   }
 361 };
 362
 363 static bool _get_bounds (const OT::cff1::accelerator_t *cff, hb_codepoint_t glyph, bounds_t &bounds, bool in_seac=false);
 364
 365 struct cff1_cs_opset_extents_t : cff1_cs_opset_t<cff1_cs_opset_extents_t, cff1_extents_param_t, cff1_path_procs_extents_t>
 366 {
 367   static void process_seac (cff1_cs_interp_env_t &env, cff1_extents_param_t& param)
 368   {
 369     unsigned int  n = env.argStack.get_count ();
 370     point_t delta;
 371     delta.x = env.argStack[n-4];
 372     delta.y = env.argStack[n-3];
 373     hb_codepoint_t base = param.cff->std_code_to_glyph (env.argStack[n-2].to_int ());
 374     hb_codepoint_t accent = param.cff->std_code_to_glyph (env.argStack[n-1].to_int ());
 375
 376     bounds_t  base_bounds, accent_bounds;
 377     if (likely (!env.in_seac && base && accent
 378                && _get_bounds (param.cff, base, base_bounds, true)
 379                && _get_bounds (param.cff, accent, accent_bounds, true)))
 380     {
 381       param.bounds.merge (base_bounds);
 382       accent_bounds.offset (delta);
 383       param.bounds.merge (accent_bounds);
 384     }
 385     else
 386       env.set_error ();
 387   }
 388 };
 389
 390 bool _get_bounds (const OT::cff1::accelerator_t *cff, hb_codepoint_t glyph, bounds_t &bounds, bool in_seac)
 391 {
 392   bounds.init ();
 393   if (unlikely (!cff->is_valid () || (glyph >= cff->num_glyphs))) return false;
 394
 395   unsigned int fd = cff->fdSelect->get_fd (glyph);
 396   const hb_ubytes_t str = (*cff->charStrings)[glyph];
 397   cff1_cs_interp_env_t env (str, *cff, fd);
 398   env.set_in_seac (in_seac);
 399   cff1_cs_interpreter_t<cff1_cs_opset_extents_t, cff1_extents_param_t> interp (env);
 400   cff1_extents_param_t param (cff);
 401   if (unlikely (!interp.interpret (param))) return false;
 402   bounds = param.bounds;
 403   return true;
 404 }
 405
 406 bool OT::cff1::accelerator_t::get_extents (hb_font_t *font, hb_codepoint_t glyph, hb_glyph_extents_t *extents) const
 407 {
 408 #ifdef HB_NO_OT_FONT_CFF
 409   /* XXX Remove check when this code moves to .hh file. */
 410   return true;
 411 #endif
 412
 413   bounds_t bounds;
 414
 415   if (!_get_bounds (this, glyph, bounds))
 416     return false;
 417
 418   if (bounds.min.x >= bounds.max.x)
 419   {
 420     extents->width = 0;
 421     extents->x_bearing = 0;
 422   }
 423   else
 424   {
 425     extents->x_bearing = roundf (bounds.min.x.to_real ());
 426     extents->width = roundf (bounds.max.x.to_real () - extents->x_bearing);
 427   }
 428   if (bounds.min.y >= bounds.max.y)
 429   {
 430     extents->height = 0;
 431     extents->y_bearing = 0;
 432   }
 433   else
 434   {
 435     extents->y_bearing = roundf (bounds.max.y.to_real ());
 436     extents->height = roundf (bounds.min.y.to_real () - extents->y_bearing);
 437   }
 438
 439   font->scale_glyph_extents (extents);
 440
 441   return true;
 442 }
 443
 444 struct cff1_path_param_t
 445 {
 446   cff1_path_param_t (const OT::cff1::accelerator_t *cff_, hb_font_t *font_,
 447                      hb_draw_session_t &draw_session_, point_t *delta_)
 448   {
 449     draw_session = &draw_session_;
 450     cff = cff_;
 451     font = font_;
 452     delta = delta_;
 453   }
 454
 455   void move_to (const point_t &p)
 456   {
 457     point_t point = p;
 458     if (delta) point.move (*delta);
 459     draw_session->move_to (font->em_fscalef_x (point.x.to_real ()), font->em_fscalef_y (point.y.to_real ()));
 460   }
 461
 462   void line_to (const point_t &p)
 463   {
 464     point_t point = p;
 465     if (delta) point.move (*delta);
 466     draw_session->line_to (font->em_fscalef_x (point.x.to_real ()), font->em_fscalef_y (point.y.to_real ()));
 467   }
 468
 469   void cubic_to (const point_t &p1, const point_t &p2, const point_t &p3)
 470   {
 471     point_t point1 = p1, point2 = p2, point3 = p3;
 472     if (delta)
 473     {
 474       point1.move (*delta);
 475       point2.move (*delta);
 476       point3.move (*delta);
 477     }
 478     draw_session->cubic_to (font->em_fscalef_x (point1.x.to_real ()), font->em_fscalef_y (point1.y.to_real ()),
 479                            font->em_fscalef_x (point2.x.to_real ()), font->em_fscalef_y (point2.y.to_real ()),
 480                            font->em_fscalef_x (point3.x.to_real ()), font->em_fscalef_y (point3.y.to_real ()));
 481   }
 482
 483   void end_path () { draw_session->close_path (); }
 484
 485   hb_font_t *font;
 486   hb_draw_session_t *draw_session;
 487   point_t *delta;
 488
 489   const OT::cff1::accelerator_t *cff;
 490 };
 491
 492 struct cff1_path_procs_path_t : path_procs_t<cff1_path_procs_path_t, cff1_cs_interp_env_t, cff1_path_param_t>
 493 {
 494   static void moveto (cff1_cs_interp_env_t &env, cff1_path_param_t& param, const point_t &pt)
 495   {
 496     param.move_to (pt);
 497     env.moveto (pt);
 498   }
 499
 500   static void line (cff1_cs_interp_env_t &env, cff1_path_param_t &param, const point_t &pt1)
 501   {
 502     param.line_to (pt1);
 503     env.moveto (pt1);
 504   }
 505
 506   static void curve (cff1_cs_interp_env_t &env, cff1_path_param_t &param, const point_t &pt1, const point_t &pt2, const point_t &pt3)
 507   {
 508     param.cubic_to (pt1, pt2, pt3);
 509     env.moveto (pt3);
 510   }
 511 };
 512
 513 static bool _get_path (const OT::cff1::accelerator_t *cff, hb_font_t *font, hb_codepoint_t glyph,
 514                        hb_draw_session_t &draw_session, bool in_seac = false, point_t *delta = nullptr);
 515
 516 struct cff1_cs_opset_path_t : cff1_cs_opset_t<cff1_cs_opset_path_t, cff1_path_param_t, cff1_path_procs_path_t>
 517 {
 518   static void process_seac (cff1_cs_interp_env_t &env, cff1_path_param_t& param)
 519   {
 520     /* End previous path */
 521     param.end_path ();
 522
 523     unsigned int n = env.argStack.get_count ();
 524     point_t delta;
 525     delta.x = env.argStack[n-4];
 526     delta.y = env.argStack[n-3];
 527     hb_codepoint_t base = param.cff->std_code_to_glyph (env.argStack[n-2].to_int ());
 528     hb_codepoint_t accent = param.cff->std_code_to_glyph (env.argStack[n-1].to_int ());
 529
 530     if (unlikely (!(!env.in_seac && base && accent
 531                     && _get_path (param.cff, param.font, base, *param.draw_session, true)
 532                     && _get_path (param.cff, param.font, accent, *param.draw_session, true, &delta))))
 533       env.set_error ();
 534   }
 535 };
 536
 537 bool _get_path (const OT::cff1::accelerator_t *cff, hb_font_t *font, hb_codepoint_t glyph,
 538                 hb_draw_session_t &draw_session, bool in_seac, point_t *delta)
 539 {
 540   if (unlikely (!cff->is_valid () || (glyph >= cff->num_glyphs))) return false;
 541
 542   unsigned int fd = cff->fdSelect->get_fd (glyph);
 543   const hb_ubytes_t str = (*cff->charStrings)[glyph];
 544   cff1_cs_interp_env_t env (str, *cff, fd);
 545   env.set_in_seac (in_seac);
 546   cff1_cs_interpreter_t<cff1_cs_opset_path_t, cff1_path_param_t> interp (env);
 547   cff1_path_param_t param (cff, font, draw_session, delta);
 548   if (unlikely (!interp.interpret (param))) return false;
 549
 550   /* Let's end the path specially since it is called inside seac also */
 551   param.end_path ();
 552
 553   return true;
 554 }
 555
 556 bool OT::cff1::accelerator_t::paint_glyph (hb_font_t *font, hb_codepoint_t glyph, hb_paint_funcs_t *funcs, void *data, hb_color_t foreground) const
 557 {
 558   funcs->push_clip_glyph (data, glyph, font);
 559   funcs->color (data, true, foreground);
 560   funcs->pop_clip (data);
 561
 562   return true;
 563 }
 564
 565 bool OT::cff1::accelerator_t::get_path (hb_font_t *font, hb_codepoint_t glyph, hb_draw_session_t &draw_session) const
 566 {
 567 #ifdef HB_NO_OT_FONT_CFF
 568   /* XXX Remove check when this code moves to .hh file. */
 569   return true;
 570 #endif
 571
 572   return _get_path (this, font, glyph, draw_session);
 573 }
 574
 575 struct get_seac_param_t
 576 {
 577   get_seac_param_t (const OT::cff1::accelerator_subset_t *_cff) : cff (_cff) {}
 578
 579   bool has_seac () const { return base && accent; }
 580
 581   const OT::cff1::accelerator_subset_t *cff;
 582   hb_codepoint_t  base = 0;
 583   hb_codepoint_t  accent = 0;
 584 };
 585
 586 struct cff1_cs_opset_seac_t : cff1_cs_opset_t<cff1_cs_opset_seac_t, get_seac_param_t>
 587 {
 588   static void process_seac (cff1_cs_interp_env_t &env, get_seac_param_t& param)
 589   {
 590     unsigned int  n = env.argStack.get_count ();
 591     hb_codepoint_t  base_char = (hb_codepoint_t)env.argStack[n-2].to_int ();
 592     hb_codepoint_t  accent_char = (hb_codepoint_t)env.argStack[n-1].to_int ();
 593
 594     param.base = param.cff->std_code_to_glyph (base_char);
 595     param.accent = param.cff->std_code_to_glyph (accent_char);
 596   }
 597 };
 598
 599 bool OT::cff1::accelerator_subset_t::get_seac_components (hb_codepoint_t glyph, hb_codepoint_t *base, hb_codepoint_t *accent) const
 600 {
 601   if (unlikely (!is_valid () || (glyph >= num_glyphs))) return false;
 602
 603   unsigned int fd = fdSelect->get_fd (glyph);
 604   const hb_ubytes_t str = (*charStrings)[glyph];
 605   cff1_cs_interp_env_t env (str, *this, fd);
 606   cff1_cs_interpreter_t<cff1_cs_opset_seac_t, get_seac_param_t> interp (env);
 607   get_seac_param_t  param (this);
 608   if (unlikely (!interp.interpret (param))) return false;
 609
 610   if (param.has_seac ())
 611   {
 612     *base = param.base;
 613     *accent = param.accent;
 614     return true;
 615   }
 616   return false;
 617 }
 618
 619
 620 #endif