freetype1/contrib/ttf2pk/ttflib.c

   1 /*
   2  *   ttflib.c
   3  *
   4  *   This file is part of the ttf2pk package.
   5  *
   6  *   Copyright 1997-1999 by
   7  *     Loyer Frederic <loyer@ensta.fr>
   8  *     Werner Lemberg <wl@gnu.org>
   9  */
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <math.h>       /* libc ANSI */
  15 #include <ctype.h>
  16
  17 #include "pklib.h"      /* for the `byte' type */
  18 #include "freetype.h"
  19 #include "ttfenc.h"
  20 #include "ttflib.h"
  21 #include "errormsg.h"
  22 #include "newobj.h"
  23 #include "ttf2tfm.h"
  24
  25 #include "extend/ftxpost.h"
  26 #include "extend/ftxopen.h"
  27
  28
  29 #define Macintosh_platform 1
  30 #define Macintosh_encoding 0
  31
  32 #define Microsoft_platform 3
  33 #define Microsoft_Symbol_encoding 0
  34 #define Microsoft_Unicode_encoding 1
  35
  36 #define SCRIPT_kana MAKE_TT_TAG('k', 'a', 'n', 'a')
  37 #define SCRIPT_hani MAKE_TT_TAG('h', 'a', 'n', 'i')
  38 #define SCRIPT_hang MAKE_TT_TAG('h', 'a', 'n', 'g')
  39
  40 #define LANGUAGE_JAN MAKE_TT_TAG('J', 'A', 'N', ' ')
  41 #define LANGUAGE_CHN MAKE_TT_TAG('C', 'H', 'N', ' ')
  42 #define LANGUAGE_KOR MAKE_TT_TAG('K', 'O', 'R', ' ')
  43
  44 #define FEATURE_vert MAKE_TT_TAG('v', 'e', 'r', 't')
  45
  46
  47 TT_Engine   engine;
  48 TT_Face     face;
  49 TT_Instance instance;
  50 TT_Glyph    glyph;
  51 TT_CharMap  char_map;
  52
  53 TT_Outline         outline;
  54 TT_Face_Properties properties;
  55 TT_BBox            bbox;
  56
  57 TT_Post post;
  58
  59 TT_Raster_Map Bit, Bit2;
  60 void          *Bitp, *Bit2p;
  61
  62 int dpi;
  63 int ptsize;
  64
  65 int x_offset, y_offset;
  66 int ppem;
  67
  68 TT_Big_Glyph_Metrics metrics;
  69
  70 TT_Matrix matrix1, matrix2;
  71
  72 TTO_GSUBHeader  gsub_;
  73 TTO_GSUBHeader  *gsub;
  74
  75 TT_UShort in_string[2];
  76 TTO_GSUB_String in, out;
  77
  78 Boolean has_gsub;
  79
  80
  81 static void
  82 SetRasterArea(int quiet)
  83 {
  84   int temp1_x, temp1_y, temp2_x, temp2_y;
  85
  86
  87   temp1_x = bbox.xMin / 64;         /* scaling F16.6 -> int */
  88   temp1_y = bbox.yMin / 64;
  89   temp2_x = (bbox.xMax + 63) / 64;
  90   temp2_y = (bbox.yMax + 63) / 64;
  91
  92   x_offset = 5 - temp1_x;
  93   y_offset = 5 - temp1_y;
  94
  95   if (!quiet)
  96     printf("  off = (%d, %d)", x_offset, y_offset);
  97
  98 #if 0
  99   x_offset = y_offset = 0;
 100 #endif
 101
 102   if (!quiet)
 103     printf("  bbox = (%d, %d) <->  (%d, %d)\n",
 104            temp1_x, temp1_y, temp2_x, temp2_y);
 105
 106   Bit.rows = temp2_y - temp1_y + 10;
 107   Bit.width = temp2_x - temp1_x + 10;
 108
 109   Bit.cols = (Bit.width + 7) / 8;       /* convert to # of bytes */
 110   Bit.flow = TT_Flow_Up;
 111   Bit.size = Bit.rows * Bit.cols;       /* number of bytes in buffer */
 112
 113   /*
 114    *   We allocate one more row to have valid pointers for comparison
 115    *   purposes in pklib.c, making `gcc -fbounds-checking' happy.
 116    */
 117
 118   if (Bitp)
 119     free(Bitp);
 120   Bitp = mymalloc(Bit.size + Bit.cols);
 121   Bit.bitmap = Bitp;
 122
 123   Bit2 = Bit;
 124
 125   if (Bit2p)
 126     free(Bit2p);
 127   Bit2p = mymalloc(Bit.size + Bit.cols);
 128   Bit2.bitmap = Bit2p;
 129 }
 130
 131
 132 static void
 133 FlipBit(void)
 134 {
 135   int y;
 136   char *p1, *p2;
 137
 138   p1 = (char *)Bit.bitmap;
 139   p2 = (char *)Bit2.bitmap + Bit2.cols * (Bit2.rows - 1);
 140
 141   for (y = 0; y < Bit.rows; y++)
 142   {
 143     memcpy(p2, p1, Bit.cols);
 144     p1 += Bit.cols;
 145     p2 -= Bit.cols;
 146   }
 147 }
 148
 149
 150 #if 0
 151
 152 static void
 153 Output(TT_Raster_Map Bit)
 154 {
 155   int x;
 156   int y;
 157   int i;
 158
 159   char *p, b;
 160
 161
 162   p = Bit.bitmap;
 163   printf("====\n");
 164
 165   for (y = 0; y < Bit.rows; y++)
 166   {
 167     printf("%3d:", y);
 168     for (x = 0; x < Bit.cols; x++)
 169     {
 170       b = *p++;
 171       for(i = 0x80; i; i >>= 1)
 172         printf((b & i) ? "x" : ".");
 173     }
 174     printf("\n");
 175   }
 176 }
 177
 178 #endif /* 0 */
 179
 180
 181 void
 182 TTFopen(char *filename, Font *fnt, int new_dpi, int new_ptsize, Boolean quiet)
 183 {
 184   unsigned short i, num_cmap;
 185   unsigned short cmap_plat;
 186   unsigned short cmap_enc;
 187   TT_Error error;
 188
 189   TT_UShort script_index, language_index, feature_index;
 190   TT_UShort req_feature_index = 0xFFFF;
 191
 192
 193   dpi = new_dpi;
 194   ptsize = new_ptsize;
 195
 196   if ((error = TT_Init_FreeType(&engine)))
 197     oops("Cannot initialize FreeType engine (error code = 0x%x).", error);
 198
 199   if (fnt->PSnames)
 200     if ((error = TT_Init_Post_Extension(engine)))
 201       oops("Cannot initialize PS name support (error code = 0x%x).", error);
 202
 203   if (fnt->rotate)
 204     if ((error = TT_Init_GSUB_Extension(engine)))
 205       oops("Cannot initialize GSUB support (error code = 0x%x).", error);
 206
 207   /*
 208    *   Load face.
 209    */
 210
 211   error = TT_Open_Face(engine, filename, &face);
 212   if (error)
 213     oops("Cannot open `%s'.", filename);
 214
 215   /*
 216    *   Get face properties and allocate preloaded arrays.
 217    */
 218
 219   TT_Get_Face_Properties(face, &properties);
 220
 221   /*
 222    *   Now we try to open the proper font in a collection.
 223    */
 224
 225   if (fnt->fontindex != 0)
 226   {
 227     if (properties.num_Faces == 1)
 228       warning("This isn't a TrueType collection.\n"
 229               "Parameter `Fontindex' is ignored.");
 230     else
 231     {
 232       TT_Close_Face(face);
 233       if ((error = TT_Open_Collection(engine, filename,
 234                                       fnt->fontindex, &face)))
 235         oops("Cannot open font %lu in TrueType Collection `%s'.",
 236              fnt->fontindex, filename);
 237     }
 238   }
 239
 240   /*
 241    *   Create instance.
 242    */
 243
 244   if ((error = TT_New_Instance(face, &instance)))
 245     oops("Cannot create instance for `%s' (error code = 0x%x).",
 246          filename, error);
 247
 248   if ((error = TT_Set_Instance_Resolutions(instance, dpi, dpi)))
 249     oops("Cannot set device resolutions (error code = 0x%x).");
 250
 251   if ((error = TT_Set_Instance_CharSize(instance, ptsize * 64)))
 252     oops("Cannot set character size (error code = 0x%x).", error);
 253
 254   ppem = (dpi * ptsize + 36) / 72;
 255
 256   if (!quiet)
 257     printf("dpi = %d, ptsize = %d, ppem = %d\n\n", dpi, ptsize, ppem);
 258
 259   matrix1.xx = (TT_Fixed)(floor(fnt->efactor * 1024) * (1<<16)/1024);
 260   matrix1.xy = (TT_Fixed)(floor(fnt->slant * 1024) * (1<<16)/1024);
 261   matrix1.yx = (TT_Fixed)0;
 262   matrix1.yy = (TT_Fixed)(1<<16);
 263
 264   if (fnt->rotate)
 265   {
 266     matrix2.xx = 0;
 267     matrix2.yx = 1L << 16;
 268     matrix2.xy = -matrix2.yx;
 269     matrix2.yy = matrix2.xx;
 270   }
 271
 272   if ((error = TT_Set_Instance_Transform_Flags(
 273                  instance,
 274                  fnt->rotate ? 1 : 0,
 275                  fnt->efactor != 1.0 ? 1 : 0)))
 276     oops("Cannot set transform flags (error code = 0x%x).", error);
 277
 278   /*
 279    *   Create glyph container.
 280    */
 281
 282   if ((error = TT_New_Glyph(face, &glyph)))
 283     oops("Cannot create glyph container (error code = 0x%x).");
 284
 285   if (fnt->PSnames != Only)
 286   {
 287     num_cmap = properties.num_CharMaps;
 288     for (i = 0; i < num_cmap; i++)
 289     {
 290       if ((error = TT_Get_CharMap_ID(face, i, &cmap_plat, &cmap_enc)))
 291         oops("Cannot query cmap (error code = 0x%x).", error);
 292       if (cmap_plat == fnt->pid && cmap_enc == fnt->eid)
 293         break;
 294     }
 295     if (i == num_cmap)
 296       oops("Invalid platform and/or encoding ID.");
 297
 298     if ((error = TT_Get_CharMap(face, i, &char_map)))
 299       oops("Cannot load cmap (error code = 0x%x).", error);
 300   }
 301
 302   if (fnt->PSnames)
 303   {
 304     if ((error = TT_Load_PS_Names(face, &post)))
 305       oops("Cannot load TrueType PS names (error code = 0x%x).", error);
 306   }
 307   else if (cmap_plat == Microsoft_platform &&
 308            cmap_enc == Microsoft_Unicode_encoding)
 309     set_encoding_scheme(encUnicode, fnt);
 310   else if (cmap_plat == Macintosh_platform &&
 311            cmap_enc == Macintosh_encoding)
 312     set_encoding_scheme(encMac, fnt);
 313   else
 314     set_encoding_scheme(encFontSpecific, fnt);
 315
 316   if (fnt->rotate)
 317   {
 318     gsub = &gsub_;
 319
 320     error = TT_Load_GSUB_Table(face, gsub, NULL);
 321     if (!error)
 322       has_gsub = True;
 323     else if (error != TT_Err_Table_Missing)
 324       warning("Cannot load GSUB table (error code = 0x%x).", error);
 325     else
 326       warning("No GSUB data available "
 327               "for vertical glyph presentation forms.");
 328
 329     /* we check for the `vert' feature in Chinese, Japanese, and Korean */
 330
 331     error = TT_GSUB_Select_Script(gsub,
 332                                   SCRIPT_kana,
 333                                   &script_index);
 334     if (error)
 335       goto check_hani;
 336     error = TT_GSUB_Select_Feature(gsub,
 337                                    FEATURE_vert,
 338                                    script_index,
 339                                    0xFFFF,
 340                                    &feature_index);
 341     if (error)
 342     {
 343       error = TT_GSUB_Select_Language(gsub,
 344                                       LANGUAGE_JAN,
 345                                       script_index,
 346                                       &language_index,
 347                                       &req_feature_index);
 348       if (error)
 349         goto check_hani;
 350       error = TT_GSUB_Select_Feature(gsub,
 351                                      FEATURE_vert,
 352                                      script_index,
 353                                      language_index,
 354                                      &feature_index);
 355       if (error)
 356         goto check_hani;
 357       else
 358         goto Done;
 359     }
 360     else
 361       goto Done;
 362
 363   check_hani:
 364     error = TT_GSUB_Select_Script(gsub,
 365                                   SCRIPT_hani,
 366                                   &script_index);
 367     if (error)
 368       goto check_hang;
 369     error = TT_GSUB_Select_Feature(gsub,
 370                                    FEATURE_vert,
 371                                    script_index,
 372                                    0xFFFF,
 373                                    &feature_index);
 374     if (error)
 375     {
 376       error = TT_GSUB_Select_Language(gsub,
 377                                       LANGUAGE_CHN,
 378                                       script_index,
 379                                       &language_index,
 380                                       &req_feature_index);
 381       if (error)
 382         goto check_hang;
 383       error = TT_GSUB_Select_Feature(gsub,
 384                                      FEATURE_vert,
 385                                      script_index,
 386                                      language_index,
 387                                      &feature_index);
 388       if (error)
 389         goto check_hang;
 390       else
 391         goto Done;
 392     }
 393     else
 394       goto Done;
 395
 396   check_hang:
 397     error = TT_GSUB_Select_Script(gsub,
 398                                   SCRIPT_hang,
 399                                   &script_index);
 400     if (error)
 401       goto Done;
 402     error = TT_GSUB_Select_Feature(gsub,
 403                                    FEATURE_vert,
 404                                    script_index,
 405                                    0xFFFF,
 406                                    &feature_index);
 407     if (error)
 408     {
 409       error = TT_GSUB_Select_Language(gsub,
 410                                       LANGUAGE_KOR,
 411                                       script_index,
 412                                       &language_index,
 413                                       &req_feature_index);
 414       if (error)
 415         goto Done;
 416       error = TT_GSUB_Select_Feature(gsub,
 417                                      FEATURE_vert,
 418                                      script_index,
 419                                      language_index,
 420                                      &feature_index);
 421     }
 422
 423   Done:
 424     if (error)
 425     {
 426       warning("There is no data for vertical typesetting in GSUB table.");
 427       has_gsub = False;
 428     }
 429
 430     if (req_feature_index != 0xFFFF)
 431       TT_GSUB_Add_Feature(gsub, req_feature_index, ALL_GLYPHS);
 432     TT_GSUB_Add_Feature(gsub, feature_index, ALL_GLYPHS);
 433
 434     in.length = 1;
 435     in.pos = 0;
 436     in.string = in_string;
 437     in.properties = NULL;
 438
 439     out.pos = 0;
 440     out.allocated = 0;
 441     out.string = NULL;
 442     out.properties = NULL;
 443   }
 444 }
 445
 446
 447 static TT_Error
 448 LoadTrueTypeChar(Font *fnt,
 449                  int idx,
 450                  Boolean hint,
 451                  Boolean quiet)
 452 {
 453   TT_Error error;
 454   int flags;
 455
 456
 457   flags = TTLOAD_SCALE_GLYPH;
 458   if (hint)
 459     flags |= TTLOAD_HINT_GLYPH;
 460
 461   error = TT_Load_Glyph(instance, glyph, idx, flags);
 462   if (!error)
 463     error = TT_Get_Glyph_Big_Metrics(glyph, &metrics);
 464   if (!error)
 465     error = TT_Get_Glyph_Outline(glyph, &outline);
 466   if (!error)
 467   {
 468     if (fnt->efactor != 1.0 || fnt->slant != 0.0 )
 469       TT_Transform_Outline(&outline, &matrix1);
 470     if (fnt->rotate)
 471       TT_Transform_Outline(&outline, &matrix2);
 472   }
 473   if (!error)
 474     error = TT_Get_Outline_BBox(&outline, &bbox); /* we need the non-
 475                                                      grid-fitted bbox */
 476   if (fnt->rotate)
 477     TT_Translate_Outline(&outline,
 478                          metrics.vertBearingY - bbox.xMin,
 479                          -fnt->y_offset * ppem * 64);
 480   if (!error)
 481     error = TT_Get_Outline_BBox(&outline, &bbox);
 482   if (!error)
 483     SetRasterArea(quiet);
 484   return error;
 485 }
 486
 487
 488 Boolean
 489 TTFprocess(Font *fnt,
 490            long Code,
 491            byte **bitmap,
 492            int *width, int *height,
 493            int *hoff, int *voff,
 494            Boolean hinting,
 495            Boolean quiet)
 496 {
 497   int Num;
 498   TT_Error error;
 499
 500
 501   if (!bitmap || !width || !height || !hoff || !voff)
 502     oops("Invalid parameter in call to TTFprocess()");
 503
 504   if (Code >= 0x10000)
 505     Num = Code & 0xFFFF;
 506   else
 507   {
 508     Num = TT_Char_Index(char_map, Code);
 509     if (has_gsub)
 510     {
 511       in_string[0] = Num;
 512       error = TT_GSUB_Apply_String(gsub, &in, &out);
 513       if (error && error != TTO_Err_Not_Covered)
 514         warning("Cannot get the vertical glyph form for glyph index %d.",
 515                 Num);
 516       else
 517         Num = out.string[0];
 518     }
 519   }
 520
 521   if ((error = LoadTrueTypeChar(fnt, Num, hinting, quiet)) == TT_Err_Ok)
 522   {
 523     memset(Bit.bitmap, 0, Bit.size);
 524     TT_Get_Glyph_Bitmap(glyph, &Bit, x_offset * 64, y_offset * 64);
 525
 526     FlipBit();
 527     *bitmap = Bit2.bitmap;
 528     *width = Bit2.width;
 529     *height = Bit2.rows;
 530     *hoff = x_offset;
 531     *voff = y_offset;
 532     /* *voff = Bit2.rows - y_offset;    */
 533     /* printf("%D %d\n", *hoff, *voff); */
 534     /* Output(Bit2);                    */
 535     return True;
 536   }
 537   else
 538     return False;
 539 }
 540
 541
 542 /*
 543  *   We collect first all glyphs addressed via the cmap.  Then we fill the
 544  *   array up with glyphs not in the cmap.
 545  *
 546  *   If PSnames is set to `Only', we get the first 256 glyphs which have
 547  *   names different from `.notdef', `.null', and `nonmarkingreturn'.
 548  *
 549  *   For nicer output, we return the glyph names in an encoding array.
 550  */
 551
 552 encoding *
 553 TTFget_first_glyphs(Font *fnt, long *array)
 554 {
 555   unsigned int i, j, Num;
 556   unsigned int index_array[257];     /* we ignore glyph index 0 */
 557   char *n;
 558   encoding *e = (encoding *)mymalloc(sizeof (encoding));
 559
 560
 561   if (!array)
 562     oops("Invalid parameter in call to TTFget_first_glyphs()");
 563
 564   for (i = 0; i < 257; i++)
 565     index_array[i] = 0;
 566
 567   j = 0;
 568   if (fnt->PSnames != Only)
 569   {
 570     for (i = 0; i <= 0xFFFF; i++)
 571     {
 572       Num = TT_Char_Index(char_map, i);
 573       if (Num < 0)
 574         oops("cmap mapping failure.");
 575       if (Num == 0)
 576         continue;
 577       if (Num <= 256)
 578         index_array[Num] = 1;
 579
 580       if (fnt->PSnames)
 581         (void)TT_Get_PS_Name(face, Num, &n);
 582       else
 583         n = code_to_adobename(i);
 584       if (strcmp(n, ".notdef") == 0)
 585         continue;
 586       if (strcmp(n, ".null") == 0)
 587         continue;
 588       if (strcmp(n, "nonmarkingreturn") == 0)
 589         continue;
 590
 591       if (j < 256)
 592       {
 593         array[j] = i;
 594         e->vec[j] = n;
 595       }
 596       else
 597         return e;
 598       j++;
 599     }
 600
 601     if (!fnt->PSnames)
 602     {
 603       for (i = 1; i < properties.num_Glyphs; i++)
 604       {
 605         if (index_array[i] == 0)
 606         {
 607           if (j < 256)
 608           {
 609             array[j] = i | 0x10000;
 610             e->vec[j] = code_to_adobename(i | 0x10000);
 611           }
 612           else
 613             return e;
 614           j++;
 615         }
 616       }
 617     }
 618   }
 619   else
 620   {
 621     for (i = 0; i < properties.num_Glyphs; i++)
 622     {
 623       char *n;
 624
 625
 626       (void)TT_Get_PS_Name(face, i, &n);
 627
 628       if (strcmp(n, ".notdef") == 0)
 629         continue;
 630       if (strcmp(n, ".null") == 0)
 631         continue;
 632       if (strcmp(n, "nonmarkingreturn") == 0)
 633         continue;
 634
 635       if (j < 256)
 636       {
 637         array[j] = i | 0x10000;
 638         e->vec[j] = n;
 639       }
 640       else
 641         return e;
 642       j++;
 643     }
 644   }
 645
 646   return NULL;              /* never reached */
 647 }
 648
 649
 650 /*
 651  *   This routine fills `array' with the subfont character codes;
 652  *   additionally, it tests for valid glyph indices.
 653  */
 654
 655 void
 656 TTFget_subfont(Font *fnt, long *array)
 657 {
 658   int i, j, Num;
 659
 660
 661   if (!fnt || !array)
 662     oops("Invalid parameter in call to TTFget_subfont()");
 663
 664   for (i = 0; i <= 0xFF; i++)
 665   {
 666     j = fnt->sf_code[i];
 667
 668     if (j < 0)
 669       array[i] = j;
 670     else
 671     {
 672       Num = TT_Char_Index(char_map, j);
 673       if (Num < 0)
 674         oops("cmap mapping failure.");
 675       else
 676         array[i] = j;
 677     }
 678   }
 679 }
 680
 681
 682 long
 683 TTFsearch_PS_name(char *name)
 684 {
 685   unsigned int i;
 686   char *n;
 687
 688
 689   for (i = 0; i < properties.num_Glyphs; i++)
 690   {
 691     TT_Get_PS_Name(face, i, &n);
 692     if (strcmp(name, n) == 0)
 693       break;
 694   }
 695
 696   if (i == properties.num_Glyphs)
 697     return -1L;
 698   else
 699     return (long)i;
 700 }
 701
 702
 703 /* end */