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