efb8355022b77db6fe3d2790063586c01ff5848b
[imager.git] / font.c
1 #include "imager.h"
2 #include "imrender.h"
3
4 #include <sys/types.h>
5 #include <sys/stat.h>
6 #include <fcntl.h>
7
8 #include <stdio.h>
9 #include <stdlib.h>
10
11 #ifdef HAVE_LIBT1
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 /* Truetype font support */
54 #ifdef HAVE_LIBTT
55
56 /* These are enabled by default when configuring Freetype 1.x
57    I haven't a clue how to reliably detect it at compile time.
58
59    We need a compilation probe in Makefile.PL
60 */
61 #define FTXPOST 1
62 #define FTXERR18 1
63
64 #include <freetype.h>
65 #define TT_CHC 5
66
67 #ifdef FTXPOST
68 #include <ftxpost.h>
69 #endif
70
71 #ifdef FTXERR18
72 #include <ftxerr18.h>
73 #endif
74
75 /* some versions of FT1.x don't seem to define this - it's font defined
76    so it won't change */
77 #ifndef TT_MS_LANGID_ENGLISH_GENERAL
78 #define TT_MS_LANGID_ENGLISH_GENERAL 0x0409
79 #endif
80
81 /* convert a code point into an index in the glyph cache */
82 #define TT_HASH(x) ((x) & 0xFF)
83
84 typedef struct i_glyph_entry_ {
85   TT_Glyph glyph;
86   unsigned long ch;
87 } i_tt_glyph_entry;
88
89 #define TT_NOCHAR (~0UL)
90
91 struct TT_Instancehandle_ {
92   TT_Instance instance;
93   TT_Instance_Metrics imetrics;
94   TT_Glyph_Metrics gmetrics[256];
95   i_tt_glyph_entry glyphs[256];
96   int smooth;
97   int ptsize;
98   int order;
99 };
100
101 typedef struct TT_Instancehandle_ TT_Instancehandle;
102
103 struct TT_Fonthandle_ {
104   TT_Face face;
105   TT_Face_Properties properties;
106   TT_Instancehandle instanceh[TT_CHC];
107   TT_CharMap char_map;
108 #ifdef FTXPOST
109   int loaded_names;
110   TT_Error load_cond;
111 #endif
112 };
113
114 /* Defines */
115
116 #define USTRCT(x) ((x).z)
117 #define TT_VALID( handle )  ( ( handle ).z != NULL )
118
119 static void i_tt_push_error(TT_Error rc);
120
121 /* Prototypes */
122
123 static  int i_tt_get_instance( TT_Fonthandle *handle, int points, int smooth );
124 static void i_tt_init_raster_map( TT_Raster_Map* bit, int width, int height, int smooth );
125 static void i_tt_done_raster_map( TT_Raster_Map *bit );
126 static void i_tt_clear_raster_map( TT_Raster_Map* bit );
127 static void i_tt_blit_or( TT_Raster_Map *dst, TT_Raster_Map *src,int x_off, int y_off );
128 static  int i_tt_get_glyph( TT_Fonthandle *handle, int inst, unsigned long j );
129 static void 
130 i_tt_render_glyph( TT_Glyph glyph, TT_Glyph_Metrics* gmetrics, 
131                    TT_Raster_Map *bit, TT_Raster_Map *small_bit, 
132                    int x_off, int y_off, int smooth );
133 static int
134 i_tt_render_all_glyphs( TT_Fonthandle *handle, int inst, TT_Raster_Map *bit, 
135                         TT_Raster_Map *small_bit, int cords[6], 
136                         char const* txt, size_t len, int smooth, int utf8 );
137 static void i_tt_dump_raster_map2( i_img* im, TT_Raster_Map* bit, int xb, int yb, const i_color *cl, int smooth );
138 static void i_tt_dump_raster_map_channel( i_img* im, TT_Raster_Map* bit, int xb, int yb, int channel, int smooth );
139 static  int
140 i_tt_rasterize( TT_Fonthandle *handle, TT_Raster_Map *bit, int cords[6], 
141                 float points, char const* txt, size_t len, int smooth, int utf8 );
142 static undef_int i_tt_bbox_inst( TT_Fonthandle *handle, int inst ,const char *txt, size_t len, int cords[6], int utf8 );
143
144
145 /* static globals needed */
146
147 static int TT_initialized = 0;
148 static TT_Engine    engine;
149 static int  LTT_dpi    = 72; /* FIXME: this ought to be a part of the call interface */
150 static int  LTT_hinted = 1;  /* FIXME: this too */
151
152
153 /*
154  * FreeType interface
155  */
156
157
158 /*
159 =item init_tt()
160
161 Initializes the freetype font rendering engine
162
163 =cut
164 */
165
166 undef_int
167 i_init_tt(void) {
168   TT_Error  error;
169   TT_Byte palette[] = { 0, 64, 127, 191, 255 };
170
171   i_clear_error();
172
173   mm_log((1,"init_tt()\n"));
174   error = TT_Init_FreeType( &engine );
175   if ( error ){
176     mm_log((1,"Initialization of freetype failed, code = 0x%x\n",error));
177     i_tt_push_error(error);
178     i_push_error(0, "Could not initialize freetype 1.x");
179     return(1);
180   }
181
182 #ifdef FTXPOST
183   error = TT_Init_Post_Extension( engine );
184   if (error) {
185     mm_log((1, "Initialization of Post extension failed = 0x%x\n", error));
186     
187     i_tt_push_error(error);
188     i_push_error(0, "Could not initialize FT 1.x POST extension");
189     return 1;
190   }
191 #endif
192
193   error = TT_Set_Raster_Gray_Palette(engine, palette);
194   if (error) {
195     mm_log((1, "Initialization of gray levels failed = 0x%x\n", error));
196     i_tt_push_error(error);
197     i_push_error(0, "Could not initialize FT 1.x POST extension");
198     return 1;
199   }
200
201   TT_initialized = 1;
202
203   return(0);
204 }
205
206
207 /* 
208 =item i_tt_get_instance(handle, points, smooth)
209
210 Finds a points+smooth instance or if one doesn't exist in the cache
211 allocates room and returns its cache entry
212
213    fontname - path to the font to load
214    handle   - handle to the font.
215    points   - points of the requested font
216    smooth   - boolean (True: antialias on, False: antialias is off)
217
218 =cut
219 */
220
221 static
222 int
223 i_tt_get_instance( TT_Fonthandle *handle, int points, int smooth ) {
224   int i,idx;
225   TT_Error error;
226   
227   mm_log((1,"i_tt_get_instance(handle 0x%X, points %d, smooth %d)\n",
228           handle,points,smooth));
229   
230   if (smooth == -1) { /* Smooth doesn't matter for this search */
231     for(i=0;i<TT_CHC;i++) {
232       if (handle->instanceh[i].ptsize==points) {
233         mm_log((1,"i_tt_get_instance: in cache - (non selective smoothing search) returning %d\n",i));
234         return i;
235       }
236     }
237     smooth=1; /* We will be adding a font - add it as smooth then */
238   } else { /* Smooth doesn't matter for this search */
239     for(i=0;i<TT_CHC;i++) {
240       if (handle->instanceh[i].ptsize == points 
241           && handle->instanceh[i].smooth == smooth) {
242         mm_log((1,"i_tt_get_instance: in cache returning %d\n",i));
243         return i;
244       }
245     }
246   }
247   
248   /* Found the instance in the cache - return the cache index */
249   
250   for(idx=0;idx<TT_CHC;idx++) {
251     if (!(handle->instanceh[idx].order)) break; /* find the lru item */
252   }
253
254   mm_log((1,"i_tt_get_instance: lru item is %d\n",idx));
255   mm_log((1,"i_tt_get_instance: lru pointer 0x%X\n",
256           USTRCT(handle->instanceh[idx].instance) ));
257   
258   if ( USTRCT(handle->instanceh[idx].instance) ) {
259     mm_log((1,"i_tt_get_instance: freeing lru item from cache %d\n",idx));
260
261     /* Free cached glyphs */
262     for(i=0;i<256;i++)
263       if ( USTRCT(handle->instanceh[idx].glyphs[i].glyph) )
264         TT_Done_Glyph( handle->instanceh[idx].glyphs[i].glyph );
265
266     for(i=0;i<256;i++) {
267       handle->instanceh[idx].glyphs[i].ch = TT_NOCHAR;
268       USTRCT(handle->instanceh[idx].glyphs[i].glyph)=NULL;
269     }
270
271     /* Free instance if needed */
272     TT_Done_Instance( handle->instanceh[idx].instance );
273   }
274   
275   /* create and initialize instance */
276   /* FIXME: probably a memory leak on fail */
277   
278   (void) (( error = TT_New_Instance( handle->face, &handle->instanceh[idx].instance ) ) || 
279           ( error = TT_Set_Instance_Resolutions( handle->instanceh[idx].instance, LTT_dpi, LTT_dpi ) ) ||
280           ( error = TT_Set_Instance_CharSize( handle->instanceh[idx].instance, points*64 ) ) );
281   
282   if ( error ) {
283     mm_log((1, "Could not create and initialize instance: error 0x%x.\n",error ));
284     return -1;
285   }
286   
287   /* Now that the instance should the inplace we need to lower all of the
288      ru counts and put `this' one with the highest entry */
289   
290   for(i=0;i<TT_CHC;i++) handle->instanceh[i].order--;
291
292   handle->instanceh[idx].order=TT_CHC-1;
293   handle->instanceh[idx].ptsize=points;
294   handle->instanceh[idx].smooth=smooth;
295   TT_Get_Instance_Metrics( handle->instanceh[idx].instance, &(handle->instanceh[idx].imetrics) );
296
297   /* Zero the memory for the glyph storage so they are not thought as
298      cached if they haven't been cached since this new font was loaded */
299
300   for(i=0;i<256;i++) {
301     handle->instanceh[idx].glyphs[i].ch = TT_NOCHAR;
302     USTRCT(handle->instanceh[idx].glyphs[i].glyph)=NULL;
303   }
304   
305   return idx;
306 }
307
308
309 /*
310 =item i_tt_new(fontname)
311
312 Creates a new font handle object, finds a character map and initialise the
313 the font handle's cache
314
315    fontname - path to the font to load
316
317 =cut
318 */
319
320 TT_Fonthandle*
321 i_tt_new(const char *fontname) {
322   TT_Error error;
323   TT_Fonthandle *handle;
324   unsigned short i,n;
325   unsigned short platform,encoding;
326
327   if (!TT_initialized && i_init_tt()) {
328     i_push_error(0, "Could not initialize FT1 engine");
329     return NULL;
330   }
331
332   i_clear_error();
333   
334   mm_log((1,"i_tt_new(fontname '%s')\n",fontname));
335   
336   /* allocate memory for the structure */
337   
338   handle = mymalloc( sizeof(TT_Fonthandle) ); /* checked 5Nov05 tonyc */
339
340   /* load the typeface */
341   error = TT_Open_Face( engine, fontname, &handle->face );
342   if ( error ) {
343     if ( error == TT_Err_Could_Not_Open_File ) {
344       mm_log((1, "Could not find/open %s.\n", fontname ));
345     }
346     else {
347       mm_log((1, "Error while opening %s, error code = 0x%x.\n",fontname, 
348               error )); 
349     }
350     i_tt_push_error(error);
351     return NULL;
352   }
353   
354   TT_Get_Face_Properties( handle->face, &(handle->properties) );
355
356   /* First, look for a Unicode charmap */
357   n = handle->properties.num_CharMaps;
358   USTRCT( handle->char_map )=NULL; /* Invalidate character map */
359   
360   for ( i = 0; i < n; i++ ) {
361     TT_Get_CharMap_ID( handle->face, i, &platform, &encoding );
362     if ( (platform == 3 && encoding == 1 ) 
363          || (platform == 0 && encoding == 0 ) ) {
364       mm_log((2,"i_tt_new - found char map platform %u encoding %u\n", 
365               platform, encoding));
366       TT_Get_CharMap( handle->face, i, &(handle->char_map) );
367       break;
368     }
369   }
370   if (!USTRCT(handle->char_map) && n != 0) {
371     /* just use the first one */
372     TT_Get_CharMap( handle->face, 0, &(handle->char_map));
373   }
374
375   /* Zero the pointsizes - and ordering */
376   
377   for(i=0;i<TT_CHC;i++) {
378     USTRCT(handle->instanceh[i].instance)=NULL;
379     handle->instanceh[i].order=i;
380     handle->instanceh[i].ptsize=0;
381     handle->instanceh[i].smooth=-1;
382   }
383
384 #ifdef FTXPOST
385   handle->loaded_names = 0;
386 #endif
387
388   mm_log((1,"i_tt_new <- 0x%X\n",handle));
389   return handle;
390 }
391
392
393
394 /*
395  *┬áraster map management
396  */
397
398 /* 
399 =item i_tt_init_raster_map(bit, width, height, smooth)
400
401 Allocates internal memory for the bitmap as needed by the parameters (internal)
402                  
403    bit    - bitmap to allocate into
404    width  - width of the bitmap
405    height - height of the bitmap
406    smooth - boolean (True: antialias on, False: antialias is off)
407
408 =cut
409 */
410
411 static
412 void
413 i_tt_init_raster_map( TT_Raster_Map* bit, int width, int height, int smooth ) {
414
415   mm_log((1,"i_tt_init_raster_map( bit 08x%08X, width %d, height %d, smooth %d)\n", bit, width, height, smooth));
416   
417   bit->rows  = height;
418   bit->width = ( width + 3 ) & -4;
419   bit->flow  = TT_Flow_Down;
420   
421   if ( smooth ) {
422     bit->cols  = bit->width;
423     bit->size  = bit->rows * bit->width;
424   } else {
425     bit->cols  = ( bit->width + 7 ) / 8;    /* convert to # of bytes     */
426     bit->size  = bit->rows * bit->cols;     /* number of bytes in buffer */
427   }
428
429   /* rows can be 0 for some glyphs, for example ' ' */
430   if (bit->rows && bit->size / bit->rows != bit->cols) {
431     i_fatal(0, "Integer overflow calculating bitmap size (%d, %d)\n",
432             bit->width, bit->rows);
433   }
434   
435   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 ));
436
437   bit->bitmap = (void *) mymalloc( bit->size ); /* checked 6Nov05 tonyc */
438   if ( !bit->bitmap ) i_fatal(0,"Not enough memory to allocate bitmap (%d)!\n",bit->size );
439 }
440
441
442 /*
443 =item i_tt_clear_raster_map(bit)
444
445 Frees the bitmap data and sets pointer to NULL (internal)
446                  
447    bit - bitmap to free
448
449 =cut
450 */
451
452 static
453 void
454 i_tt_done_raster_map( TT_Raster_Map *bit ) {
455   myfree( bit->bitmap );
456   bit->bitmap = NULL;
457 }
458
459
460 /*
461 =item i_tt_clear_raster_map(bit)
462
463 Clears the specified bitmap (internal)
464                  
465    bit - bitmap to zero
466
467 =cut
468 */
469
470
471 static
472 void
473 i_tt_clear_raster_map( TT_Raster_Map*  bit ) {
474   memset( bit->bitmap, 0, bit->size );
475 }
476
477
478 /* 
479 =item i_tt_blit_or(dst, src, x_off, y_off)
480
481 function that blits one raster map into another (internal)
482                  
483    dst   - destination bitmap
484    src   - source bitmap
485    x_off - x offset into the destination bitmap
486    y_off - y offset into the destination bitmap
487
488 =cut
489 */
490
491 static
492 void
493 i_tt_blit_or( TT_Raster_Map *dst, TT_Raster_Map *src,int x_off, int y_off ) {
494   int  x,  y;
495   int  x1, x2, y1, y2;
496   unsigned char *s, *d;
497   
498   x1 = x_off < 0 ? -x_off : 0;
499   y1 = y_off < 0 ? -y_off : 0;
500   
501   x2 = (int)dst->cols - x_off;
502   if ( x2 > src->cols ) x2 = src->cols;
503   
504   y2 = (int)dst->rows - y_off;
505   if ( y2 > src->rows ) y2 = src->rows;
506
507   if ( x1 >= x2 ) return;
508
509   /* do the real work now */
510
511   for ( y = y1; y < y2; ++y ) {
512     s = ( (unsigned char*)src->bitmap ) + y * src->cols + x1;
513     d = ( (unsigned char*)dst->bitmap ) + ( y + y_off ) * dst->cols + x1 + x_off;
514     
515     for ( x = x1; x < x2; ++x ) {
516       if (*s > *d)
517         *d = *s;
518       d++;
519       s++;
520     }
521   }
522 }
523
524 /* useful for debugging */
525 #if 0
526
527 static void dump_raster_map(FILE *out, TT_Raster_Map *bit ) {
528   int x, y;
529   fprintf(out, "cols %d rows %d  flow %d\n", bit->cols, bit->rows, bit->flow);
530   for (y = 0; y < bit->rows; ++y) {
531     fprintf(out, "%2d:", y);
532     for (x = 0; x < bit->cols; ++x) {
533       if ((x & 7) == 0 && x) putc(' ', out);
534       fprintf(out, "%02x", ((unsigned char *)bit->bitmap)[y*bit->cols+x]);
535     }
536     putc('\n', out);
537   }
538 }
539
540 #endif
541
542 /* 
543 =item i_tt_get_glyph(handle, inst, j) 
544
545 Function to see if a glyph exists and if so cache it (internal)
546                  
547    handle - pointer to font handle
548    inst   - font instance
549    j      - charcode of glyph
550
551 =cut
552 */
553
554 static
555 int
556 i_tt_get_glyph( TT_Fonthandle *handle, int inst, unsigned long j) {
557   unsigned short load_flags, code;
558   TT_Error error;
559
560   mm_log((1, "i_tt_get_glyph(handle 0x%X, inst %d, j %d (%c))\n",
561           handle,inst,j, ((j >= ' ' && j <= '~') ? j : '.')));
562   
563   /*mm_log((1, "handle->instanceh[inst].glyphs[j]=0x%08X\n",handle->instanceh[inst].glyphs[j] ));*/
564
565   if ( TT_VALID(handle->instanceh[inst].glyphs[TT_HASH(j)].glyph)
566        && handle->instanceh[inst].glyphs[TT_HASH(j)].ch == j) {
567     mm_log((1,"i_tt_get_glyph: %d in cache\n",j));
568     return 1;
569   }
570
571   if ( TT_VALID(handle->instanceh[inst].glyphs[TT_HASH(j)].glyph) ) {
572     /* clean up the entry */
573     TT_Done_Glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph );
574     USTRCT( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph ) = NULL;
575     handle->instanceh[inst].glyphs[TT_HASH(j)].ch = TT_NOCHAR;
576   }
577   
578   /* Ok - it wasn't cached - try to get it in */
579   load_flags = TTLOAD_SCALE_GLYPH;
580   if ( LTT_hinted ) load_flags |= TTLOAD_HINT_GLYPH;
581   
582   if ( !TT_VALID(handle->char_map) ) {
583     code = (j - ' ' + 1) < 0 ? 0 : (j - ' ' + 1);
584     if ( code >= handle->properties.num_Glyphs ) code = 0;
585   } else code = TT_Char_Index( handle->char_map, j );
586   
587   if ( (error = TT_New_Glyph( handle->face, &handle->instanceh[inst].glyphs[TT_HASH(j)].glyph)) ) {
588     mm_log((1, "Cannot allocate and load glyph: error 0x%x.\n", error ));
589     i_push_error(error, "TT_New_Glyph()");
590     return 0;
591   }
592   if ( (error = TT_Load_Glyph( handle->instanceh[inst].instance, handle->instanceh[inst].glyphs[TT_HASH(j)].glyph, code, load_flags)) ) {
593     mm_log((1, "Cannot allocate and load glyph: error 0x%x.\n", error ));
594     /* Don't leak */
595     TT_Done_Glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph );
596     USTRCT( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph ) = NULL;
597     i_push_error(error, "TT_Load_Glyph()");
598     return 0;
599   }
600
601   /* At this point the glyph should be allocated and loaded */
602   handle->instanceh[inst].glyphs[TT_HASH(j)].ch = j;
603
604   /* Next get the glyph metrics */
605   error = TT_Get_Glyph_Metrics( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph, 
606                                 &handle->instanceh[inst].gmetrics[TT_HASH(j)] );
607   if (error) {
608     mm_log((1, "TT_Get_Glyph_Metrics: error 0x%x.\n", error ));
609     TT_Done_Glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph );
610     USTRCT( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph ) = NULL;
611     handle->instanceh[inst].glyphs[TT_HASH(j)].ch = TT_NOCHAR;
612     i_push_error(error, "TT_Get_Glyph_Metrics()");
613     return 0;
614   }
615
616   return 1;
617 }
618
619 /*
620 =item i_tt_has_chars(handle, text, len, utf8, out)
621
622 Check if the given characters are defined by the font.  Note that len
623 is the number of bytes, not the number of characters (when utf8 is
624 non-zero).
625
626 Returns the number of characters that were checked.
627
628 =cut
629 */
630
631 int
632 i_tt_has_chars(TT_Fonthandle *handle, char const *text, size_t len, int utf8,
633                char *out) {
634   int count = 0;
635   mm_log((1, "i_tt_has_chars(handle %p, text %p, len %d, utf8 %d)\n", 
636           handle, text, len, utf8));
637
638   while (len) {
639     unsigned long c;
640     int index;
641     if (utf8) {
642       c = i_utf8_advance(&text, &len);
643       if (c == ~0UL) {
644         i_push_error(0, "invalid UTF8 character");
645         return 0;
646       }
647     }
648     else {
649       c = (unsigned char)*text++;
650       --len;
651     }
652     
653     if (TT_VALID(handle->char_map)) {
654       index = TT_Char_Index(handle->char_map, c);
655     }
656     else {
657       index = (c - ' ' + 1) < 0 ? 0 : (c - ' ' + 1);
658       if (index >= handle->properties.num_Glyphs)
659         index = 0;
660     }
661     *out++ = index != 0;
662     ++count;
663   }
664
665   return count;
666 }
667
668 /* 
669 =item i_tt_destroy(handle)
670
671 Clears the data taken by a font including all cached data such as
672 pixmaps and glyphs
673                  
674    handle - pointer to font handle
675
676 =cut
677 */
678
679 void
680 i_tt_destroy( TT_Fonthandle *handle) {
681   TT_Close_Face( handle->face );
682   myfree( handle );
683   
684   /* FIXME: Should these be freed automatically by the library? 
685
686   TT_Done_Instance( instance );
687   void
688     i_tt_done_glyphs( void ) {
689     int  i;
690
691     if ( !glyphs ) return;
692     
693     for ( i = 0; i < 256; ++i ) TT_Done_Glyph( glyphs[i] );
694     free( glyphs );
695     
696     glyphs = NULL;
697   }
698   */
699 }
700
701
702 /*
703  * FreeType Rendering functions
704  */
705
706
707 /* 
708 =item i_tt_render_glyph(handle, gmetrics, bit, smallbit, x_off, y_off, smooth)
709
710 Renders a single glyph into the bit rastermap (internal)
711
712    handle   - pointer to font handle
713    gmetrics - the metrics for the glyph to be rendered
714    bit      - large bitmap that is the destination for the text
715    smallbit - small bitmap that is used only if smooth is true
716    x_off    - x offset of glyph
717    y_off    - y offset of glyph
718    smooth   - boolean (True: antialias on, False: antialias is off)
719
720 =cut
721 */
722
723 static
724 void
725 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 ) {
726   
727   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",
728           USTRCT(glyph), gmetrics, bit, small_bit, x_off,y_off,smooth));
729   
730   if ( !smooth ) TT_Get_Glyph_Bitmap( glyph, bit, x_off * 64, y_off * 64);
731   else {
732     TT_F26Dot6 xmin, ymin, xmax, ymax;
733
734     xmin =  gmetrics->bbox.xMin & -64;
735     ymin =  gmetrics->bbox.yMin & -64;
736     xmax = (gmetrics->bbox.xMax + 63) & -64;
737     ymax = (gmetrics->bbox.yMax + 63) & -64;
738     
739     i_tt_clear_raster_map( small_bit );
740     TT_Get_Glyph_Pixmap( glyph, small_bit, -xmin, -ymin );
741     i_tt_blit_or( bit, small_bit, xmin/64 + x_off, -ymin/64 - y_off );
742   }
743 }
744
745
746 /*
747 =item i_tt_render_all_glyphs(handle, inst, bit, small_bit, cords, txt, len, smooth)
748
749 calls i_tt_render_glyph to render each glyph into the bit rastermap (internal)
750
751    handle   - pointer to font handle
752    inst     - font instance
753    bit      - large bitmap that is the destination for the text
754    smallbit - small bitmap that is used only if smooth is true
755    txt      - string to render
756    len      - length of the string to render
757    smooth   - boolean (True: antialias on, False: antialias is off)
758
759 =cut
760 */
761
762 static
763 int
764 i_tt_render_all_glyphs( TT_Fonthandle *handle, int inst, TT_Raster_Map *bit,
765                         TT_Raster_Map *small_bit, int cords[6], 
766                         char const* txt, size_t len, int smooth, int utf8 ) {
767   unsigned long j;
768   TT_F26Dot6 x,y;
769   
770   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",
771           handle, inst, bit, small_bit, len, txt, len, smooth, utf8));
772   
773   /* 
774      y=-( handle->properties.horizontal->Descender * handle->instanceh[inst].imetrics.y_ppem )/(handle->properties.header->Units_Per_EM);
775   */
776
777   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 */
778   y=-cords[4];
779   
780   while (len) {
781     if (utf8) {
782       j = i_utf8_advance(&txt, &len);
783       if (j == ~0UL) {
784         i_push_error(0, "invalid UTF8 character");
785         return 0;
786       }
787     }
788     else {
789       j = (unsigned char)*txt++;
790       --len;
791     }
792     if ( !i_tt_get_glyph(handle,inst,j) ) 
793       continue;
794     i_tt_render_glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph, 
795                        &handle->instanceh[inst].gmetrics[TT_HASH(j)], bit, 
796                        small_bit, x, y, smooth );
797     x += handle->instanceh[inst].gmetrics[TT_HASH(j)].advance / 64;
798   }
799
800   return 1;
801 }
802
803
804 /*
805  * Functions to render rasters (single channel images) onto images
806  */
807
808 /* 
809 =item i_tt_dump_raster_map2(im, bit, xb, yb, cl, smooth)
810
811 Function to dump a raster onto an image in color used by i_tt_text() (internal).
812
813    im     - image to dump raster on
814    bit    - bitmap that contains the text to be dumped to im
815    xb, yb - coordinates, left edge and baseline
816    cl     - color to use for text
817    smooth - boolean (True: antialias on, False: antialias is off)
818
819 =cut
820 */
821
822 static
823 void
824 i_tt_dump_raster_map2( i_img* im, TT_Raster_Map* bit, int xb, int yb, const i_color *cl, int smooth ) {
825   unsigned char *bmap;
826   int x, y;
827   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));
828   
829   bmap = bit->bitmap;
830
831   if ( smooth ) {
832
833     i_render r;
834     i_render_init(&r, im, bit->cols);
835     for(y=0;y<bit->rows;y++) {
836 #if 0
837       for(x=0;x<bit->width;x++) {
838        c = (unsigned char)bmap[y*(bit->cols)+x];
839        i=255-c;
840        i_gpix(im,x+xb,y+yb,&val);
841        for(ch=0;ch<im->channels;ch++) 
842          val.channel[ch] = (c*cl->channel[ch]+i*val.channel[ch])/255;
843        i_ppix(im,x+xb,y+yb,&val);
844       }
845 #else
846       i_render_color(&r, xb, yb+y, bit->cols, bmap + y*bit->cols, cl);
847 #endif
848     }
849     i_render_done(&r);
850   } else {
851     for(y=0;y<bit->rows;y++) {
852       unsigned mask = 0x80;
853       unsigned char *p = bmap + y * bit->cols;
854
855       for(x = 0; x < bit->width; x++) {
856         if (*p & mask) {
857           i_ppix(im, x+xb, y+yb, cl);
858         }
859         mask >>= 1;
860         if (!mask) {
861           mask = 0x80;
862           ++p;
863         }
864       }
865     }
866
867   }
868 }
869
870
871 /*
872 =item i_tt_dump_raster_map_channel(im, bit, xb, yb, channel, smooth)
873
874 Function to dump a raster onto a single channel image in color (internal)
875
876    im      - image to dump raster on
877    bit     - bitmap that contains the text to be dumped to im
878    xb, yb  - coordinates, left edge and baseline
879    channel - channel to copy to
880    smooth  - boolean (True: antialias on, False: antialias is off)
881
882 =cut
883 */
884
885 static
886 void
887 i_tt_dump_raster_map_channel( i_img* im, TT_Raster_Map*  bit, int xb, int yb, int channel, int smooth ) {
888   unsigned char *bmap;
889   i_color val;
890   int c,x,y;
891   int old_mask = im->ch_mask;
892   im->ch_mask = 1 << channel;
893
894   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));
895   
896   bmap = bit->bitmap;
897   
898   if ( smooth ) {
899     for(y=0;y<bit->rows;y++) for(x=0;x<bit->width;x++) {
900       c = bmap[y*(bit->cols)+x];
901       val.channel[channel] = c;
902       i_ppix(im,x+xb,y+yb,&val);
903     }
904   } else {
905     for(y=0;y<bit->rows;y++) {
906       unsigned mask = 0x80;
907       unsigned char *p = bmap + y * bit->cols;
908
909       for(x=0;x<bit->width;x++) {
910         val.channel[channel] = (*p & mask) ? 255 : 0;
911         i_ppix(im,x+xb,y+yb,&val);
912         
913         mask >>= 1;
914         if (!mask) {
915           ++p;
916           mask = 0x80;
917         }
918       }
919     }
920   }
921   im->ch_mask = old_mask;
922 }
923
924
925 /* 
926 =item i_tt_rasterize(handle, bit, cords, points, txt, len, smooth) 
927
928 interface for generating single channel raster of text (internal)
929
930    handle - pointer to font handle
931    bit    - the bitmap that is allocated, rendered into and NOT freed
932    cords  - the bounding box (modified in place)
933    points - font size to use
934    txt    - string to render
935    len    - length of the string to render
936    smooth - boolean (True: antialias on, False: antialias is off)
937
938 =cut
939 */
940
941 static
942 int
943 i_tt_rasterize( TT_Fonthandle *handle, TT_Raster_Map *bit, int cords[6], float points, char const* txt, size_t len, int smooth, int utf8 ) {
944   int inst;
945   int width, height;
946   TT_Raster_Map small_bit;
947   
948   /* find or install an instance */
949   if ( (inst=i_tt_get_instance(handle,points,smooth)) < 0) { 
950     mm_log((1,"i_tt_rasterize: get instance failed\n"));
951     return 0;
952   }
953   
954   /* calculate bounding box */
955   if (!i_tt_bbox_inst( handle, inst, txt, len, cords, utf8 ))
956     return 0;
957     
958   
959   width  = cords[2]-cords[0];
960   height = cords[5]-cords[4];
961   
962   mm_log((1,"i_tt_rasterize: width=%d, height=%d\n",width, height )); 
963   
964   i_tt_init_raster_map ( bit, width, height, smooth );
965   i_tt_clear_raster_map( bit );
966   if ( smooth ) i_tt_init_raster_map( &small_bit, handle->instanceh[inst].imetrics.x_ppem + 32, height, smooth );
967   
968   if (!i_tt_render_all_glyphs( handle, inst, bit, &small_bit, cords, txt, len, 
969                                smooth, utf8 )) {
970     if ( smooth ) 
971       i_tt_done_raster_map( &small_bit );
972     return 0;
973   }
974
975   if ( smooth ) i_tt_done_raster_map( &small_bit );
976   return 1;
977 }
978
979
980
981 /* 
982  * Exported text rendering interfaces
983  */
984
985
986 /*
987 =item i_tt_cp(handle, im, xb, yb, channel, points, txt, len, smooth, utf8)
988
989 Interface to text rendering into a single channel in an image
990
991    handle  - pointer to font handle
992    im      - image to render text on to
993    xb, yb  - coordinates, left edge and baseline
994    channel - channel to render into
995    points  - font size to use
996    txt     - string to render
997    len     - length of the string to render
998    smooth  - boolean (True: antialias on, False: antialias is off)
999
1000 =cut
1001 */
1002
1003 undef_int
1004 i_tt_cp( TT_Fonthandle *handle, i_img *im, int xb, int yb, int channel, float points, char const* txt, size_t len, int smooth, int utf8, int align ) {
1005
1006   int cords[BOUNDING_BOX_COUNT];
1007   int ascent, st_offset, y;
1008   TT_Raster_Map bit;
1009   
1010   i_clear_error();
1011   if (! i_tt_rasterize( handle, &bit, cords, points, txt, len, smooth, utf8 ) ) return 0;
1012   
1013   ascent=cords[BBOX_ASCENT];
1014   st_offset=cords[BBOX_NEG_WIDTH];
1015   y = align ? yb-ascent : yb;
1016
1017   i_tt_dump_raster_map_channel( im, &bit, xb-st_offset , y, channel, smooth );
1018   i_tt_done_raster_map( &bit );
1019
1020   return 1;
1021 }
1022
1023
1024 /* 
1025 =item i_tt_text(handle, im, xb, yb, cl, points, txt, len, smooth, utf8) 
1026
1027 Interface to text rendering in a single color onto an image
1028
1029    handle  - pointer to font handle
1030    im      - image to render text on to
1031    xb, yb  - coordinates, left edge and baseline
1032    cl      - color to use for text
1033    points  - font size to use
1034    txt     - string to render
1035    len     - length of the string to render
1036    smooth  - boolean (True: antialias on, False: antialias is off)
1037
1038 =cut
1039 */
1040
1041 undef_int
1042 i_tt_text( TT_Fonthandle *handle, i_img *im, int xb, int yb, const i_color *cl, float points, char const* txt, size_t len, int smooth, int utf8, int align) {
1043   int cords[BOUNDING_BOX_COUNT];
1044   int ascent, st_offset, y;
1045   TT_Raster_Map bit;
1046
1047   i_clear_error();
1048   
1049   if (! i_tt_rasterize( handle, &bit, cords, points, txt, len, smooth, utf8 ) ) return 0;
1050   
1051   ascent=cords[BBOX_ASCENT];
1052   st_offset=cords[BBOX_NEG_WIDTH];
1053   y = align ? yb-ascent : yb;
1054
1055   i_tt_dump_raster_map2( im, &bit, xb+st_offset, y, cl, smooth ); 
1056   i_tt_done_raster_map( &bit );
1057
1058   return 1;
1059 }
1060
1061
1062 /*
1063 =item i_tt_bbox_inst(handle, inst, txt, len, cords, utf8) 
1064
1065 Function to get texts bounding boxes given the instance of the font (internal)
1066
1067    handle - pointer to font handle
1068    inst   -  font instance
1069    txt    -  string to measure
1070    len    -  length of the string to render
1071    cords  - the bounding box (modified in place)
1072
1073 =cut
1074 */
1075
1076 static
1077 undef_int
1078 i_tt_bbox_inst( TT_Fonthandle *handle, int inst ,const char *txt, size_t len, int cords[BOUNDING_BOX_COUNT], int utf8 ) {
1079   int upm, casc, cdesc, first;
1080   
1081   int start    = 0;
1082   int width    = 0;
1083   int gdescent = 0;
1084   int gascent  = 0;
1085   int descent  = 0;
1086   int ascent   = 0;
1087   int rightb   = 0;
1088
1089   unsigned long j;
1090   unsigned char *ustr;
1091   ustr=(unsigned char*)txt;
1092
1093   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));
1094
1095   upm     = handle->properties.header->Units_Per_EM;
1096   gascent  = ( handle->properties.horizontal->Ascender  * handle->instanceh[inst].imetrics.y_ppem + upm - 1) / upm;
1097   gdescent = ( handle->properties.horizontal->Descender * handle->instanceh[inst].imetrics.y_ppem - upm + 1) / upm;
1098   
1099   width   = 0;
1100   start   = 0;
1101   
1102   mm_log((1, "i_tt_box_inst: gascent=%d gdescent=%d\n", gascent, gdescent));
1103
1104   first=1;
1105   while (len) {
1106     if (utf8) {
1107       j = i_utf8_advance(&txt, &len);
1108       if (j == ~0UL) {
1109         i_push_error(0, "invalid UTF8 character");
1110         return 0;
1111       }
1112     }
1113     else {
1114       j = (unsigned char)*txt++;
1115       --len;
1116     }
1117     if ( i_tt_get_glyph(handle,inst,j) ) {
1118       TT_Glyph_Metrics *gm = handle->instanceh[inst].gmetrics + TT_HASH(j);
1119       width += gm->advance   / 64;
1120       casc   = (gm->bbox.yMax+63) / 64;
1121       cdesc  = (gm->bbox.yMin-63) / 64;
1122
1123       mm_log((1, "i_tt_box_inst: glyph='%c' casc=%d cdesc=%d\n", 
1124               ((j >= ' ' && j <= '~') ? j : '.'), casc, cdesc));
1125
1126       if (first) {
1127         start    = gm->bbox.xMin / 64;
1128         ascent   = (gm->bbox.yMax+63) / 64;
1129         descent  = (gm->bbox.yMin-63) / 64;
1130         first = 0;
1131       }
1132       if (!len) { /* if at end of string */
1133         /* the right-side bearing - in case the right-side of a 
1134            character goes past the right of the advance width,
1135            as is common for italic fonts
1136         */
1137         rightb = gm->advance - gm->bearingX 
1138           - (gm->bbox.xMax - gm->bbox.xMin);
1139         /* fprintf(stderr, "font info last: %d %d %d %d\n", 
1140            gm->bbox.xMax, gm->bbox.xMin, gm->advance, rightb); */
1141       }
1142
1143       ascent  = (ascent  >  casc ?  ascent : casc );
1144       descent = (descent < cdesc ? descent : cdesc);
1145     }
1146   }
1147   
1148   cords[BBOX_NEG_WIDTH]=start;
1149   cords[BBOX_GLOBAL_DESCENT]=gdescent;
1150   cords[BBOX_POS_WIDTH]=width;
1151   if (rightb < 0)
1152     cords[BBOX_POS_WIDTH] -= rightb / 64;
1153   cords[BBOX_GLOBAL_ASCENT]=gascent;
1154   cords[BBOX_DESCENT]=descent;
1155   cords[BBOX_ASCENT]=ascent;
1156   cords[BBOX_ADVANCE_WIDTH] = width;
1157   cords[BBOX_RIGHT_BEARING] = rightb / 64;
1158
1159   return BBOX_RIGHT_BEARING + 1;
1160 }
1161
1162
1163 /*
1164 =item i_tt_bbox(handle, points, txt, len, cords, utf8)
1165
1166 Interface to get a strings bounding box
1167
1168    handle - pointer to font handle
1169    points - font size to use
1170    txt    - string to render
1171    len    - length of the string to render
1172    cords  - the bounding box (modified in place)
1173
1174 =cut
1175 */
1176
1177 undef_int
1178 i_tt_bbox( TT_Fonthandle *handle, float points,const char *txt,size_t len,int cords[6], int utf8) {
1179   int inst;
1180
1181   i_clear_error();
1182   mm_log((1,"i_tt_box(handle 0x%X,points %f,txt '%.*s', len %d, utf8 %d)\n",handle,points,len,txt,len, utf8));
1183
1184   if ( (inst=i_tt_get_instance(handle,points,-1)) < 0) {
1185     i_push_errorf(0, "i_tt_get_instance(%g)", points);
1186     mm_log((1,"i_tt_text: get instance failed\n"));
1187     return 0;
1188   }
1189
1190   return i_tt_bbox_inst(handle, inst, txt, len, cords, utf8);
1191 }
1192
1193 /*
1194 =item i_tt_face_name(handle, name_buf, name_buf_size)
1195
1196 Retrieve's the font's postscript name.
1197
1198 This is complicated by the need to handle encodings and so on.
1199
1200 =cut
1201  */
1202 int
1203 i_tt_face_name(TT_Fonthandle *handle, char *name_buf, size_t name_buf_size) {
1204   TT_Face_Properties props;
1205   int name_count;
1206   int i;
1207   TT_UShort platform_id, encoding_id, lang_id, name_id;
1208   TT_UShort name_len;
1209   TT_String *name;
1210   int want_index = -1; /* an acceptable but not perfect name */
1211   int score = 0;
1212
1213   i_clear_error();
1214   
1215   TT_Get_Face_Properties(handle->face, &props);
1216   name_count = props.num_Names;
1217   for (i = 0; i < name_count; ++i) {
1218     TT_Get_Name_ID(handle->face, i, &platform_id, &encoding_id, &lang_id, 
1219                    &name_id);
1220
1221     TT_Get_Name_String(handle->face, i, &name, &name_len);
1222
1223     if (platform_id != TT_PLATFORM_APPLE_UNICODE && name_len
1224         && name_id == TT_NAME_ID_PS_NAME) {
1225       int might_want_index = -1;
1226       int might_score = 0;
1227       if ((platform_id == TT_PLATFORM_MACINTOSH && encoding_id == TT_MAC_ID_ROMAN)
1228           ||
1229           (platform_id == TT_PLATFORM_MICROSOFT && encoding_id == TT_MS_LANGID_ENGLISH_UNITED_STATES)) {
1230         /* exactly what we want */
1231         want_index = i;
1232         break;
1233       }
1234       
1235       if (platform_id == TT_PLATFORM_MICROSOFT
1236           && (encoding_id & 0xFF) == TT_MS_LANGID_ENGLISH_GENERAL) {
1237         /* any english is good */
1238         might_want_index = i;
1239         might_score = 9;
1240       }
1241       /* there might be something in between */
1242       else {
1243         /* anything non-unicode is better than nothing */
1244         might_want_index = i;
1245         might_score = 1;
1246       }
1247       if (might_score > score) {
1248         score = might_score;
1249         want_index = might_want_index;
1250       }
1251     }
1252   }
1253
1254   if (want_index != -1) {
1255     TT_Get_Name_String(handle->face, want_index, &name, &name_len);
1256     
1257     strncpy(name_buf, name, name_buf_size);
1258     name_buf[name_buf_size-1] = '\0';
1259
1260     return strlen(name) + 1;
1261   }
1262   else {
1263     i_push_error(0, "no face name present");
1264     return 0;
1265   }
1266 }
1267
1268 void i_tt_dump_names(TT_Fonthandle *handle) {
1269   TT_Face_Properties props;
1270   int name_count;
1271   int i;
1272   TT_UShort platform_id, encoding_id, lang_id, name_id;
1273   TT_UShort name_len;
1274   TT_String *name;
1275   
1276   TT_Get_Face_Properties(handle->face, &props);
1277   name_count = props.num_Names;
1278   for (i = 0; i < name_count; ++i) {
1279     TT_Get_Name_ID(handle->face, i, &platform_id, &encoding_id, &lang_id, 
1280                    &name_id);
1281     TT_Get_Name_String(handle->face, i, &name, &name_len);
1282
1283     printf("# %d: plat %d enc %d lang %d name %d value ", i, platform_id,
1284            encoding_id, lang_id, name_id);
1285     if (platform_id == TT_PLATFORM_APPLE_UNICODE) {
1286       printf("(unicode)\n");
1287     }
1288     else {
1289       printf("'%s'\n", name);
1290     }
1291   }
1292   fflush(stdout);
1293 }
1294
1295 int
1296 i_tt_glyph_name(TT_Fonthandle *handle, unsigned long ch, char *name_buf, 
1297                  size_t name_buf_size) {
1298 #ifdef FTXPOST
1299   TT_Error rc;
1300   TT_String *psname;
1301   TT_UShort index;
1302
1303   i_clear_error();
1304
1305   if (!handle->loaded_names) {
1306     TT_Post post;
1307     mm_log((1, "Loading PS Names"));
1308     handle->load_cond = TT_Load_PS_Names(handle->face, &post);
1309     ++handle->loaded_names;
1310   }
1311
1312   if (handle->load_cond) {
1313     i_push_errorf(handle->load_cond, "error loading names (%d)", handle->load_cond);
1314     return 0;
1315   }
1316   
1317   index = TT_Char_Index(handle->char_map, ch);
1318   if (!index) {
1319     i_push_error(0, "no such character");
1320     return 0;
1321   }
1322
1323   rc = TT_Get_PS_Name(handle->face, index, &psname);
1324
1325   if (rc) {
1326     i_push_error(rc, "error getting name");
1327     return 0;
1328   }
1329
1330   strncpy(name_buf, psname, name_buf_size);
1331   name_buf[name_buf_size-1] = '\0';
1332
1333   return strlen(psname) + 1;
1334 #else
1335   mm_log((1, "FTXPOST extension not enabled\n"));
1336   i_clear_error();
1337   i_push_error(0, "Use of FTXPOST extension disabled");
1338
1339   return 0;
1340 #endif
1341 }
1342
1343 /*
1344 =item i_tt_push_error(code)
1345
1346 Push an error message and code onto the Imager error stack.
1347
1348 =cut
1349 */
1350 static void
1351 i_tt_push_error(TT_Error rc) {
1352 #ifdef FTXERR18
1353   TT_String const *msg = TT_ErrToString18(rc);
1354
1355   i_push_error(rc, msg);
1356 #else
1357   i_push_errorf(rc, "Error code 0x%04x", (unsigned)rc);
1358 #endif
1359 }
1360
1361 #endif /* HAVE_LIBTT */
1362
1363
1364 /*
1365 =back
1366
1367 =head1 AUTHOR
1368
1369 Arnar M. Hrafnkelsson <addi@umich.edu>
1370
1371 =head1 SEE ALSO
1372
1373 Imager(3)
1374
1375 =cut
1376 */