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