FT2/freetyp2.c

   1 /*
   2 =head1 NAME
   3
   4 freetyp2.c - font support via the FreeType library version 2.
   5
   6 =head1 SYNOPSIS
   7
   8   if (!i_ft2_init()) { error }
   9   FT2_Fonthandle *font;
  10   font = i_ft2_new(name, index);
  11   if (!i_ft2_setdpi(font, xdpi, ydpi)) { error }
  12   if (!i_ft2_getdpi(font, &xdpi, &ydpi)) { error }
  13   double matrix[6];
  14   if (!i_ft2_settransform(font, matrix)) { error }
  15   int bbox[BOUNDING_BOX_COUNT];
  16   if (!i_ft2_bbox(font, cheight, cwidth, text, length, bbox, utf8)) { error }
  17   i_img *im = ...;
  18   i_color cl;
  19   if (!i_ft2_text(font, im, tx, ty, cl, cheight, cwidth, text, length, align,
  20                   aa)) { error }
  21   if (!i_ft2_cp(font, im, tx, ty, channel, cheight, cwidth, text, length,
  22                 align, aa)) { error }
  23   i_ft2_destroy(font);
  24
  25 =head1 DESCRIPTION
  26
  27 Implements Imager font support using the FreeType2 library.
  28
  29 The FreeType2 library understands several font file types, including
  30 Truetype, Type1 and Windows FNT.
  31
  32 =over
  33
  34 =cut
  35 */
  36
  37 #include "imext.h"
  38 #include "imft2.h"
  39 #include <stdio.h>
  40 #include <math.h>
  41 #include <ft2build.h>
  42 #include FT_FREETYPE_H
  43 #ifdef FT_MULTIPLE_MASTERS_H
  44 #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
  45 #define IM_FT2_MM
  46 #include FT_MULTIPLE_MASTERS_H
  47 #endif
  48 #endif
  49
  50 static void ft2_push_message(int code);
  51
  52 static int ft2_initialized = 0;
  53 static FT_Library library;
  54
  55 static int i_min(int a, int b);
  56 static int i_max(int a, int b);
  57
  58 /*
  59 =item i_ft2_init(void)
  60
  61 Initializes the Freetype 2 library.
  62
  63 Returns true on success, false on failure.
  64
  65 =cut
  66 */
  67 int
  68 i_ft2_init(void) {
  69   FT_Error error;
  70
  71   i_clear_error();
  72   error = FT_Init_FreeType(&library);
  73   if (error) {
  74     ft2_push_message(error);
  75     i_push_error(0, "Initializing Freetype2");
  76     return 0;
  77   }
  78
  79   ft2_initialized = 1;
  80
  81   return 1;
  82 }
  83
  84 struct FT2_Fonthandle {
  85   FT_Face face;
  86   int xdpi, ydpi;
  87   int hint;
  88   FT_Encoding encoding;
  89
  90   /* used to adjust so we can align the draw point to the top-left */
  91   double matrix[6];
  92
  93 #ifdef IM_FT2_MM
  94   /* Multiple master data if any */
  95   int has_mm;
  96   FT_Multi_Master mm;
  97 #endif
  98 };
  99
 100 /* the following is used to select a "best" encoding */
 101 static struct enc_score {
 102   FT_Encoding encoding;
 103   int score;
 104 } enc_scores[] =
 105 {
 106   /* the selections here are fairly arbitrary
 107      ideally we need to give the user a list of encodings available
 108      and a mechanism to choose one */
 109   { ft_encoding_unicode,        10 },
 110   { ft_encoding_sjis,            8 },
 111   { ft_encoding_gb2312,          8 },
 112   { ft_encoding_big5,            8 },
 113   { ft_encoding_wansung,         8 },
 114   { ft_encoding_johab,           8 },
 115   { ft_encoding_latin_2,         6 },
 116   { ft_encoding_apple_roman,     6 },
 117   { ft_encoding_adobe_standard,  6 },
 118   { ft_encoding_adobe_expert,    6 },
 119 };
 120
 121 /*
 122 =item i_ft2_new(char *name, int index)
 123
 124 Creates a new font object, from the file given by I<name>.  I<index>
 125 is the index of the font in a file with multiple fonts, where 0 is the
 126 first font.
 127
 128 Return NULL on failure.
 129
 130 =cut
 131 */
 132
 133 FT2_Fonthandle *
 134 i_ft2_new(const char *name, int index) {
 135   FT_Error error;
 136   FT2_Fonthandle *result;
 137   FT_Face face;
 138   int i, j;
 139   FT_Encoding encoding;
 140   int score;
 141
 142   mm_log((1, "i_ft2_new(name %p, index %d)\n", name, index));
 143
 144   if (!ft2_initialized && !i_ft2_init())
 145     return NULL;
 146
 147   i_clear_error();
 148   error = FT_New_Face(library, name, index, &face);
 149   if (error) {
 150     ft2_push_message(error);
 151     i_push_error(error, "Opening face");
 152     mm_log((2, "error opening face '%s': %d\n", name, error));
 153     return NULL;
 154   }
 155
 156   encoding = face->num_charmaps ? face->charmaps[0]->encoding : ft_encoding_unicode;
 157   score = 0;
 158   for (i = 0; i < face->num_charmaps; ++i) {
 159     FT_Encoding enc_entry = face->charmaps[i]->encoding;
 160     mm_log((2, "i_ft2_new, encoding %lX platform %u encoding %u\n",
 161             enc_entry, face->charmaps[i]->platform_id,
 162             face->charmaps[i]->encoding_id));
 163     for (j = 0; j < sizeof(enc_scores) / sizeof(*enc_scores); ++j) {
 164       if (enc_scores[j].encoding == enc_entry && enc_scores[j].score > score) {
 165         encoding = enc_entry;
 166         score = enc_scores[j].score;
 167         break;
 168       }
 169     }
 170   }
 171   FT_Select_Charmap(face, encoding);
 172   mm_log((2, "i_ft2_new, selected encoding %lX\n", encoding));
 173
 174   result = mymalloc(sizeof(FT2_Fonthandle));
 175   result->face = face;
 176   result->xdpi = result->ydpi = 72;
 177   result->encoding = encoding;
 178
 179   /* by default we disable hinting on a call to i_ft2_settransform()
 180      if we don't do this, then the hinting can the untransformed text
 181      to be a different size to the transformed text.
 182      Obviously we have it initially enabled.
 183   */
 184   result->hint = 1;
 185
 186   /* I originally forgot this:   :/ */
 187   /*i_ft2_settransform(result, matrix); */
 188   result->matrix[0] = 1; result->matrix[1] = 0; result->matrix[2] = 0;
 189   result->matrix[3] = 0; result->matrix[4] = 1; result->matrix[5] = 0;
 190
 191 #ifdef IM_FT2_MM
 192  {
 193    FT_Multi_Master *mm = &result->mm;
 194    int i;
 195
 196    if ((face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) != 0
 197        && (error = FT_Get_Multi_Master(face, mm)) == 0) {
 198      mm_log((2, "MM Font, %d axes, %d designs\n", mm->num_axis, mm->num_designs));
 199      for (i = 0; i < mm->num_axis; ++i) {
 200        mm_log((2, "  axis %d name %s range %ld - %ld\n", i, mm->axis[i].name,
 201                (long)(mm->axis[i].minimum), (long)(mm->axis[i].maximum)));
 202      }
 203      result->has_mm = 1;
 204    }
 205    else {
 206      mm_log((2, "No multiple masters\n"));
 207      result->has_mm = 0;
 208    }
 209  }
 210 #endif
 211
 212   return result;
 213 }
 214
 215 /*
 216 =item i_ft2_destroy(FT2_Fonthandle *handle)
 217
 218 Destroys a font object, which must have been the return value of
 219 i_ft2_new().
 220
 221 =cut
 222 */
 223 void
 224 i_ft2_destroy(FT2_Fonthandle *handle) {
 225   FT_Done_Face(handle->face);
 226   myfree(handle);
 227 }
 228
 229 /*
 230 =item i_ft2_setdpi(FT2_Fonthandle *handle, int xdpi, int ydpi)
 231
 232 Sets the resolution in dots per inch at which point sizes scaled, by
 233 default xdpi and ydpi are 72, so that 1 point maps to 1 pixel.
 234
 235 Both xdpi and ydpi should be positive.
 236
 237 Return true on success.
 238
 239 =cut
 240 */
 241 int
 242 i_ft2_setdpi(FT2_Fonthandle *handle, int xdpi, int ydpi) {
 243   i_clear_error();
 244   if (xdpi > 0 && ydpi > 0) {
 245     handle->xdpi = xdpi;
 246     handle->ydpi = ydpi;
 247     return 0;
 248   }
 249   else {
 250     i_push_error(0, "resolutions must be positive");
 251     return 0;
 252   }
 253 }
 254
 255 /*
 256 =item i_ft2_getdpi(FT2_Fonthandle *handle, int *xdpi, int *ydpi)
 257
 258 Retrieves the current horizontal and vertical resolutions at which
 259 point sizes are scaled.
 260
 261 =cut
 262 */
 263 int
 264 i_ft2_getdpi(FT2_Fonthandle *handle, int *xdpi, int *ydpi) {
 265   *xdpi = handle->xdpi;
 266   *ydpi = handle->ydpi;
 267
 268   return 1;
 269 }
 270
 271 /*
 272 =item i_ft2_settransform(FT2_FontHandle *handle, double *matrix)
 273
 274 Sets a transormation matrix for output.
 275
 276 This should be a 2 x 3 matrix like:
 277
 278  matrix[0]   matrix[1]   matrix[2]
 279  matrix[3]   matrix[4]   matrix[5]
 280
 281 =cut
 282 */
 283 int
 284 i_ft2_settransform(FT2_Fonthandle *handle, const double *matrix) {
 285   FT_Matrix m;
 286   FT_Vector v;
 287   int i;
 288
 289   m.xx = matrix[0] * 65536;
 290   m.xy = matrix[1] * 65536;
 291   v.x  = matrix[2]; /* this could be pels of 26.6 fixed - not sure */
 292   m.yx = matrix[3] * 65536;
 293   m.yy = matrix[4] * 65536;
 294   v.y  = matrix[5]; /* see just above */
 295
 296   FT_Set_Transform(handle->face, &m, &v);
 297
 298   for (i = 0; i < 6; ++i)
 299     handle->matrix[i] = matrix[i];
 300   handle->hint = 0;
 301
 302   return 1;
 303 }
 304
 305 /*
 306 =item i_ft2_sethinting(FT2_Fonthandle *handle, int hinting)
 307
 308 If hinting is non-zero then glyph hinting is enabled, otherwise disabled.
 309
 310 i_ft2_settransform() disables hinting to prevent distortions in
 311 gradual text transformations.
 312
 313 =cut
 314 */
 315 int i_ft2_sethinting(FT2_Fonthandle *handle, int hinting) {
 316   handle->hint = hinting;
 317   return 1;
 318 }
 319
 320 /*
 321 =item i_ft2_bbox(FT2_Fonthandle *handle, double cheight, double cwidth, char *text, size_t len, int *bbox)
 322
 323 Retrieves bounding box information for the font at the given
 324 character width and height.  This ignores the transformation matrix.
 325
 326 Returns non-zero on success.
 327
 328 =cut
 329 */
 330 int
 331 i_ft2_bbox(FT2_Fonthandle *handle, double cheight, double cwidth,
 332            char const *text, size_t len, int *bbox, int utf8) {
 333   FT_Error error;
 334   int width;
 335   int index;
 336   int first;
 337   int ascent = 0, descent = 0;
 338   int glyph_ascent, glyph_descent;
 339   FT_Glyph_Metrics *gm;
 340   int start = 0;
 341   int loadFlags = FT_LOAD_DEFAULT;
 342   int rightb = 0;
 343
 344   mm_log((1, "i_ft2_bbox(handle %p, cheight %f, cwidth %f, text %p, len %d, bbox %p)\n",
 345           handle, cheight, cwidth, text, len, bbox));
 346
 347   error = FT_Set_Char_Size(handle->face, cwidth*64, cheight*64,
 348                            handle->xdpi, handle->ydpi);
 349   if (error) {
 350     ft2_push_message(error);
 351     i_push_error(0, "setting size");
 352   }
 353
 354   if (!handle->hint)
 355     loadFlags |= FT_LOAD_NO_HINTING;
 356
 357   first = 1;
 358   width = 0;
 359   while (len) {
 360     unsigned long c;
 361     if (utf8) {
 362       c = i_utf8_advance(&text, &len);
 363       if (c == ~0UL) {
 364         i_push_error(0, "invalid UTF8 character");
 365         return 0;
 366       }
 367     }
 368     else {
 369       c = (unsigned char)*text++;
 370       --len;
 371     }
 372
 373     index = FT_Get_Char_Index(handle->face, c);
 374     error = FT_Load_Glyph(handle->face, index, loadFlags);
 375     if (error) {
 376       ft2_push_message(error);
 377       i_push_errorf(0, "loading glyph for character \\x%02x (glyph 0x%04X)",
 378                     c, index);
 379       return 0;
 380     }
 381     gm = &handle->face->glyph->metrics;
 382     glyph_ascent = gm->horiBearingY / 64;
 383     glyph_descent = glyph_ascent - gm->height/64;
 384     if (first) {
 385       start = gm->horiBearingX / 64;
 386       /* handles -ve values properly */
 387       ascent = glyph_ascent;
 388       descent = glyph_descent;
 389       first = 0;
 390     }
 391
 392     if (glyph_ascent > ascent)
 393       ascent = glyph_ascent;
 394     if (glyph_descent < descent)
 395       descent = glyph_descent;
 396
 397     width += gm->horiAdvance / 64;
 398
 399     if (len == 0) {
 400       /* last character
 401        handle the case where the right the of the character overlaps the
 402        right*/
 403       rightb = (gm->horiAdvance - gm->horiBearingX - gm->width)/64;
 404       /*if (rightb > 0)
 405         rightb = 0;*/
 406     }
 407   }
 408
 409   bbox[BBOX_NEG_WIDTH] = start;
 410   bbox[BBOX_GLOBAL_DESCENT] = handle->face->size->metrics.descender / 64;
 411   bbox[BBOX_POS_WIDTH] = width;
 412   if (rightb < 0)
 413     bbox[BBOX_POS_WIDTH] -= rightb;
 414   bbox[BBOX_GLOBAL_ASCENT] = handle->face->size->metrics.ascender / 64;
 415   bbox[BBOX_DESCENT] = descent;
 416   bbox[BBOX_ASCENT] = ascent;
 417   bbox[BBOX_ADVANCE_WIDTH] = width;
 418   bbox[BBOX_RIGHT_BEARING] = rightb;
 419   mm_log((1, " bbox=> negw=%d glob_desc=%d pos_wid=%d glob_asc=%d desc=%d asc=%d adv_width=%d rightb=%d\n", bbox[0], bbox[1], bbox[2], bbox[3], bbox[4], bbox[5], bbox[6], bbox[7]));
 420
 421   return BBOX_RIGHT_BEARING + 1;
 422 }
 423
 424 /*
 425 =item transform_box(FT2_FontHandle *handle, int bbox[4])
 426
 427 bbox contains coorinates of a the top-left and bottom-right of a bounding
 428 box relative to a point.
 429
 430 This is then transformed and the values in bbox[4] are the top-left
 431 and bottom-right of the new bounding box.
 432
 433 This is meant to provide the bounding box of a transformed character
 434 box.  The problem is that if the character was round and is rotated,
 435 the real bounding box isn't going to be much different from the
 436 original, but this function will return a _bigger_ bounding box.  I
 437 suppose I could work my way through the glyph outline, but that's
 438 too much hard work.
 439
 440 =cut
 441 */
 442 void ft2_transform_box(FT2_Fonthandle *handle, int bbox[4]) {
 443   double work[8];
 444   double *matrix = handle->matrix;
 445
 446   work[0] = matrix[0] * bbox[0] + matrix[1] * bbox[1];
 447   work[1] = matrix[3] * bbox[0] + matrix[4] * bbox[1];
 448   work[2] = matrix[0] * bbox[2] + matrix[1] * bbox[1];
 449   work[3] = matrix[3] * bbox[2] + matrix[4] * bbox[1];
 450   work[4] = matrix[0] * bbox[0] + matrix[1] * bbox[3];
 451   work[5] = matrix[3] * bbox[0] + matrix[4] * bbox[3];
 452   work[6] = matrix[0] * bbox[2] + matrix[1] * bbox[3];
 453   work[7] = matrix[3] * bbox[2] + matrix[4] * bbox[3];
 454
 455   bbox[0] = floor(i_min(i_min(work[0], work[2]),i_min(work[4], work[6])));
 456   bbox[1] = floor(i_min(i_min(work[1], work[3]),i_min(work[5], work[7])));
 457   bbox[2] = ceil(i_max(i_max(work[0], work[2]),i_max(work[4], work[6])));
 458   bbox[3] = ceil(i_max(i_max(work[1], work[3]),i_max(work[5], work[7])));
 459 }
 460
 461 /*
 462 =item expand_bounds(int bbox[4], int bbox2[4])
 463
 464 Treating bbox[] and bbox2[] as 2 bounding boxes, produces a new
 465 bounding box in bbox[] that encloses both.
 466
 467 =cut
 468 */
 469 static void expand_bounds(int bbox[4], int bbox2[4]) {
 470   bbox[0] = i_min(bbox[0], bbox2[0]);
 471   bbox[1] = i_min(bbox[1], bbox2[1]);
 472   bbox[2] = i_max(bbox[2], bbox2[2]);
 473   bbox[3] = i_max(bbox[3], bbox2[3]);
 474 }
 475
 476 /*
 477 =item i_ft2_bbox_r(FT2_Fonthandle *handle, double cheight, double cwidth, char *text, size_t len, int vlayout, int utf8, int *bbox)
 478
 479 Retrieves bounding box information for the font at the given
 480 character width and height.
 481
 482 This version finds the rectangular bounding box of the glyphs, with
 483 the text as transformed by the transformation matrix.  As with
 484 i_ft2_bbox (bbox[0], bbox[1]) will the the offset from the start of
 485 the topline to the top-left of the bounding box.  Unlike i_ft2_bbox()
 486 this could be near the bottom left corner of the box.
 487
 488 (bbox[4], bbox[5]) is the offset to the start of the baseline.
 489 (bbox[6], bbox[7]) is the offset from the start of the baseline to the
 490 end of the baseline.
 491
 492 Returns non-zero on success.
 493
 494 =cut
 495 */
 496 int
 497 i_ft2_bbox_r(FT2_Fonthandle *handle, double cheight, double cwidth,
 498            char const *text, size_t len, int vlayout, int utf8, int *bbox) {
 499   FT_Error error;
 500   int width;
 501   int index;
 502   int first;
 503   int ascent = 0, descent = 0;
 504   int glyph_ascent, glyph_descent;
 505   FT_Glyph_Metrics *gm;
 506   int work[4];
 507   int bounds[4];
 508   double x = 0, y = 0;
 509   int i;
 510   FT_GlyphSlot slot;
 511   int loadFlags = FT_LOAD_DEFAULT;
 512
 513   if (vlayout)
 514     loadFlags |= FT_LOAD_VERTICAL_LAYOUT;
 515   if (!handle->hint)
 516     loadFlags |= FT_LOAD_NO_HINTING;
 517
 518   error = FT_Set_Char_Size(handle->face, cwidth*64, cheight*64,
 519                            handle->xdpi, handle->ydpi);
 520   if (error) {
 521     ft2_push_message(error);
 522     i_push_error(0, "setting size");
 523   }
 524
 525   first = 1;
 526   width = 0;
 527   while (len) {
 528     unsigned long c;
 529     if (utf8) {
 530       c = i_utf8_advance(&text, &len);
 531       if (c == ~0UL) {
 532         i_push_error(0, "invalid UTF8 character");
 533         return 0;
 534       }
 535     }
 536     else {
 537       c = (unsigned char)*text++;
 538       --len;
 539     }
 540
 541     index = FT_Get_Char_Index(handle->face, c);
 542     error = FT_Load_Glyph(handle->face, index, loadFlags);
 543     if (error) {
 544       ft2_push_message(error);
 545       i_push_errorf(0, "loading glyph for character \\x%02x (glyph 0x%04X)",
 546                     c, index);
 547       return 0;
 548     }
 549     slot = handle->face->glyph;
 550     gm = &slot->metrics;
 551
 552     /* these probably don't mean much for vertical layouts */
 553     glyph_ascent = gm->horiBearingY / 64;
 554     glyph_descent = glyph_ascent - gm->height/64;
 555     if (vlayout) {
 556       work[0] = gm->vertBearingX;
 557       work[1] = gm->vertBearingY;
 558     }
 559     else {
 560       work[0] = gm->horiBearingX;
 561       work[1] = gm->horiBearingY;
 562     }
 563     work[2] = gm->width  + work[0];
 564     work[3] = work[1] - gm->height;
 565     if (first) {
 566       bbox[4] = work[0] * handle->matrix[0] + work[1] * handle->matrix[1] + handle->matrix[2];
 567       bbox[5] = work[0] * handle->matrix[3] + work[1] * handle->matrix[4] + handle->matrix[5];
 568       bbox[4] = bbox[4] < 0 ? -(-bbox[4] + 32)/64 : (bbox[4] + 32) / 64;
 569       bbox[5] /= 64;
 570     }
 571     ft2_transform_box(handle, work);
 572     for (i = 0; i < 4; ++i)
 573       work[i] /= 64;
 574     work[0] += x;
 575     work[1] += y;
 576     work[2] += x;
 577     work[3] += y;
 578     if (first) {
 579       for (i = 0; i < 4; ++i)
 580         bounds[i] = work[i];
 581       ascent = glyph_ascent;
 582       descent = glyph_descent;
 583       first = 0;
 584     }
 585     else {
 586       expand_bounds(bounds, work);
 587     }
 588     x += slot->advance.x / 64;
 589     y += slot->advance.y / 64;
 590
 591     if (glyph_ascent > ascent)
 592       ascent = glyph_ascent;
 593     if (glyph_descent > descent)
 594       descent = glyph_descent;
 595
 596     if (len == 0) {
 597       /* last character
 598        handle the case where the right the of the character overlaps the
 599        right*/
 600       /*int rightb = gm->horiAdvance - gm->horiBearingX - gm->width;
 601       if (rightb < 0)
 602       width -= rightb / 64;*/
 603     }
 604   }
 605
 606   /* at this point bounds contains the bounds relative to the CP,
 607      and x, y hold the final position relative to the CP */
 608   /*bounds[0] -= x;
 609   bounds[1] -= y;
 610   bounds[2] -= x;
 611   bounds[3] -= y;*/
 612
 613   bbox[0] = bounds[0];
 614   bbox[1] = -bounds[3];
 615   bbox[2] = bounds[2];
 616   bbox[3] = -bounds[1];
 617   bbox[6] = x;
 618   bbox[7] = -y;
 619
 620   return 1;
 621 }
 622
 623 static int
 624 make_bmp_map(FT_Bitmap *bitmap, unsigned char *map);
 625
 626 /*
 627 =item i_ft2_text(FT2_Fonthandle *handle, i_img *im, int tx, int ty, i_color *cl, double cheight, double cwidth, char *text, size_t len, int align, int aa)
 628
 629 Renders I<text> to (I<tx>, I<ty>) in I<im> using color I<cl> at the given
 630 I<cheight> and I<cwidth>.
 631
 632 If align is 0, then the text is rendered with the top-left of the
 633 first character at (I<tx>, I<ty>).  If align is non-zero then the text
 634 is rendered with (I<tx>, I<ty>) aligned with the base-line of the
 635 characters.
 636
 637 If aa is non-zero then the text is anti-aliased.
 638
 639 Returns non-zero on success.
 640
 641 =cut
 642 */
 643 int
 644 i_ft2_text(FT2_Fonthandle *handle, i_img *im, int tx, int ty, const i_color *cl,
 645            double cheight, double cwidth, char const *text, size_t len,
 646            int align, int aa, int vlayout, int utf8) {
 647   FT_Error error;
 648   int index;
 649   FT_Glyph_Metrics *gm;
 650   int bbox[BOUNDING_BOX_COUNT];
 651   FT_GlyphSlot slot;
 652   int x, y;
 653   unsigned char *bmp;
 654   unsigned char map[256];
 655   char last_mode = ft_pixel_mode_none;
 656   int last_grays = -1;
 657   int loadFlags = FT_LOAD_DEFAULT;
 658   i_render *render;
 659
 660   mm_log((1, "i_ft2_text(handle %p, im %p, tx %d, ty %d, cl %p, cheight %f, cwidth %f, text %p, len %d, align %d, aa %d)\n",
 661           handle, im, tx, ty, cl, cheight, cwidth, text, align, aa));
 662
 663   if (vlayout) {
 664     if (!FT_HAS_VERTICAL(handle->face)) {
 665       i_push_error(0, "face has no vertical metrics");
 666       return 0;
 667     }
 668     loadFlags |= FT_LOAD_VERTICAL_LAYOUT;
 669   }
 670   if (!handle->hint)
 671     loadFlags |= FT_LOAD_NO_HINTING;
 672
 673   /* set the base-line based on the string ascent */
 674   if (!i_ft2_bbox(handle, cheight, cwidth, text, len, bbox, utf8))
 675     return 0;
 676
 677   if (aa)
 678     render = i_render_new(im, bbox[BBOX_POS_WIDTH] - bbox[BBOX_NEG_WIDTH]);
 679
 680   if (!align) {
 681     /* this may need adjustment */
 682     tx -= bbox[0] * handle->matrix[0] + bbox[5] * handle->matrix[1] + handle->matrix[2];
 683     ty += bbox[0] * handle->matrix[3] + bbox[5] * handle->matrix[4] + handle->matrix[5];
 684   }
 685   while (len) {
 686     unsigned long c;
 687     if (utf8) {
 688       c = i_utf8_advance(&text, &len);
 689       if (c == ~0UL) {
 690         i_push_error(0, "invalid UTF8 character");
 691         return 0;
 692       }
 693     }
 694     else {
 695       c = (unsigned char)*text++;
 696       --len;
 697     }
 698
 699     index = FT_Get_Char_Index(handle->face, c);
 700     error = FT_Load_Glyph(handle->face, index, loadFlags);
 701     if (error) {
 702       ft2_push_message(error);
 703       i_push_errorf(0, "loading glyph for character \\x%02x (glyph 0x%04X)",
 704                     c, index);
 705       if (aa)
 706         i_render_delete(render);
 707       return 0;
 708     }
 709     slot = handle->face->glyph;
 710     gm = &slot->metrics;
 711
 712     if (gm->width) {
 713       error = FT_Render_Glyph(slot, aa ? ft_render_mode_normal : ft_render_mode_mono);
 714       if (error) {
 715         ft2_push_message(error);
 716         i_push_errorf(0, "rendering glyph 0x%04X (character \\x%02X)");
 717       if (aa)
 718         i_render_delete(render);
 719         return 0;
 720       }
 721       if (slot->bitmap.pixel_mode == ft_pixel_mode_mono) {
 722         bmp = slot->bitmap.buffer;
 723         for (y = 0; y < slot->bitmap.rows; ++y) {
 724           int pos = 0;
 725           int bit = 0x80;
 726           for (x = 0; x < slot->bitmap.width; ++x) {
 727             if (bmp[pos] & bit)
 728               i_ppix(im, tx+x+slot->bitmap_left, ty+y-slot->bitmap_top, cl);
 729
 730             bit >>= 1;
 731             if (bit == 0) {
 732               bit = 0x80;
 733               ++pos;
 734             }
 735           }
 736           bmp += slot->bitmap.pitch;
 737         }
 738       }
 739       else {
 740         /* grey scale or something we can treat as greyscale */
 741         /* we create a map to convert from the bitmap values to 0-255 */
 742         if (last_mode != slot->bitmap.pixel_mode
 743             || last_grays != slot->bitmap.num_grays) {
 744           if (!make_bmp_map(&slot->bitmap, map))
 745             return 0;
 746           last_mode = slot->bitmap.pixel_mode;
 747           last_grays = slot->bitmap.num_grays;
 748         }
 749
 750         bmp = slot->bitmap.buffer;
 751         for (y = 0; y < slot->bitmap.rows; ++y) {
 752           if (last_mode == ft_pixel_mode_grays &&
 753               last_grays != 255) {
 754             for (x = 0; x < slot->bitmap.width; ++x)
 755               bmp[x] = map[bmp[x]];
 756           }
 757           i_render_color(render, tx + slot->bitmap_left, ty-slot->bitmap_top+y,
 758                          slot->bitmap.width, bmp, cl);
 759           bmp += slot->bitmap.pitch;
 760         }
 761       }
 762     }
 763
 764     tx += slot->advance.x / 64;
 765     ty -= slot->advance.y / 64;
 766   }
 767
 768   if (aa)
 769     i_render_delete(render);
 770
 771   return 1;
 772 }
 773
 774 /*
 775 =item i_ft2_cp(FT2_Fonthandle *handle, i_img *im, int tx, int ty, int channel, double cheight, double cwidth, char *text, size_t len, int align, int aa)
 776
 777 Renders I<text> to (I<tx>, I<ty>) in I<im> to I<channel> at the given
 778 I<cheight> and I<cwidth>.
 779
 780 If align is 0, then the text is rendered with the top-left of the
 781 first character at (I<tx>, I<ty>).  If align is non-zero then the text
 782 is rendered with (I<tx>, I<ty>) aligned with the base-line of the
 783 characters.
 784
 785 If aa is non-zero then the text is anti-aliased.
 786
 787 Returns non-zero on success.
 788
 789 =cut
 790 */
 791
 792 int
 793 i_ft2_cp(FT2_Fonthandle *handle, i_img *im, int tx, int ty, int channel,
 794          double cheight, double cwidth, char const *text, size_t len, int align,
 795          int aa, int vlayout, int utf8) {
 796   int bbox[8];
 797   i_img *work;
 798   i_color cl, cl2;
 799   int x, y;
 800
 801   mm_log((1, "i_ft2_cp(handle %p, im %p, tx %d, ty %d, channel %d, cheight %f, cwidth %f, text %p, len %d, ...)\n",
 802           handle, im, tx, ty, channel, cheight, cwidth, text, len));
 803
 804   if (vlayout && !FT_HAS_VERTICAL(handle->face)) {
 805     i_push_error(0, "face has no vertical metrics");
 806     return 0;
 807   }
 808
 809   if (!i_ft2_bbox_r(handle, cheight, cwidth, text, len, vlayout, utf8, bbox))
 810     return 0;
 811
 812   work = i_img_8_new(bbox[2]-bbox[0]+1, bbox[3]-bbox[1]+1, 1);
 813   cl.channel[0] = 255;
 814   if (!i_ft2_text(handle, work, -bbox[0], -bbox[1], &cl, cheight, cwidth,
 815                   text, len, 1, aa, vlayout, utf8))
 816     return 0;
 817
 818   if (!align) {
 819     tx -= bbox[4];
 820     ty += bbox[5];
 821   }
 822
 823   /* render to the specified channel */
 824   /* this will be sped up ... */
 825   for (y = 0; y < work->ysize; ++y) {
 826     for (x = 0; x < work->xsize; ++x) {
 827       i_gpix(work, x, y, &cl);
 828       i_gpix(im, tx + x + bbox[0], ty + y + bbox[1], &cl2);
 829       cl2.channel[channel] = cl.channel[0];
 830       i_ppix(im, tx + x + bbox[0], ty + y + bbox[1], &cl2);
 831     }
 832   }
 833   i_img_destroy(work);
 834   return 1;
 835 }
 836
 837 /*
 838 =item i_ft2_has_chars(handle, char *text, size_t len, int utf8, char *out)
 839
 840 Check if the given characters are defined by the font.
 841
 842 Returns the number of characters that were checked.
 843
 844 =cut
 845 */
 846 int i_ft2_has_chars(FT2_Fonthandle *handle, char const *text, size_t len,
 847                     int utf8, char *out) {
 848   int count = 0;
 849   mm_log((1, "i_ft2_has_chars(handle %p, text %p, len %d, utf8 %d)\n",
 850           handle, text, len, utf8));
 851
 852   while (len) {
 853     unsigned long c;
 854     int index;
 855     if (utf8) {
 856       c = i_utf8_advance(&text, &len);
 857       if (c == ~0UL) {
 858         i_push_error(0, "invalid UTF8 character");
 859         return 0;
 860       }
 861     }
 862     else {
 863       c = (unsigned char)*text++;
 864       --len;
 865     }
 866
 867     index = FT_Get_Char_Index(handle->face, c);
 868     *out++ = index != 0;
 869     ++count;
 870   }
 871
 872   return count;
 873 }
 874
 875 /* uses a method described in fterrors.h to build an error translation
 876    function
 877 */
 878 #undef __FTERRORS_H__
 879 #define FT_ERRORDEF(e, v, s) case v: i_push_error(code, s); return;
 880 #define FT_ERROR_START_LIST
 881 #define FT_ERROR_END_LIST
 882
 883 /*
 884 =back
 885
 886 =head2 Internal Functions
 887
 888 These functions are used in the implementation of freetyp2.c and should not
 889 (usually cannot) be called from outside it.
 890
 891 =over
 892
 893 =item ft2_push_message(int code)
 894
 895 Pushes an error message corresponding to code onto the error stack.
 896
 897 =cut
 898 */
 899 static void ft2_push_message(int code) {
 900   char unknown[40];
 901
 902   switch (code) {
 903 #include FT_ERRORS_H
 904   }
 905
 906   sprintf(unknown, "Unknown Freetype2 error code 0x%04X\n", code);
 907   i_push_error(code, unknown);
 908 }
 909
 910 /*
 911 =item make_bmp_map(FT_Bitmap *bitmap, unsigned char *map)
 912
 913 Creates a map to convert grey levels from the glyphs bitmap into
 914 values scaled 0..255.
 915
 916 =cut
 917 */
 918 static int
 919 make_bmp_map(FT_Bitmap *bitmap, unsigned char *map) {
 920   int scale;
 921   int i;
 922
 923   switch (bitmap->pixel_mode) {
 924   case ft_pixel_mode_grays:
 925     scale = bitmap->num_grays;
 926     break;
 927
 928   default:
 929     i_push_errorf(0, "I can't handle pixel mode %d", bitmap->pixel_mode);
 930     return 0;
 931   }
 932
 933   /* build the table */
 934   for (i = 0; i < scale; ++i)
 935     map[i] = i * 255 / (bitmap->num_grays - 1);
 936
 937   return 1;
 938 }
 939
 940 /* FREETYPE_PATCH was introduced in 2.0.6, we don't want a false
 941    positive on 2.0.0 to 2.0.4, so we accept a false negative in 2.0.5 */
 942 #ifndef FREETYPE_PATCH
 943 #define FREETYPE_PATCH 4
 944 #endif
 945
 946 /* FT_Get_Postscript_Name() was introduced in FT2.0.5 */
 947 #define IM_HAS_FACE_NAME (FREETYPE_MINOR > 0 || FREETYPE_PATCH >= 5)
 948 /* #define IM_HAS_FACE_NAME 0 */
 949
 950 /*
 951 =item i_ft2_face_name(handle, name_buf, name_buf_size)
 952
 953 Fills the given buffer with the Postscript Face name of the font,
 954 if there is one.
 955
 956 =cut
 957 */
 958
 959 int
 960 i_ft2_face_name(FT2_Fonthandle *handle, char *name_buf, size_t name_buf_size) {
 961 #if IM_HAS_FACE_NAME
 962   char const *name = FT_Get_Postscript_Name(handle->face);
 963
 964   i_clear_error();
 965
 966   if (name) {
 967     strncpy(name_buf, name, name_buf_size);
 968     name_buf[name_buf_size-1] = '\0';
 969
 970     return strlen(name) + 1;
 971   }
 972   else {
 973     i_push_error(0, "no face name available");
 974     *name_buf = '\0';
 975
 976     return 0;
 977   }
 978 #else
 979   i_clear_error();
 980   i_push_error(0, "Freetype 2.0.6 or later required");
 981   *name_buf = '\0';
 982
 983   return 0;
 984 #endif
 985 }
 986
 987 int
 988 i_ft2_can_face_name(void) {
 989   return IM_HAS_FACE_NAME;
 990 }
 991
 992 /* FT_Has_PS_Glyph_Names() was introduced in FT2.1.1 */
 993 /* well, I assume FREETYPE_MAJOR is 2, since we're here */
 994 #if FREETYPE_MINOR < 1 || (FREETYPE_MINOR == 1 && FREETYPE_PATCH < 1)
 995 #define FT_Has_PS_Glyph_Names(face) (FT_HAS_GLYPH_NAMES(face))
 996 #endif
 997
 998 int
 999 i_ft2_glyph_name(FT2_Fonthandle *handle, unsigned long ch, char *name_buf,
1000                  size_t name_buf_size, int reliable_only) {
1001 #ifdef FT_CONFIG_OPTION_NO_GLYPH_NAMES
1002   i_clear_error();
1003   *name_buf = '\0';
1004   i_push_error(0, "FT2 configured without glyph name support");
1005
1006   return 0;
1007 #else
1008   FT_UInt index;
1009
1010   i_clear_error();
1011
1012   if (!FT_HAS_GLYPH_NAMES(handle->face)) {
1013     i_push_error(0, "no glyph names in font");
1014     *name_buf = '\0';
1015     return 0;
1016   }
1017   if (reliable_only && !FT_Has_PS_Glyph_Names(handle->face)) {
1018     i_push_error(0, "no reliable glyph names in font - set reliable_only to 0 to try anyway");
1019     *name_buf = '\0';
1020     return 0;
1021   }
1022
1023   index = FT_Get_Char_Index(handle->face, ch);
1024
1025   if (index) {
1026     FT_Error error = FT_Get_Glyph_Name(handle->face, index, name_buf,
1027                                        name_buf_size);
1028     if (error) {
1029       ft2_push_message(error);
1030       *name_buf = '\0';
1031       return 0;
1032     }
1033     if (*name_buf) {
1034       return strlen(name_buf) + 1;
1035     }
1036     else {
1037       return 0;
1038     }
1039   }
1040   else {
1041     i_push_error(0, "no glyph for that character");
1042     *name_buf = 0;
1043     return 0;
1044   }
1045 #endif
1046 }
1047
1048 int
1049 i_ft2_can_do_glyph_names(void) {
1050 #ifdef FT_CONFIG_OPTION_NO_GLYPH_NAMES
1051   return 0;
1052 #else
1053   return 1;
1054 #endif
1055 }
1056
1057 int
1058 i_ft2_face_has_glyph_names(FT2_Fonthandle *handle) {
1059 #ifdef FT_CONFIG_OPTION_NO_GLYPH_NAMES
1060   return 0;
1061 #else
1062   return FT_Has_PS_Glyph_Names(handle->face);
1063 #endif
1064 }
1065
1066 int
1067 i_ft2_is_multiple_master(FT2_Fonthandle *handle) {
1068   i_clear_error();
1069 #ifdef IM_FT2_MM
1070   return handle->has_mm;
1071 #else
1072   return 0;
1073 #endif
1074 }
1075
1076 int
1077 i_ft2_get_multiple_masters(FT2_Fonthandle *handle, i_font_mm *mm) {
1078 #ifdef IM_FT2_MM
1079   int i;
1080   FT_Multi_Master *mms = &handle->mm;
1081
1082   i_clear_error();
1083   if (!handle->has_mm) {
1084     i_push_error(0, "Font has no multiple masters");
1085     return 0;
1086   }
1087   mm->num_axis = mms->num_axis;
1088   mm->num_designs = mms->num_designs;
1089   for (i = 0; i < mms->num_axis; ++i) {
1090     mm->axis[i].name = mms->axis[i].name;
1091     mm->axis[i].minimum = mms->axis[i].minimum;
1092     mm->axis[i].maximum = mms->axis[i].maximum;
1093   }
1094
1095   return 1;
1096 #else
1097   i_clear_error();
1098   i_push_error(0, "Multiple master functions unavailable");
1099   return 0;
1100 #endif
1101 }
1102
1103 int
1104 i_ft2_set_mm_coords(FT2_Fonthandle *handle, int coord_count, const long *coords) {
1105 #ifdef IM_FT2_MM
1106   int i;
1107   FT_Long ftcoords[T1_MAX_MM_AXIS];
1108   FT_Error error;
1109
1110   i_clear_error();
1111   if (!handle->has_mm) {
1112     i_push_error(0, "Font has no multiple masters");
1113     return 0;
1114   }
1115   if (coord_count != handle->mm.num_axis) {
1116     i_push_error(0, "Number of MM coords doesn't match MM axis count");
1117     return 0;
1118   }
1119   for (i = 0; i < coord_count; ++i)
1120     ftcoords[i] = coords[i];
1121
1122   error = FT_Set_MM_Design_Coordinates(handle->face, coord_count, ftcoords);
1123   if (error) {
1124     ft2_push_message(error);
1125     return 0;
1126   }
1127
1128   return 1;
1129 #else
1130   i_clear_error();
1131   i_push_error(0, "Multiple master functions unavailable");
1132
1133   return 0;
1134 #endif
1135 }
1136
1137 static int
1138 i_min(int a, int b) {
1139   return a < b ? a : b;
1140 }
1141
1142 static int
1143 i_max(int a, int b) {
1144   return a > b ? a : b;
1145 }
1146
1147 /*
1148 =back
1149
1150 =head1 AUTHOR
1151
1152 Tony Cook <tony@develop-help.com>, with a fair amount of help from
1153 reading the code in font.c.
1154
1155 =head1 SEE ALSO
1156
1157 font.c, Imager::Font(3), Imager(3)
1158
1159 http://www.freetype.org/
1160
1161 =cut
1162 */
1163