home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume20 / hp2pk / part03 / writepk.c < prev   
C/C++ Source or Header  |  1991-06-02  |  19KB  |  707 lines
  1. /*  WRITEPK.C - Write data to a TeX PK font file
  2.  ***************************************************************************
  3.  *
  4.  *    void init_pk_file(fp, comment, dsize, density, pkp)
  5.  *    FILE *fp;
  6.  *    char *comment;
  7.  *    fixnum dsize;
  8.  *    int density;
  9.  *    struct pk_preamble *pkp;
  10.  *
  11.  *    void write_pk_character(fp, pkc, bmp)
  12.  *    FILE *fp;
  13.  *    struct pk_chardata *pkc;
  14.  *    struct character_bitmap *bmp;
  15.  *
  16.  *    void end_pk_file(fp)
  17.  *    FILE *fp;
  18.  *
  19.  ***************************************************************************
  20.  *
  21.  *    Source of information for TeX PK font files:
  22.  *
  23.  *        GFtoPK.WEB by Tomas Rokicki
  24.  *
  25.  ***************************************************************************
  26.  *    EDIT HISTORY
  27.  *    19-Oct-90    SRMc - split out from HP2PK.C to improve modularity
  28.  *    14-Jan-91    SRMc - add TURBO C patches from Thomas B. Ridgeway
  29.  *                (ridgeway@blackbox.hacc.washington.edu)
  30.  ***************************************************************************
  31.  * Copyright 1990, 1991 by the Summer Institute of Linguistics, Inc.
  32.  * All rights reserved.
  33.  */
  34. /*#define TURBO_C*/        /* uncomment if using MSDOS TURBO C */
  35. #include <stdio.h>
  36. #ifdef BSD
  37. extern int memcmp();
  38. extern char *memset(), *memcpy();
  39. #include <strings.h>
  40. #else
  41. #ifdef TURBO_C
  42. #include <mem.h>
  43. #define MSDOS
  44. #else
  45. #ifndef THINK_C        /* THINK C includes memxxx() functions in <string.h> */
  46. #include <memory.h>
  47. #endif
  48. #endif
  49. #include <string.h>
  50. #endif
  51. #include "pk.h"
  52. #include "bitmap.h"
  53.  
  54. #define END_OF_BITMAP    2    /* used in write_pk_character() */
  55.  
  56. /************************************************************************/
  57. /*               EXTERN DECLARATIONS                */
  58. /************************************************************************/
  59.  
  60. extern void exit();
  61.  
  62. /* from MYALLOC.C */
  63. extern char *myalloc(), *myrealloc();
  64. extern void myfree();
  65.  
  66. /* from BIGENDIO.C */
  67. extern void put_halfword(), put_3_bytes(), put_fullword();
  68.  
  69. /************************************************************************/
  70. /*            STATIC GLOBAL VARIABLES                */
  71. /************************************************************************/
  72. /*
  73.  *  powers of two (used in various computations)
  74.  */
  75. static unsigned long power[32] = {
  76.     0x00000001L, 0x00000002L, 0x00000004L, 0x00000008L,
  77.     0x00000010L, 0x00000020L, 0x00000040L, 0x00000080L,
  78.     0x00000100L, 0x00000200L, 0x00000400L, 0x00000800L,
  79.     0x00001000L, 0x00002000L, 0x00004000L, 0x00008000L, 
  80.     0x00010000L, 0x00020000L, 0x00040000L, 0x00080000L,
  81.     0x00100000L, 0x00200000L, 0x00400000L, 0x00800000L,
  82.     0x01000000L, 0x02000000L, 0x04000000L, 0x08000000L,
  83.     0x10000000L, 0x20000000L, 0x40000000L, 0x80000000L
  84.     };
  85. /*
  86.  *  globals for pk_nyb() output
  87.  */
  88. static short bit_weight;        /* either 1 or 16 */
  89. static unsigned char output_byte;    /* current stored value */
  90.  
  91. /****************************************************************************
  92.  * NAME
  93.  *    init_pk_file
  94.  * ARGUMENTS
  95.  *    fp      - output PK FILE pointer
  96.  *    comment - comment string for PK file
  97.  *    dsize   - font design size (fixed-point, 20-bit fraction)
  98.  *    density - dots per inch of the font bitmap
  99.  *    pkp     - pointer to PK file preamble structure
  100.  * DESCRIPTION
  101.  *    Fill in and write the header information for a .PK file.
  102.  * RETURN VALUE
  103.  *    none
  104.  */
  105. void init_pk_file(fp, comment, dsize, density, pkp)
  106. FILE *fp;
  107. char *comment;
  108. fixnum dsize;
  109. int density;
  110. struct pk_preamble *pkp;
  111. {
  112. int i;
  113. double d;
  114. /*
  115.  *  fill in the preamble
  116.  */
  117. pkp->preamble     = PK_PRE;
  118. pkp->ident        = PK_ID;
  119. pkp->comment_size = strlen(comment);
  120. memcpy( pkp->comment, comment, pkp->comment_size );
  121. pkp->designsize   = dsize;
  122. pkp->checksum     = 0L;
  123. d = (density / 72.27) * 65536.0;
  124. pkp->hppp         = d;
  125. pkp->vppp         = pkp->hppp;        /* assumes square pixels */
  126. /*
  127.  *  write the preamble
  128.  */
  129. putc(pkp->preamble, fp);
  130. putc(pkp->ident,    fp);
  131. putc(pkp->comment_size, fp);
  132. for ( i = 0 ; i < pkp->comment_size ; ++i )    /* one byte at a time */
  133.     putc( pkp->comment[i], fp);         /* ensures proper byte order */
  134. put_fullword(pkp->designsize, fp);
  135. put_fullword(pkp->checksum,   fp);
  136. put_fullword(pkp->hppp, fp);
  137. put_fullword(pkp->vppp, fp);
  138. }
  139.  
  140. /****************************************************************************
  141.  * MACRO NAME
  142.  *    ADD_BIT_COUNT
  143.  * ARGUMENTS
  144.  *    x - value to store in the bit_counts array
  145.  * DESCRIPTION
  146.  *    Add a value to the bit_counts array, increasing the array size if
  147.  *    necessary.
  148.  */
  149. #define ADD_BIT_COUNT(x) \
  150. if (current_bit_count == last_bit_count)\
  151.     { \
  152.     bit_counts = (int *)myrealloc((char *)bit_counts,\
  153.     (unsigned)((max_bit_counts_size+(pkc->pixel_height)) * sizeof(int)));\
  154.     current_bit_count = &bit_counts[max_bit_counts_size];\
  155.     max_bit_counts_size += (pkc->pixel_height);\
  156.     last_bit_count = &bit_counts[max_bit_counts_size];\
  157.     } \
  158. *current_bit_count++ = (x)
  159.  
  160. /****************************************************************************
  161.  * NAME
  162.  *    static pk_nyb
  163.  * ARGUMENTS
  164.  *    a  - 4-bit "nybble" for output
  165.  *    fp - output PK FILE pointer
  166.  * DESCRIPTION
  167.  *    Write a 4-bit "nybble" to the PK file, storing intermediate values in
  168.  *    output_byte and using bit_weight as a flag.
  169.  * RETURN VALUE
  170.  *    none
  171.  */
  172. static void pk_nyb(a,fp)
  173. unsigned char a;
  174. FILE *fp;
  175. {
  176. if (bit_weight == 16)
  177.     {
  178.     output_byte = (a << 4) & 0xF0;
  179.     bit_weight = 1;
  180.     }
  181. else
  182.     {
  183.     putc( (output_byte + (a & 0xF)) & 0xFF, fp);;
  184.     bit_weight = 16;
  185.     }
  186. }
  187.  
  188. /****************************************************************************
  189.  * NAME
  190.  *    write_pk_character
  191.  * ARGUMENTS
  192.  *    fp  - output PK FILE pointer
  193.  *    pkc - pointer to PK character data structure
  194.  *    bmp - pointer to character bitmap data
  195.  * DESCRIPTION
  196.  *    Write one character's info to the PK file.
  197.  *    This function converts a raw bitmap into the dense format used by PK
  198.  *    files.  (algorithms courtesy of PXtoPK and GFtoPK)
  199.  * RETURN VALUE
  200.  *    none
  201.  */
  202. void write_pk_character(fp, pkc, bmp)
  203. FILE *fp;
  204. struct pk_chardata *pkc;
  205. struct character_bitmap *bmp;
  206. {
  207. /* (this is largely translated borrowed code from GFtoPK, which is why
  208.  *  there aren't too many comments at times */
  209. long best_packet_length;
  210. int i, j, k;
  211. int count;
  212. int bit, oldbit;
  213. long  curr_word = 0L;
  214. int bit_ptr;
  215. int bit_mod_32 = 0;
  216. long *prast;
  217. long *end_raster;
  218. int dyn_f;
  219. long deriv[13+1];        /* array[1..13] of integer */
  220. int first_on;
  221. int state;
  222. int on;
  223. int h_bit;
  224. int p_bit;
  225. int r_on, s_on;
  226. int r_count, s_count;
  227. int max_2;
  228. long  pred_pk_loc;
  229. int buff;
  230.  
  231. static long *zero_row = NULL;
  232. static long *ones_row = NULL;
  233. static int max_row_size = 0;
  234.  
  235. static int *row_repeats = NULL;
  236. static int max_column_size = 0;
  237. int *cur_repeat;
  238. int repeat_flag;
  239.  
  240. static int *bit_counts = NULL;
  241. static int max_bit_counts_size = 0;
  242. int *current_bit_count, *first_bit_count, *last_bit_count;
  243. int *r_bit_count, *s_bit_count;
  244. /*
  245.  *  set up an all-zeros row and an all-ones row
  246.  */
  247. if (bmp->raster_width > max_row_size)
  248.     {
  249.     max_row_size = bmp->raster_width;
  250.     if (zero_row)
  251.     myfree(zero_row);
  252.     zero_row = (long *)myalloc( (unsigned)(4 * max_row_size) );
  253.     memset( zero_row, 0x00, 4 * max_row_size );
  254.     if (ones_row)
  255.     myfree(ones_row);
  256.     ones_row = (long *)myalloc( (unsigned)(4 * max_row_size) );
  257.     }
  258. memset( ones_row, 0xFF, 4 * bmp->raster_width );
  259. i = pkc->pixel_width % 32;
  260. if (i == 1)
  261.     ones_row[bmp->raster_width - 1] = power[31];    /* MAXLONGINT */
  262. else if (i > 1)
  263.     ones_row[bmp->raster_width - 1] = -power[32-i];
  264. /*
  265.  *  set markers for runs of identical rows of bits
  266.  */
  267. if (((pkc->pixel_height)+1) > max_column_size)
  268.     {
  269.     if (row_repeats)
  270.     myfree(row_repeats);
  271.     max_column_size = (pkc->pixel_height) + 1;
  272.     row_repeats = (int *)myalloc( (unsigned)(max_column_size * sizeof(int)) );
  273.     }
  274. for (    prast = bmp->raster, i = 0 ;
  275.     i < (pkc->pixel_height)-1 ;
  276.     ++i, prast += bmp->raster_width )
  277.     {
  278.     if (memcmp( prast, zero_row, bmp->raster_width * 4) == 0)
  279.     row_repeats[i] = 0;        /* skip all-zero rows */
  280.     else if (memcmp( prast, ones_row, bmp->raster_width * 4) == 0)
  281.     row_repeats[i] = 0;        /* skip all-one rows */
  282.     else if (memcmp(prast, prast+bmp->raster_width, bmp->raster_width * 4)==0)
  283.     row_repeats[i] = 1;        /* mark this equal to next row */
  284.     else
  285.     row_repeats[i] = 0;        /* not equal to next row... */
  286.     }
  287. row_repeats[(pkc->pixel_height)-1] = 0;    /* last row can't equal "next" */
  288. /*
  289.  *  convert boolean markers of repeated rows into repeat counts
  290.  */
  291. for ( i = 0 ; i < (pkc->pixel_height) ; i = k + 1 )
  292.     {
  293.     k = i;
  294.     while ((row_repeats[k] == 1) && (k < (pkc->pixel_height)))
  295.     ++k;
  296.     row_repeats[i] = k - i;
  297.     }
  298. row_repeats[(pkc->pixel_height)] = 0;        /* to simplify bookkeepping */
  299. /*
  300.  *  create the bit counts for each row
  301.  */
  302. if (((pkc->pixel_height) * 5) > max_bit_counts_size)
  303.     {
  304.     if (bit_counts)
  305.     myfree(bit_counts);
  306.     max_bit_counts_size = (pkc->pixel_height) * 5;
  307.     bit_counts = (int *)myalloc((unsigned)(max_bit_counts_size * sizeof(int)));
  308.     }
  309. last_bit_count = &bit_counts[max_bit_counts_size];
  310. prast = bmp->raster;
  311. cur_repeat = row_repeats;
  312. current_bit_count = bit_counts;
  313. repeat_flag = 0;
  314. end_raster = &(bmp->raster[(pkc->pixel_height) * bmp->raster_width]);
  315. count = 0;
  316. for ( bit_ptr = pkc->pixel_width, oldbit = 0 ; oldbit != END_OF_BITMAP ; ++bit_ptr )
  317.     {
  318.     if (bit_ptr == pkc->pixel_width)
  319.     {
  320.     /*
  321.      *  time to try the next row of this bitmap
  322.      */
  323.     if (*cur_repeat > 0)
  324.         {
  325.         /*
  326.          *  skip over rows that are repeated
  327.          */
  328.         repeat_flag = *cur_repeat;
  329.         cur_repeat += repeat_flag;
  330.         prast += bmp->raster_width * repeat_flag;
  331.         }
  332.     ++cur_repeat;
  333.     bit_mod_32 = 0;
  334.     bit_ptr = 0;
  335.     }
  336.     --bit_mod_32;
  337.     if (bit_mod_32 == -1)
  338.     {
  339.     /*
  340.      *  time to get the next longword of this row
  341.      */
  342.     bit_mod_32 = 31;
  343.     curr_word = *prast++;
  344.     }
  345.     if (prast > end_raster)
  346.     bit = END_OF_BITMAP;        /* at end of character bitmap */
  347.     else if (curr_word & power[bit_mod_32])
  348.     {
  349.     bit = 1;
  350.     curr_word ^= power[bit_mod_32];
  351.     }
  352.     else
  353.     bit = 0;
  354.     if (bit == oldbit)
  355.     ++count;
  356.     else
  357.     {
  358.     ADD_BIT_COUNT( count );
  359.     count = 1;
  360.     oldbit = bit;
  361.     if (repeat_flag > 0)
  362.         {
  363.         ADD_BIT_COUNT( -repeat_flag );
  364.         repeat_flag = 0;
  365.         }
  366.     }
  367.     }
  368. ADD_BIT_COUNT( 0 );
  369. ADD_BIT_COUNT( 0 );
  370. /*
  371.  *  Quoting from GFTOPK.WEB, from which the following code was adapted:
  372.  *
  373.  *    Here is another piece of rather intricate code.  Here we determine the
  374.  *    smallest size in which we can pack the data, calculating |dyn_f| in
  375.  *    the process.  To do this, we calculate the size required if |dyn_f| is
  376.  *    0, and put this in |pkc->packet_length|.  Then, we calculate the changes in the
  377.  *    size for each increment of |dyn_f|, and stick these values in the
  378.  *    |deriv| array.  Finally, we scan through this array, and find the
  379.  *    final minimum value, which we then use to send the character data.
  380.  */
  381. for ( i = 0 ; i <= 13 ; ++i )
  382.     deriv[i] = 0;
  383. first_on = (bit_counts[0] == 0);
  384. if (first_on)
  385.     first_bit_count = &bit_counts[1];
  386. else
  387.     first_bit_count = &bit_counts[0];
  388. pkc->packet_length = 0L;
  389. for (    current_bit_count = first_bit_count ; *current_bit_count != 0 ; )
  390.     {
  391.     /*  Quoting again from GFTOPK.WEB, except for changes in variable names:
  392.      *
  393.      *        When we enter this module, we have a count, at
  394.      *        |*current_bit_count|.  First, we add to the |pkc->packet_length| the
  395.      *        number of nybbles that this count would require, assuming
  396.      *        |dyn_f| to be zero.  Since when |dyn_f| is zero, there are no
  397.      *        one nybble counts, we simply check the two-nybble counts, and
  398.      *        then the extensible counts.
  399.      *
  400.      *        Next, we take the count value and determine the value of
  401.      *        |dyn_f| (if any) that would cause this count to take either
  402.      *        more or less nybbles.  If a valid value for |dyn_f| exists in
  403.      *        this range, we accumulate this change in the |deriv| array.
  404.      *
  405.      *        We know that a repeat count of one will not change the length
  406.      *        of the raster representation, no matter what |dyn_f| is,
  407.      *        because it is always represented by the nybble 15, so we do
  408.      *        that as a special case.
  409.      */
  410.     j = *current_bit_count++;
  411.     if (j == -1)
  412.     ++pkc->packet_length;            /* we have a row repeat count of 1 */
  413.     else
  414.     {
  415.     if (j < 0)
  416.         {
  417.         ++pkc->packet_length;
  418.         j = -j;            /* get positive row count */
  419.         }
  420.     if (j < 209)            /* 208 = 13 * 16 (13 is max dyn_f) */
  421.         pkc->packet_length += 2;
  422.     else
  423.         {
  424.         k = j - 193;        /* 192 = 12 * 16 */
  425.         while (k >= 16)
  426.         {
  427.         k = k / 16;
  428.         pkc->packet_length += 2;
  429.         }
  430.         ++pkc->packet_length;
  431.             }
  432.     if (j < 14)
  433.         --deriv[j];
  434.     else if (j < 209)
  435.         ++deriv[(223-j)/15];
  436.     else
  437.         {
  438.         k = 16;
  439.         while ((k * 16) < (j + 3))
  440.         k = k * 16;
  441.         if ((j - k) <= 192)
  442.         deriv[(207-j+k)/15] += 2;
  443.         }
  444.     }
  445.     }
  446. /*
  447.  *  set best_packet_length to the best size for the given value of dyn_f
  448.  */
  449. best_packet_length = pkc->packet_length;
  450. dyn_f = 0;
  451. for ( i = 1 ; i <= 13 ; ++i )
  452.     {
  453.     pkc->packet_length += deriv[i];
  454.     if (pkc->packet_length <= best_packet_length)
  455.     {
  456.     best_packet_length = pkc->packet_length;
  457.     dyn_f = i;
  458.     }
  459.     }
  460. pkc->packet_length = (best_packet_length + 1) / 2;    /* convert from nybble to byte size */
  461. if (    (pkc->packet_length > (((pkc->pixel_height) * pkc->pixel_width + 7) / 8)) ||
  462.     (((pkc->pixel_height) * pkc->pixel_width) == 0) )
  463.     {
  464.     /*
  465.      *  raw bitmap is the best we can do -- no compression possible
  466.      */
  467.     pkc->packet_length = ((pkc->pixel_height) * pkc->pixel_width + 7) / 8;
  468.     dyn_f = 14;
  469.     }
  470. /*
  471.  * write character preamble
  472.  */
  473. pkc->flag_byte = dyn_f << 4;
  474. if (first_on)
  475.     pkc->flag_byte |= 0x08;
  476. if (    (pkc->tfm_width > 0xFFFFFFL) || (pkc->tfm_width < 0L)          ||
  477.     (pkc->dx < 0L)               || (pkc->packet_length > 196579L) ||
  478.     (pkc->pixel_width > 0xFFFFL) || (pkc->pixel_height > 0xFFFFL)  ||
  479.     (pkc->hoff > 32767L)         || (pkc->hoff < -32768L)          ||
  480.     (pkc->voff > 32767L)         || (pkc->voff < -32768L) )
  481.     {
  482.     pkc->packet_length += 28L;
  483.     pkc->flag_byte |= 0x07;
  484.     /*
  485.      * write long character preamble
  486.      */
  487.     putc(pkc->flag_byte & 0xFF, fp);
  488.     put_fullword(pkc->packet_length, fp);
  489.     put_fullword(pkc->char_code, fp);
  490.     pred_pk_loc = ftell(fp) + pkc->packet_length;
  491.     put_fullword(pkc->tfm_width, fp);
  492.     put_fullword(pkc->dx, fp);
  493.     put_fullword(pkc->dy, fp);
  494.     put_fullword((long)pkc->pixel_width, fp);
  495.     put_fullword((long)(pkc->pixel_height), fp);
  496.     put_fullword(pkc->hoff, fp);
  497.     put_fullword(pkc->voff, fp);
  498.     }
  499. else if ((pkc->dx > 0xFF0000L)    || (pkc->packet_length > 1016) ||
  500.      (pkc->pixel_width > 255) || (pkc->pixel_height > 255)   ||
  501.      (pkc->hoff > 127)        || (pkc->hoff < -128)          ||
  502.      (pkc->voff > 127)        || (pkc->voff < -128) )
  503.     {
  504.     pkc->packet_length += 13L;
  505.     pkc->flag_byte |= (pkc->packet_length >> 16) | 4;
  506.     /*
  507.      *  write two-byte short character preamble
  508.      */
  509.     putc(pkc->flag_byte & 0xFF, fp);
  510.     put_halfword((unsigned short)(pkc->packet_length & 0xFFFF), fp);
  511.     putc((unsigned short)pkc->char_code & 0xFF, fp);
  512.     pred_pk_loc = ftell(fp) + pkc->packet_length;
  513.     put_3_bytes(pkc->tfm_width, fp);
  514.     put_halfword((unsigned short)(pkc->dx >> 16), fp);
  515.     put_halfword((unsigned short)pkc->pixel_width, fp);
  516.     put_halfword((unsigned short)(pkc->pixel_height), fp);
  517.     put_halfword((unsigned short)pkc->hoff, fp);
  518.     put_halfword((unsigned short)pkc->voff, fp);
  519.     }
  520. else
  521.     {
  522.     pkc->packet_length += 8L;
  523.     pkc->flag_byte |= pkc->packet_length >> 8;
  524.     /*
  525.      * write one-byte short character preamble
  526.      */
  527.     putc(pkc->flag_byte & 0xFF, fp);
  528.     putc((unsigned char)(pkc->packet_length & 0xFF), fp);
  529.     putc((unsigned char)pkc->char_code & 0xFF, fp);
  530.     pred_pk_loc = ftell(fp) + pkc->packet_length;
  531.     put_3_bytes(pkc->tfm_width, fp);
  532.     putc((unsigned char)(pkc->dx >> 16) & 0xFF, fp);
  533.     putc((unsigned char)pkc->pixel_width & 0xFF, fp);
  534.     putc((unsigned char)(pkc->pixel_height) & 0xFF, fp);
  535.     putc((unsigned char)pkc->hoff & 0xFF, fp);
  536.     putc((unsigned char)pkc->voff & 0xFF, fp);
  537.     }
  538. if (dyn_f != 14)
  539.     {
  540.     /*
  541.      * send compressed format
  542.      */
  543.     bit_weight = 16;
  544.     max_2 = 208 - 15 * dyn_f;        /* set max value for two nybbles */
  545.     current_bit_count = first_bit_count;
  546.     while (*current_bit_count != 0)
  547.     {
  548.     j = *current_bit_count++;
  549.     if (j == -1)
  550.         pk_nyb(15,fp);        /* send special row repeat count = 1 */
  551.     else 
  552.         {
  553.         if (j < 0)
  554.         {
  555.         pk_nyb(14,fp);        /* send row repeat flag */
  556.         j = -j;            /* convert to positive count */
  557.                 }
  558.         if (j <= dyn_f)
  559.         pk_nyb(j,fp);        /* small, one-nybble value */
  560.         else if (j <= max_2)
  561.         {            /* two-nybble value */
  562.         j = j - dyn_f - 1;
  563.         pk_nyb(j / 16 + dyn_f + 1, fp);
  564.         pk_nyb(j % 16, fp);
  565.         }
  566.         else
  567.         {            /* multi-nybble value */
  568.         j = j - max_2 + 15;
  569.         k = 16;
  570.         while (k <= j)
  571.             {
  572.             k = k * 16;
  573.             pk_nyb(0,fp);
  574.             }
  575.         while (k > 1)
  576.             {
  577.             k = k / 16;
  578.             pk_nyb(j / k, fp);
  579.             j = j % k;
  580.             }
  581.         }
  582.         }
  583.     }
  584.     if (bit_weight != 16)
  585.     putc(output_byte & 0xFF, fp);    /* pad to byte boundary */
  586.     }
  587. else
  588.     {
  589.     /*
  590.      *  send raw bit map
  591.      */
  592.     buff = 0;
  593.     p_bit = 8;
  594.     current_bit_count = first_bit_count;
  595.     r_bit_count = s_bit_count = bit_counts;
  596.     h_bit = pkc->pixel_width;
  597.     on = !first_on;
  598.     state = r_on = s_on = 0;
  599.     count = r_count = s_count = 0;
  600.     repeat_flag = 0;
  601.     while ((*current_bit_count != 0) || state || (count > 0))
  602.     {
  603.     if (state)
  604.         {
  605.         count = r_count;
  606.         current_bit_count = r_bit_count;
  607.         on = r_on;
  608.         --repeat_flag;
  609.         }
  610.     else
  611.         {
  612.         r_count = count;
  613.         r_bit_count = current_bit_count;
  614.         r_on = on;
  615.         }
  616.     /*
  617.      * send one row by bits
  618.      */
  619.     do  {
  620.         if (count == 0)
  621.         {
  622.         if (*current_bit_count < 0)
  623.             {
  624.             if (!state)
  625.             repeat_flag = -(*current_bit_count);
  626.             ++current_bit_count;
  627.             }
  628.         count = *current_bit_count++;
  629.         on = !on;
  630.         }
  631.         if ((count >= p_bit) && (p_bit < h_bit))
  632.         {
  633.         if (on)
  634.             buff = buff + power[p_bit] - 1;
  635.         putc(buff & 0xFF, fp);
  636.         buff = 0;
  637.         h_bit = h_bit - p_bit;
  638.         count = count - p_bit;
  639.         p_bit = 8;
  640.                 }
  641.         else if ((count < p_bit) && (count < h_bit))
  642.         {
  643.         if (on)
  644.             buff = buff + power[p_bit] - power[p_bit-count];
  645.         p_bit = p_bit - count;
  646.         h_bit = h_bit - count;
  647.         count = 0;
  648.                 }
  649.         else
  650.         {
  651.         if (on)
  652.             buff = buff + power[p_bit] - power[p_bit-h_bit];
  653.         count = count - h_bit;
  654.         p_bit = p_bit - h_bit;
  655.         h_bit = pkc->pixel_width;
  656.         if (p_bit == 0)
  657.             {
  658.             putc(buff & 0xFF, fp);
  659.             buff = 0;
  660.             p_bit = 8;
  661.             }
  662.         }
  663.         } while (h_bit != pkc->pixel_width);
  664.     if (state && (repeat_flag == 0))
  665.         {
  666.         count = s_count;
  667.         current_bit_count = s_bit_count;
  668.         on = s_on;
  669.         state = 0;
  670.         }
  671.     else if (!state && (repeat_flag > 0))
  672.         {
  673.         s_count = count;
  674.         s_bit_count = current_bit_count;
  675.         s_on = on;
  676.         state = 1;
  677.         }
  678.     }
  679.     if (p_bit != 8)
  680.     putc(buff & 0xFF, fp);
  681.     }
  682. if (pred_pk_loc != ftell(fp))
  683.     {
  684.     fflush(stdout);
  685.     fprintf(stderr, "\nERROR: Bad predicted character length.\n");
  686.     exit(1);
  687.     }
  688. }
  689.  
  690. /****************************************************************************
  691.  * NAME
  692.  *    end_pk_file
  693.  * ARGUMENTS
  694.  *    fp - output PK FILE pointer
  695.  * DESCRIPTION
  696.  *    Write the postamble for the .PK file.
  697.  * RETURN VALUE
  698.  *    none
  699.  */
  700. void end_pk_file(fp)
  701. FILE *fp;
  702. {
  703. putc(PK_POST & 0xFF, fp);
  704. while (ftell(fp) % 4 != 0)
  705.     putc(PK_NO_OP & 0xFF, fp);
  706. }
  707.