freetype1/contrib/ttf2pk/pklib.c

   1 /*
   2  *   pklib.c
   3  *
   4  *   This file is part of the ttf2pk package.
   5  *
   6  *   Copyright 1997-1999 by
   7  *     Frederic Loyer <loyer@ensta.fr>
   8  *     Werner Lemberg <wl@gnu.org>
   9  */
  10
  11 /*
  12  *   This code has been derived from the program gsftopk.
  13  *   Here the original copyright.
  14  */
  15
  16 /*
  17  * Copyright (c) 1994 Paul Vojta.  All rights reserved.
  18  *
  19  * Redistribution and use in source and binary forms, with or without
  20  * modification, are permitted provided that the following conditions
  21  * are met:
  22  * 1. Redistributions of source code must retain the above copyright
  23  *    notice, this list of conditions and the following disclaimer.
  24  * 2. Redistributions in binary form must reproduce the above copyright
  25  *    notice, this list of conditions and the following disclaimer in the
  26  *    documentation and/or other materials provided with the distribution.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  38  * SUCH DAMAGE.
  39  */
  40
  41
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <stddef.h>         /* for size_t */
  45 #include <string.h>
  46 #include <errno.h>
  47 #include <ctype.h>
  48
  49 #include "newobj.h"
  50 #include "pklib.h"
  51 #include "errormsg.h"
  52 #include "filesrch.h"
  53
  54 #ifndef MAXPATHLEN
  55 #define MAXPATHLEN 256
  56 #endif
  57
  58 #define PK_PRE  (char)247
  59 #define PK_ID   89
  60 #define PK_POST (char)245
  61 #define PK_NOP  (char)246
  62
  63 int dpi;
  64
  65 FILE *pk_file;
  66
  67
  68 /*
  69  *   Information from the .tfm file.
  70  */
  71
  72 int tfm_lengths[12];
  73
  74 #define lh tfm_lengths[1]
  75 #define bc tfm_lengths[2]
  76 #define ec tfm_lengths[3]
  77 #define nw tfm_lengths[4]
  78
  79 long checksum;
  80 long design;
  81 byte width_index[256];
  82 long tfm_widths[256];
  83
  84 /*
  85  *   Information on the bitmap currently being worked on.
  86  */
  87
  88 byte   *bitmap;
  89 int    width;
  90 int    skip;
  91 int    height;
  92 int    hoff;
  93 int    voff;
  94 int    bytes_wide;
  95 size_t bm_size;
  96 byte   *bitmap_end;
  97 int    pk_len;
  98
  99 /*
 100  *   Here's the path searching stuff.  First the typedefs and variables.
 101  */
 102
 103 static char searchpath[MAXPATHLEN + 1];
 104
 105 #define HUNKSIZE (MAXPATHLEN + 2)
 106
 107 struct spacenode                /* used for storage of directory names */
 108 {
 109   struct spacenode *next;
 110   char             *sp_end;     /* end of data for this chunk */
 111   char             sp[HUNKSIZE];
 112 } firstnode;
 113
 114
 115
 116 static FILE *
 117 search_tfm(char **name)
 118 {
 119   char *p;
 120   FILE *f;
 121
 122
 123   p = TeX_search_tfm(name);
 124   if (p == NULL)
 125     return NULL;
 126   strcpy(searchpath, p);
 127   f = fopen(searchpath, "rb");
 128   return f;
 129 }
 130
 131
 132 static long
 133 getlong(FILE *f)
 134 {
 135   unsigned long value;
 136
 137
 138   value  = (unsigned long)getc(f) << 24;
 139   value |= (unsigned long)getc(f) << 16;
 140   value |= (unsigned long)getc(f) << 8;
 141   value |= (unsigned long)getc(f);
 142   return value;
 143 }
 144
 145
 146 char line[82];
 147
 148
 149 static byte masks[] = {0, 1, 3, 7, 017, 037, 077, 0177, 0377};
 150
 151 byte flag;
 152 int pk_dyn_f;
 153 int pk_dyn_g;
 154 int base;          /* cost of this character if pk_dyn_f = 0 */
 155 int deltas[13];    /* cost of increasing pk_dyn_f from i to i+1 */
 156
 157
 158 /*
 159  *   Add up statistics for putting out the given shift count.
 160  */
 161
 162 static void
 163 tallyup(int n)
 164 {
 165   int m;
 166
 167
 168   if (n > 208)
 169   {
 170     ++base;
 171     n -= 192;
 172     for (m = 0x100; m != 0 && m < n; m <<= 4)
 173       base += 2;
 174     if (m != 0 && (m = (m - n) / 15) < 13)
 175       deltas[m] += 2;
 176   }
 177   else if (n > 13)
 178     ++deltas[(208 - n) / 15];
 179   else
 180     --deltas[n - 1];
 181 }
 182
 183
 184 /*
 185  *   Routines for storing the shift counts.
 186  */
 187
 188 static Boolean odd = False;
 189 static byte part;
 190
 191
 192 static void
 193 pk_put_nyb(int n)
 194 {
 195   if (odd)
 196   {
 197     *bitmap_end++ = (part << 4) | n;
 198     odd = False;
 199   }
 200   else
 201   {
 202     part = n;
 203     odd = True;
 204   }
 205 }
 206
 207
 208 static void
 209 pk_put_long(int n)
 210 {
 211   if (n >= 16)
 212   {
 213     pk_put_nyb(0);
 214     pk_put_long(n / 16);
 215   }
 216   pk_put_nyb(n % 16);
 217 }
 218
 219
 220 static void
 221 pk_put_count(int n)
 222 {
 223   if (n > pk_dyn_f)
 224   {
 225     if (n > pk_dyn_g)
 226       pk_put_long(n - pk_dyn_g + 15);
 227     else
 228     {
 229       pk_put_nyb(pk_dyn_f + (n - pk_dyn_f + 15) / 16);
 230       pk_put_nyb((n - pk_dyn_f - 1) % 16);
 231     }
 232   }
 233   else
 234     pk_put_nyb(n);
 235 }
 236
 237
 238 static void
 239 trim_bitmap(void)
 240 {
 241   byte *p;
 242   byte mask;
 243
 244
 245   /* clear out garbage bits in bitmap */
 246
 247   if (width % 8 != 0)
 248   {
 249     mask = ~masks[8 - width % 8];
 250     for (p = bitmap + bytes_wide - 1; p < bitmap_end; p += bytes_wide)
 251       *p &= mask;
 252   }
 253
 254   /* Find the bounding box of the bitmap. */
 255
 256   /* trim top */
 257
 258   skip = 0;
 259   mask = 0;
 260
 261   for (;;)
 262   {
 263     if (bitmap >= bitmap_end)   /* if bitmap is empty */
 264     {
 265       width = height = hoff = voff = 0;
 266       return;
 267     }
 268
 269     p = bitmap + bytes_wide;
 270     while (p > bitmap)
 271       mask |= *--p;
 272     if (mask)
 273       break;
 274     ++skip;
 275     bitmap += bytes_wide;
 276   }
 277
 278   height -= skip;
 279   voff -= skip;
 280
 281 #ifdef  DEBUG
 282   if (skip < 2 || skip > 3)
 283     printf("Character has %d empty rows at top\n", skip);
 284 #endif
 285
 286   /* trim bottom */
 287
 288   skip = 0;
 289   mask = 0;
 290
 291   for (;;)
 292   {
 293     p = bitmap_end - bytes_wide;
 294     while (p < bitmap_end)
 295       mask |= *p++;
 296     if (mask)
 297       break;
 298     ++skip;
 299     bitmap_end -= bytes_wide;
 300   }
 301
 302   height -= skip;
 303
 304 #ifdef  DEBUG
 305   if (skip < 2 || skip > 3)
 306     printf("Character has %d empty rows at bottom\n", skip);
 307 #endif
 308
 309   /* trim right */
 310
 311   skip = 0;
 312   --width;
 313
 314   for (;;)
 315   {
 316     mask = 0;
 317     for (p = bitmap + width / 8; p < bitmap_end; p += bytes_wide)
 318       mask |= *p;
 319     if (mask & (0x80 >> (width % 8)))
 320       break;
 321
 322     --width;
 323     ++skip;
 324   }
 325
 326   ++width;
 327
 328 #ifdef  DEBUG
 329   if (skip < 2 || skip > 3)
 330     printf("Character has %d empty columns at right\n", skip);
 331 #endif
 332
 333   /* trim left */
 334
 335   skip = 0;
 336
 337   for (;;)
 338   {
 339     mask = 0;
 340     for (p = bitmap + skip / 8; p < bitmap_end; p += bytes_wide)
 341       mask |= *p;
 342     if (mask & (0x80 >> (skip % 8)))
 343       break;
 344
 345     ++skip;
 346   }
 347
 348   width -= skip;
 349   hoff -= skip;
 350
 351 #ifdef  DEBUG
 352   if (skip < 2 || skip > 3)
 353     printf("Character has %d empty columns at left\n", skip);
 354 #endif
 355
 356   bitmap += skip / 8;
 357   skip = skip % 8;
 358 }
 359
 360
 361 /*
 362  *   Pack the bitmap using the rll method.  (Return false if it's better
 363  *   to just pack the bits.)
 364  */
 365
 366 static Boolean
 367 pk_rll_cvt(void)
 368 {
 369   static int   *counts   = NULL; /* area for saving bit counts */
 370   static int   maxcounts = 0;    /* size of this area */
 371   unsigned int ncounts;          /* max to allow this time */
 372   int          *nextcount;       /* next count value */
 373
 374   int  *counts_end;              /* pointer to end */
 375   byte *rowptr;
 376   byte *p;
 377   byte mask;
 378   byte *rowdup;                  /* last row checked for dup */
 379   byte paint_switch;             /* 0 or 0xff */
 380   int  bits_left;                /* bits left in row */
 381   int  cost;
 382   int  i;
 383
 384
 385   /* Allocate space for bit counts. */
 386
 387   ncounts = (width * height + 3) / 4;
 388   if (ncounts > maxcounts)
 389   {
 390     if (counts != NULL)
 391       free(counts);
 392     counts = (int *)mymalloc((ncounts + 2) * sizeof (int));
 393     maxcounts = ncounts;
 394   }
 395   counts_end = counts + ncounts;
 396
 397   /* Form bit counts and collect statistics */
 398
 399   base = 0;
 400   memset(deltas, 0, sizeof (deltas));
 401   rowdup = NULL;                    /* last row checked for duplicates */
 402   p = rowptr = bitmap;
 403   mask = 0x80 >> skip;
 404   flag = 0;
 405   paint_switch = 0;
 406
 407   if (*p & mask)
 408   {
 409     flag = 8;
 410     paint_switch = 0xff;
 411   }
 412
 413   bits_left = width;
 414   nextcount = counts;
 415
 416   while (rowptr < bitmap_end)       /* loop over shift counts */
 417   {
 418     int shift_count = bits_left;
 419
 420
 421     for (;;)
 422     {
 423       if (bits_left == 0)
 424       {
 425         if ((p = rowptr += bytes_wide) >= bitmap_end)
 426           break;
 427         mask = 0x80 >> skip;
 428         bits_left = width;
 429         shift_count += width;
 430       }
 431       if (((*p ^ paint_switch) & mask) != 0)
 432         break;
 433       --bits_left;
 434       mask >>= 1;
 435       if (mask == 0)
 436       {
 437         ++p;
 438         while (*p == paint_switch && bits_left >= 8)
 439         {
 440           ++p;
 441           bits_left -= 8;
 442         }
 443         mask = 0x80;
 444       }
 445     }
 446
 447     if (nextcount >= counts_end)
 448       return False;
 449     shift_count -= bits_left;
 450     *nextcount++ = shift_count;
 451     tallyup(shift_count);
 452
 453     /* check for duplicate rows */
 454     if (rowptr != rowdup && bits_left != width)
 455     {
 456       byte *p1 = rowptr;
 457       byte *q  = rowptr + bytes_wide;
 458       int repeat_count;
 459
 460
 461       while (q < bitmap_end && *p1 == *q)
 462       {
 463         ++p1;
 464         ++q;
 465       }
 466       repeat_count = (p1 - rowptr) / bytes_wide;
 467       if (repeat_count > 0)
 468       {
 469         *nextcount++ = -repeat_count;
 470         if (repeat_count == 1)
 471           --base;
 472         else
 473         {
 474           ++base;
 475           tallyup(repeat_count);
 476         }
 477         rowptr += repeat_count * bytes_wide;
 478       }
 479       rowdup = rowptr;
 480     }
 481     paint_switch = ~paint_switch;
 482   }
 483
 484 #ifdef  DEBUG
 485   /*
 486    *      Dump the bitmap
 487    */
 488
 489   for (p = bitmap; p < bitmap_end; p += bytes_wide)
 490   {
 491     byte *p1 = p;
 492     int j;
 493
 494
 495     mask = 0x80 >> skip;
 496     for (j = 0; j < width; ++j)
 497     {
 498       putchar(*p1 & mask ? '@' : '.');
 499       if ((mask >>= 1) == 0)
 500       {
 501         mask = 0x80;
 502         ++p1;
 503       }
 504     }
 505     putchar('\n');
 506   }
 507   putchar('\n');
 508 #endif
 509
 510   /* Determine the best pk_dyn_f */
 511
 512   pk_dyn_f = 0;
 513   cost = base += 2 * (nextcount - counts);
 514
 515   for (i = 1; i < 14; ++i)
 516   {
 517     base += deltas[i - 1];
 518     if (base < cost)
 519     {
 520       pk_dyn_f = i;
 521       cost = base;
 522     }
 523   }
 524
 525   /* last chance to bail out */
 526
 527   if (cost * 4 > width * height)
 528     return False;
 529
 530   /* Pack the bit counts */
 531
 532   pk_dyn_g = 208 - 15 * pk_dyn_f;
 533   flag |= pk_dyn_f << 4;
 534   bitmap_end = bitmap;
 535   *nextcount = 0;
 536   nextcount = counts;
 537
 538   while (*nextcount != 0)
 539   {
 540     if (*nextcount > 0)
 541       pk_put_count(*nextcount);
 542     else
 543       if (*nextcount == -1)
 544         pk_put_nyb(15);
 545       else
 546       {
 547         pk_put_nyb(14);
 548         pk_put_count(-*nextcount);
 549       }
 550       ++nextcount;
 551   }
 552
 553   if (odd)
 554   {
 555     pk_put_nyb(0);
 556     ++cost;
 557   }
 558
 559   if (cost != 2 * (bitmap_end - bitmap))
 560     printf("Cost miscalculation:  expected %d, got %ld\n",
 561              cost, (long)(2 * (bitmap_end - bitmap)));
 562   pk_len = bitmap_end - bitmap;
 563   return True;
 564 }
 565
 566
 567 static void
 568 pk_bm_cvt(void)
 569 {
 570   byte *rowptr;
 571   byte *p;
 572   int  blib1;          /* bits left in byte */
 573   int  bits_left;      /* bits left in row */
 574   byte *q;
 575   int  blib2;
 576   byte nextbyte;
 577
 578
 579   flag = 14 << 4;
 580   q = bitmap;
 581   blib2 = 8;
 582   nextbyte = 0;
 583
 584   for (rowptr = bitmap; rowptr < bitmap_end; rowptr += bytes_wide)
 585   {
 586     p = rowptr;
 587     blib1 = 8 - skip;
 588     bits_left = width;
 589
 590     if (blib2 != 8)
 591     {
 592       int n;
 593
 594
 595       if (blib1 < blib2)
 596       {
 597         nextbyte |= *p << (blib2 - blib1);
 598         n = blib1;
 599       }
 600       else
 601       {
 602         nextbyte |= *p >> (blib1 - blib2);
 603         n = blib2;
 604       }
 605       blib2 -= n;
 606       if ((bits_left -= n) < 0)
 607       {
 608         blib2 -= bits_left;
 609         continue;
 610       }
 611       if ((blib1 -= n) == 0)
 612       {
 613         blib1 = 8;
 614         ++p;
 615         if (blib2 > 0)
 616         {
 617           nextbyte |= *p >> (8 - blib2);
 618           blib1 -= blib2;
 619           bits_left -= blib2;
 620           if (bits_left < 0)
 621           {
 622             blib2 = -bits_left;
 623             continue;
 624           }
 625         }
 626       }
 627       *q++ = nextbyte;
 628     }
 629
 630     /* fill up whole (destination) bytes */
 631
 632     while (bits_left >= 8)
 633     {
 634       nextbyte = *p++ << (8 - blib1);
 635       *q++ = nextbyte | (*p >> blib1);
 636       bits_left -= 8;
 637     }
 638
 639     /* now do the remainder */
 640
 641     nextbyte = *p << (8 - blib1);
 642     if (bits_left > blib1)
 643       nextbyte |= p[1] >> blib1;
 644     blib2 = 8 - bits_left;
 645   }
 646
 647   if (blib2 != 8)
 648     *q++ = nextbyte;
 649
 650   pk_len = q - bitmap;
 651 }
 652
 653
 654 static void
 655 putshort(short w)
 656 {
 657   putc(w >> 8, pk_file);
 658   putc(w, pk_file);
 659 }
 660
 661
 662 static void
 663 putmed(long w)
 664 {
 665   putc(w >> 16, pk_file);
 666   putc(w >> 8, pk_file);
 667   putc(w, pk_file);
 668 }
 669
 670
 671 static void
 672 putlong(long w)
 673 {
 674   putc(w >> 24, pk_file);
 675   putc(w >> 16, pk_file);
 676   putc(w >> 8, pk_file);
 677   putc(w, pk_file);
 678 }
 679
 680
 681 char
 682 xgetc(FILE *f)
 683 {
 684   int c;
 685
 686
 687   c = getc(f);
 688   if (c == EOF)
 689     oops("Premature end of file.");
 690   return (byte)c;
 691 }
 692
 693
 694 /*
 695  *   Open and read the tfm file.
 696  */
 697
 698 void
 699 TFMopen(char **filename)
 700 {
 701   FILE *tfm_file;
 702   int  i;
 703   int  cc;
 704
 705
 706   tfm_file = search_tfm(filename);
 707   if (tfm_file == NULL)
 708     oops("Cannot find tfm file.");
 709
 710   for (i = 0; i < 12; i++)
 711   {
 712     int j;
 713
 714
 715     j = (int)((byte)getc(tfm_file)) << 8;
 716     tfm_lengths[i] = j | (int)((byte)xgetc(tfm_file));
 717   }
 718
 719   checksum = getlong(tfm_file);
 720   design = getlong(tfm_file);
 721   fseek(tfm_file, 4 * (lh + 6), 0);
 722
 723   for (cc = bc; cc <= ec; ++cc)
 724   {
 725     width_index[cc] = (byte)xgetc(tfm_file);
 726
 727     (void)xgetc(tfm_file);
 728     (void)xgetc(tfm_file);
 729     (void)xgetc(tfm_file);
 730   }
 731
 732   for (i = 0; i < nw; ++i)
 733     tfm_widths[i] = getlong(tfm_file);
 734
 735   fclose(tfm_file);
 736 }
 737
 738
 739 /*
 740  *   Create pk file and write preamble.
 741  */
 742
 743 void
 744 PKopen(char *filename,
 745        char *ident,
 746        int resolution)
 747 {
 748   int ppp;
 749   int i;
 750
 751
 752   dpi = resolution;
 753
 754   if ((pk_file = fopen(filename, "wb")) == NULL)
 755   {
 756     perror(filename);
 757     exit(1);
 758   }
 759
 760   putc(PK_PRE, pk_file);
 761   putc(PK_ID, pk_file);
 762
 763   i = strlen(ident);
 764
 765   putc(i, pk_file);
 766   fwrite(ident, 1, i, pk_file);
 767   putlong(design);
 768   putlong(checksum);
 769   ppp = dpi / 72.27 * 65536.0 + 0.5;
 770   putlong(ppp);                         /* hppp */
 771   putlong(ppp);                         /* vppp */
 772 }
 773
 774
 775 void
 776 PKputglyph(int cc,
 777            int llx, int lly, int urx, int ury,
 778            int w, int h,
 779            byte *b)
 780 {
 781   float char_width;
 782
 783   long dm;
 784   long tfm_wid;
 785
 786
 787   bitmap = b;
 788   width = w;
 789   height = h;
 790
 791   hoff = -llx;
 792   voff = ury - 2; /* Don't ask me why `-2' */
 793                   /*   Fred                */
 794
 795   if (width != urx - llx || height != ury - lly)
 796     oops("Dimensions do not match:  (%d - %d) (%d - %d) <=> %d %d",
 797            llx, lly, urx, ury, width, height);
 798
 799   bytes_wide = (width + 7) / 8;
 800   bm_size = bytes_wide * height;
 801   bitmap_end = bitmap + bm_size;
 802
 803   trim_bitmap();
 804
 805   if (height == 0 || !pk_rll_cvt())
 806     pk_bm_cvt();
 807
 808   if (!width_index[cc])
 809     return;
 810
 811   tfm_wid = tfm_widths[width_index[cc]];
 812   char_width = tfm_wid / 1048576.0 * design / 1048576.0 * dpi / 72.27;
 813   dm = (long)(char_width + 0.5) - (char_width < -0.5);
 814
 815   if (pk_len + 8 < 4 * 256 && tfm_wid < (1<<24) &&
 816       dm >= 0 && dm < 256 && width < 256 && height < 256 &&
 817       hoff >= -128 && hoff < 128 && voff >= -128 && voff < 128)
 818   {
 819     putc(flag | ((pk_len + 8) >> 8), pk_file);
 820     putc(pk_len + 8, pk_file);
 821     putc(cc, pk_file);
 822     putmed(tfm_wid);
 823     putc(dm, pk_file);
 824     putc(width, pk_file);
 825     putc(height, pk_file);
 826     putc(hoff, pk_file);
 827     putc(voff, pk_file);
 828   }
 829   else if (pk_len + 13 < 3 * 65536L && tfm_wid < (1<<24) &&
 830            dm >= 0 && dm < 65536L && width < 65536L && height < 65536L &&
 831            hoff >= -65536L && hoff < 65536L &&
 832            voff >= -65536L && voff < 65536L)
 833   {
 834     putc(flag | 4 | ((pk_len + 13) >> 16), pk_file);
 835     putshort(pk_len + 13);
 836     putc(cc, pk_file);
 837     putmed(tfm_wid);
 838     putshort(dm);
 839     putshort(width);
 840     putshort(height);
 841     putshort(hoff);
 842     putshort(voff);
 843   }
 844   else
 845   {
 846     putc(flag | 7, pk_file);
 847     putlong(pk_len + 28);
 848     putlong(cc);
 849     putlong(tfm_wid);
 850     putlong((long)(char_width * 65536.0 + 0.5) - (char_width < -0.5));
 851     putlong(0);
 852     putlong(width);
 853     putlong(height);
 854     putlong(hoff);
 855     putlong(voff);
 856   }
 857   fwrite(bitmap, 1, pk_len, pk_file);
 858 }
 859
 860
 861 void
 862 PKclose(void)
 863 {
 864   putc(PK_POST, pk_file);
 865   while (ftell(pk_file) % 4 != 0)
 866     putc(PK_NOP, pk_file);
 867
 868   fclose(pk_file);
 869 }
 870
 871
 872 /* end */