long delayed renaming of m_fatal() to i_fatal() to match Imager's
[imager.git] / font.c
1 #include "imager.h"
2
3 #include <sys/types.h>
4 #include <sys/stat.h>
5 #include <fcntl.h>
6
7 #include <stdio.h>
8 #include <stdlib.h>
9
10 #ifdef HAVE_LIBT1
11 #include <t1lib.h>
12 #endif
13
14
15 /*
16 =head1 NAME
17
18 font.c - implements font handling functions for t1 and truetype fonts
19
20 =head1 SYNOPSIS
21
22   i_init_fonts();
23
24   #ifdef HAVE_LIBT1
25   fontnum = i_t1_new(path_to_pfb, path_to_afm);
26   i_t1_bbox(fontnum, points, "foo", 3, int cords[6]);
27   rc = i_t1_destroy(fontnum);
28   #endif
29
30   #ifdef HAVE_LIBTT
31   handle = i_tt_new(path_to_ttf);
32   rc = i_tt_bbox(handle, points, "foo", 3, int cords[6], utf8);
33   i_tt_destroy(handle);
34
35   // and much more
36
37 =head1 DESCRIPTION
38
39 font.c implements font creation, rendering, bounding box functions and
40 more for Imager.
41
42 =head1 FUNCTION REFERENCE
43
44 Some of these functions are internal.
45
46 =over
47
48 =cut
49
50 */
51
52 /* 
53 =item i_init_fonts()
54
55 Initialize font rendering libraries if they are avaliable.
56
57 =cut
58 */
59
60 undef_int 
61 i_init_fonts(int t1log) {
62   mm_log((1,"Initializing fonts\n"));
63
64 #ifdef HAVE_LIBT1
65   i_init_t1(t1log);
66 #endif
67   
68 #ifdef HAVE_LIBTT
69   i_init_tt();
70 #endif
71
72 #ifdef HAVE_FT2
73   if (!i_ft2_init())
74     return 0;
75 #endif
76
77   return(1); /* FIXME: Always true - check the return values of the init_t1 and init_tt functions */
78 }
79
80
81
82
83 #ifdef HAVE_LIBT1
84
85 static int t1_get_flags(char const *flags);
86 static char *t1_from_utf8(char const *in, int len, int *outlen);
87
88 static void t1_push_error(void);
89
90 static int t1_active_fonts = 0;
91 static int t1_initialized = 0;
92
93 /* 
94 =item i_init_t1(t1log)
95
96 Initializes the t1lib font rendering engine.
97
98 =cut
99 */
100
101 undef_int
102 i_init_t1(int t1log) {
103   int init_flags = IGNORE_CONFIGFILE|IGNORE_FONTDATABASE;
104   mm_log((1,"init_t1()\n"));
105
106   if (t1_active_fonts) {
107     mm_log((1, "Cannot re-initialize T1 - active fonts\n"));
108     return 1;
109   }
110
111   if (t1_initialized) {
112     T1_CloseLib();
113   }
114   
115   if (t1log)
116     init_flags |= LOGFILE;
117   if ((T1_InitLib(init_flags) == NULL)){
118     mm_log((1,"Initialization of t1lib failed\n"));
119     return(1);
120   }
121   T1_SetLogLevel(T1LOG_DEBUG);
122   i_t1_set_aa(1); /* Default Antialias value */
123
124   ++t1_initialized;
125
126   return(0);
127 }
128
129
130 /* 
131 =item i_close_t1()
132
133 Shuts the t1lib font rendering engine down.
134
135   This it seems that this function is never used.
136
137 =cut
138 */
139
140 void
141 i_close_t1(void) {
142   T1_CloseLib();
143   t1_initialized = 0;
144 }
145
146
147 /*
148 =item i_t1_new(pfb, afm)
149
150 Loads the fonts with the given filenames, returns its font id
151
152  pfb -  path to pfb file for font
153  afm -  path to afm file for font
154
155 =cut
156 */
157
158 int
159 i_t1_new(char *pfb,char *afm) {
160   int font_id;
161
162   mm_log((1,"i_t1_new(pfb %s,afm %s)\n",pfb,(afm?afm:"NULL")));
163   font_id = T1_AddFont(pfb);
164   if (font_id<0) {
165     mm_log((1,"i_t1_new: Failed to load pfb file '%s' - return code %d.\n",pfb,font_id));
166     return font_id;
167   }
168   
169   if (afm != NULL) {
170     mm_log((1,"i_t1_new: requesting afm file '%s'.\n",afm));
171     if (T1_SetAfmFileName(font_id,afm)<0) mm_log((1,"i_t1_new: afm loading of '%s' failed.\n",afm));
172   }
173
174   ++t1_active_fonts;
175
176   return font_id;
177 }
178
179 /*
180 =item i_t1_destroy(font_id)
181
182 Frees resources for a t1 font with given font id.
183
184    font_id - number of the font to free
185
186 =cut
187 */
188
189 int
190 i_t1_destroy(int font_id) {
191   mm_log((1,"i_t1_destroy(font_id %d)\n",font_id));
192
193   --t1_active_fonts;
194
195   return T1_DeleteFont(font_id);
196 }
197
198
199 /*
200 =item i_t1_set_aa(st)
201
202 Sets the antialiasing level of the t1 library.
203
204    st - 0 =  NONE, 1 = LOW, 2 =  HIGH.
205
206 =cut
207 */
208
209 void
210 i_t1_set_aa(int st) {
211   int i;
212   unsigned long cst[17];
213   switch(st) {
214   case 0:
215     T1_AASetBitsPerPixel( 8 );
216     T1_AASetLevel( T1_AA_NONE );
217     T1_AANSetGrayValues( 0, 255 );
218     mm_log((1,"setting T1 antialias to none\n"));
219     break;
220   case 1:
221     T1_AASetBitsPerPixel( 8 );
222     T1_AASetLevel( T1_AA_LOW );
223     T1_AASetGrayValues( 0,65,127,191,255 );
224     mm_log((1,"setting T1 antialias to low\n"));
225     break;
226   case 2:
227     T1_AASetBitsPerPixel(8);
228     T1_AASetLevel(T1_AA_HIGH);
229     for(i=0;i<17;i++) cst[i]=(i*255)/16;
230     T1_AAHSetGrayValues( cst );
231     mm_log((1,"setting T1 antialias to high\n"));
232   }
233 }
234
235
236 /* 
237 =item i_t1_cp(im, xb, yb, channel, fontnum, points, str, len, align)
238
239 Interface to text rendering into a single channel in an image
240
241    im        pointer to image structure
242    xb        x coordinate of start of string
243    yb        y coordinate of start of string ( see align )
244    channel - destination channel
245    fontnum - t1 library font id
246    points  - number of points in fontheight
247    str     - string to render
248    len     - string length
249    align   - (0 - top of font glyph | 1 - baseline )
250
251 =cut
252 */
253
254 undef_int
255 i_t1_cp(i_img *im,int xb,int yb,int channel,int fontnum,float points,char* str,int len,int align, int utf8, char const *flags) {
256   GLYPH *glyph;
257   int xsize,ysize,x,y;
258   i_color val;
259   int mod_flags = t1_get_flags(flags);
260
261   unsigned int ch_mask_store;
262   
263   if (im == NULL) { mm_log((1,"i_t1_cp: Null image in input\n")); return(0); }
264
265   if (utf8) {
266     int worklen;
267     char *work = t1_from_utf8(str, len, &worklen);
268     glyph=T1_AASetString( fontnum, work, worklen, 0, mod_flags, points, NULL);
269     myfree(work);
270   }
271   else {
272     glyph=T1_AASetString( fontnum, str, len, 0, mod_flags, points, NULL);
273   }
274   if (glyph == NULL)
275     return 0;
276
277   mm_log((1,"metrics: ascent: %d descent: %d\n",glyph->metrics.ascent,glyph->metrics.descent));
278   mm_log((1," leftSideBearing: %d rightSideBearing: %d\n",glyph->metrics.leftSideBearing,glyph->metrics.rightSideBearing));
279   mm_log((1," advanceX: %d  advanceY: %d\n",glyph->metrics.advanceX,glyph->metrics.advanceY));
280   mm_log((1,"bpp: %d\n",glyph->bpp));
281   
282   xsize=glyph->metrics.rightSideBearing-glyph->metrics.leftSideBearing;
283   ysize=glyph->metrics.ascent-glyph->metrics.descent;
284   
285   mm_log((1,"width: %d height: %d\n",xsize,ysize));
286
287   ch_mask_store=im->ch_mask;
288   im->ch_mask=1<<channel;
289
290   if (align==1) { xb+=glyph->metrics.leftSideBearing; yb-=glyph->metrics.ascent; }
291   
292   for(y=0;y<ysize;y++) for(x=0;x<xsize;x++) {
293     val.channel[channel]=glyph->bits[y*xsize+x];
294     i_ppix(im,x+xb,y+yb,&val);
295   }
296   
297   im->ch_mask=ch_mask_store;
298   return 1;
299 }
300
301
302 /*
303 =item i_t1_bbox(handle, fontnum, points, str, len, cords)
304
305 function to get a strings bounding box given the font id and sizes
306
307    handle  - pointer to font handle   
308    fontnum - t1 library font id
309    points  - number of points in fontheight
310    str     - string to measure
311    len     - string length
312    cords   - the bounding box (modified in place)
313
314 =cut
315 */
316
317 int
318 i_t1_bbox(int fontnum,float points,const char *str,int len,int cords[6], int utf8,char const *flags) {
319   BBox bbox;
320   BBox gbbox;
321   int mod_flags = t1_get_flags(flags);
322   int advance;
323   
324   mm_log((1,"i_t1_bbox(fontnum %d,points %.2f,str '%.*s', len %d)\n",fontnum,points,len,str,len));
325   T1_LoadFont(fontnum);  /* FIXME: Here a return code is ignored - haw haw haw */ 
326   if (utf8) {
327     int worklen;
328     char *work = t1_from_utf8(str, len, &worklen);
329     bbox = T1_GetStringBBox(fontnum,work,worklen,0,mod_flags);
330     myfree(work);
331   }
332   else {
333     bbox = T1_GetStringBBox(fontnum,(char *)str,len,0,mod_flags);
334   }
335   gbbox = T1_GetFontBBox(fontnum);
336   advance = T1_GetStringWidth(fontnum, (char *)str, len, 0, mod_flags);
337   
338   mm_log((1,"bbox: (%d,%d,%d,%d)\n",
339           (int)(bbox.llx*points/1000),
340           (int)(gbbox.lly*points/1000),
341           (int)(bbox.urx*points/1000),
342           (int)(gbbox.ury*points/1000),
343           (int)(bbox.lly*points/1000),
344           (int)(bbox.ury*points/1000) ));
345
346
347   cords[BBOX_NEG_WIDTH]=((float)bbox.llx*points)/1000;
348   cords[BBOX_POS_WIDTH]=((float)bbox.urx*points)/1000;
349
350   cords[BBOX_GLOBAL_DESCENT]=((float)gbbox.lly*points)/1000;
351   cords[BBOX_GLOBAL_ASCENT]=((float)gbbox.ury*points)/1000;
352
353   cords[BBOX_DESCENT]=((float)bbox.lly*points)/1000;
354   cords[BBOX_ASCENT]=((float)bbox.ury*points)/1000;
355
356   cords[BBOX_ADVANCE_WIDTH] = ((float)advance * points)/1000;
357   cords[BBOX_RIGHT_BEARING] = 
358     cords[BBOX_ADVANCE_WIDTH] - cords[BBOX_POS_WIDTH];
359
360   return BBOX_RIGHT_BEARING+1;
361 }
362
363
364 /*
365 =item i_t1_text(im, xb, yb, cl, fontnum, points, str, len, align)
366
367 Interface to text rendering in a single color onto an image
368
369    im      - pointer to image structure
370    xb      - x coordinate of start of string
371    yb      - y coordinate of start of string ( see align )
372    cl      - color to draw the text in
373    fontnum - t1 library font id
374    points  - number of points in fontheight
375    str     - char pointer to string to render
376    len     - string length
377    align   - (0 - top of font glyph | 1 - baseline )
378
379 =cut
380 */
381
382 undef_int
383 i_t1_text(i_img *im,int xb,int yb,const i_color *cl,int fontnum,float points,const char* str,int len,int align, int utf8, char const *flags) {
384   GLYPH *glyph;
385   int xsize,ysize,x,y,ch;
386   i_color val;
387   unsigned char c,i;
388   int mod_flags = t1_get_flags(flags);
389
390   if (im == NULL) { mm_log((1,"i_t1_cp: Null image in input\n")); return(0); }
391
392   if (utf8) {
393     int worklen;
394     char *work = t1_from_utf8(str, len, &worklen);
395     glyph=T1_AASetString( fontnum, work, worklen, 0, mod_flags, points, NULL);
396     myfree(work);
397   }
398   else {
399     /* T1_AASetString() accepts a char * not a const char */
400     glyph=T1_AASetString( fontnum, (char *)str, len, 0, mod_flags, points, NULL);
401   }
402   if (glyph == NULL)
403     return 0;
404
405   mm_log((1,"metrics:  ascent: %d descent: %d\n",glyph->metrics.ascent,glyph->metrics.descent));
406   mm_log((1," leftSideBearing: %d rightSideBearing: %d\n",glyph->metrics.leftSideBearing,glyph->metrics.rightSideBearing));
407   mm_log((1," advanceX: %d advanceY: %d\n",glyph->metrics.advanceX,glyph->metrics.advanceY));
408   mm_log((1,"bpp: %d\n",glyph->bpp));
409   
410   xsize=glyph->metrics.rightSideBearing-glyph->metrics.leftSideBearing;
411   ysize=glyph->metrics.ascent-glyph->metrics.descent;
412   
413   mm_log((1,"width: %d height: %d\n",xsize,ysize));
414
415   if (align==1) { xb+=glyph->metrics.leftSideBearing; yb-=glyph->metrics.ascent; }
416   
417   for(y=0;y<ysize;y++) for(x=0;x<xsize;x++) {
418     c=glyph->bits[y*xsize+x];
419     i=255-c;
420     i_gpix(im,x+xb,y+yb,&val);
421     for(ch=0;ch<im->channels;ch++) val.channel[ch]=(c*cl->channel[ch]+i*val.channel[ch])/255;
422     i_ppix(im,x+xb,y+yb,&val);
423   }
424   return 1;
425 }
426
427 /*
428 =item t1_get_flags(flags)
429
430 Processes the characters in I<flags> to create a mod_flags value used
431 by some T1Lib functions.
432
433 =cut
434  */
435 static int
436 t1_get_flags(char const *flags) {
437   int mod_flags = T1_KERNING;
438
439   while (*flags) {
440     switch (*flags++) {
441     case 'u': case 'U': mod_flags |= T1_UNDERLINE; break;
442     case 'o': case 'O': mod_flags |= T1_OVERLINE; break;
443     case 's': case 'S': mod_flags |= T1_OVERSTRIKE; break;
444       /* ignore anything we don't recognize */
445     }
446   }
447
448   return mod_flags;
449 }
450
451 /*
452 =item t1_from_utf8(char const *in, int len, int *outlen)
453
454 Produces an unencoded version of I<in> by dropping any Unicode
455 character over 255.
456
457 Returns a newly allocated buffer which should be freed with myfree().
458 Sets *outlen to the number of bytes used in the output string.
459
460 =cut
461 */
462
463 static char *
464 t1_from_utf8(char const *in, int len, int *outlen) {
465   /* at this point len is from a perl SV, so can't approach MAXINT */
466   char *out = mymalloc(len+1); /* checked 5Nov05 tonyc */
467   char *p = out;
468   unsigned long c;
469
470   while (len) {
471     c = i_utf8_advance(&in, &len);
472     if (c == ~0UL) {
473       myfree(out);
474       i_push_error(0, "invalid UTF8 character");
475       return 0;
476     }
477     /* yeah, just drop them */
478     if (c < 0x100) {
479       *p++ = (char)c;
480     }
481   }
482   *p = '\0';
483   *outlen = p - out;
484
485   return out;
486 }
487
488 /*
489 =item i_t1_has_chars(font_num, text, len, utf8, out)
490
491 Check if the given characters are defined by the font.  Note that len
492 is the number of bytes, not the number of characters (when utf8 is
493 non-zero).
494
495 out[char index] will be true if the character exists.
496
497 Accepts UTF-8, but since T1 can only have 256 characters, any chars
498 with values over 255 will simply be returned as false.
499
500 Returns the number of characters that were checked.
501
502 =cut
503 */
504
505 int
506 i_t1_has_chars(int font_num, const char *text, int len, int utf8,
507                char *out) {
508   int count = 0;
509   
510   mm_log((1, "i_t1_has_chars(font_num %d, text %p, len %d, utf8 %d)\n", 
511           font_num, text, len, utf8));
512
513   i_clear_error();
514   if (T1_LoadFont(font_num)) {
515     t1_push_error();
516     return 0;
517   }
518
519   while (len) {
520     unsigned long c;
521     if (utf8) {
522       c = i_utf8_advance(&text, &len);
523       if (c == ~0UL) {
524         i_push_error(0, "invalid UTF8 character");
525         return 0;
526       }
527     }
528     else {
529       c = (unsigned char)*text++;
530       --len;
531     }
532     
533     if (c >= 0x100) {
534       /* limit of 256 characters for T1 */
535       *out++ = 0;
536     }
537     else {
538       char const * name = T1_GetCharName(font_num, (unsigned char)c);
539
540       if (name) {
541         *out++ = strcmp(name, ".notdef") != 0;
542       }
543       else {
544         mm_log((2, "  No name found for character %lx\n", c));
545         *out++ = 0;
546       }
547     }
548     ++count;
549   }
550
551   return count;
552 }
553
554 /*
555 =item i_t1_face_name(font_num, name_buf, name_buf_size)
556
557 Copies the face name of the given C<font_num> to C<name_buf>.  Returns
558 the number of characters required to store the name (which can be
559 larger than C<name_buf_size>, including the space required to store
560 the terminating NUL).
561
562 If name_buf is too small (as specified by name_buf_size) then the name
563 will be truncated.  name_buf will always be NUL termintaed.
564
565 =cut
566 */
567
568 int
569 i_t1_face_name(int font_num, char *name_buf, size_t name_buf_size) {
570   char *name;
571
572   T1_errno = 0;
573   if (T1_LoadFont(font_num)) {
574     t1_push_error();
575     return 0;
576   }
577   name = T1_GetFontName(font_num);
578
579   if (name) {
580     strncpy(name_buf, name, name_buf_size);
581     name_buf[name_buf_size-1] = '\0';
582     return strlen(name) + 1;
583   }
584   else {
585     t1_push_error();
586     return 0;
587   }
588 }
589
590 int
591 i_t1_glyph_name(int font_num, unsigned long ch, char *name_buf, 
592                  size_t name_buf_size) {
593   char *name;
594
595   i_clear_error();
596   if (ch > 0xFF) {
597     return 0;
598   }
599   if (T1_LoadFont(font_num)) {
600     t1_push_error();
601     return 0;
602   }
603   name = T1_GetCharName(font_num, (unsigned char)ch);
604   if (name) {
605     if (strcmp(name, ".notdef")) {
606       strncpy(name_buf, name, name_buf_size);
607       name_buf[name_buf_size-1] = '\0';
608       return strlen(name) + 1;
609     }
610     else {
611       return 0;
612     }
613   }
614   else {
615     t1_push_error();
616     return 0;
617   }
618 }
619
620 static void
621 t1_push_error(void) {
622   switch (T1_errno) {
623   case 0: 
624     i_push_error(0, "No error"); 
625     break;
626
627 #ifdef T1ERR_SCAN_FONT_FORMAT
628   case T1ERR_SCAN_FONT_FORMAT:
629     i_push_error(T1ERR_SCAN_FONT_FORMAT, "SCAN_FONT_FORMAT"); 
630     break;
631 #endif
632
633 #ifdef T1ERR_SCAN_FILE_OPEN_ERR
634   case T1ERR_SCAN_FILE_OPEN_ERR:
635     i_push_error(T1ERR_SCAN_FILE_OPEN_ERR, "SCAN_FILE_OPEN_ERR"); 
636     break;
637 #endif
638
639 #ifdef T1ERR_SCAN_OUT_OF_MEMORY
640   case T1ERR_SCAN_OUT_OF_MEMORY:
641     i_push_error(T1ERR_SCAN_OUT_OF_MEMORY, "SCAN_OUT_OF_MEMORY"); 
642     break;
643 #endif
644
645 #ifdef T1ERR_SCAN_ERROR
646   case T1ERR_SCAN_ERROR:
647     i_push_error(T1ERR_SCAN_ERROR, "SCAN_ERROR"); 
648     break;
649 #endif
650
651 #ifdef T1ERR_SCAN_FILE_EOF
652   case T1ERR_SCAN_FILE_EOF:
653     i_push_error(T1ERR_SCAN_FILE_EOF, "SCAN_FILE_EOF"); 
654     break;
655 #endif
656
657 #ifdef T1ERR_PATH_ERROR
658   case T1ERR_PATH_ERROR:
659     i_push_error(T1ERR_PATH_ERROR, "PATH_ERROR"); 
660     break;
661 #endif
662
663 #ifdef T1ERR_PARSE_ERROR
664   case T1ERR_PARSE_ERROR:
665     i_push_error(T1ERR_PARSE_ERROR, "PARSE_ERROR"); 
666     break;
667 #endif
668
669 #ifdef T1ERR_TYPE1_ABORT
670   case T1ERR_TYPE1_ABORT:
671     i_push_error(T1ERR_TYPE1_ABORT, "TYPE1_ABORT"); 
672     break;
673 #endif
674
675 #ifdef T1ERR_INVALID_FONTID
676   case T1ERR_INVALID_FONTID:
677     i_push_error(T1ERR_INVALID_FONTID, "INVALID_FONTID"); 
678     break;
679 #endif
680
681 #ifdef T1ERR_INVALID_PARAMETER
682   case T1ERR_INVALID_PARAMETER:
683     i_push_error(T1ERR_INVALID_PARAMETER, "INVALID_PARAMETER"); 
684     break;
685 #endif
686
687 #ifdef T1ERR_OP_NOT_PERMITTED
688   case T1ERR_OP_NOT_PERMITTED:
689     i_push_error(T1ERR_OP_NOT_PERMITTED, "OP_NOT_PERMITTED"); 
690     break;
691 #endif
692
693 #ifdef T1ERR_ALLOC_MEM
694   case T1ERR_ALLOC_MEM:
695     i_push_error(T1ERR_ALLOC_MEM, "ALLOC_MEM"); 
696     break;
697 #endif
698
699 #ifdef T1ERR_FILE_OPEN_ERR
700   case T1ERR_FILE_OPEN_ERR:
701     i_push_error(T1ERR_FILE_OPEN_ERR, "FILE_OPEN_ERR"); 
702     break;
703 #endif
704
705 #ifdef T1ERR_UNSPECIFIED
706   case T1ERR_UNSPECIFIED:
707     i_push_error(T1ERR_UNSPECIFIED, "UNSPECIFIED"); 
708     break;
709 #endif
710
711 #ifdef T1ERR_NO_AFM_DATA
712   case T1ERR_NO_AFM_DATA:
713     i_push_error(T1ERR_NO_AFM_DATA, "NO_AFM_DATA"); 
714     break;
715 #endif
716
717 #ifdef T1ERR_X11
718   case T1ERR_X11:
719     i_push_error(T1ERR_X11, "X11"); 
720     break;
721 #endif
722
723 #ifdef T1ERR_COMPOSITE_CHAR
724   case T1ERR_COMPOSITE_CHAR:
725     i_push_error(T1ERR_COMPOSITE_CHAR, "COMPOSITE_CHAR"); 
726     break;
727 #endif
728
729   default:
730     i_push_errorf(T1_errno, "unknown error %d", (int)T1_errno);
731   }
732 }
733
734 #endif /* HAVE_LIBT1 */
735
736
737 /* Truetype font support */
738 #ifdef HAVE_LIBTT
739
740 /* These are enabled by default when configuring Freetype 1.x
741    I haven't a clue how to reliably detect it at compile time.
742
743    We need a compilation probe in Makefile.PL
744 */
745 #define FTXPOST 1
746 #define FTXERR18 1
747
748 #include <freetype.h>
749 #define TT_CHC 5
750
751 #ifdef FTXPOST
752 #include <ftxpost.h>
753 #endif
754
755 #ifdef FTXERR18
756 #include <ftxerr18.h>
757 #endif
758
759 /* some versions of FT1.x don't seem to define this - it's font defined
760    so it won't change */
761 #ifndef TT_MS_LANGID_ENGLISH_GENERAL
762 #define TT_MS_LANGID_ENGLISH_GENERAL 0x0409
763 #endif
764
765 /* convert a code point into an index in the glyph cache */
766 #define TT_HASH(x) ((x) & 0xFF)
767
768 typedef struct i_glyph_entry_ {
769   TT_Glyph glyph;
770   unsigned long ch;
771 } i_tt_glyph_entry;
772
773 #define TT_NOCHAR (~0UL)
774
775 struct TT_Instancehandle_ {
776   TT_Instance instance;
777   TT_Instance_Metrics imetrics;
778   TT_Glyph_Metrics gmetrics[256];
779   i_tt_glyph_entry glyphs[256];
780   int smooth;
781   int ptsize;
782   int order;
783 };
784
785 typedef struct TT_Instancehandle_ TT_Instancehandle;
786
787 struct TT_Fonthandle_ {
788   TT_Face face;
789   TT_Face_Properties properties;
790   TT_Instancehandle instanceh[TT_CHC];
791   TT_CharMap char_map;
792 #ifdef FTXPOST
793   int loaded_names;
794   TT_Error load_cond;
795 #endif
796 };
797
798 /* Defines */
799
800 #define USTRCT(x) ((x).z)
801 #define TT_VALID( handle )  ( ( handle ).z != NULL )
802
803 static void i_tt_push_error(TT_Error rc);
804
805 /* Prototypes */
806
807 static  int i_tt_get_instance( TT_Fonthandle *handle, int points, int smooth );
808 static void i_tt_init_raster_map( TT_Raster_Map* bit, int width, int height, int smooth );
809 static void i_tt_done_raster_map( TT_Raster_Map *bit );
810 static void i_tt_clear_raster_map( TT_Raster_Map* bit );
811 static void i_tt_blit_or( TT_Raster_Map *dst, TT_Raster_Map *src,int x_off, int y_off );
812 static  int i_tt_get_glyph( TT_Fonthandle *handle, int inst, unsigned long j );
813 static void 
814 i_tt_render_glyph( TT_Glyph glyph, TT_Glyph_Metrics* gmetrics, 
815                    TT_Raster_Map *bit, TT_Raster_Map *small_bit, 
816                    int x_off, int y_off, int smooth );
817 static int
818 i_tt_render_all_glyphs( TT_Fonthandle *handle, int inst, TT_Raster_Map *bit, 
819                         TT_Raster_Map *small_bit, int cords[6], 
820                         char const* txt, int len, int smooth, int utf8 );
821 static void i_tt_dump_raster_map2( i_img* im, TT_Raster_Map* bit, int xb, int yb, const i_color *cl, int smooth );
822 static void i_tt_dump_raster_map_channel( i_img* im, TT_Raster_Map* bit, int xb, int yb, int channel, int smooth );
823 static  int
824 i_tt_rasterize( TT_Fonthandle *handle, TT_Raster_Map *bit, int cords[6], 
825                 float points, char const* txt, int len, int smooth, int utf8 );
826 static undef_int i_tt_bbox_inst( TT_Fonthandle *handle, int inst ,const char *txt, int len, int cords[6], int utf8 );
827
828
829 /* static globals needed */
830
831 static TT_Engine    engine;
832 static int  LTT_dpi    = 72; /* FIXME: this ought to be a part of the call interface */
833 static int  LTT_hinted = 1;  /* FIXME: this too */
834
835
836 /*
837  * FreeType interface
838  */
839
840
841 /*
842 =item init_tt()
843
844 Initializes the freetype font rendering engine
845
846 =cut
847 */
848
849 undef_int
850 i_init_tt() {
851   TT_Error  error;
852   mm_log((1,"init_tt()\n"));
853   error = TT_Init_FreeType( &engine );
854   if ( error ){
855     mm_log((1,"Initialization of freetype failed, code = 0x%x\n",error));
856     return(1);
857   }
858
859 #ifdef FTXPOST
860   error = TT_Init_Post_Extension( engine );
861   if (error) {
862     mm_log((1, "Initialization of Post extension failed = 0x%x\n", error));
863     return 1;
864   }
865 #endif
866
867   return(0);
868 }
869
870
871 /* 
872 =item i_tt_get_instance(handle, points, smooth)
873
874 Finds a points+smooth instance or if one doesn't exist in the cache
875 allocates room and returns its cache entry
876
877    fontname - path to the font to load
878    handle   - handle to the font.
879    points   - points of the requested font
880    smooth   - boolean (True: antialias on, False: antialias is off)
881
882 =cut
883 */
884
885 static
886 int
887 i_tt_get_instance( TT_Fonthandle *handle, int points, int smooth ) {
888   int i,idx;
889   TT_Error error;
890   
891   mm_log((1,"i_tt_get_instance(handle 0x%X, points %d, smooth %d)\n",
892           handle,points,smooth));
893   
894   if (smooth == -1) { /* Smooth doesn't matter for this search */
895     for(i=0;i<TT_CHC;i++) {
896       if (handle->instanceh[i].ptsize==points) {
897         mm_log((1,"i_tt_get_instance: in cache - (non selective smoothing search) returning %d\n",i));
898         return i;
899       }
900     }
901     smooth=1; /* We will be adding a font - add it as smooth then */
902   } else { /* Smooth doesn't matter for this search */
903     for(i=0;i<TT_CHC;i++) {
904       if (handle->instanceh[i].ptsize == points 
905           && handle->instanceh[i].smooth == smooth) {
906         mm_log((1,"i_tt_get_instance: in cache returning %d\n",i));
907         return i;
908       }
909     }
910   }
911   
912   /* Found the instance in the cache - return the cache index */
913   
914   for(idx=0;idx<TT_CHC;idx++) {
915     if (!(handle->instanceh[idx].order)) break; /* find the lru item */
916   }
917
918   mm_log((1,"i_tt_get_instance: lru item is %d\n",idx));
919   mm_log((1,"i_tt_get_instance: lru pointer 0x%X\n",
920           USTRCT(handle->instanceh[idx].instance) ));
921   
922   if ( USTRCT(handle->instanceh[idx].instance) ) {
923     mm_log((1,"i_tt_get_instance: freeing lru item from cache %d\n",idx));
924
925     /* Free cached glyphs */
926     for(i=0;i<256;i++)
927       if ( USTRCT(handle->instanceh[idx].glyphs[i].glyph) )
928         TT_Done_Glyph( handle->instanceh[idx].glyphs[i].glyph );
929
930     for(i=0;i<256;i++) {
931       handle->instanceh[idx].glyphs[i].ch = TT_NOCHAR;
932       USTRCT(handle->instanceh[idx].glyphs[i].glyph)=NULL;
933     }
934
935     /* Free instance if needed */
936     TT_Done_Instance( handle->instanceh[idx].instance );
937   }
938   
939   /* create and initialize instance */
940   /* FIXME: probably a memory leak on fail */
941   
942   (void) (( error = TT_New_Instance( handle->face, &handle->instanceh[idx].instance ) ) || 
943           ( error = TT_Set_Instance_Resolutions( handle->instanceh[idx].instance, LTT_dpi, LTT_dpi ) ) ||
944           ( error = TT_Set_Instance_CharSize( handle->instanceh[idx].instance, points*64 ) ) );
945   
946   if ( error ) {
947     mm_log((1, "Could not create and initialize instance: error 0x%x.\n",error ));
948     return -1;
949   }
950   
951   /* Now that the instance should the inplace we need to lower all of the
952      ru counts and put `this' one with the highest entry */
953   
954   for(i=0;i<TT_CHC;i++) handle->instanceh[i].order--;
955
956   handle->instanceh[idx].order=TT_CHC-1;
957   handle->instanceh[idx].ptsize=points;
958   handle->instanceh[idx].smooth=smooth;
959   TT_Get_Instance_Metrics( handle->instanceh[idx].instance, &(handle->instanceh[idx].imetrics) );
960
961   /* Zero the memory for the glyph storage so they are not thought as
962      cached if they haven't been cached since this new font was loaded */
963
964   for(i=0;i<256;i++) {
965     handle->instanceh[idx].glyphs[i].ch = TT_NOCHAR;
966     USTRCT(handle->instanceh[idx].glyphs[i].glyph)=NULL;
967   }
968   
969   return idx;
970 }
971
972
973 /*
974 =item i_tt_new(fontname)
975
976 Creates a new font handle object, finds a character map and initialise the
977 the font handle's cache
978
979    fontname - path to the font to load
980
981 =cut
982 */
983
984 TT_Fonthandle*
985 i_tt_new(const char *fontname) {
986   TT_Error error;
987   TT_Fonthandle *handle;
988   unsigned short i,n;
989   unsigned short platform,encoding;
990
991   i_clear_error();
992   
993   mm_log((1,"i_tt_new(fontname '%s')\n",fontname));
994   
995   /* allocate memory for the structure */
996   
997   handle = mymalloc( sizeof(TT_Fonthandle) ); /* checked 5Nov05 tonyc */
998
999   /* load the typeface */
1000   error = TT_Open_Face( engine, fontname, &handle->face );
1001   if ( error ) {
1002     if ( error == TT_Err_Could_Not_Open_File ) {
1003       mm_log((1, "Could not find/open %s.\n", fontname ));
1004     }
1005     else {
1006       mm_log((1, "Error while opening %s, error code = 0x%x.\n",fontname, 
1007               error )); 
1008     }
1009     i_tt_push_error(error);
1010     return NULL;
1011   }
1012   
1013   TT_Get_Face_Properties( handle->face, &(handle->properties) );
1014
1015   /* First, look for a Unicode charmap */
1016   n = handle->properties.num_CharMaps;
1017   USTRCT( handle->char_map )=NULL; /* Invalidate character map */
1018   
1019   for ( i = 0; i < n; i++ ) {
1020     TT_Get_CharMap_ID( handle->face, i, &platform, &encoding );
1021     if ( (platform == 3 && encoding == 1 ) 
1022          || (platform == 0 && encoding == 0 ) ) {
1023       mm_log((2,"i_tt_new - found char map platform %u encoding %u\n", 
1024               platform, encoding));
1025       TT_Get_CharMap( handle->face, i, &(handle->char_map) );
1026       break;
1027     }
1028   }
1029   if (!USTRCT(handle->char_map) && n != 0) {
1030     /* just use the first one */
1031     TT_Get_CharMap( handle->face, 0, &(handle->char_map));
1032   }
1033
1034   /* Zero the pointsizes - and ordering */
1035   
1036   for(i=0;i<TT_CHC;i++) {
1037     USTRCT(handle->instanceh[i].instance)=NULL;
1038     handle->instanceh[i].order=i;
1039     handle->instanceh[i].ptsize=0;
1040     handle->instanceh[i].smooth=-1;
1041   }
1042
1043 #ifdef FTXPOST
1044   handle->loaded_names = 0;
1045 #endif
1046
1047   mm_log((1,"i_tt_new <- 0x%X\n",handle));
1048   return handle;
1049 }
1050
1051
1052
1053 /*
1054  *┬áraster map management
1055  */
1056
1057 /* 
1058 =item i_tt_init_raster_map(bit, width, height, smooth)
1059
1060 Allocates internal memory for the bitmap as needed by the parameters (internal)
1061                  
1062    bit    - bitmap to allocate into
1063    width  - width of the bitmap
1064    height - height of the bitmap
1065    smooth - boolean (True: antialias on, False: antialias is off)
1066
1067 =cut
1068 */
1069
1070 static
1071 void
1072 i_tt_init_raster_map( TT_Raster_Map* bit, int width, int height, int smooth ) {
1073
1074   mm_log((1,"i_tt_init_raster_map( bit 08x%08X, width %d, height %d, smooth %d)\n", bit, width, height, smooth));
1075   
1076   bit->rows  = height;
1077   bit->width = ( width + 3 ) & -4;
1078   bit->flow  = TT_Flow_Down;
1079   
1080   if ( smooth ) {
1081     bit->cols  = bit->width;
1082     bit->size  = bit->rows * bit->width;
1083   } else {
1084     bit->cols  = ( bit->width + 7 ) / 8;    /* convert to # of bytes     */
1085     bit->size  = bit->rows * bit->cols;     /* number of bytes in buffer */
1086   }
1087
1088   /* rows can be 0 for some glyphs, for example ' ' */
1089   if (bit->rows && bit->size / bit->rows != bit->cols) {
1090     i_fatal(0, "Integer overflow calculating bitmap size (%d, %d)\n",
1091             bit->width, bit->rows);
1092   }
1093   
1094   mm_log((1,"i_tt_init_raster_map: bit->width %d, bit->cols %d, bit->rows %d, bit->size %d)\n", bit->width, bit->cols, bit->rows, bit->size ));
1095
1096   bit->bitmap = (void *) mymalloc( bit->size ); /* checked 6Nov05 tonyc */
1097   if ( !bit->bitmap ) i_fatal(0,"Not enough memory to allocate bitmap (%d)!\n",bit->size );
1098 }
1099
1100
1101 /*
1102 =item i_tt_clear_raster_map(bit)
1103
1104 Frees the bitmap data and sets pointer to NULL (internal)
1105                  
1106    bit - bitmap to free
1107
1108 =cut
1109 */
1110
1111 static
1112 void
1113 i_tt_done_raster_map( TT_Raster_Map *bit ) {
1114   myfree( bit->bitmap );
1115   bit->bitmap = NULL;
1116 }
1117
1118
1119 /*
1120 =item i_tt_clear_raster_map(bit)
1121
1122 Clears the specified bitmap (internal)
1123                  
1124    bit - bitmap to zero
1125
1126 =cut
1127 */
1128
1129
1130 static
1131 void
1132 i_tt_clear_raster_map( TT_Raster_Map*  bit ) {
1133   memset( bit->bitmap, 0, bit->size );
1134 }
1135
1136
1137 /* 
1138 =item i_tt_blit_or(dst, src, x_off, y_off)
1139
1140 function that blits one raster map into another (internal)
1141                  
1142    dst   - destination bitmap
1143    src   - source bitmap
1144    x_off - x offset into the destination bitmap
1145    y_off - y offset into the destination bitmap
1146
1147 =cut
1148 */
1149
1150 static
1151 void
1152 i_tt_blit_or( TT_Raster_Map *dst, TT_Raster_Map *src,int x_off, int y_off ) {
1153   int  x,  y;
1154   int  x1, x2, y1, y2;
1155   char *s, *d;
1156   
1157   x1 = x_off < 0 ? -x_off : 0;
1158   y1 = y_off < 0 ? -y_off : 0;
1159   
1160   x2 = (int)dst->cols - x_off;
1161   if ( x2 > src->cols ) x2 = src->cols;
1162   
1163   y2 = (int)dst->rows - y_off;
1164   if ( y2 > src->rows ) y2 = src->rows;
1165
1166   if ( x1 >= x2 ) return;
1167
1168   /* do the real work now */
1169
1170   for ( y = y1; y < y2; ++y ) {
1171     s = ( (char*)src->bitmap ) + y * src->cols + x1;
1172     d = ( (char*)dst->bitmap ) + ( y + y_off ) * dst->cols + x1 + x_off;
1173     
1174     for ( x = x1; x < x2; ++x ) {
1175       if (*s > *d)
1176         *d = *s;
1177       d++;
1178       s++;
1179     }
1180   }
1181 }
1182
1183 /* useful for debugging */
1184 #if 0
1185
1186 static void dump_raster_map(FILE *out, TT_Raster_Map *bit ) {
1187   int x, y;
1188   fprintf(out, "cols %d rows %d  flow %d\n", bit->cols, bit->rows, bit->flow);
1189   for (y = 0; y < bit->rows; ++y) {
1190     fprintf(out, "%2d:", y);
1191     for (x = 0; x < bit->cols; ++x) {
1192       if ((x & 7) == 0 && x) putc(' ', out);
1193       fprintf(out, "%02x", ((unsigned char *)bit->bitmap)[y*bit->cols+x]);
1194     }
1195     putc('\n', out);
1196   }
1197 }
1198
1199 #endif
1200
1201 /* 
1202 =item i_tt_get_glyph(handle, inst, j) 
1203
1204 Function to see if a glyph exists and if so cache it (internal)
1205                  
1206    handle - pointer to font handle
1207    inst   - font instance
1208    j      - charcode of glyph
1209
1210 =cut
1211 */
1212
1213 static
1214 int
1215 i_tt_get_glyph( TT_Fonthandle *handle, int inst, unsigned long j) {
1216   unsigned short load_flags, code;
1217   TT_Error error;
1218
1219   mm_log((1, "i_tt_get_glyph(handle 0x%X, inst %d, j %d (%c))\n",
1220           handle,inst,j, ((j >= ' ' && j <= '~') ? j : '.')));
1221   
1222   /*mm_log((1, "handle->instanceh[inst].glyphs[j]=0x%08X\n",handle->instanceh[inst].glyphs[j] ));*/
1223
1224   if ( TT_VALID(handle->instanceh[inst].glyphs[TT_HASH(j)].glyph)
1225        && handle->instanceh[inst].glyphs[TT_HASH(j)].ch == j) {
1226     mm_log((1,"i_tt_get_glyph: %d in cache\n",j));
1227     return 1;
1228   }
1229
1230   if ( TT_VALID(handle->instanceh[inst].glyphs[TT_HASH(j)].glyph) ) {
1231     /* clean up the entry */
1232     TT_Done_Glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph );
1233     USTRCT( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph ) = NULL;
1234     handle->instanceh[inst].glyphs[TT_HASH(j)].ch = TT_NOCHAR;
1235   }
1236   
1237   /* Ok - it wasn't cached - try to get it in */
1238   load_flags = TTLOAD_SCALE_GLYPH;
1239   if ( LTT_hinted ) load_flags |= TTLOAD_HINT_GLYPH;
1240   
1241   if ( !TT_VALID(handle->char_map) ) {
1242     code = (j - ' ' + 1) < 0 ? 0 : (j - ' ' + 1);
1243     if ( code >= handle->properties.num_Glyphs ) code = 0;
1244   } else code = TT_Char_Index( handle->char_map, j );
1245   
1246   if ( (error = TT_New_Glyph( handle->face, &handle->instanceh[inst].glyphs[TT_HASH(j)].glyph)) ) {
1247     mm_log((1, "Cannot allocate and load glyph: error 0x%x.\n", error ));
1248     i_push_error(error, "TT_New_Glyph()");
1249     return 0;
1250   }
1251   if ( (error = TT_Load_Glyph( handle->instanceh[inst].instance, handle->instanceh[inst].glyphs[TT_HASH(j)].glyph, code, load_flags)) ) {
1252     mm_log((1, "Cannot allocate and load glyph: error 0x%x.\n", error ));
1253     /* Don't leak */
1254     TT_Done_Glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph );
1255     USTRCT( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph ) = NULL;
1256     i_push_error(error, "TT_Load_Glyph()");
1257     return 0;
1258   }
1259
1260   /* At this point the glyph should be allocated and loaded */
1261   handle->instanceh[inst].glyphs[TT_HASH(j)].ch = j;
1262
1263   /* Next get the glyph metrics */
1264   error = TT_Get_Glyph_Metrics( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph, 
1265                                 &handle->instanceh[inst].gmetrics[TT_HASH(j)] );
1266   if (error) {
1267     mm_log((1, "TT_Get_Glyph_Metrics: error 0x%x.\n", error ));
1268     TT_Done_Glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph );
1269     USTRCT( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph ) = NULL;
1270     handle->instanceh[inst].glyphs[TT_HASH(j)].ch = TT_NOCHAR;
1271     i_push_error(error, "TT_Get_Glyph_Metrics()");
1272     return 0;
1273   }
1274
1275   return 1;
1276 }
1277
1278 /*
1279 =item i_tt_has_chars(handle, text, len, utf8, out)
1280
1281 Check if the given characters are defined by the font.  Note that len
1282 is the number of bytes, not the number of characters (when utf8 is
1283 non-zero).
1284
1285 Returns the number of characters that were checked.
1286
1287 =cut
1288 */
1289
1290 int
1291 i_tt_has_chars(TT_Fonthandle *handle, char const *text, int len, int utf8,
1292                char *out) {
1293   int count = 0;
1294   mm_log((1, "i_tt_has_chars(handle %p, text %p, len %d, utf8 %d)\n", 
1295           handle, text, len, utf8));
1296
1297   while (len) {
1298     unsigned long c;
1299     int index;
1300     if (utf8) {
1301       c = i_utf8_advance(&text, &len);
1302       if (c == ~0UL) {
1303         i_push_error(0, "invalid UTF8 character");
1304         return 0;
1305       }
1306     }
1307     else {
1308       c = (unsigned char)*text++;
1309       --len;
1310     }
1311     
1312     if (TT_VALID(handle->char_map)) {
1313       index = TT_Char_Index(handle->char_map, c);
1314     }
1315     else {
1316       index = (c - ' ' + 1) < 0 ? 0 : (c - ' ' + 1);
1317       if (index >= handle->properties.num_Glyphs)
1318         index = 0;
1319     }
1320     *out++ = index != 0;
1321     ++count;
1322   }
1323
1324   return count;
1325 }
1326
1327 /* 
1328 =item i_tt_destroy(handle)
1329
1330 Clears the data taken by a font including all cached data such as
1331 pixmaps and glyphs
1332                  
1333    handle - pointer to font handle
1334
1335 =cut
1336 */
1337
1338 void
1339 i_tt_destroy( TT_Fonthandle *handle) {
1340   TT_Close_Face( handle->face );
1341   myfree( handle );
1342   
1343   /* FIXME: Should these be freed automatically by the library? 
1344
1345   TT_Done_Instance( instance );
1346   void
1347     i_tt_done_glyphs( void ) {
1348     int  i;
1349
1350     if ( !glyphs ) return;
1351     
1352     for ( i = 0; i < 256; ++i ) TT_Done_Glyph( glyphs[i] );
1353     free( glyphs );
1354     
1355     glyphs = NULL;
1356   }
1357   */
1358 }
1359
1360
1361 /*
1362  * FreeType Rendering functions
1363  */
1364
1365
1366 /* 
1367 =item i_tt_render_glyph(handle, gmetrics, bit, smallbit, x_off, y_off, smooth)
1368
1369 Renders a single glyph into the bit rastermap (internal)
1370
1371    handle   - pointer to font handle
1372    gmetrics - the metrics for the glyph to be rendered
1373    bit      - large bitmap that is the destination for the text
1374    smallbit - small bitmap that is used only if smooth is true
1375    x_off    - x offset of glyph
1376    y_off    - y offset of glyph
1377    smooth   - boolean (True: antialias on, False: antialias is off)
1378
1379 =cut
1380 */
1381
1382 static
1383 void
1384 i_tt_render_glyph( TT_Glyph glyph, TT_Glyph_Metrics* gmetrics, TT_Raster_Map *bit, TT_Raster_Map *small_bit, int x_off, int y_off, int smooth ) {
1385   
1386   mm_log((1,"i_tt_render_glyph(glyph 0x0%X, gmetrics 0x0%X, bit 0x%X, small_bit 0x%X, x_off %d, y_off %d, smooth %d)\n",
1387           USTRCT(glyph), gmetrics, bit, small_bit, x_off,y_off,smooth));
1388   
1389   if ( !smooth ) TT_Get_Glyph_Bitmap( glyph, bit, x_off * 64, y_off * 64);
1390   else {
1391     TT_F26Dot6 xmin, ymin, xmax, ymax;
1392
1393     xmin =  gmetrics->bbox.xMin & -64;
1394     ymin =  gmetrics->bbox.yMin & -64;
1395     xmax = (gmetrics->bbox.xMax + 63) & -64;
1396     ymax = (gmetrics->bbox.yMax + 63) & -64;
1397     
1398     i_tt_clear_raster_map( small_bit );
1399     TT_Get_Glyph_Pixmap( glyph, small_bit, -xmin, -ymin );
1400     i_tt_blit_or( bit, small_bit, xmin/64 + x_off, -ymin/64 - y_off );
1401   }
1402 }
1403
1404
1405 /*
1406 =item i_tt_render_all_glyphs(handle, inst, bit, small_bit, cords, txt, len, smooth)
1407
1408 calls i_tt_render_glyph to render each glyph into the bit rastermap (internal)
1409
1410    handle   - pointer to font handle
1411    inst     - font instance
1412    bit      - large bitmap that is the destination for the text
1413    smallbit - small bitmap that is used only if smooth is true
1414    txt      - string to render
1415    len      - length of the string to render
1416    smooth   - boolean (True: antialias on, False: antialias is off)
1417
1418 =cut
1419 */
1420
1421 static
1422 int
1423 i_tt_render_all_glyphs( TT_Fonthandle *handle, int inst, TT_Raster_Map *bit,
1424                         TT_Raster_Map *small_bit, int cords[6], 
1425                         char const* txt, int len, int smooth, int utf8 ) {
1426   unsigned long j;
1427   TT_F26Dot6 x,y;
1428   
1429   mm_log((1,"i_tt_render_all_glyphs( handle 0x%X, inst %d, bit 0x%X, small_bit 0x%X, txt '%.*s', len %d, smooth %d, utf8 %d)\n",
1430           handle, inst, bit, small_bit, len, txt, len, smooth, utf8));
1431   
1432   /* 
1433      y=-( handle->properties.horizontal->Descender * handle->instanceh[inst].imetrics.y_ppem )/(handle->properties.header->Units_Per_EM);
1434   */
1435
1436   x=-cords[0]; /* FIXME: If you font is antialiased this should be expanded by one to allow for aa expansion and the allocation too - do before passing here */
1437   y=-cords[4];
1438   
1439   while (len) {
1440     if (utf8) {
1441       j = i_utf8_advance(&txt, &len);
1442       if (j == ~0UL) {
1443         i_push_error(0, "invalid UTF8 character");
1444         return 0;
1445       }
1446     }
1447     else {
1448       j = (unsigned char)*txt++;
1449       --len;
1450     }
1451     if ( !i_tt_get_glyph(handle,inst,j) ) 
1452       continue;
1453     i_tt_render_glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph, 
1454                        &handle->instanceh[inst].gmetrics[TT_HASH(j)], bit, 
1455                        small_bit, x, y, smooth );
1456     x += handle->instanceh[inst].gmetrics[TT_HASH(j)].advance / 64;
1457   }
1458
1459   return 1;
1460 }
1461
1462
1463 /*
1464  * Functions to render rasters (single channel images) onto images
1465  */
1466
1467 /* 
1468 =item i_tt_dump_raster_map2(im, bit, xb, yb, cl, smooth)
1469
1470 Function to dump a raster onto an image in color used by i_tt_text() (internal).
1471
1472    im     - image to dump raster on
1473    bit    - bitmap that contains the text to be dumped to im
1474    xb, yb - coordinates, left edge and baseline
1475    cl     - color to use for text
1476    smooth - boolean (True: antialias on, False: antialias is off)
1477
1478 =cut
1479 */
1480
1481 static
1482 void
1483 i_tt_dump_raster_map2( i_img* im, TT_Raster_Map* bit, int xb, int yb, const i_color *cl, int smooth ) {
1484   char *bmap;
1485   i_color val;
1486   int c, i, ch, x, y;
1487   mm_log((1,"i_tt_dump_raster_map2(im 0x%x, bit 0x%X, xb %d, yb %d, cl 0x%X)\n",im,bit,xb,yb,cl));
1488   
1489   bmap = (char *)bit->bitmap;
1490
1491   if ( smooth ) {
1492
1493     for(y=0;y<bit->rows;y++) for(x=0;x<bit->width;x++) {
1494       c=(255*bmap[y*(bit->cols)+x])/4;
1495       i=255-c;
1496       i_gpix(im,x+xb,y+yb,&val);
1497       for(ch=0;ch<im->channels;ch++) val.channel[ch]=(c*cl->channel[ch]+i*val.channel[ch])/255;
1498       i_ppix(im,x+xb,y+yb,&val);
1499     }
1500
1501   } else {
1502
1503     for(y=0;y<bit->rows;y++) for(x=0;x<bit->width;x++) {
1504       c=( bmap[y*bit->cols+x/8] & (128>>(x%8)) ) ? 255 : 0;
1505       i=255-c;
1506       i_gpix(im,x+xb,y+yb,&val);
1507       for(ch=0;ch<im->channels;ch++) val.channel[ch]=(c*cl->channel[ch]+i*val.channel[ch])/255;
1508       i_ppix(im,x+xb,y+yb,&val);
1509     }
1510
1511   }
1512 }
1513
1514
1515 /*
1516 =item i_tt_dump_raster_map_channel(im, bit, xb, yb, channel, smooth)
1517
1518 Function to dump a raster onto a single channel image in color (internal)
1519
1520    im      - image to dump raster on
1521    bit     - bitmap that contains the text to be dumped to im
1522    xb, yb  - coordinates, left edge and baseline
1523    channel - channel to copy to
1524    smooth  - boolean (True: antialias on, False: antialias is off)
1525
1526 =cut
1527 */
1528
1529 static
1530 void
1531 i_tt_dump_raster_map_channel( i_img* im, TT_Raster_Map*  bit, int xb, int yb, int channel, int smooth ) {
1532   char *bmap;
1533   i_color val;
1534   int c,x,y;
1535
1536   mm_log((1,"i_tt_dump_raster_channel(im 0x%x, bit 0x%X, xb %d, yb %d, channel %d)\n",im,bit,xb,yb,channel));
1537   
1538   bmap = (char *)bit->bitmap;
1539   
1540   if ( smooth ) {
1541     for(y=0;y<bit->rows;y++) for(x=0;x<bit->width;x++) {
1542       c=(255*bmap[y*(bit->cols)+x])/4;
1543       i_gpix(im,x+xb,y+yb,&val);
1544       val.channel[channel]=c;
1545       i_ppix(im,x+xb,y+yb,&val);
1546     }
1547   } else {
1548     for(y=0;y<bit->rows;y++) for(x=0;x<bit->width;x++) {
1549       c=( bmap[y*bit->cols+x/8] & (128>>(x%8)) ) ? 255 : 0;
1550       i_gpix(im,x+xb,y+yb,&val);
1551       val.channel[channel]=c;
1552       i_ppix(im,x+xb,y+yb,&val);
1553     }
1554   }
1555 }
1556
1557
1558 /* 
1559 =item i_tt_rasterize(handle, bit, cords, points, txt, len, smooth) 
1560
1561 interface for generating single channel raster of text (internal)
1562
1563    handle - pointer to font handle
1564    bit    - the bitmap that is allocated, rendered into and NOT freed
1565    cords  - the bounding box (modified in place)
1566    points - font size to use
1567    txt    - string to render
1568    len    - length of the string to render
1569    smooth - boolean (True: antialias on, False: antialias is off)
1570
1571 =cut
1572 */
1573
1574 static
1575 int
1576 i_tt_rasterize( TT_Fonthandle *handle, TT_Raster_Map *bit, int cords[6], float points, char const* txt, int len, int smooth, int utf8 ) {
1577   int inst;
1578   int width, height;
1579   TT_Raster_Map small_bit;
1580   
1581   /* find or install an instance */
1582   if ( (inst=i_tt_get_instance(handle,points,smooth)) < 0) { 
1583     mm_log((1,"i_tt_rasterize: get instance failed\n"));
1584     return 0;
1585   }
1586   
1587   /* calculate bounding box */
1588   if (!i_tt_bbox_inst( handle, inst, txt, len, cords, utf8 ))
1589     return 0;
1590     
1591   
1592   width  = cords[2]-cords[0];
1593   height = cords[5]-cords[4];
1594   
1595   mm_log((1,"i_tt_rasterize: width=%d, height=%d\n",width, height )); 
1596   
1597   i_tt_init_raster_map ( bit, width, height, smooth );
1598   i_tt_clear_raster_map( bit );
1599   if ( smooth ) i_tt_init_raster_map( &small_bit, handle->instanceh[inst].imetrics.x_ppem + 32, height, smooth );
1600   
1601   if (!i_tt_render_all_glyphs( handle, inst, bit, &small_bit, cords, txt, len, 
1602                                smooth, utf8 )) {
1603     if ( smooth ) 
1604       i_tt_done_raster_map( &small_bit );
1605     return 0;
1606   }
1607
1608   if ( smooth ) i_tt_done_raster_map( &small_bit );
1609   return 1;
1610 }
1611
1612
1613
1614 /* 
1615  * Exported text rendering interfaces
1616  */
1617
1618
1619 /*
1620 =item i_tt_cp(handle, im, xb, yb, channel, points, txt, len, smooth, utf8)
1621
1622 Interface to text rendering into a single channel in an image
1623
1624    handle  - pointer to font handle
1625    im      - image to render text on to
1626    xb, yb  - coordinates, left edge and baseline
1627    channel - channel to render into
1628    points  - font size to use
1629    txt     - string to render
1630    len     - length of the string to render
1631    smooth  - boolean (True: antialias on, False: antialias is off)
1632
1633 =cut
1634 */
1635
1636 undef_int
1637 i_tt_cp( TT_Fonthandle *handle, i_img *im, int xb, int yb, int channel, float points, char const* txt, int len, int smooth, int utf8, int align ) {
1638
1639   int cords[BOUNDING_BOX_COUNT];
1640   int ascent, st_offset, y;
1641   TT_Raster_Map bit;
1642   
1643   i_clear_error();
1644   if (! i_tt_rasterize( handle, &bit, cords, points, txt, len, smooth, utf8 ) ) return 0;
1645   
1646   ascent=cords[BBOX_ASCENT];
1647   st_offset=cords[BBOX_NEG_WIDTH];
1648   y = align ? yb-ascent : yb;
1649
1650   i_tt_dump_raster_map_channel( im, &bit, xb-st_offset , y, channel, smooth );
1651   i_tt_done_raster_map( &bit );
1652
1653   return 1;
1654 }
1655
1656
1657 /* 
1658 =item i_tt_text(handle, im, xb, yb, cl, points, txt, len, smooth, utf8) 
1659
1660 Interface to text rendering in a single color onto an image
1661
1662    handle  - pointer to font handle
1663    im      - image to render text on to
1664    xb, yb  - coordinates, left edge and baseline
1665    cl      - color to use for text
1666    points  - font size to use
1667    txt     - string to render
1668    len     - length of the string to render
1669    smooth  - boolean (True: antialias on, False: antialias is off)
1670
1671 =cut
1672 */
1673
1674 undef_int
1675 i_tt_text( TT_Fonthandle *handle, i_img *im, int xb, int yb, const i_color *cl, float points, char const* txt, int len, int smooth, int utf8, int align) {
1676   int cords[BOUNDING_BOX_COUNT];
1677   int ascent, st_offset, y;
1678   TT_Raster_Map bit;
1679
1680   i_clear_error();
1681   
1682   if (! i_tt_rasterize( handle, &bit, cords, points, txt, len, smooth, utf8 ) ) return 0;
1683   
1684   ascent=cords[BBOX_ASCENT];
1685   st_offset=cords[BBOX_NEG_WIDTH];
1686   y = align ? yb-ascent : yb;
1687
1688   i_tt_dump_raster_map2( im, &bit, xb+st_offset, y, cl, smooth ); 
1689   i_tt_done_raster_map( &bit );
1690
1691   return 1;
1692 }
1693
1694
1695 /*
1696 =item i_tt_bbox_inst(handle, inst, txt, len, cords, utf8) 
1697
1698 Function to get texts bounding boxes given the instance of the font (internal)
1699
1700    handle - pointer to font handle
1701    inst   -  font instance
1702    txt    -  string to measure
1703    len    -  length of the string to render
1704    cords  - the bounding box (modified in place)
1705
1706 =cut
1707 */
1708
1709 static
1710 undef_int
1711 i_tt_bbox_inst( TT_Fonthandle *handle, int inst ,const char *txt, int len, int cords[BOUNDING_BOX_COUNT], int utf8 ) {
1712   int upm, casc, cdesc, first;
1713   
1714   int start    = 0;
1715   int width    = 0;
1716   int gdescent = 0;
1717   int gascent  = 0;
1718   int descent  = 0;
1719   int ascent   = 0;
1720   int rightb   = 0;
1721
1722   unsigned long j;
1723   unsigned char *ustr;
1724   ustr=(unsigned char*)txt;
1725
1726   mm_log((1,"i_tt_box_inst(handle 0x%X,inst %d,txt '%.*s', len %d, utf8 %d)\n",handle,inst,len,txt,len, utf8));
1727
1728   upm     = handle->properties.header->Units_Per_EM;
1729   gascent  = ( handle->properties.horizontal->Ascender  * handle->instanceh[inst].imetrics.y_ppem + upm - 1) / upm;
1730   gdescent = ( handle->properties.horizontal->Descender * handle->instanceh[inst].imetrics.y_ppem - upm + 1) / upm;
1731   
1732   width   = 0;
1733   start   = 0;
1734   
1735   mm_log((1, "i_tt_box_inst: gascent=%d gdescent=%d\n", gascent, gdescent));
1736
1737   first=1;
1738   while (len) {
1739     if (utf8) {
1740       j = i_utf8_advance(&txt, &len);
1741       if (j == ~0UL) {
1742         i_push_error(0, "invalid UTF8 character");
1743         return 0;
1744       }
1745     }
1746     else {
1747       j = (unsigned char)*txt++;
1748       --len;
1749     }
1750     if ( i_tt_get_glyph(handle,inst,j) ) {
1751       TT_Glyph_Metrics *gm = handle->instanceh[inst].gmetrics + TT_HASH(j);
1752       width += gm->advance   / 64;
1753       casc   = (gm->bbox.yMax+63) / 64;
1754       cdesc  = (gm->bbox.yMin-63) / 64;
1755
1756       mm_log((1, "i_tt_box_inst: glyph='%c' casc=%d cdesc=%d\n", 
1757               ((j >= ' ' && j <= '~') ? j : '.'), casc, cdesc));
1758
1759       if (first) {
1760         start    = gm->bbox.xMin / 64;
1761         ascent   = (gm->bbox.yMax+63) / 64;
1762         descent  = (gm->bbox.yMin-63) / 64;
1763         first = 0;
1764       }
1765       if (!len) { /* if at end of string */
1766         /* the right-side bearing - in case the right-side of a 
1767            character goes past the right of the advance width,
1768            as is common for italic fonts
1769         */
1770         rightb = gm->advance - gm->bearingX 
1771           - (gm->bbox.xMax - gm->bbox.xMin);
1772         /* fprintf(stderr, "font info last: %d %d %d %d\n", 
1773            gm->bbox.xMax, gm->bbox.xMin, gm->advance, rightb); */
1774       }
1775
1776       ascent  = (ascent  >  casc ?  ascent : casc );
1777       descent = (descent < cdesc ? descent : cdesc);
1778     }
1779   }
1780   
1781   cords[BBOX_NEG_WIDTH]=start;
1782   cords[BBOX_GLOBAL_DESCENT]=gdescent;
1783   cords[BBOX_POS_WIDTH]=width;
1784   if (rightb < 0)
1785     cords[BBOX_POS_WIDTH] -= rightb / 64;
1786   cords[BBOX_GLOBAL_ASCENT]=gascent;
1787   cords[BBOX_DESCENT]=descent;
1788   cords[BBOX_ASCENT]=ascent;
1789   cords[BBOX_ADVANCE_WIDTH] = width;
1790   cords[BBOX_RIGHT_BEARING] = rightb / 64;
1791
1792   return BBOX_RIGHT_BEARING + 1;
1793 }
1794
1795
1796 /*
1797 =item i_tt_bbox(handle, points, txt, len, cords, utf8)
1798
1799 Interface to get a strings bounding box
1800
1801    handle - pointer to font handle
1802    points - font size to use
1803    txt    - string to render
1804    len    - length of the string to render
1805    cords  - the bounding box (modified in place)
1806
1807 =cut
1808 */
1809
1810 undef_int
1811 i_tt_bbox( TT_Fonthandle *handle, float points,const char *txt,int len,int cords[6], int utf8) {
1812   int inst;
1813
1814   i_clear_error();
1815   mm_log((1,"i_tt_box(handle 0x%X,points %f,txt '%.*s', len %d, utf8 %d)\n",handle,points,len,txt,len, utf8));
1816
1817   if ( (inst=i_tt_get_instance(handle,points,-1)) < 0) {
1818     i_push_errorf(0, "i_tt_get_instance(%g)", points);
1819     mm_log((1,"i_tt_text: get instance failed\n"));
1820     return 0;
1821   }
1822
1823   return i_tt_bbox_inst(handle, inst, txt, len, cords, utf8);
1824 }
1825
1826 /*
1827 =item i_tt_face_name(handle, name_buf, name_buf_size)
1828
1829 Retrieve's the font's postscript name.
1830
1831 This is complicated by the need to handle encodings and so on.
1832
1833 =cut
1834  */
1835 int
1836 i_tt_face_name(TT_Fonthandle *handle, char *name_buf, size_t name_buf_size) {
1837   TT_Face_Properties props;
1838   int name_count;
1839   int i;
1840   TT_UShort platform_id, encoding_id, lang_id, name_id;
1841   TT_UShort name_len;
1842   TT_String *name;
1843   int want_index = -1; /* an acceptable but not perfect name */
1844   int score = 0;
1845
1846   i_clear_error();
1847   
1848   TT_Get_Face_Properties(handle->face, &props);
1849   name_count = props.num_Names;
1850   for (i = 0; i < name_count; ++i) {
1851     TT_Get_Name_ID(handle->face, i, &platform_id, &encoding_id, &lang_id, 
1852                    &name_id);
1853
1854     TT_Get_Name_String(handle->face, i, &name, &name_len);
1855
1856     if (platform_id != TT_PLATFORM_APPLE_UNICODE && name_len
1857         && name_id == TT_NAME_ID_PS_NAME) {
1858       int might_want_index = -1;
1859       int might_score = 0;
1860       if ((platform_id == TT_PLATFORM_MACINTOSH && encoding_id == TT_MAC_ID_ROMAN)
1861           ||
1862           (platform_id == TT_PLATFORM_MICROSOFT && encoding_id == TT_MS_LANGID_ENGLISH_UNITED_STATES)) {
1863         /* exactly what we want */
1864         want_index = i;
1865         break;
1866       }
1867       
1868       if (platform_id == TT_PLATFORM_MICROSOFT
1869           && (encoding_id & 0xFF) == TT_MS_LANGID_ENGLISH_GENERAL) {
1870         /* any english is good */
1871         might_want_index = i;
1872         might_score = 9;
1873       }
1874       /* there might be something in between */
1875       else {
1876         /* anything non-unicode is better than nothing */
1877         might_want_index = i;
1878         might_score = 1;
1879       }
1880       if (might_score > score) {
1881         score = might_score;
1882         want_index = might_want_index;
1883       }
1884     }
1885   }
1886
1887   if (want_index != -1) {
1888     TT_Get_Name_String(handle->face, want_index, &name, &name_len);
1889     
1890     strncpy(name_buf, name, name_buf_size);
1891     name_buf[name_buf_size-1] = '\0';
1892
1893     return strlen(name) + 1;
1894   }
1895   else {
1896     i_push_error(0, "no face name present");
1897     return 0;
1898   }
1899 }
1900
1901 void i_tt_dump_names(TT_Fonthandle *handle) {
1902   TT_Face_Properties props;
1903   int name_count;
1904   int i;
1905   TT_UShort platform_id, encoding_id, lang_id, name_id;
1906   TT_UShort name_len;
1907   TT_String *name;
1908   
1909   TT_Get_Face_Properties(handle->face, &props);
1910   name_count = props.num_Names;
1911   for (i = 0; i < name_count; ++i) {
1912     TT_Get_Name_ID(handle->face, i, &platform_id, &encoding_id, &lang_id, 
1913                    &name_id);
1914     TT_Get_Name_String(handle->face, i, &name, &name_len);
1915
1916     printf("# %d: plat %d enc %d lang %d name %d value ", i, platform_id,
1917            encoding_id, lang_id, name_id);
1918     if (platform_id == TT_PLATFORM_APPLE_UNICODE) {
1919       printf("(unicode)\n");
1920     }
1921     else {
1922       printf("'%s'\n", name);
1923     }
1924   }
1925 }
1926
1927 int
1928 i_tt_glyph_name(TT_Fonthandle *handle, unsigned long ch, char *name_buf, 
1929                  size_t name_buf_size) {
1930 #ifdef FTXPOST
1931   TT_Error rc;
1932   TT_String *psname;
1933   TT_UShort index;
1934
1935   i_clear_error();
1936
1937   if (!handle->loaded_names) {
1938     TT_Post post;
1939     mm_log((1, "Loading PS Names"));
1940     handle->load_cond = TT_Load_PS_Names(handle->face, &post);
1941     ++handle->loaded_names;
1942   }
1943
1944   if (handle->load_cond) {
1945     i_push_errorf(rc, "error loading names (%d)", handle->load_cond);
1946     return 0;
1947   }
1948   
1949   index = TT_Char_Index(handle->char_map, ch);
1950   if (!index) {
1951     i_push_error(0, "no such character");
1952     return 0;
1953   }
1954
1955   rc = TT_Get_PS_Name(handle->face, index, &psname);
1956
1957   if (rc) {
1958     i_push_error(rc, "error getting name");
1959     return 0;
1960   }
1961
1962   strncpy(name_buf, psname, name_buf_size);
1963   name_buf[name_buf_size-1] = '\0';
1964
1965   return strlen(psname) + 1;
1966 #else
1967   mm_log((1, "FTXPOST extension not enabled\n"));
1968   i_clear_error();
1969   i_push_error(0, "Use of FTXPOST extension disabled");
1970
1971   return 0;
1972 #endif
1973 }
1974
1975 /*
1976 =item i_tt_push_error(code)
1977
1978 Push an error message and code onto the Imager error stack.
1979
1980 =cut
1981 */
1982 static void
1983 i_tt_push_error(TT_Error rc) {
1984 #ifdef FTXERR18
1985   TT_String const *msg = TT_ErrToString18(rc);
1986
1987   i_push_error(rc, msg);
1988 #else
1989   i_push_errorf(rc, "Error code 0x%04x", (unsigned)rc);
1990 #endif
1991 }
1992
1993 #endif /* HAVE_LIBTT */
1994
1995
1996 /*
1997 =back
1998
1999 =head1 AUTHOR
2000
2001 Arnar M. Hrafnkelsson <addi@umich.edu>
2002
2003 =head1 SEE ALSO
2004
2005 Imager(3)
2006
2007 =cut
2008 */