w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

pts_fax.c
Go to the documentation of this file.
1 /*
2  * pts_fax.c -- a compact CCITTFax compressor and uncompressor) implementation
3  * compiled by pts@fazekas.hu at Sun Jul 7 19:51:42 CEST 2002
4  *
5  * algorithm ripped from GNU Ghostscript, implementation and (C):
6  *
7 Copyright (C) 1993, 1995, 1996, 1997, 1998, 1999 Aladdin Enterprises. All
8 rights reserved.
9 
10 GNU Ghostscript is free software; you can redistribute it and/or
11 modify it under the terms of version 2 of the GNU General Public
12 License as published by the Free Software Foundation.
13 
14 GNU Ghostscript is distributed in the hope that it will be
15 useful, but WITHOUT ANY WARRANTY; without even the implied warranty
16 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
18 
19 You should have received a copy of the GNU General Public License
20 along with this program so you can know your rights and responsibilities.
21 It should be in a file named doc/COPYING. If not, write to the
22 Free Software Foundation, Inc., 59 Temple Place Suite 330, Boston, MA
23 02111-1307, USA.
24  */
25 
26 #include "pts_fax.h"
27 #if 0 /* doesn't work in C++ */
28 # define intern static
29 # define impl static
30 # define intern_const static const
31 # define impl_const static const
32 #else
33 # define intern static
34 # define impl static
35 # define intern_const extern const
36 # define impl_const const
37 #endif
38 /* #define cxxintern extern */
39 
40 #ifdef __GNUC__
41 #ifndef __clang__
42 #pragma implementation
43 #endif
44 #endif
45 
46 /* misc_types.h by pts@fazekas.hu at Sat Jul 6 19:20:17 CEST 2002 */
47 #ifndef MISC_TYPES_H
48 #define MISC_TYPES_H 1
49 
50 /* #include "config2.h" */
51 
52 #define BEGIN do {
53 #define END } while (0)
54 #ifndef DO_NOTHING
55 # define DO_NOTHING BEGIN END
56 #endif
57 
58 # define if_debug0(c,s) DO_NOTHING
59 # define if_debug1(c,s,a1) DO_NOTHING
60 # define if_debug2(c,s,a1,a2) DO_NOTHING
61 # define if_debug3(c,s,a1,a2,a3) DO_NOTHING
62 # define if_debug4(c,s,a1,a2,a3,a4) DO_NOTHING
63 # define if_debug5(c,s,a1,a2,a3,a4,a5) DO_NOTHING
64 # define if_debug6(c,s,a1,a2,a3,a4,a5,a6) DO_NOTHING
65 # define if_debug7(c,s,a1,a2,a3,a4,a5,a6,a7) DO_NOTHING
66 # define if_debug8(c,s,a1,a2,a3,a4,a5,a6,a7,a8) DO_NOTHING
67 # define if_debug9(c,s,a1,a2,a3,a4,a5,a6,a7,a8,a9) DO_NOTHING
68 # define if_debug10(c,s,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) DO_NOTHING
69 # define if_debug11(c,s,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11) DO_NOTHING
70 # define if_debug12(c,s,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) DO_NOTHING
71 
72 /* to the one that all the compilers seem to have.... */
73 #ifndef min
74 # define min(a, b) (((a) < (b)) ? (a) : (b))
75 #endif
76 #ifndef max
77 # define max(a, b) (((a) > (b)) ? (a) : (b))
78 #endif
79 
80 /* Define a standard way to round values to a (constant) modulus. */
81 #define ROUND_DOWN(value, modulus)\
82  ( (modulus) & ((modulus) - 1) ? /* not a power of 2 */\
83  (value) - (value) % (modulus) :\
84  (value) & -(modulus) )
85 #define ROUND_UP(value, modulus)\
86  ( (modulus) & ((modulus) - 1) ? /* not a power of 2 */\
87  ((value) + ((modulus) - 1)) / (modulus) * (modulus) :\
88  ((value) + ((modulus) - 1)) & -(modulus) )
89 
90 #define countof(a) (sizeof(a) / sizeof((a)[0]))
91 
92 #define gs_alloc_bytes(a, n, c) ss->xalloc_(n)
93 #define gs_free_object(a, ptr, c) ss->free_(ptr)
94 
95 #endif /* gstypes.h */
96 /* end of former misc_types.h */
97 
98 /* gsbittab.h */
99 /*$Id: pts_fax.c,v 1.3 2005/02/21 13:09:56 pts Exp $ */
100 /* Interface to tables for bit operations */
101 
102 #ifndef gsbittab_INCLUDED
103 # define gsbittab_INCLUDED
104 
105 /*
106  * Generate tables for transforming 2, 4, 6, or 8 bits.
107  */
108 #define btab2_(v0,v2,v1)\
109  v0,v1+v0,v2+v0,v2+v1+v0
110 #define bit_table_2(v0,v2,v1) btab2_(v0,v2,v1)
111 #define btab4_(v0,v8,v4,v2,v1)\
112  btab2_(v0,v2,v1), btab2_(v4+v0,v2,v1),\
113  btab2_(v8+v0,v2,v1), btab2_(v8+v4+v0,v2,v1)
114 #define bit_table_4(v0,v8,v4,v2,v1) btab4_(v0,v8,v4,v2,v1)
115 #define btab6_(v0,v20,v10,v8,v4,v2,v1)\
116  btab4_(v0,v8,v4,v2,v1), btab4_(v10+v0,v8,v4,v2,v1),\
117  btab4_(v20+v0,v8,v4,v2,v1), btab4_(v20+v10+v0,v8,v4,v2,v1)
118 #define bit_table_6(v0,v20,v10,v8,v4,v2,v1) btab6_(v0,v20,v10,v8,v4,v2,v1)
119 #define bit_table_8(v0,v80,v40,v20,v10,v8,v4,v2,v1)\
120  btab6_(v0,v20,v10,v8,v4,v2,v1), btab6_(v40+v0,v20,v10,v8,v4,v2,v1),\
121  btab6_(v80+v0,v20,v10,v8,v4,v2,v1), btab6_(v80+v40+v0,v20,v10,v8,v4,v2,v1)
122 
123 /*
124  * byte_reverse_bits[B] = the unsigned char B with the order of bits reversed.
125  */
126 intern_const unsigned char byte_reverse_bits[256];
127 
128 /*
129  * byte_right_mask[N] = a unsigned char with N trailing 1s, 0 <= N <= 8.
130  */
131 intern_const unsigned char byte_right_mask[9];
132 
133 /*
134  * byte_count_bits[B] = the number of 1-bits in a unsigned char with value B.
135  */
136 intern_const unsigned char byte_count_bits[256];
137 
138 /*
139  * byte_bit_run_length_N[B], for 0 <= N <= 7, gives the length of the
140  * run of 1-bits starting at bit N in a unsigned char with value B,
141  * numbering the bits in the unsigned char as 01234567. If the run includes
142  * the low-order bit (i.e., might be continued into a following unsigned char),
143  * the run length is increased by 8.
144  */
145 intern_const unsigned char
150 
151 /*
152  * byte_bit_run_length[N] points to byte_bit_run_length_N.
153  * byte_bit_run_length_neg[N] = byte_bit_run_length[-N & 7].
154  */
155 intern_const unsigned char *const byte_bit_run_length[8];
156 intern_const unsigned char *const byte_bit_run_length_neg[8];
157 
158 /*
159  * byte_acegbdfh_to_abcdefgh[acegbdfh] = abcdefgh, where the letters
160  * denote the individual bits of the unsigned char.
161  */
162 intern_const unsigned char byte_acegbdfh_to_abcdefgh[256];
163 
164 #endif /* gsbittab_INCLUDED */
165 
166 /* end of former gsbittab.h */
167 
168 /* shc.h */
169 /*$Id: pts_fax.c,v 1.3 2005/02/21 13:09:56 pts Exp $ */
170 /* Common definitions for filters using Huffman coding */
171 
172 #ifndef shc_INCLUDED
173 # define shc_INCLUDED
174 
175 /* #include "gsbittab.h" */
176 
177 #define hc_bits_size (SIZEOF_INT * 8)
178 #define s_hce_init_inline(ss)\
179  ((ss)->bits = 0, (ss)->bits_left = hc_bits_size)
180 #define s_hcd_init_inline(ss)\
181  ((ss)->bits = 0, (ss)->bits_left = 0)
182 
183 /*
184  * These definitions are valid for code lengths up to 16 bits
185  * and non-negative decoded values up to 15 bits.
186  *
187  * We define 3 different representations of the code: encoding tables,
188  * decoding tables, and a definition table which can be generated easily
189  * from frequency information and which in turn can easily generate
190  * the encoding and decoding tables.
191  *
192  * The definition table has two parts: a list of the number of i-bit
193  * codes for each i >= 1, and the decoded values corresponding to
194  * the code values in increasing lexicographic order (which will also
195  * normally be decreasing code frequency). Calling these two lists
196  * L[1..M] and V[0..N-1] respectively, we have the following invariants:
197  * - 1 <= M <= max_hc_length, N >= 2.
198  * - L[0] = 0.
199  * - for i=1..M, L[i] >= 0.
200  * - sum(i=1..M: L[i]) = N.
201  * - sum(i=1..M: L[i] * 2^-i) = 1.
202  * - V[0..N-1] are a permutation of the integers 0..N-1.
203  */
204 #define max_hc_length 16
205 typedef struct hc_definition_s {
206  unsigned short *counts; /* [0..M] */
207  unsigned int num_counts; /* M */
208  unsigned short *values; /* [0..N-1] */
209  unsigned int num_values; /* N */
211 
212 /**** pts ****/
213 struct stream_hc_state_s;
214 /* definition moved to pts_fax.h */
215 
216 /* ------ Encoding tables ------ */
217 
218 /* Define the structure for the encoding tables. */
219 typedef struct hce_code_s {
220  unsigned short code;
221  unsigned short code_length;
223 
224 #define hce_entry(c, len) { c, len }
225 
226 typedef struct hce_table_s {
227  unsigned int count;
230 
231 #define hce_bits_available(n)\
232  (ss->bits_left >= (n) || wlimit - q > ((n) - ss->bits_left - 1) >> 3)
233 
234 /* ------ Encoding utilities ------ */
235 
236 /*
237  * Put a code on the output. The client is responsible for ensuring
238  * that q does not exceed pw->limit.
239  */
240 
241 #ifdef DEBUG
242 # define hc_print_value(code, clen)\
243  (gs_debug_c('W') ?\
244  (dlprintf2("[W]0x%x,%d\n", code, clen), 0) : 0)
245 # define hc_print_value_then(code, clen) hc_print_value(code, clen),
246 #else
247 # define hc_print_value(code, clen) 0
248 # define hc_print_value_then(code, clen) /* */
249 #endif
250 #define hc_print_code(rp) hc_print_value((rp)->code, (rp)->code_length)
251 
252 /* Declare variables that hold the encoder state. */
253 #define hce_declare_state\
254  register unsigned int bits;\
255  register int bits_left
256 
257 /* Load the state from the stream. */
258 /* Free variables: ss, bits, bits_left. */
259 #define hce_load_state()\
260  bits = ss->bits, bits_left = ss->bits_left
261 
262 /* Store the state back in the stream. */
263 /* Free variables: ss, bits, bits_left. */
264 #define hce_store_state()\
265  ss->bits = bits, ss->bits_left = bits_left
266 
267 /* Put a code on the stream. */
268 intern void hc_put_code_proc _((bool, unsigned char *, unsigned int));
269 
270 #define hc_put_value(ss, q, code, clen)\
271  (hc_print_value_then(code, clen)\
272  ((bits_left -= (clen)) >= 0 ?\
273  (bits += (code) << bits_left) :\
274  (hc_put_code_proc((ss)->FirstBitLowOrder,\
275  q += hc_bits_size >> 3,\
276  (bits + ((code) >> -bits_left))),\
277  bits = (code) << (bits_left += hc_bits_size))))
278 #define hc_put_code(ss, q, cp)\
279  hc_put_value(ss, q, (cp)->code, (cp)->code_length)
280 
281 /*
282  * Force out the final bits to the output.
283  * Note that this does a store_state, but not a load_state.
284  */
285 intern unsigned char *hc_put_last_bits_proc _((struct stream_hc_state_s *, unsigned char *, unsigned int, int));
286 
287 #define hc_put_last_bits(ss, q)\
288  hc_put_last_bits_proc(ss, q, bits, bits_left)
289 
290 /* ------ Decoding tables ------ */
291 
292 /*
293  * Define the structure for the decoding tables.
294  * First-level nodes are either leaves, which have
295  * value = decoded value
296  * code_length <= initial_bits
297  * or non-leaves, which have
298  * value = the index of a sub-table
299  * code_length = initial_bits + the number of additional dispatch bits
300  * Second-level nodes are always leaves, with
301  * code_length = the actual number of bits in the code - initial_bits.
302  */
303 
304 typedef struct hcd_code_s {
305  short value;
306  unsigned short code_length;
308 
309 typedef struct hcd_table_s {
310  unsigned int count;
311  unsigned int initial_bits;
314 
315 /* Declare variables that hold the decoder state. */
316 #define hcd_declare_state\
317  register const unsigned char *p;\
318  const unsigned char *rlimit;\
319  unsigned int bits;\
320  int bits_left
321 
322 /* Load the state from the stream. */
323 /* Free variables: pr, ss, p, rlimit, bits, bits_left. */
324 #define hcd_load_state()\
325  p = pr->ptr,\
326  rlimit = pr->limit,\
327  bits = ss->bits,\
328  bits_left = ss->bits_left
329 
330 /* Store the state back in the stream. */
331 /* Put back any complete bytes into the input buffer. */
332 /* Free variables: pr, ss, p, bits, bits_left. */
333 #define hcd_store_state()\
334  pr->ptr = p -= (bits_left >> 3),\
335  ss->bits = bits >>= (bits_left & ~7),\
336  ss->bits_left = bits_left &= 7
337 
338 /* Macros to get blocks of bits from the input stream. */
339 /* Invariants: 0 <= bits_left <= bits_size; */
340 /* bits [bits_left-1..0] contain valid data. */
341 
342 #define hcd_bits_available(n)\
343  (bits_left >= (n) || rlimit - p > ((n) - bits_left - 1) >> 3)
344 /* For hcd_ensure_bits, n must not be greater than 8. */
345 #define HCD_ENSURE_BITS_ELSE(n)\
346  if (bits_left >= n)\
347  DO_NOTHING;\
348  else HCD_MORE_BITS_ELSE
349 #define hcd_ensure_bits(n, outl)\
350  BEGIN HCD_ENSURE_BITS_ELSE(n) goto outl; END
351 
352 /* Load more bits into the buffer. */
353 #define HCD_MORE_BITS_1_ELSE\
354  if (p < rlimit) {\
355  int c = *++p;\
356 \
357  if (ss->FirstBitLowOrder)\
358  c = byte_reverse_bits[c];\
359  bits = (bits << 8) + c, bits_left += 8;\
360  } else
361 #if hc_bits_size == 16
362 # define HCD_MORE_BITS_ELSE HCD_MORE_BITS_1_ELSE
363 #else /* hc_bits_size >= 32 */
364 # define HCD_MORE_BITS_ELSE\
365  if (rlimit - p >= 3) {\
366  if (ss->FirstBitLowOrder)\
367  bits = (bits << 24) + ((unsigned int)byte_reverse_bits[p[1]] << 16) + ((unsigned int)byte_reverse_bits[p[2]] << 8) + byte_reverse_bits[p[3]];\
368  else\
369  bits = (bits << 24) + ((unsigned int)p[1] << 16) + ((unsigned int)p[2] << 8) + p[3];\
370  bits_left += 24, p += 3;\
371  } else HCD_MORE_BITS_1_ELSE
372 #endif
373 #define hcd_more_bits(outl)\
374  BEGIN HCD_MORE_BITS_ELSE goto outl; END
375 
376 #define hcd_peek_bits(n) ((bits >> (bits_left - (n))) & ((1 << (n)) - 1))
377 
378 /* hcd_peek_var_bits requires bits_left <= 8. */
379 #define hcd_peek_var_bits(n)\
380  ((bits >> (bits_left - (n))) & byte_right_mask[n])
381 
382 /* hcd_peek_bits_left requires bits_left <= 8. */
383 #define hcd_peek_bits_left()\
384  (bits & byte_right_mask[bits_left])
385 
386 #define hcd_skip_bits(n) (bits_left -= (n))
387 
388 #endif /* shc_INCLUDED */
389 
390 /* end of former shc.h */
391 
392 /* scf.h */
393 /*$Id: pts_fax.c,v 1.3 2005/02/21 13:09:56 pts Exp $ */
394 /* Common definitions for CCITTFax encoding and decoding filters */
395 
396 #ifndef scf_INCLUDED
397 # define scf_INCLUDED
398 
399 /* #include "shc.h" */
400 
401 /*
402  * The CCITT Group 3 (T.4) and Group 4 (T.6) fax specifications map
403  * run lengths to Huffman codes. White and black have different mappings.
404  * If the run length is 64 or greater, two or more codes are needed:
405  * - One or more 'make-up' codes for 2560 pixels;
406  * - A 'make-up' code that encodes the multiple of 64;
407  * - A 'termination' code for the remainder.
408  * For runs of 63 or less, only the 'termination' code is needed.
409  */
410 
411 /* ------ Encoding tables ------ */
412 
413 /*
414  * The maximum possible length of a scan line is determined by the
415  * requirement that 3 runs have to fit into the stream buffer.
416  * A run of length N requires approximately ceil(N / 2560) makeup codes,
417  * hence 1.5 * ceil(N / 2560) bytes. Taking the largest safe stream
418  * buffer size as 32K, we arrive at the following maximum width:
419  */
420 #if SIZEOF_INT > 2
421 # define cfe_max_width (2560 * 32000 * 2 / 3)
422 #else
423 # define cfe_max_width (max_int - 40) /* avoid overflows */
424 #endif
425 /* The +5 in cfe_max_code_bytes is a little conservative. */
426 #define cfe_max_code_bytes(width) ((width) / 2560 * 3 / 2 + 5)
427 
429 
430 /* Codes common to 1-D and 2-D encoding. */
431 /* The decoding algorithms know that EOL is 0....01. */
432 #define run_eol_code_length 12
433 #define run_eol_code_value 1
435 typedef struct cf_runs_s {
442 intern_const cfe_run cf_uncompressed_exit[10]; /* indexed by 2 x length of */
443 
444  /* white run + (1 if next run black, 0 if white) */
445 /* 1-D encoding. */
447 
448 /* 2-D encoding. */
450 
451 #define cf2_run_pass_length 4
452 #define cf2_run_pass_value 0x1
453 #define cf2_run_vertical_offset 3
454 intern_const cfe_run cf2_run_vertical[7]; /* indexed by b1 - a1 + offset */
456 
457 #define cf2_run_horizontal_value 1
458 #define cf2_run_horizontal_length 3
460 
461 /* 2-D Group 3 encoding. */
464 
465 /* ------ Decoding tables ------ */
466 
468 
469 #define run_length value
470 
471 /*
472  * The value in the decoding tables is either a white or black run length,
473  * or a (negative) exceptional value.
474  */
475 #define run_error (-1)
476 #define run_zeros (-2) /* EOL follows, possibly with more padding first */
477 #define run_uncompressed (-3)
478 /* 2-D codes */
479 #define run2_pass (-4)
480 #define run2_horizontal (-5)
481 
482 #define cfd_white_initial_bits 8
483 #define cfd_white_min_bits 4 /* shortest white run */
484 /* intern_const cfd_node cf_white_decode[]; */
485 
486 #define cfd_black_initial_bits 7
487 #define cfd_black_min_bits 2 /* shortest black run */
488 /* intern_const cfd_node cf_black_decode[]; */
489 
490 #define cfd_2d_initial_bits 7
491 #define cfd_2d_min_bits 4 /* shortest non-H/V 2-D run */
492 /* intern_const cfd_node cf_2d_decode[]; */
493 
494 #define cfd_uncompressed_initial_bits 6 /* must be 6 */
495 /* intern_const cfd_node cf_uncompressed_decode[]; */
496 
497 /* ------ Run detection macros ------ */
498 
499 /*
500  * For the run detection macros:
501  * white_byte is 0 or 0xff for BlackIs1 or !BlackIs1 respectively;
502  * data holds p[-1], inverted if !BlackIs1;
503  * count is the number of valid bits remaining in the scan line.
504  */
505 
506 /* Aliases for bit processing tables. */
507 #define cf_byte_run_length byte_bit_run_length_neg
508 #define cf_byte_run_length_0 byte_bit_run_length_0
509 
510 /* Skip over white pixels to find the next black pixel in the input. */
511 /* Store the run length in rlen, and update data, p, and count. */
512 /* There are many more white pixels in typical input than black pixels, */
513 /* and the runs of white pixels tend to be much longer, so we use */
514 /* substantially different loops for the two cases. */
515 
516 #define skip_white_pixels(data, p, count, white_byte, rlen)\
517 BEGIN\
518  rlen = cf_byte_run_length[count & 7][data ^ 0xff];\
519  if ( rlen >= 8 ) { /* run extends past unsigned char boundary */\
520  if ( white_byte == 0 ) {\
521  if ( p[0] ) { data = p[0]; p += 1; rlen -= 8; }\
522  else if ( p[1] ) { data = p[1]; p += 2; }\
523  else {\
524  while ( !(p[2] | p[3] | p[4] | p[5]) )\
525  p += 4, rlen += 32;\
526  if ( p[2] ) {\
527  data = p[2]; p += 3; rlen += 8;\
528  } else if ( p[3] ) {\
529  data = p[3]; p += 4; rlen += 16;\
530  } else if ( p[4] ) {\
531  data = p[4]; p += 5; rlen += 24;\
532  } else /* p[5] */ {\
533  data = p[5]; p += 6; rlen += 32;\
534  }\
535  }\
536  } else {\
537  if ( p[0] != 0xff ) { data = (unsigned char)~p[0]; p += 1; rlen -= 8; }\
538  else if ( p[1] != 0xff ) { data = (unsigned char)~p[1]; p += 2; }\
539  else {\
540  while ( (p[2] & p[3] & p[4] & p[5]) == 0xff )\
541  p += 4, rlen += 32;\
542  if ( p[2] != 0xff ) {\
543  data = (unsigned char)~p[2]; p += 3; rlen += 8;\
544  } else if ( p[3] != 0xff ) {\
545  data = (unsigned char)~p[3]; p += 4; rlen += 16;\
546  } else if ( p[4] != 0xff ) {\
547  data = (unsigned char)~p[4]; p += 5; rlen += 24;\
548  } else /* p[5] != 0xff */ {\
549  data = (unsigned char)~p[5]; p += 6; rlen += 32;\
550  }\
551  }\
552  }\
553  rlen += cf_byte_run_length_0[data ^ 0xff];\
554  }\
555  count -= rlen;\
556 END
557 
558 /* Skip over black pixels to find the next white pixel in the input. */
559 /* Store the run length in rlen, and update data, p, and count. */
560 
561 #define skip_black_pixels(data, p, count, white_byte, rlen)\
562 BEGIN\
563  rlen = cf_byte_run_length[count & 7][data];\
564  if ( rlen >= 8 ) {\
565  if ( white_byte == 0 )\
566  for ( ; ; p += 4, rlen += 32 ) {\
567  if ( p[0] != 0xff ) { data = p[0]; p += 1; rlen -= 8; break; }\
568  if ( p[1] != 0xff ) { data = p[1]; p += 2; break; }\
569  if ( p[2] != 0xff ) { data = p[2]; p += 3; rlen += 8; break; }\
570  if ( p[3] != 0xff ) { data = p[3]; p += 4; rlen += 16; break; }\
571  }\
572  else\
573  for ( ; ; p += 4, rlen += 32 ) {\
574  if ( p[0] ) { data = (unsigned char)~p[0]; p += 1; rlen -= 8; break; }\
575  if ( p[1] ) { data = (unsigned char)~p[1]; p += 2; break; }\
576  if ( p[2] ) { data = (unsigned char)~p[2]; p += 3; rlen += 8; break; }\
577  if ( p[3] ) { data = (unsigned char)~p[3]; p += 4; rlen += 16; break; }\
578  }\
579  rlen += cf_byte_run_length_0[data];\
580  }\
581  count -= rlen;\
582 END
583 
584 #endif /* scf_INCLUDED */
585 
586 /* end of former scf.h */
587 
588 #if USE_BUILTIN_FAXE
589 #if OBJDEP
590 # warning PROVIDES: pts_faxe
591 #endif
592 /* scfe.c */
593 /*$Id: pts_fax.c,v 1.3 2005/02/21 13:09:56 pts Exp $ */
594 /* CCITTFax encoding filter */
595 /* #include "config2.h" */
596 /* #include "scf.h" */
597 /* #include "scfx.h" */
598 
599 /* ------ Macros and support routines ------ */
600 
601 /* Statistics */
602 
603 #ifdef DEBUG
604 
605 typedef struct stats_runs_s {
606  unsigned long termination[64];
607  unsigned long make_up[41];
608 } stats_runs_t;
609 static stats_runs_t stats_white_runs, stats_black_runs;
610 
611 #define COUNT_RUN(tab, i) (tab)[i]++;
612 
613 static void
614 print_run_stats(const stats_runs_t * stats)
615 {
616  int i;
617  unsigned long total;
618 
619  for (i = 0, total = 0; i < 41; i++)
620  dprintf1(" %lu", stats->make_up[i]),
621  total += stats->make_up[i];
622  dprintf1(" total=%lu\n\t", total);
623  for (i = 0, total = 0; i < 64; i++)
624  dprintf1(" %lu", stats->termination[i]),
625  total += stats->termination[i];
626  dprintf1(" total=%lu\n", total);
627 }
628 
629 #else /* !DEBUG */
630 
631 #define COUNT_RUN(cnt, i) DO_NOTHING
632 
633 #endif /* DEBUG */
634 
635 /* Put a run onto the output stream. */
636 /* Free variables: q, bits, bits_left. */
637 
638 #define CF_PUT_RUN(ss, lenv, rt, stats)\
639 BEGIN\
640  cfe_run rr;\
641 \
642  if ( lenv >= 64 ) {\
643  hce_store_state();\
644  q = cf_put_long_run(ss, q, lenv, &rt);\
645  hce_load_state();\
646  lenv &= 63;\
647  }\
648  rr = rt.termination[lenv];\
649  COUNT_RUN(stats.termination, lenv);\
650  hc_put_value(ss, q, rr.code, rr.code_length);\
651 END
652 
653 static unsigned char *
654 cf_put_long_run(stream_CFE_state * ss, unsigned char * q, int lenv, const cf_runs * prt)
655 {
657  cfe_run rr;
658 
659 #ifdef DEBUG
660  stats_runs_t *pstats =
661  (prt == &cf_white_runs ? &stats_white_runs : &stats_black_runs);
662 
663 #endif
664 
665  hce_load_state();
666  while (lenv >= 2560 + 64) {
667  rr = prt->make_up[40];
668  COUNT_RUN(pstats->make_up, 40);
669  hc_put_value(ss, q, rr.code, rr.code_length);
670  lenv -= 2560;
671  }
672  rr = prt->make_up[lenv >> 6];
673  COUNT_RUN(pstats->make_up, lenv >> 6);
674  hc_put_value(ss, q, rr.code, rr.code_length);
675  hce_store_state();
676  return q;
677 }
678 
679 #define CF_PUT_WHITE_RUN(ss, lenv)\
680  CF_PUT_RUN(ss, lenv, cf_white_runs, stats_white_runs)
681 
682 #define CF_PUT_BLACK_RUN(ss, lenv)\
683  CF_PUT_RUN(ss, lenv, cf_black_runs, stats_black_runs)
684 
685 /* ------ CCITTFaxEncode ------ */
686 
687 /* private_st_CFE_state(); */
688 
689 static void s_CFE_release _((stream_state *));
690 
691 /* Set default parameter values. */
692 static void
694 {
695  stream_CFE_state *const ss = (stream_CFE_state *) st;
696 
698 }
699 
700 /* Initialize CCITTFaxEncode filter */
701 static int
703 {
704  stream_CFE_state *const ss = (stream_CFE_state *) st;
705  int columns = ss->Columns;
706 
707  /*
708  * The worst case for encoding is alternating white and black pixels.
709  * For 1-D encoding, the worst case is 9 bits per 2 pixels; for 2-D
710  * (horizontal), 12 bits per 2 pixels. To fill out a scan line,
711  * we may add up to 6 12-bit EOL codes.
712  */
713  /**** pts: added UL ****/
714  int code_bytes =
715  ((columns * (ss->K == 0 ? 9UL : 12UL)) >> 4) + 20; /* add slop */
716  int raster = ss->raster =
717  ROUND_UP((columns + 7) >> 3, ss->DecodedByteAlign);
718 
719  s_hce_init_inline(ss);
720  ss->lbuf = ss->lprev = ss->lcode = 0; /* in case we have to release */
721  if (columns > cfe_max_width)
722  return PTSFAX_ERRC;
723 /****** WRONG ******/
724  /* Because skip_white_pixels can look as many as 4 bytes ahead, */
725  /* we need to allow 4 extra bytes at the end of the row buffers. */
726  ss->lbuf = (unsigned char*)gs_alloc_bytes(st->memory, raster + 4, "CFE lbuf");
727  ss->lcode = (unsigned char*)gs_alloc_bytes(st->memory, code_bytes, "CFE lcode");
728  if (ss->lbuf == 0 || ss->lcode == 0) {
729  s_CFE_release(st);
730  return PTSFAX_ERRC;
731 /****** WRONG ******/
732  }
733  if (ss->K != 0) {
734  ss->lprev = (unsigned char*)gs_alloc_bytes(st->memory, raster + 4, "CFE lprev");
735  if (ss->lprev == 0) {
736  s_CFE_release(st);
737  return PTSFAX_ERRC;
738 /****** WRONG ******/
739  }
740  /* Clear the initial reference line for 2-D encoding. */
741  /* Make sure it is terminated properly. */
742  ss->memset_(ss->lprev, (ss->BlackIs1 ? 0 : 0xff), raster);
743  if (columns & 7)
744  ss->lprev[raster - 1] ^= 0x80 >> (columns & 7);
745  else
746  ss->lprev[raster] = ~~ss->lprev[0];
747  }
748  ss->read_count = raster;
749  ss->write_count = 0;
750  ss->k_left = (ss->K > 0 ? 1 : ss->K);
751  ss->max_code_bytes = code_bytes;
752  return 0;
753 }
754 
755 /* Release the filter. */
756 static void
758 {
759  stream_CFE_state *const ss = (stream_CFE_state *) st;
760 
761  gs_free_object(st->memory, ss->lprev, "CFE lprev(close)");
762  gs_free_object(st->memory, ss->lcode, "CFE lcode(close)");
763  gs_free_object(st->memory, ss->lbuf, "CFE lbuf(close)");
764 }
765 
766 /* Flush the buffer */
767 static void cf_encode_1d _((stream_CFE_state *, const unsigned char *,
769 static void cf_encode_2d _((stream_CFE_state *, const unsigned char *,
770  stream_cursor_write *, const unsigned char *));
771 static int
773  stream_cursor_write * pw, bool last)
774 {
775  stream_CFE_state *const ss = (stream_CFE_state *) st;
776  const unsigned char *rlimit = pr->limit;
777  unsigned char *wlimit = pw->limit;
778  int raster = ss->raster;
779  unsigned char end_mask = 1 << (-ss->Columns & 7);
780  int status = 0;
781 
782  for (;;) {
784 
785  if_debug2('w', "[w]CFE: read_count = %d, write_count=%d,\n",
786  ss->read_count, ss->write_count);
787  if_debug6('w', " pr = 0x%lx(%d)0x%lx, pw = 0x%lx(%d)0x%lx\n",
788  (unsigned long) pr->ptr, (int)(rlimit - pr->ptr), (unsigned long) rlimit,
789  (unsigned long) pw->ptr, (int)(wlimit - pw->ptr), (unsigned long) wlimit);
790  if (ss->write_count) {
791  /* Copy more of an encoded line to the caller. */
792  int wcount = wlimit - pw->ptr;
793  int ccount = min(wcount, ss->write_count);
794 
795  ss->memcpy_(pw->ptr + 1, ss->lcode + ss->code_bytes - ss->write_count,
796  ccount);
797  pw->ptr += ccount;
798  if ((ss->write_count -= ccount) > 0) {
799  status = 1;
800  break;
801  }
802  }
803  if (ss->read_count) {
804  /* Copy more of an unencoded line from the caller. */
805  int rcount = rlimit - pr->ptr;
806  int ccount = min(rcount, ss->read_count);
807 
808  if (rcount == 0 && last)
809  break;
810  ss->memcpy_(ss->lbuf + raster - ss->read_count,
811  pr->ptr + 1, ccount);
812  pr->ptr += ccount;
813  if ((ss->read_count -= ccount) != 0)
814  break;
815  }
816  /*
817  * We have a full scan line in lbuf. Ensure that it ends with
818  * two polarity changes.
819  */
820  {
821  unsigned char *end = ss->lbuf + raster - 1;
822  unsigned char end_bit = *end & end_mask;
823  unsigned char not_bit = end_bit ^ end_mask;
824 
825  *end &= -end_mask;
826  if (end_mask == 1)
827  end[1] = (end_bit ? 0x40 : 0x80);
828  else if (end_mask == 2)
829  *end |= not_bit >> 1, end[1] = end_bit << 7;
830  else
831  *end |= (not_bit >> 1) | (end_bit >> 2);
832  }
833  /*
834  * Write the output directly to the caller's buffer if it's large
835  * enough, otherwise to our own buffer.
836  */
837  if (wlimit - pw->ptr >= ss->max_code_bytes) {
838  w = *pw;
839  } else {
840  w.ptr = ss->lcode - 1;
841  w.limit = w.ptr + ss->max_code_bytes;
842  }
843 #ifdef DEBUG
844  if (ss->K > 0) {
845  if_debug1('w', "[w]new row, k_left=%d\n",
846  ss->k_left);
847  } else {
848  if_debug0('w', "[w]new row\n");
849  }
850 #endif
851  /*
852  * Write an EOL (actually a "beginning of line") if requested.
853  */
854  if (ss->EndOfLine) {
855  const cfe_run *rp =
856  (ss->K <= 0 ? &cf_run_eol :
857  ss->k_left > 1 ? &cf2_run_eol_2d :
858  &cf2_run_eol_1d);
859  cfe_run run;
860 
862 
863  hce_load_state();
864  if (ss->EncodedByteAlign) {
865  run = *rp;
866  /* Pad the run on the left */
867  /* so it winds up unsigned char-aligned. */
868  run.code_length +=
870  if (run.code_length > 16) /* <= 23 */
871  bits_left -= run.code_length & 7,
872  run.code_length = 16;
873  rp = &run;
874  }
875  hc_put_code(ss, w.ptr, rp);
876  hce_store_state();
877  } else if (ss->EncodedByteAlign)
878  ss->bits_left &= ~7;
879  /* Encode the line. */
880  if (ss->K == 0)
881  cf_encode_1d(ss, ss->lbuf, &w); /* pure 1-D */
882  else if (ss->K < 0)
883  cf_encode_2d(ss, ss->lbuf, &w, ss->lprev); /* pure 2-D */
884  else if (--(ss->k_left)) /* mixed, use 2-D */
885  cf_encode_2d(ss, ss->lbuf, &w, ss->lprev);
886  else { /* mixed, use 1-D */
887  cf_encode_1d(ss, ss->lbuf, &w);
888  ss->k_left = ss->K;
889  }
890  /*
891  * If we didn't write directly to the client's buffer, schedule
892  * the output data to be written.
893  */
894  if (w.limit == wlimit)
895  pw->ptr = w.ptr;
896  else
897  ss->write_count = ss->code_bytes = w.ptr - (ss->lcode - 1);
898  if (ss->K != 0) {
899  /* In 2-D modes, swap the current and previous scan lines. */
900  unsigned char *temp = ss->lbuf;
901 
902  ss->lbuf = ss->lprev;
903  ss->lprev = temp;
904  }
905  /* Note that the input buffer needs refilling. */
906  ss->read_count = raster;
907  }
908  /*
909  * When we exit from the loop, we know that write_count = 0, and
910  * there is no line waiting to be processed in the input buffer.
911  */
912  if (last && status == 0) {
913  const cfe_run *rp =
914  (ss->K > 0 ? &cf2_run_eol_1d : &cf_run_eol);
915  int i = (!ss->EndOfBlock ? 0 : ss->K < 0 ? 2 : 6);
916  unsigned int bits_to_write =
917  hc_bits_size - ss->bits_left + i * rp->code_length;
918  unsigned char *q = pw->ptr;
919 
921 
922  if (0U+(wlimit - q) < (bits_to_write + 7) >> 3) { /* PTS_UNSIGNED */
923  status = 1;
924  goto out;
925  }
926  hce_load_state();
927  if (ss->EncodedByteAlign)
928  bits_left &= ~7;
929  while (--i >= 0)
930  hc_put_code(ss, q, rp);
931  /* Force out the last unsigned char or bytes. */
932  pw->ptr = hc_put_last_bits((stream_hc_state *) ss, q);
933  }
934  out:
935  if_debug9('w', "[w]CFE exit %d: read_count = %d, write_count = %d,\n pr = 0x%lx(%d)0x%lx; pw = 0x%lx(%d)0x%lx\n",
936  status, ss->read_count, ss->write_count,
937  (unsigned long) pr->ptr, (int)(rlimit - pr->ptr), (unsigned long) rlimit,
938  (unsigned long) pw->ptr, (int)(wlimit - pw->ptr), (unsigned long) wlimit);
939 #ifdef DEBUG
940  if (pr->ptr > rlimit || pw->ptr > wlimit) {
941  lprintf("Pointer overrun!\n");
943  }
944  if (gs_debug_c('w') && status == 1) {
945  dlputs("[w]white runs:");
946  print_run_stats(&stats_white_runs);
947  dlputs("[w]black runs:");
948  print_run_stats(&stats_black_runs);
949  }
950 #endif
951  return status;
952 }
953 
954 /* Encode a 1-D scan line. */
955 static void
956 cf_encode_1d(stream_CFE_state * ss, const unsigned char * lbuf, stream_cursor_write * pw)
957 {
958  unsigned int count = ss->raster << 3;
959  unsigned char *q = pw->ptr;
960  int end_count = -ss->Columns & 7;
961  int rlen;
962 
964  const unsigned char *p = lbuf;
965  unsigned char invert = (ss->BlackIs1 ? 0 : 0xff);
966 
967  /* Invariant: data = p[-1] ^ invert. */
968  unsigned int data = *p++ ^ invert;
969 
970  hce_load_state();
971  while (count != 0U+end_count) { /* PTS_UNSIGNED */
972  /* Parse a white run. */
973  skip_white_pixels(data, p, count, invert, rlen);
974  CF_PUT_WHITE_RUN(ss, rlen);
975  if (count == 0U+end_count) /* PTS_UNSIGNED */
976  break;
977  /* Parse a black run. */
978  skip_black_pixels(data, p, count, invert, rlen);
979  CF_PUT_BLACK_RUN(ss, rlen);
980  }
981  hce_store_state();
982  pw->ptr = q;
983 }
984 
985 /* Encode a 2-D scan line. */
986 static void
987 cf_encode_2d(stream_CFE_state * ss, const unsigned char * lbuf, stream_cursor_write * pw,
988  const unsigned char * lprev)
989 {
990  unsigned char invert_white = (ss->BlackIs1 ? 0 : 0xff);
991  unsigned char invert = invert_white;
992  unsigned int count = ss->raster << 3;
993  int end_count = -ss->Columns & 7;
994  const unsigned char *p = lbuf;
995  unsigned char *q = pw->ptr;
996  unsigned int data = *p++ ^ invert;
997 
999  /*
1000  * In order to handle the nominal 'changing white' at the beginning of
1001  * each scan line, we need to suppress the test for an initial black bit
1002  * in the reference line when we are at the very beginning of the scan
1003  * line. To avoid an extra test, we use two different mask tables.
1004  */
1005  static const unsigned char initial_count_bit[8] =
1006  {
1007  0, 1, 2, 4, 8, 0x10, 0x20, 0x40
1008  };
1009  static const unsigned char further_count_bit[8] =
1010  {
1011  0x80, 1, 2, 4, 8, 0x10, 0x20, 0x40
1012  };
1013  const unsigned char *count_bit = initial_count_bit;
1014 
1015  hce_load_state();
1016  while (count != 0U+end_count) { /* PTS_UNSIGNED */
1017  /*
1018  * If invert == invert_white, white and black have their
1019  * correct meanings; if invert == ~invert_white,
1020  * black and white are interchanged.
1021  */
1022  unsigned int a0 = count;
1023  unsigned int a1;
1024 
1025 #define b1 (a1 - diff) /* only for printing */
1026  int diff;
1027  unsigned int prev_count = count;
1028  const unsigned char *prev_p = p - lbuf + lprev;
1029  unsigned char prev_data = prev_p[-1] ^ invert;
1030  int rlen;
1031 
1032  /* Find the a1 and b1 transitions. */
1033  skip_white_pixels(data, p, count, invert, rlen);
1034  a1 = count;
1035  if ((prev_data & count_bit[prev_count & 7])) {
1036  /* Look for changing white first. */
1037  skip_black_pixels(prev_data, prev_p, prev_count, invert, rlen);
1038  }
1039  count_bit = further_count_bit; /* no longer at beginning */
1040  pass:
1041  if (prev_count != 0U+end_count) /* PTS_UNSIGNED */
1042  skip_white_pixels(prev_data, prev_p, prev_count, invert, rlen);
1043  diff = a1 - prev_count; /* i.e., logical b1 - a1 */
1044  /* In all the comparisons below, remember that count */
1045  /* runs downward, not upward, so the comparisons are */
1046  /* reversed. */
1047  if (diff <= -2) {
1048  /* Could be a pass mode. Find b2. */
1049  if (prev_count != 0U+ end_count) /* PTS_UNSIGNED */
1050  skip_black_pixels(prev_data, prev_p,
1051  prev_count, invert, rlen);
1052  if (prev_count > a1) {
1053  /* Use pass mode. */
1054  if_debug4('W', "[W]pass: count = %d, a1 = %d, b1 = %d, new count = %d\n",
1055  a0, a1, b1, prev_count);
1057  a0 = prev_count;
1058  goto pass;
1059  }
1060  }
1061  /* Check for vertical coding. */
1062  if (diff <= 3 && diff >= -3) {
1063  /* Use vertical coding. */
1064  const cfe_run *cp = &cf2_run_vertical[diff + 3];
1065 
1066  if_debug5('W', "[W]vertical %d: count = %d, a1 = %d, b1 = %d, new count = %d\n",
1067  diff, a0, a1, b1, count);
1068  hc_put_code(ss, q, cp);
1069  invert = ~~invert; /* a1 polarity changes */
1070  data ^= 0xff;
1071  continue;
1072  }
1073  /* No luck, use horizontal coding. */
1074  if (count != 0U+end_count) /* PTS_UNSIGNED */
1075  skip_black_pixels(data, p, count, invert, rlen); /* find a2 */
1078  a0 -= a1;
1079  a1 -= count;
1080  if (invert == invert_white) {
1081  if_debug3('W', "[W]horizontal: white = %d, black = %d, new count = %d\n",
1082  a0, a1, count);
1083  CF_PUT_WHITE_RUN(ss, a0);
1084  CF_PUT_BLACK_RUN(ss, a1);
1085  } else {
1086  if_debug3('W', "[W]horizontal: black = %d, white = %d, new count = %d\n",
1087  a0, a1, count);
1088  CF_PUT_BLACK_RUN(ss, a0);
1089  CF_PUT_WHITE_RUN(ss, a1);
1090 #undef b1
1091  }
1092  }
1093  hce_store_state();
1094  pw->ptr = q;
1095 }
1096 
1097 /* Stream template */
1099  /*0, &st_CFE_state*/ s_CFE_init, s_CFE_process, 1, 1,
1101 };
1102 /* end of former scfe.c */
1103 
1104 /* scfetab.c */
1105 /*$Id: pts_fax.c,v 1.3 2005/02/21 13:09:56 pts Exp $ */
1106 /* Tables for CCITTFaxEncode filter */
1107 /* #include "scommon.h" */ /* for scf.h */
1108 /* #include "scf.h" */
1109 
1110 /* We make this a separate file so that it can be used by */
1111 /* the program that generates the tables for the CCITTFaxDecode filter. */
1112 
1113 /* ------ Run encoding tables ------ */
1114 
1115 /* Abbreviate hce_entry to make the file smaller. */
1116 #define RUN(c,len) hce_entry(c,len)
1117 
1118 /* Define the end-of-line code. */
1119 /* Code in scfd.c and scfdgen.c knows that the run value is 1. */
1122 
1123 /* Define the 1-D code that signals uncompressed data. */
1125 RUN(0xf, 12);
1126 
1127 /* Define the 2-D run codes. */
1131 {
1132  RUN(0x3, 7),
1133  RUN(0x3, 6),
1134  RUN(0x3, 3),
1135  RUN(0x1, 1),
1136  RUN(0x2, 3),
1137  RUN(0x2, 6),
1138  RUN(0x2, 7)
1139 };
1143 RUN(0xf, 10);
1144 
1145 /* EOL codes for Group 3 2-D. */
1146 /* Code in scfd.c knows that these are 0...01x. */
1148 RUN((run_eol_code_value << 1) + 1, run_eol_code_length + 1);
1150 RUN((run_eol_code_value << 1) + 0, run_eol_code_length + 1);
1151 
1152 /* White run codes. */
1154 {
1155  { /* Termination codes */
1156  RUN(0x35, 8), RUN(0x7, 6), RUN(0x7, 4), RUN(0x8, 4),
1157  RUN(0xb, 4), RUN(0xc, 4), RUN(0xe, 4), RUN(0xf, 4),
1158  RUN(0x13, 5), RUN(0x14, 5), RUN(0x7, 5), RUN(0x8, 5),
1159  RUN(0x8, 6), RUN(0x3, 6), RUN(0x34, 6), RUN(0x35, 6),
1160  RUN(0x2a, 6), RUN(0x2b, 6), RUN(0x27, 7), RUN(0xc, 7),
1161  RUN(0x8, 7), RUN(0x17, 7), RUN(0x3, 7), RUN(0x4, 7),
1162  RUN(0x28, 7), RUN(0x2b, 7), RUN(0x13, 7), RUN(0x24, 7),
1163  RUN(0x18, 7), RUN(0x2, 8), RUN(0x3, 8), RUN(0x1a, 8),
1164  RUN(0x1b, 8), RUN(0x12, 8), RUN(0x13, 8), RUN(0x14, 8),
1165  RUN(0x15, 8), RUN(0x16, 8), RUN(0x17, 8), RUN(0x28, 8),
1166  RUN(0x29, 8), RUN(0x2a, 8), RUN(0x2b, 8), RUN(0x2c, 8),
1167  RUN(0x2d, 8), RUN(0x4, 8), RUN(0x5, 8), RUN(0xa, 8),
1168  RUN(0xb, 8), RUN(0x52, 8), RUN(0x53, 8), RUN(0x54, 8),
1169  RUN(0x55, 8), RUN(0x24, 8), RUN(0x25, 8), RUN(0x58, 8),
1170  RUN(0x59, 8), RUN(0x5a, 8), RUN(0x5b, 8), RUN(0x4a, 8),
1171  RUN(0x4b, 8), RUN(0x32, 8), RUN(0x33, 8), RUN(0x34, 8)
1172  },
1173  { /* Make-up codes */
1174  RUN(0, 0) /* dummy */ , RUN(0x1b, 5), RUN(0x12, 5), RUN(0x17, 6),
1175  RUN(0x37, 7), RUN(0x36, 8), RUN(0x37, 8), RUN(0x64, 8),
1176  RUN(0x65, 8), RUN(0x68, 8), RUN(0x67, 8), RUN(0xcc, 9),
1177  RUN(0xcd, 9), RUN(0xd2, 9), RUN(0xd3, 9), RUN(0xd4, 9),
1178  RUN(0xd5, 9), RUN(0xd6, 9), RUN(0xd7, 9), RUN(0xd8, 9),
1179  RUN(0xd9, 9), RUN(0xda, 9), RUN(0xdb, 9), RUN(0x98, 9),
1180  RUN(0x99, 9), RUN(0x9a, 9), RUN(0x18, 6), RUN(0x9b, 9),
1181  RUN(0x8, 11), RUN(0xc, 11), RUN(0xd, 11), RUN(0x12, 12),
1182  RUN(0x13, 12), RUN(0x14, 12), RUN(0x15, 12), RUN(0x16, 12),
1183  RUN(0x17, 12), RUN(0x1c, 12), RUN(0x1d, 12), RUN(0x1e, 12),
1184  RUN(0x1f, 12)
1185  }
1186 };
1187 
1188 /* Black run codes. */
1190 {
1191  { /* Termination codes */
1192  RUN(0x37, 10), RUN(0x2, 3), RUN(0x3, 2), RUN(0x2, 2),
1193  RUN(0x3, 3), RUN(0x3, 4), RUN(0x2, 4), RUN(0x3, 5),
1194  RUN(0x5, 6), RUN(0x4, 6), RUN(0x4, 7), RUN(0x5, 7),
1195  RUN(0x7, 7), RUN(0x4, 8), RUN(0x7, 8), RUN(0x18, 9),
1196  RUN(0x17, 10), RUN(0x18, 10), RUN(0x8, 10), RUN(0x67, 11),
1197  RUN(0x68, 11), RUN(0x6c, 11), RUN(0x37, 11), RUN(0x28, 11),
1198  RUN(0x17, 11), RUN(0x18, 11), RUN(0xca, 12), RUN(0xcb, 12),
1199  RUN(0xcc, 12), RUN(0xcd, 12), RUN(0x68, 12), RUN(0x69, 12),
1200  RUN(0x6a, 12), RUN(0x6b, 12), RUN(0xd2, 12), RUN(0xd3, 12),
1201  RUN(0xd4, 12), RUN(0xd5, 12), RUN(0xd6, 12), RUN(0xd7, 12),
1202  RUN(0x6c, 12), RUN(0x6d, 12), RUN(0xda, 12), RUN(0xdb, 12),
1203  RUN(0x54, 12), RUN(0x55, 12), RUN(0x56, 12), RUN(0x57, 12),
1204  RUN(0x64, 12), RUN(0x65, 12), RUN(0x52, 12), RUN(0x53, 12),
1205  RUN(0x24, 12), RUN(0x37, 12), RUN(0x38, 12), RUN(0x27, 12),
1206  RUN(0x28, 12), RUN(0x58, 12), RUN(0x59, 12), RUN(0x2b, 12),
1207  RUN(0x2c, 12), RUN(0x5a, 12), RUN(0x66, 12), RUN(0x67, 12)
1208  },
1209  { /* Make-up codes. */
1210  RUN(0, 0) /* dummy */ , RUN(0xf, 10), RUN(0xc8, 12), RUN(0xc9, 12),
1211  RUN(0x5b, 12), RUN(0x33, 12), RUN(0x34, 12), RUN(0x35, 12),
1212  RUN(0x6c, 13), RUN(0x6d, 13), RUN(0x4a, 13), RUN(0x4b, 13),
1213  RUN(0x4c, 13), RUN(0x4d, 13), RUN(0x72, 13), RUN(0x73, 13),
1214  RUN(0x74, 13), RUN(0x75, 13), RUN(0x76, 13), RUN(0x77, 13),
1215  RUN(0x52, 13), RUN(0x53, 13), RUN(0x54, 13), RUN(0x55, 13),
1216  RUN(0x5a, 13), RUN(0x5b, 13), RUN(0x64, 13), RUN(0x65, 13),
1217  RUN(0x8, 11), RUN(0xc, 11), RUN(0xd, 11), RUN(0x12, 12),
1218  RUN(0x13, 12), RUN(0x14, 12), RUN(0x15, 12), RUN(0x16, 12),
1219  RUN(0x17, 12), RUN(0x1c, 12), RUN(0x1d, 12), RUN(0x1e, 12),
1220  RUN(0x1f, 12)
1221  }
1222 };
1223 
1224 /* Uncompressed codes. */
1226 {
1227  RUN(1, 1),
1228  RUN(1, 2),
1229  RUN(1, 3),
1230  RUN(1, 4),
1231  RUN(1, 5),
1232  RUN(1, 6)
1233 };
1234 
1235 /* Uncompressed exit codes. */
1237 {
1238  RUN(2, 8), RUN(3, 8),
1239  RUN(2, 9), RUN(3, 9),
1240  RUN(2, 10), RUN(3, 10),
1241  RUN(2, 11), RUN(3, 11),
1242  RUN(2, 12), RUN(3, 12)
1243 };
1244 
1245 #if 0
1246 /* Some C compilers insist on having executable code in every file.... */
1247 void scfetab_dummy _((void)); /* for picky compilers */
1248 void
1249 scfetab_dummy(void)
1250 {
1251 }
1252 #endif
1253 
1254 /* end of former scfetab.c */
1255 
1256 #endif /* USE_BUILTIN_FAXE */
1257 
1258 #if USE_BUILTIN_FAXD
1259 #if OBJDEP
1260 # warning PROVIDES: pts_faxd
1261 #endif
1262 /* scfdtab.c; must be before scfd.c */
1263 /* #include "scommon.h" */ /* for scf.h */
1264 /* #include "scf.h" */
1265 
1266 /* White decoding table. */
1267 impl_const cfd_node cf_white_decode[] = {
1268  { 256, 12 },
1269  { 272, 12 },
1270  { 29, 8 },
1271  { 30, 8 },
1272  { 45, 8 },
1273  { 46, 8 },
1274  { 22, 7 },
1275  { 22, 7 },
1276  { 23, 7 },
1277  { 23, 7 },
1278  { 47, 8 },
1279  { 48, 8 },
1280  { 13, 6 },
1281  { 13, 6 },
1282  { 13, 6 },
1283  { 13, 6 },
1284  { 20, 7 },
1285  { 20, 7 },
1286  { 33, 8 },
1287  { 34, 8 },
1288  { 35, 8 },
1289  { 36, 8 },
1290  { 37, 8 },
1291  { 38, 8 },
1292  { 19, 7 },
1293  { 19, 7 },
1294  { 31, 8 },
1295  { 32, 8 },
1296  { 1, 6 },
1297  { 1, 6 },
1298  { 1, 6 },
1299  { 1, 6 },
1300  { 12, 6 },
1301  { 12, 6 },
1302  { 12, 6 },
1303  { 12, 6 },
1304  { 53, 8 },
1305  { 54, 8 },
1306  { 26, 7 },
1307  { 26, 7 },
1308  { 39, 8 },
1309  { 40, 8 },
1310  { 41, 8 },
1311  { 42, 8 },
1312  { 43, 8 },
1313  { 44, 8 },
1314  { 21, 7 },
1315  { 21, 7 },
1316  { 28, 7 },
1317  { 28, 7 },
1318  { 61, 8 },
1319  { 62, 8 },
1320  { 63, 8 },
1321  { 0, 8 },
1322  { 320, 8 },
1323  { 384, 8 },
1324  { 10, 5 },
1325  { 10, 5 },
1326  { 10, 5 },
1327  { 10, 5 },
1328  { 10, 5 },
1329  { 10, 5 },
1330  { 10, 5 },
1331  { 10, 5 },
1332  { 11, 5 },
1333  { 11, 5 },
1334  { 11, 5 },
1335  { 11, 5 },
1336  { 11, 5 },
1337  { 11, 5 },
1338  { 11, 5 },
1339  { 11, 5 },
1340  { 27, 7 },
1341  { 27, 7 },
1342  { 59, 8 },
1343  { 60, 8 },
1344  { 288, 9 },
1345  { 290, 9 },
1346  { 18, 7 },
1347  { 18, 7 },
1348  { 24, 7 },
1349  { 24, 7 },
1350  { 49, 8 },
1351  { 50, 8 },
1352  { 51, 8 },
1353  { 52, 8 },
1354  { 25, 7 },
1355  { 25, 7 },
1356  { 55, 8 },
1357  { 56, 8 },
1358  { 57, 8 },
1359  { 58, 8 },
1360  { 192, 6 },
1361  { 192, 6 },
1362  { 192, 6 },
1363  { 192, 6 },
1364  { 1664, 6 },
1365  { 1664, 6 },
1366  { 1664, 6 },
1367  { 1664, 6 },
1368  { 448, 8 },
1369  { 512, 8 },
1370  { 292, 9 },
1371  { 640, 8 },
1372  { 576, 8 },
1373  { 294, 9 },
1374  { 296, 9 },
1375  { 298, 9 },
1376  { 300, 9 },
1377  { 302, 9 },
1378  { 256, 7 },
1379  { 256, 7 },
1380  { 2, 4 },
1381  { 2, 4 },
1382  { 2, 4 },
1383  { 2, 4 },
1384  { 2, 4 },
1385  { 2, 4 },
1386  { 2, 4 },
1387  { 2, 4 },
1388  { 2, 4 },
1389  { 2, 4 },
1390  { 2, 4 },
1391  { 2, 4 },
1392  { 2, 4 },
1393  { 2, 4 },
1394  { 2, 4 },
1395  { 2, 4 },
1396  { 3, 4 },
1397  { 3, 4 },
1398  { 3, 4 },
1399  { 3, 4 },
1400  { 3, 4 },
1401  { 3, 4 },
1402  { 3, 4 },
1403  { 3, 4 },
1404  { 3, 4 },
1405  { 3, 4 },
1406  { 3, 4 },
1407  { 3, 4 },
1408  { 3, 4 },
1409  { 3, 4 },
1410  { 3, 4 },
1411  { 3, 4 },
1412  { 128, 5 },
1413  { 128, 5 },
1414  { 128, 5 },
1415  { 128, 5 },
1416  { 128, 5 },
1417  { 128, 5 },
1418  { 128, 5 },
1419  { 128, 5 },
1420  { 8, 5 },
1421  { 8, 5 },
1422  { 8, 5 },
1423  { 8, 5 },
1424  { 8, 5 },
1425  { 8, 5 },
1426  { 8, 5 },
1427  { 8, 5 },
1428  { 9, 5 },
1429  { 9, 5 },
1430  { 9, 5 },
1431  { 9, 5 },
1432  { 9, 5 },
1433  { 9, 5 },
1434  { 9, 5 },
1435  { 9, 5 },
1436  { 16, 6 },
1437  { 16, 6 },
1438  { 16, 6 },
1439  { 16, 6 },
1440  { 17, 6 },
1441  { 17, 6 },
1442  { 17, 6 },
1443  { 17, 6 },
1444  { 4, 4 },
1445  { 4, 4 },
1446  { 4, 4 },
1447  { 4, 4 },
1448  { 4, 4 },
1449  { 4, 4 },
1450  { 4, 4 },
1451  { 4, 4 },
1452  { 4, 4 },
1453  { 4, 4 },
1454  { 4, 4 },
1455  { 4, 4 },
1456  { 4, 4 },
1457  { 4, 4 },
1458  { 4, 4 },
1459  { 4, 4 },
1460  { 5, 4 },
1461  { 5, 4 },
1462  { 5, 4 },
1463  { 5, 4 },
1464  { 5, 4 },
1465  { 5, 4 },
1466  { 5, 4 },
1467  { 5, 4 },
1468  { 5, 4 },
1469  { 5, 4 },
1470  { 5, 4 },
1471  { 5, 4 },
1472  { 5, 4 },
1473  { 5, 4 },
1474  { 5, 4 },
1475  { 5, 4 },
1476  { 14, 6 },
1477  { 14, 6 },
1478  { 14, 6 },
1479  { 14, 6 },
1480  { 15, 6 },
1481  { 15, 6 },
1482  { 15, 6 },
1483  { 15, 6 },
1484  { 64, 5 },
1485  { 64, 5 },
1486  { 64, 5 },
1487  { 64, 5 },
1488  { 64, 5 },
1489  { 64, 5 },
1490  { 64, 5 },
1491  { 64, 5 },
1492  { 6, 4 },
1493  { 6, 4 },
1494  { 6, 4 },
1495  { 6, 4 },
1496  { 6, 4 },
1497  { 6, 4 },
1498  { 6, 4 },
1499  { 6, 4 },
1500  { 6, 4 },
1501  { 6, 4 },
1502  { 6, 4 },
1503  { 6, 4 },
1504  { 6, 4 },
1505  { 6, 4 },
1506  { 6, 4 },
1507  { 6, 4 },
1508  { 7, 4 },
1509  { 7, 4 },
1510  { 7, 4 },
1511  { 7, 4 },
1512  { 7, 4 },
1513  { 7, 4 },
1514  { 7, 4 },
1515  { 7, 4 },
1516  { 7, 4 },
1517  { 7, 4 },
1518  { 7, 4 },
1519  { 7, 4 },
1520  { 7, 4 },
1521  { 7, 4 },
1522  { 7, 4 },
1523  { 7, 4 },
1524  { -2, 3 },
1525  { -2, 3 },
1526  { -1, 0 },
1527  { -1, 0 },
1528  { -1, 0 },
1529  { -1, 0 },
1530  { -1, 0 },
1531  { -1, 0 },
1532  { -1, 0 },
1533  { -1, 0 },
1534  { -1, 0 },
1535  { -1, 0 },
1536  { -1, 0 },
1537  { -1, 0 },
1538  { -1, 0 },
1539  { -3, 4 },
1540  { 1792, 3 },
1541  { 1792, 3 },
1542  { 1984, 4 },
1543  { 2048, 4 },
1544  { 2112, 4 },
1545  { 2176, 4 },
1546  { 2240, 4 },
1547  { 2304, 4 },
1548  { 1856, 3 },
1549  { 1856, 3 },
1550  { 1920, 3 },
1551  { 1920, 3 },
1552  { 2368, 4 },
1553  { 2432, 4 },
1554  { 2496, 4 },
1555  { 2560, 4 },
1556  { 1472, 1 },
1557  { 1536, 1 },
1558  { 1600, 1 },
1559  { 1728, 1 },
1560  { 704, 1 },
1561  { 768, 1 },
1562  { 832, 1 },
1563  { 896, 1 },
1564  { 960, 1 },
1565  { 1024, 1 },
1566  { 1088, 1 },
1567  { 1152, 1 },
1568  { 1216, 1 },
1569  { 1280, 1 },
1570  { 1344, 1 },
1571  { 1408, 1 }
1572 };
1573 
1574 /* Black decoding table. */
1575 impl_const cfd_node cf_black_decode[] = {
1576  { 128, 12 },
1577  { 160, 13 },
1578  { 224, 12 },
1579  { 256, 12 },
1580  { 10, 7 },
1581  { 11, 7 },
1582  { 288, 12 },
1583  { 12, 7 },
1584  { 9, 6 },
1585  { 9, 6 },
1586  { 8, 6 },
1587  { 8, 6 },
1588  { 7, 5 },
1589  { 7, 5 },
1590  { 7, 5 },
1591  { 7, 5 },
1592  { 6, 4 },
1593  { 6, 4 },
1594  { 6, 4 },
1595  { 6, 4 },
1596  { 6, 4 },
1597  { 6, 4 },
1598  { 6, 4 },
1599  { 6, 4 },
1600  { 5, 4 },
1601  { 5, 4 },
1602  { 5, 4 },
1603  { 5, 4 },
1604  { 5, 4 },
1605  { 5, 4 },
1606  { 5, 4 },
1607  { 5, 4 },
1608  { 1, 3 },
1609  { 1, 3 },
1610  { 1, 3 },
1611  { 1, 3 },
1612  { 1, 3 },
1613  { 1, 3 },
1614  { 1, 3 },
1615  { 1, 3 },
1616  { 1, 3 },
1617  { 1, 3 },
1618  { 1, 3 },
1619  { 1, 3 },
1620  { 1, 3 },
1621  { 1, 3 },
1622  { 1, 3 },
1623  { 1, 3 },
1624  { 4, 3 },
1625  { 4, 3 },
1626  { 4, 3 },
1627  { 4, 3 },
1628  { 4, 3 },
1629  { 4, 3 },
1630  { 4, 3 },
1631  { 4, 3 },
1632  { 4, 3 },
1633  { 4, 3 },
1634  { 4, 3 },
1635  { 4, 3 },
1636  { 4, 3 },
1637  { 4, 3 },
1638  { 4, 3 },
1639  { 4, 3 },
1640  { 3, 2 },
1641  { 3, 2 },
1642  { 3, 2 },
1643  { 3, 2 },
1644  { 3, 2 },
1645  { 3, 2 },
1646  { 3, 2 },
1647  { 3, 2 },
1648  { 3, 2 },
1649  { 3, 2 },
1650  { 3, 2 },
1651  { 3, 2 },
1652  { 3, 2 },
1653  { 3, 2 },
1654  { 3, 2 },
1655  { 3, 2 },
1656  { 3, 2 },
1657  { 3, 2 },
1658  { 3, 2 },
1659  { 3, 2 },
1660  { 3, 2 },
1661  { 3, 2 },
1662  { 3, 2 },
1663  { 3, 2 },
1664  { 3, 2 },
1665  { 3, 2 },
1666  { 3, 2 },
1667  { 3, 2 },
1668  { 3, 2 },
1669  { 3, 2 },
1670  { 3, 2 },
1671  { 3, 2 },
1672  { 2, 2 },
1673  { 2, 2 },
1674  { 2, 2 },
1675  { 2, 2 },
1676  { 2, 2 },
1677  { 2, 2 },
1678  { 2, 2 },
1679  { 2, 2 },
1680  { 2, 2 },
1681  { 2, 2 },
1682  { 2, 2 },
1683  { 2, 2 },
1684  { 2, 2 },
1685  { 2, 2 },
1686  { 2, 2 },
1687  { 2, 2 },
1688  { 2, 2 },
1689  { 2, 2 },
1690  { 2, 2 },
1691  { 2, 2 },
1692  { 2, 2 },
1693  { 2, 2 },
1694  { 2, 2 },
1695  { 2, 2 },
1696  { 2, 2 },
1697  { 2, 2 },
1698  { 2, 2 },
1699  { 2, 2 },
1700  { 2, 2 },
1701  { 2, 2 },
1702  { 2, 2 },
1703  { 2, 2 },
1704  { -2, 4 },
1705  { -2, 4 },
1706  { -1, 0 },
1707  { -1, 0 },
1708  { -1, 0 },
1709  { -1, 0 },
1710  { -1, 0 },
1711  { -1, 0 },
1712  { -1, 0 },
1713  { -1, 0 },
1714  { -1, 0 },
1715  { -1, 0 },
1716  { -1, 0 },
1717  { -1, 0 },
1718  { -1, 0 },
1719  { -3, 5 },
1720  { 1792, 4 },
1721  { 1792, 4 },
1722  { 1984, 5 },
1723  { 2048, 5 },
1724  { 2112, 5 },
1725  { 2176, 5 },
1726  { 2240, 5 },
1727  { 2304, 5 },
1728  { 1856, 4 },
1729  { 1856, 4 },
1730  { 1920, 4 },
1731  { 1920, 4 },
1732  { 2368, 5 },
1733  { 2432, 5 },
1734  { 2496, 5 },
1735  { 2560, 5 },
1736  { 18, 3 },
1737  { 18, 3 },
1738  { 18, 3 },
1739  { 18, 3 },
1740  { 18, 3 },
1741  { 18, 3 },
1742  { 18, 3 },
1743  { 18, 3 },
1744  { 52, 5 },
1745  { 52, 5 },
1746  { 640, 6 },
1747  { 704, 6 },
1748  { 768, 6 },
1749  { 832, 6 },
1750  { 55, 5 },
1751  { 55, 5 },
1752  { 56, 5 },
1753  { 56, 5 },
1754  { 1280, 6 },
1755  { 1344, 6 },
1756  { 1408, 6 },
1757  { 1472, 6 },
1758  { 59, 5 },
1759  { 59, 5 },
1760  { 60, 5 },
1761  { 60, 5 },
1762  { 1536, 6 },
1763  { 1600, 6 },
1764  { 24, 4 },
1765  { 24, 4 },
1766  { 24, 4 },
1767  { 24, 4 },
1768  { 25, 4 },
1769  { 25, 4 },
1770  { 25, 4 },
1771  { 25, 4 },
1772  { 1664, 6 },
1773  { 1728, 6 },
1774  { 320, 5 },
1775  { 320, 5 },
1776  { 384, 5 },
1777  { 384, 5 },
1778  { 448, 5 },
1779  { 448, 5 },
1780  { 512, 6 },
1781  { 576, 6 },
1782  { 53, 5 },
1783  { 53, 5 },
1784  { 54, 5 },
1785  { 54, 5 },
1786  { 896, 6 },
1787  { 960, 6 },
1788  { 1024, 6 },
1789  { 1088, 6 },
1790  { 1152, 6 },
1791  { 1216, 6 },
1792  { 64, 3 },
1793  { 64, 3 },
1794  { 64, 3 },
1795  { 64, 3 },
1796  { 64, 3 },
1797  { 64, 3 },
1798  { 64, 3 },
1799  { 64, 3 },
1800  { 13, 1 },
1801  { 13, 1 },
1802  { 13, 1 },
1803  { 13, 1 },
1804  { 13, 1 },
1805  { 13, 1 },
1806  { 13, 1 },
1807  { 13, 1 },
1808  { 13, 1 },
1809  { 13, 1 },
1810  { 13, 1 },
1811  { 13, 1 },
1812  { 13, 1 },
1813  { 13, 1 },
1814  { 13, 1 },
1815  { 13, 1 },
1816  { 23, 4 },
1817  { 23, 4 },
1818  { 50, 5 },
1819  { 51, 5 },
1820  { 44, 5 },
1821  { 45, 5 },
1822  { 46, 5 },
1823  { 47, 5 },
1824  { 57, 5 },
1825  { 58, 5 },
1826  { 61, 5 },
1827  { 256, 5 },
1828  { 16, 3 },
1829  { 16, 3 },
1830  { 16, 3 },
1831  { 16, 3 },
1832  { 17, 3 },
1833  { 17, 3 },
1834  { 17, 3 },
1835  { 17, 3 },
1836  { 48, 5 },
1837  { 49, 5 },
1838  { 62, 5 },
1839  { 63, 5 },
1840  { 30, 5 },
1841  { 31, 5 },
1842  { 32, 5 },
1843  { 33, 5 },
1844  { 40, 5 },
1845  { 41, 5 },
1846  { 22, 4 },
1847  { 22, 4 },
1848  { 14, 1 },
1849  { 14, 1 },
1850  { 14, 1 },
1851  { 14, 1 },
1852  { 14, 1 },
1853  { 14, 1 },
1854  { 14, 1 },
1855  { 14, 1 },
1856  { 14, 1 },
1857  { 14, 1 },
1858  { 14, 1 },
1859  { 14, 1 },
1860  { 14, 1 },
1861  { 14, 1 },
1862  { 14, 1 },
1863  { 14, 1 },
1864  { 15, 2 },
1865  { 15, 2 },
1866  { 15, 2 },
1867  { 15, 2 },
1868  { 15, 2 },
1869  { 15, 2 },
1870  { 15, 2 },
1871  { 15, 2 },
1872  { 128, 5 },
1873  { 192, 5 },
1874  { 26, 5 },
1875  { 27, 5 },
1876  { 28, 5 },
1877  { 29, 5 },
1878  { 19, 4 },
1879  { 19, 4 },
1880  { 20, 4 },
1881  { 20, 4 },
1882  { 34, 5 },
1883  { 35, 5 },
1884  { 36, 5 },
1885  { 37, 5 },
1886  { 38, 5 },
1887  { 39, 5 },
1888  { 21, 4 },
1889  { 21, 4 },
1890  { 42, 5 },
1891  { 43, 5 },
1892  { 0, 3 },
1893  { 0, 3 },
1894  { 0, 3 },
1895  { 0, 3 }
1896 };
1897 
1898 /* 2-D decoding table. */
1899 impl_const cfd_node cf_2d_decode[] = {
1900  { 128, 11 },
1901  { 144, 10 },
1902  { 6, 7 },
1903  { 0, 7 },
1904  { 5, 6 },
1905  { 5, 6 },
1906  { 1, 6 },
1907  { 1, 6 },
1908  { -4, 4 },
1909  { -4, 4 },
1910  { -4, 4 },
1911  { -4, 4 },
1912  { -4, 4 },
1913  { -4, 4 },
1914  { -4, 4 },
1915  { -4, 4 },
1916  { -5, 3 },
1917  { -5, 3 },
1918  { -5, 3 },
1919  { -5, 3 },
1920  { -5, 3 },
1921  { -5, 3 },
1922  { -5, 3 },
1923  { -5, 3 },
1924  { -5, 3 },
1925  { -5, 3 },
1926  { -5, 3 },
1927  { -5, 3 },
1928  { -5, 3 },
1929  { -5, 3 },
1930  { -5, 3 },
1931  { -5, 3 },
1932  { 4, 3 },
1933  { 4, 3 },
1934  { 4, 3 },
1935  { 4, 3 },
1936  { 4, 3 },
1937  { 4, 3 },
1938  { 4, 3 },
1939  { 4, 3 },
1940  { 4, 3 },
1941  { 4, 3 },
1942  { 4, 3 },
1943  { 4, 3 },
1944  { 4, 3 },
1945  { 4, 3 },
1946  { 4, 3 },
1947  { 4, 3 },
1948  { 2, 3 },
1949  { 2, 3 },
1950  { 2, 3 },
1951  { 2, 3 },
1952  { 2, 3 },
1953  { 2, 3 },
1954  { 2, 3 },
1955  { 2, 3 },
1956  { 2, 3 },
1957  { 2, 3 },
1958  { 2, 3 },
1959  { 2, 3 },
1960  { 2, 3 },
1961  { 2, 3 },
1962  { 2, 3 },
1963  { 2, 3 },
1964  { 3, 1 },
1965  { 3, 1 },
1966  { 3, 1 },
1967  { 3, 1 },
1968  { 3, 1 },
1969  { 3, 1 },
1970  { 3, 1 },
1971  { 3, 1 },
1972  { 3, 1 },
1973  { 3, 1 },
1974  { 3, 1 },
1975  { 3, 1 },
1976  { 3, 1 },
1977  { 3, 1 },
1978  { 3, 1 },
1979  { 3, 1 },
1980  { 3, 1 },
1981  { 3, 1 },
1982  { 3, 1 },
1983  { 3, 1 },
1984  { 3, 1 },
1985  { 3, 1 },
1986  { 3, 1 },
1987  { 3, 1 },
1988  { 3, 1 },
1989  { 3, 1 },
1990  { 3, 1 },
1991  { 3, 1 },
1992  { 3, 1 },
1993  { 3, 1 },
1994  { 3, 1 },
1995  { 3, 1 },
1996  { 3, 1 },
1997  { 3, 1 },
1998  { 3, 1 },
1999  { 3, 1 },
2000  { 3, 1 },
2001  { 3, 1 },
2002  { 3, 1 },
2003  { 3, 1 },
2004  { 3, 1 },
2005  { 3, 1 },
2006  { 3, 1 },
2007  { 3, 1 },
2008  { 3, 1 },
2009  { 3, 1 },
2010  { 3, 1 },
2011  { 3, 1 },
2012  { 3, 1 },
2013  { 3, 1 },
2014  { 3, 1 },
2015  { 3, 1 },
2016  { 3, 1 },
2017  { 3, 1 },
2018  { 3, 1 },
2019  { 3, 1 },
2020  { 3, 1 },
2021  { 3, 1 },
2022  { 3, 1 },
2023  { 3, 1 },
2024  { 3, 1 },
2025  { 3, 1 },
2026  { 3, 1 },
2027  { 3, 1 },
2028  { -2, 4 },
2029  { -1, 0 },
2030  { -1, 0 },
2031  { -1, 0 },
2032  { -1, 0 },
2033  { -1, 0 },
2034  { -1, 0 },
2035  { -1, 0 },
2036  { -1, 0 },
2037  { -1, 0 },
2038  { -1, 0 },
2039  { -1, 0 },
2040  { -1, 0 },
2041  { -1, 0 },
2042  { -1, 0 },
2043  { -1, 0 },
2044  { -1, 0 },
2045  { -1, 0 },
2046  { -1, 0 },
2047  { -1, 0 },
2048  { -1, 0 },
2049  { -1, 0 },
2050  { -1, 0 },
2051  { -3, 3 }
2052 };
2053 
2054 /* Uncompresssed decoding table. */
2055 impl_const cfd_node cf_uncompressed_decode[] = {
2056  { 64, 12 },
2057  { 5, 6 },
2058  { 4, 5 },
2059  { 4, 5 },
2060  { 3, 4 },
2061  { 3, 4 },
2062  { 3, 4 },
2063  { 3, 4 },
2064  { 2, 3 },
2065  { 2, 3 },
2066  { 2, 3 },
2067  { 2, 3 },
2068  { 2, 3 },
2069  { 2, 3 },
2070  { 2, 3 },
2071  { 2, 3 },
2072  { 1, 2 },
2073  { 1, 2 },
2074  { 1, 2 },
2075  { 1, 2 },
2076  { 1, 2 },
2077  { 1, 2 },
2078  { 1, 2 },
2079  { 1, 2 },
2080  { 1, 2 },
2081  { 1, 2 },
2082  { 1, 2 },
2083  { 1, 2 },
2084  { 1, 2 },
2085  { 1, 2 },
2086  { 1, 2 },
2087  { 1, 2 },
2088  { 0, 1 },
2089  { 0, 1 },
2090  { 0, 1 },
2091  { 0, 1 },
2092  { 0, 1 },
2093  { 0, 1 },
2094  { 0, 1 },
2095  { 0, 1 },
2096  { 0, 1 },
2097  { 0, 1 },
2098  { 0, 1 },
2099  { 0, 1 },
2100  { 0, 1 },
2101  { 0, 1 },
2102  { 0, 1 },
2103  { 0, 1 },
2104  { 0, 1 },
2105  { 0, 1 },
2106  { 0, 1 },
2107  { 0, 1 },
2108  { 0, 1 },
2109  { 0, 1 },
2110  { 0, 1 },
2111  { 0, 1 },
2112  { 0, 1 },
2113  { 0, 1 },
2114  { 0, 1 },
2115  { 0, 1 },
2116  { 0, 1 },
2117  { 0, 1 },
2118  { 0, 1 },
2119  { 0, 1 },
2120  { -1, 0 },
2121  { -1, 0 },
2122  { 8, 6 },
2123  { 9, 6 },
2124  { 6, 5 },
2125  { 6, 5 },
2126  { 7, 5 },
2127  { 7, 5 },
2128  { 4, 4 },
2129  { 4, 4 },
2130  { 4, 4 },
2131  { 4, 4 },
2132  { 5, 4 },
2133  { 5, 4 },
2134  { 5, 4 },
2135  { 5, 4 },
2136  { 2, 3 },
2137  { 2, 3 },
2138  { 2, 3 },
2139  { 2, 3 },
2140  { 2, 3 },
2141  { 2, 3 },
2142  { 2, 3 },
2143  { 2, 3 },
2144  { 3, 3 },
2145  { 3, 3 },
2146  { 3, 3 },
2147  { 3, 3 },
2148  { 3, 3 },
2149  { 3, 3 },
2150  { 3, 3 },
2151  { 3, 3 },
2152  { 0, 2 },
2153  { 0, 2 },
2154  { 0, 2 },
2155  { 0, 2 },
2156  { 0, 2 },
2157  { 0, 2 },
2158  { 0, 2 },
2159  { 0, 2 },
2160  { 0, 2 },
2161  { 0, 2 },
2162  { 0, 2 },
2163  { 0, 2 },
2164  { 0, 2 },
2165  { 0, 2 },
2166  { 0, 2 },
2167  { 0, 2 },
2168  { 1, 2 },
2169  { 1, 2 },
2170  { 1, 2 },
2171  { 1, 2 },
2172  { 1, 2 },
2173  { 1, 2 },
2174  { 1, 2 },
2175  { 1, 2 },
2176  { 1, 2 },
2177  { 1, 2 },
2178  { 1, 2 },
2179  { 1, 2 },
2180  { 1, 2 },
2181  { 1, 2 },
2182  { 1, 2 },
2183  { 1, 2 }
2184 };
2185 
2186 #if 0
2187 /* Dummy executable code to pacify compilers. */
2188 void scfdtab_dummy _((void));
2189 void
2190 scfdtab_dummy()
2191 {
2192 }
2193 #endif
2194 /* end of former scfdtab.c */
2195 /* scfd.c */
2196 /*$Id: pts_fax.c,v 1.3 2005/02/21 13:09:56 pts Exp $ */
2197 /* CCITTFax decoding filter */
2198 /* #include "gstypes.h" */
2199 /* #include "scf.h" */
2200 /* #include "scfx.h" */
2201 
2202 /* Utility procedures */
2203 int stream_move _((stream_cursor_read *, stream_cursor_write *)); /* in stream.c */
2204 
2205 /* ------ CCITTFaxDecode ------ */
2206 
2207 /* private_st_CFD_state(); */
2208 
2209 /* Set default parameter values. */
2210 static void
2211 s_CFD_set_defaults(register stream_state * st)
2212 {
2213  stream_CFD_state *const ss = (stream_CFD_state *) st;
2214 
2216 }
2217 
2218 /* Initialize CCITTFaxDecode filter */
2219 static int
2220 s_CFD_init(stream_state * st)
2221 {
2222  stream_CFD_state *const ss = (stream_CFD_state *) st;
2223  int raster = ss->raster =
2224  ROUND_UP((ss->Columns + 7) >> 3, ss->DecodedByteAlign);
2225  unsigned char white = (ss->BlackIs1 ? 0 : 0xff);
2226 
2227  s_hcd_init_inline(ss);
2228  /* Because skip_white_pixels can look as many as 4 bytes ahead, */
2229  /* we need to allow 4 extra bytes at the end of the row buffers. */
2230  ss->lbuf = (unsigned char*)gs_alloc_bytes(st->memory, raster + 4, "CFD lbuf");
2231  ss->lprev = 0;
2232  if (ss->lbuf == 0)
2233  return PTSFAX_ERRC;
2234 /****** WRONG ******/
2235  if (ss->K != 0) {
2236  ss->lprev = (unsigned char*)gs_alloc_bytes(st->memory, raster + 4, "CFD lprev");
2237  if (ss->lprev == 0)
2238  return PTSFAX_ERRC;
2239 /****** WRONG ******/
2240  /* Clear the initial reference line for 2-D encoding. */
2241  ss->memset_(ss->lbuf, white, raster);
2242  /* Ensure that the scan of the reference line will stop. */
2243  ss->lbuf[raster] = 0xa0;
2244  }
2245  ss->k_left = min(ss->K, 0);
2246  ss->run_color = 0;
2247  ss->damaged_rows = 0;
2248  ss->skipping_damage = false;
2249  ss->cbit = 0;
2250  ss->uncomp_run = 0;
2251  ss->rows_left = (ss->Rows <= 0 || ss->EndOfBlock ? -1 : ss->Rows + 1);
2252  ss->rpos = ss->wpos = raster - 1;
2253  ss->eol_count = 0;
2254  ss->invert = white;
2255  ss->min_left = 1;
2256  return 0;
2257 }
2258 
2259 /* Release the filter. */
2260 static void
2261 s_CFD_release(stream_state * st)
2262 {
2263  stream_CFD_state *const ss = (stream_CFD_state *) st;
2264 
2265  gs_free_object(st->memory, ss->lprev, "CFD lprev(close)");
2266  gs_free_object(st->memory, ss->lbuf, "CFD lbuf(close)");
2267 }
2268 
2269 /* Declare the variables that hold the state. */
2270 #define cfd_declare_state\
2271  hcd_declare_state;\
2272  register unsigned char *q;\
2273  int qbit
2274 /* Load the state from the stream. */
2275 #define cfd_load_state()\
2276  hcd_load_state(),\
2277  q = ss->lbuf + ss->wpos, qbit = ss->cbit
2278 /* Store the state back in the stream. */
2279 #define cfd_store_state()\
2280  hcd_store_state(),\
2281  ss->wpos = q - ss->lbuf, ss->cbit = qbit
2282 
2283 /* Macros to get blocks of bits from the input stream. */
2284 /* Invariants: 0 <= bits_left <= bits_size; */
2285 /* bits [bits_left-1..0] contain valid data. */
2286 
2287 #define avail_bits(n) hcd_bits_available(n)
2288 #define ensure_bits(n, outl) hcd_ensure_bits(n, outl)
2289 #define peek_bits(n) hcd_peek_bits(n)
2290 #define peek_var_bits(n) hcd_peek_var_bits(n)
2291 #define skip_bits(n) hcd_skip_bits(n)
2292 
2293 /* Get a run from the stream. */
2294 #ifdef DEBUG
2295 # define IF_DEBUG(expr) expr
2296 #else
2297 # define IF_DEBUG(expr) DO_NOTHING
2298 #endif
2299 #define get_run(decode, initial_bits, min_bits, runlen, str, locl, outl)\
2300  BEGIN\
2301  const cfd_node *np;\
2302  int clen;\
2303 \
2304  HCD_ENSURE_BITS_ELSE(initial_bits) {\
2305  /* We might still have enough bits for the specific code. */\
2306  if (bits_left < min_bits) goto outl;\
2307  np = &decode[hcd_peek_bits_left() << (initial_bits - bits_left)];\
2308  if ((clen = np->code_length) > bits_left) goto outl;\
2309  goto locl;\
2310  }\
2311  np = &decode[peek_bits(initial_bits)];\
2312  if ((clen = np->code_length) > initial_bits) {\
2313  IF_DEBUG(unsigned int init_bits = peek_bits(initial_bits));\
2314  if (!avail_bits(clen)) goto outl;\
2315  clen -= initial_bits;\
2316  skip_bits(initial_bits);\
2317  ensure_bits(clen, outl); /* can't goto outl */\
2318  np = &decode[np->run_length + peek_var_bits(clen)];\
2319  if_debug4('W', "%s xcode=0x%x,%d rlen=%d\n", str,\
2320  (init_bits << np->code_length) +\
2321  peek_var_bits(np->code_length),\
2322  initial_bits + np->code_length,\
2323  np->run_length);\
2324  skip_bits(np->code_length);\
2325  } else {\
2326  locl: if_debug4('W', "%s code=0x%x,%d rlen=%d\n", str,\
2327  peek_var_bits(clen), clen, np->run_length);\
2328  skip_bits(clen);\
2329  }\
2330  runlen = np->run_length;\
2331  END
2332 
2333 /* Skip data bits for a white run. */
2334 /* rlen is either less than 64, or a multiple of 64. */
2335 #define skip_data(rlen, makeup_label)\
2336  if ( (qbit -= rlen) < 0 )\
2337  { q -= qbit >> 3, qbit &= 7;\
2338  if ( rlen >= 64 ) goto makeup_label;\
2339  }
2340 
2341 /* Invert data bits for a black run. */
2342 /* If rlen >= 64, execute makeup_action: this is to handle */
2343 /* makeup codes efficiently, since these are always a multiple of 64. */
2344 #define invert_data(rlen, black_byte, makeup_action, d)\
2345  if ( rlen > qbit )\
2346  { *q++ ^= (1 << qbit) - 1;\
2347  rlen -= qbit;\
2348  switch ( rlen >> 3 )\
2349  {\
2350  case 7: /* original rlen possibly >= 64 */\
2351  if ( rlen + qbit >= 64 ) goto d;\
2352  *q++ = black_byte;\
2353  case 6: *q++ = black_byte;\
2354  case 5: *q++ = black_byte;\
2355  case 4: *q++ = black_byte;\
2356  case 3: *q++ = black_byte;\
2357  case 2: *q++ = black_byte;\
2358  case 1: *q = black_byte;\
2359  rlen &= 7;\
2360  if ( !rlen ) { qbit = 0; break; }\
2361  q++;\
2362  case 0: /* know rlen != 0 */\
2363  qbit = 8 - rlen;\
2364  *q ^= 0xff << qbit;\
2365  break;\
2366  default: /* original rlen >= 64 */\
2367 d: ss->memset_(q, black_byte, rlen >> 3);\
2368  q += rlen >> 3;\
2369  rlen &= 7;\
2370  if ( !rlen ) qbit = 0, q--;\
2371  else qbit = 8 - rlen, *q ^= 0xff << qbit;\
2372  makeup_action;\
2373  }\
2374  }\
2375  else\
2376  qbit -= rlen,\
2377  *q ^= ((1 << rlen) - 1) << qbit
2378 
2379 /* Buffer refill for CCITTFaxDecode filter */
2380 static int cf_decode_eol _((stream_CFD_state *, stream_cursor_read *));
2381 static int cf_decode_1d _((stream_CFD_state *, stream_cursor_read *));
2382 static int cf_decode_2d _((stream_CFD_state *, stream_cursor_read *));
2383 static int cf_decode_uncompressed _((stream_CFD_state *, stream_cursor_read *));
2384 static int
2385 s_CFD_process(stream_state * st, stream_cursor_read * pr,
2386  stream_cursor_write * pw, bool last)
2387 {
2388  stream_CFD_state *const ss = (stream_CFD_state *) st;
2389  int wstop = ss->raster - 1;
2390  int eol_count = ss->eol_count;
2391  int k_left = ss->k_left;
2392  int rows_left = ss->rows_left;
2393  int status = 0;
2394 
2395  (void)last; /**** pts ****/
2396 
2397 #ifdef DEBUG
2398  const unsigned char *rstart = pr->ptr;
2399  const unsigned char *wstart = pw->ptr;
2400 
2401 #endif
2402 
2403  top:
2404 #ifdef DEBUG
2405  {
2407  hcd_load_state();
2408  if_debug8('w', "\
2409 [w]CFD_process top: eol_count=%d, k_left=%d, rows_left=%d\n\
2410  bits=0x%lx, bits_left=%d, read %u, wrote %u%s\n",
2411  eol_count, k_left, rows_left,
2412  (unsigned long) bits, bits_left,
2413  (unsigned int) (p - rstart), (unsigned int) (pw->ptr - wstart),
2414  (ss->skipping_damage ? ", skipping damage" : ""));
2415  }
2416 #endif
2417  if (ss->skipping_damage) { /* Skip until we reach an EOL. */
2419  int skip;
2420 
2421  status = 0;
2422  do {
2423  switch ((skip = cf_decode_eol(ss, pr))) {
2424  default: /* not EOL */
2425  hcd_load_state();
2426  skip_bits(-skip);
2427  hcd_store_state();
2428  continue;
2429  case 0: /* need more input */
2430  goto out;
2431  case 1: /* EOL */
2432  { /* Back up over the EOL. */
2433  hcd_load_state();
2435  hcd_store_state();
2436  }
2437  ss->skipping_damage = false;
2438  }
2439  }
2440  while (ss->skipping_damage);
2441  ss->damaged_rows++;
2442  }
2443  /*
2444  * Check for a completed input scan line. This isn't quite as
2445  * simple as it seems, because we could have run out of input data
2446  * between a makeup code and a 0-length termination code, or in a
2447  * 2-D line before a final horizontal code with a 0-length second
2448  * run. There's probably a way to think about this situation that
2449  * doesn't require a special check, but I haven't found it yet.
2450  */
2451  if (ss->wpos == wstop && ss->cbit <= (-ss->Columns & 7) &&
2452  (k_left == 0 ? !(ss->run_color & ~1) : ss->run_color == 0)
2453  ) { /* Check for completed data to be copied to the client. */
2454  /* (We could avoid the extra copy step for 1-D, but */
2455  /* it's simpler not to, and it doesn't cost much.) */
2456  if (ss->rpos < ss->wpos) {
2458 
2459  cr.ptr = ss->lbuf + ss->rpos;
2460  cr.limit = ss->lbuf + ss->wpos;
2461  status = stream_move(&cr, pw);
2462  ss->rpos = cr.ptr - ss->lbuf;
2463  if (status)
2464  goto out;
2465  }
2466  if (rows_left > 0 && --rows_left == 0) {
2467  status = EOFC;
2468  goto out;
2469  }
2470  if (ss->K != 0) {
2471  unsigned char *prev_bits = ss->lprev;
2472 
2473  ss->lprev = ss->lbuf;
2474  ss->lbuf = prev_bits;
2475  if (ss->K > 0)
2476  k_left = (k_left == 0 ? ss->K : k_left) - 1;
2477  }
2478  ss->rpos = ss->wpos = -1;
2479  ss->eol_count = eol_count = 0;
2480  ss->cbit = 0;
2481  ss->invert = (ss->BlackIs1 ? 0 : 0xff);
2482  ss->memset_(ss->lbuf, ss->invert, wstop + 1);
2483  ss->run_color = 0;
2484  /*
2485  * If EndOfLine is true, we want to include the unsigned char padding
2486  * in the string of initial zeros in the EOL. If EndOfLine
2487  * is false, we aren't sure what we should do....
2488  */
2489  if (ss->EncodedByteAlign & !ss->EndOfLine)
2490  ss->bits_left &= ~7;
2491  }
2492  /* If we're between scan lines, scan for EOLs. */
2493  if (ss->wpos < 0) {
2494  while ((status = cf_decode_eol(ss, pr)) > 0) {
2495  if_debug0('w', "[w]EOL\n");
2496  /* If we are in a Group 3 mixed regime, */
2497  /* check the next bit for 1- vs. 2-D. */
2498  if (ss->K > 0) {
2500  hcd_load_state();
2501  ensure_bits(1, out); /* can't fail */
2502  k_left = (peek_bits(1) ? 0 : 1);
2503  skip_bits(1);
2504  hcd_store_state();
2505  }
2506  ++eol_count;
2507  /*
2508  * According to Adobe, the decoder should always check for
2509  * the EOD sequence, regardless of EndOfBlock: the Red Book's
2510  * documentation of EndOfBlock is wrong.
2511  */
2512  if (eol_count == (ss->K < 0 ? 2 : 6)) {
2513  status = EOFC;
2514  goto out;
2515  }
2516  }
2517  if (status == 0) /* input empty while scanning EOLs */
2518  goto out;
2519  switch (eol_count) {
2520  case 0:
2521  if (ss->EndOfLine) { /* EOL is required, but none is present. */
2522  status = PTSFAX_ERRC;
2523  goto check;
2524  }
2525  case 1:
2526  break;
2527  default:
2528  status = PTSFAX_ERRC;
2529  goto check;
2530  }
2531  }
2532  /* Now decode actual data. */
2533  if (k_left < 0) {
2534  if_debug0('w', "[w2]new row\n");
2535  status = cf_decode_2d(ss, pr);
2536  } else if (k_left == 0) {
2537  if_debug0('w', "[w1]new row\n");
2538  status = cf_decode_1d(ss, pr);
2539  } else {
2540  if_debug1('w', "[w1]new 2-D row, %d left\n", k_left);
2541  status = cf_decode_2d(ss, pr);
2542  }
2543  if_debug3('w', "[w]CFD status = %d, wpos = %d, cbit = %d\n",
2544  status, ss->wpos, ss->cbit);
2545  check:switch (status) {
2546  case 1: /* output full */
2547  goto top;
2548  case PTSFAX_ERRC:
2549  /* Check for special handling of damaged rows. */
2550  if (ss->damaged_rows >= ss->DamagedRowsBeforeError ||
2551  !(ss->EndOfLine && ss->K >= 0)
2552  )
2553  break;
2554  /* Substitute undamaged data if appropriate. */
2555 /****** NOT IMPLEMENTED YET ******/
2556  {
2557  ss->wpos = wstop;
2558  ss->cbit = -ss->Columns & 7;
2559  ss->run_color = 0;
2560  }
2561  ss->skipping_damage = true;
2562  goto top;
2563  default:
2564  ss->damaged_rows = 0; /* finished a good row */
2565  }
2566  out:ss->k_left = k_left;
2567  ss->rows_left = rows_left;
2568  ss->eol_count = eol_count;
2569  return status;
2570 }
2571 
2572 /*
2573  * Decode a leading EOL, if any.
2574  * If an EOL is present, skip over it and return 1;
2575  * if no EOL is present, read no input and return -N, where N is the
2576  * number of initial bits that can be skipped in the search for an EOL;
2577  * if more input is needed, return 0.
2578  * Note that if we detected an EOL, we know that we can back up over it;
2579  * if we detected an N-bit non-EOL, we know that at least N bits of data
2580  * are available in the buffer.
2581  */
2582 static int
2583 cf_decode_eol(stream_CFD_state * ss, stream_cursor_read * pr)
2584 {
2586  int zeros;
2587  int look_ahead;
2588 
2589  hcd_load_state();
2590  for (zeros = 0; zeros < run_eol_code_length - 1; zeros++) {
2591  ensure_bits(1, out);
2592  if (peek_bits(1))
2593  return -(zeros + 1);
2594  skip_bits(1);
2595  }
2596  /* We definitely have an EOL. Skip further zero bits. */
2597  look_ahead = (ss->K > 0 ? 2 : 1);
2598  for (;;) {
2599  ensure_bits(look_ahead, back);
2600  if (peek_bits(1))
2601  break;
2602  skip_bits(1);
2603  }
2604  skip_bits(1);
2605  hcd_store_state();
2606  return 1;
2607  back: /*
2608  * We ran out of data while skipping zeros.
2609  * We know we are at a unsigned char boundary, and have just skipped
2610  * at least run_eol_code_length - 1 zeros. However,
2611  * bits_left may be 1 if look_ahead == 2.
2612  */
2613  bits &= (1 << bits_left) - 1;
2615  hcd_store_state();
2616  out:return 0;
2617 }
2618 
2619 /* Decode a 1-D scan line. */
2620 static int
2621 cf_decode_1d(stream_CFD_state * ss, stream_cursor_read * pr)
2622 {
2623  cfd_declare_state;
2624  unsigned char black_byte = (ss->BlackIs1 ? 0xff : 0);
2625  int end_bit = -ss->Columns & 7;
2626  unsigned char *stop = ss->lbuf - 1 + ss->raster;
2627  int run_color = ss->run_color;
2628  int status;
2629  int bcnt;
2630 
2631  cfd_load_state();
2632  if_debug1('w', "[w1]entry run_color = %d\n", ss->run_color);
2633  if (ss->run_color > 0)
2634  goto db;
2635  else
2636  goto dw;
2637 #define q_at_stop() (q >= stop && (qbit <= end_bit || q > stop))
2638  top:run_color = 0;
2639  if (q_at_stop())
2640  goto done;
2641  dw: /* Decode a white run. */
2643  bcnt, "[w1]white", dwl, out0);
2644  if (bcnt < 0) { /* exceptional situation */
2645  switch (bcnt) {
2646  case run_uncompressed: /* Uncompressed data. */
2647  cfd_store_state();
2648  bcnt = cf_decode_uncompressed(ss, pr);
2649  if (bcnt < 0)
2650  return bcnt;
2651  cfd_load_state();
2652  if (bcnt)
2653  goto db;
2654  else
2655  goto dw;
2656  /*case run_error: */
2657  /*case run_zeros: *//* Premature end-of-line. */
2658  default:
2659  status = PTSFAX_ERRC;
2660  goto out;
2661  }
2662  }
2663  skip_data(bcnt, dwx);
2664  if (q_at_stop()) {
2665  run_color = 0; /* not inside a run */
2666  goto done;
2667  }
2668  run_color = 1;
2669  db: /* Decode a black run. */
2671  bcnt, "[w1]black", dbl, out1);
2672  if (bcnt < 0) { /* All exceptional codes are invalid here. */
2673 /****** WRONG, uncompressed IS ALLOWED ******/
2674  status = PTSFAX_ERRC;
2675  goto out;
2676  }
2677  /* Invert bits designated by black run. */
2678  invert_data(bcnt, black_byte, goto dbx, idb);
2679  goto top;
2680  dwx: /* If we run out of data after a makeup code, */
2681  /* note that we are still processing a white run. */
2682  run_color = -1;
2683  goto dw;
2684  dbx: /* If we run out of data after a makeup code, */
2685  /* note that we are still processing a black run. */
2686  run_color = 2;
2687  goto db;
2688  done:if (q > stop || qbit < end_bit)
2689  status = PTSFAX_ERRC;
2690  else
2691  status = 1;
2692  out:cfd_store_state();
2693  ss->run_color = run_color;
2694  if_debug1('w', "[w1]exit run_color = %d\n", run_color);
2695  return status;
2696  out0: /* We already set run_color to 0 or -1. */
2697  status = 0;
2698  goto out;
2699  out1: /* We already set run_color to 1 or 2. */
2700  status = 0;
2701  goto out;
2702 }
2703 
2704 /* Decode a 2-D scan line. */
2705 static int
2706 cf_decode_2d(stream_CFD_state * ss, stream_cursor_read * pr)
2707 {
2708  cfd_declare_state;
2709  unsigned char invert_white = (ss->BlackIs1 ? 0 : 0xff);
2710  unsigned char black_byte = ~~invert_white;
2711  unsigned char invert = ss->invert;
2712  int end_count = -ss->Columns & 7;
2713  unsigned int raster = ss->raster;
2714  unsigned char *q0 = ss->lbuf;
2715  unsigned char *prev_q01 = ss->lprev + 1;
2716  unsigned char *endptr = q0 - 1 + raster;
2717  int init_count = raster << 3;
2718  register int count;
2719  int rlen;
2720  int status;
2721 
2722  cfd_load_state();
2723  count = ((endptr - q) << 3) + qbit;
2724  endptr[1] = 0xa0; /* a unsigned char with some 0s and some 1s, */
2725  /* to ensure run scan will stop */
2726  if_debug1('W', "[w2]raster=%d\n", raster);
2727  switch (ss->run_color) {
2728  case -2:
2729  ss->run_color = 0;
2730  goto hww;
2731  case -1:
2732  ss->run_color = 0;
2733  goto hbw;
2734  case 1:
2735  ss->run_color = 0;
2736  goto hwb;
2737  case 2:
2738  ss->run_color = 0;
2739  goto hbb;
2740  /*case 0: */
2741  }
2742  top:if (count <= end_count) {
2743  status = (count < end_count ? PTSFAX_ERRC : 1);
2744  goto out;
2745  }
2746  /* If invert == invert_white, white and black have their */
2747  /* correct meanings; if invert == ~invert_white, */
2748  /* black and white are interchanged. */
2749  if_debug1('W', "[w2]%4d:\n", count);
2750 #ifdef DEBUG
2751  /* Check the invariant between q, qbit, and count. */
2752  {
2753  int pcount = (endptr - q) * 8 + qbit;
2754 
2755  if (pcount != count)
2756  dlprintf2("[w2]Error: count=%d pcount=%d\n",
2757  count, pcount);
2758  }
2759 #endif
2760  /*
2761  * We could just use get_run here, but we can do better. However,
2762  * we must be careful to handle the case where the very last codes
2763  * in the input stream are 1-bit "vertical 0" codes: we can't just
2764  * use ensure_bits(3, ...) and go to get more data if it fails.
2765  */
2766  ensure_bits(3, out3);
2767 #define vertical_0 (countof(cf2_run_vertical) / 2)
2768  switch (peek_bits(3)) {
2769  default /*4..7*/ : /* vertical(0) */
2770 v0: skip_bits(1);
2771  rlen = vertical_0;
2772  break;
2773  case 2: /* vertical(+1) */
2774  skip_bits(3);
2775  rlen = vertical_0 + 1;
2776  break;
2777  case 3: /* vertical(-1) */
2778  skip_bits(3);
2779  rlen = vertical_0 - 1;
2780  break;
2781  case 1: /* horizontal */
2782  skip_bits(3);
2783  if (invert == invert_white)
2784  goto hww;
2785  else
2786  goto hbb;
2787  case 0: /* everything else */
2789  rlen, "[w2]", d2l, out0);
2790  /* rlen may be run2_pass, run_uncompressed, or */
2791  /* 0..countof(cf2_run_vertical)-1. */
2792  if (rlen < 0)
2793  switch (rlen) {
2794  case run2_pass:
2795  break;
2796  case run_uncompressed:
2797  {
2798  int which;
2799 
2800  cfd_store_state();
2801  which = cf_decode_uncompressed(ss, pr);
2802  if (which < 0) {
2803  status = which;
2804  goto out;
2805  }
2806  cfd_load_state();
2807 /****** ADJUST count ******/
2808  invert = (which ? ~~invert_white : invert_white);
2809  }
2810  goto top;
2811  default: /* run_error, run_zeros */
2812  status = PTSFAX_ERRC;
2813  goto out;
2814  }
2815  }
2816  /* Interpreting the run requires scanning the */
2817  /* previous ('reference') line. */
2818  {
2819  int prev_count = count;
2820  unsigned char prev_data;
2821  int dlen;
2822  static const unsigned char count_bit[8] =
2823  {0x80, 1, 2, 4, 8, 0x10, 0x20, 0x40};
2824  unsigned char *prev_q = prev_q01 + (q - q0);
2825  int plen;
2826 
2827  if (!(count & 7))
2828  prev_q++; /* because of skip macros */
2829  prev_data = prev_q[-1] ^ invert;
2830  /* Find the b1 transition. */
2831  if ((prev_data & count_bit[prev_count & 7]) &&
2832  (prev_count < init_count || invert != invert_white)
2833  ) { /* Look for changing white first. */
2834  if_debug1('W', " data=0x%x", prev_data);
2835  skip_black_pixels(prev_data, prev_q,
2836  prev_count, invert, plen);
2837  if (prev_count < end_count) /* overshot */
2838  prev_count = end_count;
2839  if_debug1('W', " b1 other=%d", prev_count);
2840  }
2841  if (prev_count != end_count) {
2842  if_debug1('W', " data=0x%x", prev_data);
2843  skip_white_pixels(prev_data, prev_q,
2844  prev_count, invert, plen);
2845  if (prev_count < end_count) /* overshot */
2846  prev_count = end_count;
2847  if_debug1('W', " b1 same=%d", prev_count);
2848  }
2849  /* b1 = prev_count; */
2850  if (rlen == run2_pass) { /* Pass mode. Find b2. */
2851  if (prev_count != end_count) {
2852  if_debug1('W', " data=0x%x", prev_data);
2853  skip_black_pixels(prev_data, prev_q,
2854  prev_count, invert, plen);
2855  if (prev_count < end_count) /* overshot */
2856  prev_count = end_count;
2857  }
2858  /* b2 = prev_count; */
2859  if_debug2('W', " b2=%d, pass %d\n",
2860  prev_count, count - prev_count);
2861  } else { /* Vertical coding. */
2862  /* Remember that count counts *down*. */
2863  prev_count += rlen - vertical_0; /* a1 */
2864  if_debug2('W', " vertical %d -> %d\n",
2865  rlen - vertical_0, prev_count);
2866  }
2867  /* Now either invert or skip from count */
2868  /* to prev_count, and reset count. */
2869  if (invert == invert_white) { /* Skip data bits. */
2870  q = endptr - (prev_count >> 3);
2871  qbit = prev_count & 7;
2872  } else { /* Invert data bits. */
2873  dlen = count - prev_count;
2874  invert_data(dlen, black_byte, DO_NOTHING, idd);
2875  }
2876  count = prev_count;
2877  if (rlen >= 0) /* vertical mode */
2878  invert = ~~invert; /* polarity changes */
2879  }
2880  goto top;
2881  out3:
2882  if (bits_left > 0 && peek_bits(1)) {
2883  /* This is a 1-bit "vertical 0" code, which we can still process. */
2884  goto v0;
2885  }
2886  /* falls through */
2887  out0:status = 0;
2888  /* falls through */
2889  out:cfd_store_state();
2890  ss->invert = invert;
2891  return status;
2892  /*
2893  * We handle horizontal decoding here, so that we can
2894  * branch back into it if we run out of input data.
2895  */
2896  /* White, then black. */
2897  hww:get_run(cf_white_decode, cfd_white_initial_bits, cfd_white_min_bits,
2898  rlen, " white", wwl, outww);
2899  if ((count -= rlen) < end_count) {
2900  status = PTSFAX_ERRC;
2901  goto out;
2902  }
2903  skip_data(rlen, hww);
2904  /* Handle the second half of a white-black horizontal code. */
2905  hwb:get_run(cf_black_decode, cfd_black_initial_bits, cfd_black_min_bits,
2906  rlen, " black", wbl, outwb);
2907  if ((count -= rlen) < end_count) {
2908  status = PTSFAX_ERRC;
2909  goto out;
2910  }
2911  invert_data(rlen, black_byte, goto hwb, ihwb);
2912  goto top;
2913  outww:ss->run_color = -2;
2914  goto out0;
2915  outwb:ss->run_color = 1;
2916  goto out0;
2917  /* Black, then white. */
2918  hbb:get_run(cf_black_decode, cfd_black_initial_bits, cfd_black_min_bits,
2919  rlen, " black", bbl, outbb);
2920  if ((count -= rlen) < end_count) {
2921  status = PTSFAX_ERRC;
2922  goto out;
2923  }
2924  invert_data(rlen, black_byte, goto hbb, ihbb);
2925  /* Handle the second half of a black-white horizontal code. */
2926  hbw:get_run(cf_white_decode, cfd_white_initial_bits, cfd_white_min_bits,
2927  rlen, " white", bwl, outbw);
2928  if ((count -= rlen) < end_count) {
2929  status = PTSFAX_ERRC;
2930  goto out;
2931  }
2932  skip_data(rlen, hbw);
2933  goto top;
2934  outbb:ss->run_color = 2;
2935  goto out0;
2936  outbw:ss->run_color = -1;
2937  goto out0;
2938 }
2939 
2940 #if 1 /*************** */
2941 static int
2942 cf_decode_uncompressed(stream_CFD_state * ss, stream_cursor_read * pr)
2943 {
2944  (void)ss;
2945  (void)pr;
2946  /**** pts ****/
2947  return PTSFAX_ERRC;
2948 }
2949 #else /*************** */
2950 
2951 /* Decode uncompressed data. */
2952 /* (Not tested: no sample data available!) */
2953 /****** DOESN'T CHECK FOR OVERFLOWING SCAN LINE ******/
2954 static int
2955 cf_decode_uncompressed(stream * s)
2956 {
2957  cfd_declare_state;
2958  const cfd_node *np;
2959  int clen, rlen;
2960 
2961  cfd_load_state();
2962  while (1) {
2963  ensure_bits(cfd_uncompressed_initial_bits, NOOUT);
2964  np = &cf_uncompressed_decode[peek_bits(cfd_uncompressed_initial_bits)];
2965  clen = np->code_length;
2966  rlen = np->run_length;
2967  if (clen > cfd_uncompressed_initial_bits) { /* Must be an exit code. */
2968  break;
2969  }
2970  if (rlen == cfd_uncompressed_initial_bits) { /* Longest representable white run */
2971  if_debug1('W', "[wu]%d\n", rlen);
2972  if ((qbit -= cfd_uncompressed_initial_bits) < 0)
2973  qbit += 8, q++;
2974  } else {
2975  if_debug1('W', "[wu]%d+1\n", rlen);
2976  if (qbit -= rlen < 0)
2977  qbit += 8, q++;
2978  *q ^= 1 << qbit;
2979  }
2980  skip_bits(clen);
2981  }
2984  ensure_bits(clen, NOOUT);
2985  np = &cf_uncompressed_decode[rlen + peek_var_bits(clen)];
2986  rlen = np->run_length;
2987  skip_bits(np->code_length);
2988  if_debug1('w', "[wu]exit %d\n", rlen);
2989  if (rlen >= 0) { /* Valid exit code, rlen = 2 * run length + next polarity */
2990  if ((qbit -= rlen >> 1) < 0)
2991  qbit += 8, q++;
2992  rlen &= 1;
2993  }
2994  out:
2995 /******* WRONG ******/
2996  cfd_store_state();
2997  return rlen;
2998 }
2999 
3000 #endif /*************** */
3001 
3002 /* Move as much data as possible from one buffer to another. */
3003 /* Return 0 if the input became empty, 1 if the output became full. */
3004 int
3005 stream_move(stream_cursor_read * pr, stream_cursor_write * pw)
3006 {
3007  unsigned int rcount = pr->limit - pr->ptr;
3008  unsigned int wcount = pw->limit - pw->ptr;
3009  unsigned int count;
3010  int status;
3011 
3012  if (rcount <= wcount)
3013  count = rcount, status = 0;
3014  else
3015  count = wcount, status = 1;
3016 
3017  /**** pts ****/ /* Dat: memcpy should be enough instead of memmove */
3018  #if 0
3019  memmove(pw->ptr + 1, pr->ptr + 1, count);
3020  pr->ptr += count;
3021  pw->ptr += count;
3022  #else
3023  while (count--!=0) *++pw->ptr=*++pr->ptr;
3024  #endif
3025  return status;
3026 }
3027 
3028 #if 1 /**** pts ****/
3029 /* Stream template */
3030 const stream_template s_CFD_template =
3031 {/*0, &st_CFD_state*/ s_CFD_init, s_CFD_process, 1, 1, s_CFD_release,
3032  s_CFD_set_defaults, 0
3033 };
3034 #endif
3035 
3036 /* end of former scfd.c */
3037 
3038 
3039 #endif /* USE_BUILTIN_FAXD */
3040 
3041 #if USE_BUILTIN_FAXE || USE_BUILTIN_FAXD
3042 /* shc.c */
3043 /*$Id: pts_fax.c,v 1.3 2005/02/21 13:09:56 pts Exp $ */
3044 /* Support code for shc.h */
3045 /* #include "scommon.h" */
3046 /* #include "shc.h" */
3047 /* #include "scfx.h" */ /**** pts ****/ /* struct stream_hc_state_s */
3048 
3049 /* ------ Encoding ------ */
3050 
3051 /* Empty the 1-word buffer onto the output stream. */
3052 /* q has already been incremented. */
3053 static void
3054 hc_put_code_proc(bool reverse_bits, unsigned char * q, unsigned int cw)
3055 {
3056 #define cb(n) ((unsigned char)(cw >> (n * 8)))
3057  if (reverse_bits) {
3058 #if hc_bits_size > 16
3059  q[-3] = byte_reverse_bits[cb(3)];
3060  q[-2] = byte_reverse_bits[cb(2)];
3061 #endif
3062  q[-1] = byte_reverse_bits[cb(1)];
3063  q[0] = byte_reverse_bits[cb(0)];
3064  } else {
3065 #if hc_bits_size > 16
3066  q[-3] = cb(3);
3067  q[-2] = cb(2);
3068 #endif
3069  q[-1] = cb(1);
3070  q[0] = cb(0);
3071  }
3072 #undef cb
3073 }
3074 
3075 /* Put out any final bytes. */
3076 /* Note that this does a store_state, but not a load_state. */
3077 static unsigned char *
3078 hc_put_last_bits_proc(stream_hc_state * ss, unsigned char * q, unsigned int bits, int bits_left)
3079 {
3080  while (bits_left < hc_bits_size) {
3081  unsigned char c = (unsigned char) (bits >> (hc_bits_size - 8));
3082 
3083  if (ss->FirstBitLowOrder)
3084  c = byte_reverse_bits[c];
3085  *++q = c;
3086  bits <<= 8;
3087  bits_left += 8;
3088  }
3089  ss->bits = bits;
3090  ss->bits_left = bits_left;
3091  return q;
3092 }
3093 
3094 /* end of former shc.c */
3095 
3096 
3097 /* gsbittab.c */
3098 /*$Id: pts_fax.c,v 1.3 2005/02/21 13:09:56 pts Exp $ */
3099 /* Tables for bit operations */
3100 /* #include "gstypes.h" */
3101 /* #include "gsbittab.h" */
3102 
3103 /* ---------------- Byte processing tables ---------------- */
3104 
3105 /*
3106  * byte_reverse_bits[B] = the unsigned char B with the order of bits reversed.
3107  */
3108 impl_const unsigned char byte_reverse_bits[256] = {
3109  bit_table_8(0, 1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80)
3110 };
3111 
3112 /*
3113  * byte_right_mask[N] = a unsigned char with N trailing 1s, 0 <= N <= 8.
3114  */
3115 impl_const unsigned char byte_right_mask[9] = {
3116  0, 1, 3, 7, 0xf, 0x1f, 0x3f, 0x7f, 0xff
3117 };
3118 
3119 /*
3120  * byte_count_bits[B] = the number of 1-bits in a unsigned char with value B.
3121  */
3122 impl_const unsigned char byte_count_bits[256] = {
3123  bit_table_8(0, 1, 1, 1, 1, 1, 1, 1, 1)
3124 };
3125 
3126 /* ---------------- Scanning tables ---------------- */
3127 
3128 /*
3129  * byte_bit_run_length_N[B], for 0 <= N <= 7, gives the length of the
3130  * run of 1-bits starting at bit N in a unsigned char with value B,
3131  * numbering the bits in the unsigned char as 01234567. If the run includes
3132  * the low-order bit (i.e., might be continued into a following unsigned char),
3133  * the run length is increased by 8.
3134  */
3135 
3136 #define t8(n) n,n,n,n,n+1,n+1,n+2,n+11
3137 #define r8(n) n,n,n,n,n,n,n,n
3138 #define r16(n) r8(n),r8(n)
3139 #define r32(n) r16(n),r16(n)
3140 #define r64(n) r32(n),r32(n)
3141 #define r128(n) r64(n),r64(n)
3142 impl_const unsigned char byte_bit_run_length_0[256] = {
3143  r128(0), r64(1), r32(2), r16(3), r8(4), t8(5)
3144 };
3145 impl_const unsigned char byte_bit_run_length_1[256] = {
3146  r64(0), r32(1), r16(2), r8(3), t8(4),
3147  r64(0), r32(1), r16(2), r8(3), t8(4)
3148 };
3149 impl_const unsigned char byte_bit_run_length_2[256] = {
3150  r32(0), r16(1), r8(2), t8(3),
3151  r32(0), r16(1), r8(2), t8(3),
3152  r32(0), r16(1), r8(2), t8(3),
3153  r32(0), r16(1), r8(2), t8(3)
3154 };
3155 impl_const unsigned char byte_bit_run_length_3[256] = {
3156  r16(0), r8(1), t8(2), r16(0), r8(1), t8(2),
3157  r16(0), r8(1), t8(2), r16(0), r8(1), t8(2),
3158  r16(0), r8(1), t8(2), r16(0), r8(1), t8(2),
3159  r16(0), r8(1), t8(2), r16(0), r8(1), t8(2)
3160 };
3161 impl_const unsigned char byte_bit_run_length_4[256] = {
3162  r8(0), t8(1), r8(0), t8(1), r8(0), t8(1), r8(0), t8(1),
3163  r8(0), t8(1), r8(0), t8(1), r8(0), t8(1), r8(0), t8(1),
3164  r8(0), t8(1), r8(0), t8(1), r8(0), t8(1), r8(0), t8(1),
3165  r8(0), t8(1), r8(0), t8(1), r8(0), t8(1), r8(0), t8(1),
3166 };
3167 
3168 #define rr8(a,b,c,d,e,f,g,h)\
3169  a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h,\
3170  a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h,\
3171  a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h,\
3172  a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h,\
3173  a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h,\
3174  a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h,\
3175  a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h,\
3176  a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h, a,b,c,d,e,f,g,h
3177 impl_const unsigned char byte_bit_run_length_5[256] = {
3178  rr8(0, 0, 0, 0, 1, 1, 2, 11)
3179 };
3180 impl_const unsigned char byte_bit_run_length_6[256] = {
3181  rr8(0, 0, 1, 10, 0, 0, 1, 10)
3182 };
3183 impl_const unsigned char byte_bit_run_length_7[256] = {
3184  rr8(0, 9, 0, 9, 0, 9, 0, 9)
3185 };
3186 
3187 /* Pointer tables indexed by bit number. */
3188 
3189 impl_const unsigned char *const byte_bit_run_length[8] = {
3194 };
3195 impl_const unsigned char *const byte_bit_run_length_neg[8] = {
3200 };
3201 
3202 /*
3203  * byte_acegbdfh_to_abcdefgh[acegbdfh] = abcdefgh, where the letters
3204  * denote the individual bits of the unsigned char.
3205  */
3207  bit_table_8(0, 0x80, 0x20, 0x08, 0x02, 0x40, 0x10, 0x04, 0x01)
3208 };
3209 
3210 #if 0
3211 /* Some C compilers insist on having executable code in every file.... */
3212 void gsbittab_dummy _((void)); /* for picky compilers */
3213 void
3214 gsbittab_dummy(void)
3215 {
3216 }
3217 #endif
3218 
3219 /* end of former gsbittab.c */
3220 #endif /* USE_BUILTIN_FAXE || USE_BUILTIN_FAXD */
3221 
3222 /* end of pts_fax.c */
static int pr(int(*writeFunc)(void *stream, const char *data, int size), void *stream, const char *data)
Definition: HTMLGen.cc:249
rp
Definition: action.c:992
cp
Definition: action.c:1035
q
Definition: afm2pl.c:2287
#define count(a)
Definition: aptex-macros.h:781
#define stop
Definition: aptex-macros.h:362
#define check(T, S)
#define white(x)
int w
Definition: dviconv.c:26
static int np
Definition: bifont.c:64
#define skip(p, c)
Definition: ptexmac.h:70
char * temp
Definition: dvidvi.c:137
struct rect data
Definition: dvipdfm.c:64
quarterword * raster
Definition: dvips.c:153
static void
Definition: fpif.c:118
#define _(String)
Definition: ftxerr18.c:64
#define a0
#define a1
#define v0
#define s
Definition: afcover.h:80
#define c(n)
Definition: gpos-common.c:150
#define memmove(d, s, n)
Definition: gsftopk.c:65
FILE * out
Definition: hbf2gf.c:286
register bit_buf_type register int bits_left
Definition: jdhuff.h:156
small capitals from c petite p
Definition: afcover.h:72
small capitals from c petite p scientific i
Definition: afcover.h:80
#define bits
Definition: infblock.c:15
int int double double double char double char * top
Definition: gdfx.h:19
#define get_run()
Definition: pkfont.c:225
#define skip_bits(n)
static struct statistic stats[]
Definition: lstatslib.c:289
int columns
Definition: pbmpscale.c:13
shortint lbuf[9600]
Definition: pmxab.c:71
static int32_t last
Definition: ppagelist.c:29
int db
Definition: ppmqvga.c:68
int invert
Definition: mag.c:82
static void hc_put_code_proc()
struct hc_definition_s hc_definition
#define cf2_run_horizontal_value
Definition: pts_fax.c:457
struct hce_code_s hce_code
#define intern
Definition: pts_fax.c:33
static void s_CFE_set_defaults(register stream_state *st)
Definition: pts_fax.c:693
#define hc_put_code(ss, q, cp)
Definition: pts_fax.c:278
const unsigned char byte_bit_run_length_4[256]
Definition: pts_fax.c:148
const cfe_run cf_uncompressed_exit[10]
Definition: pts_fax.c:1236
#define cfd_white_min_bits
Definition: pts_fax.c:483
#define run_uncompressed
Definition: pts_fax.c:477
#define intern_const
Definition: pts_fax.c:35
const unsigned char *const byte_bit_run_length_neg[8]
Definition: pts_fax.c:3195
#define cfd_2d_initial_bits
Definition: pts_fax.c:490
static int s_CFE_init(register stream_state *st)
Definition: pts_fax.c:702
#define r64(n)
Definition: pts_fax.c:3140
#define impl_const
Definition: pts_fax.c:36
#define CF_PUT_WHITE_RUN(ss, lenv)
Definition: pts_fax.c:679
const unsigned char byte_bit_run_length_7[256]
Definition: pts_fax.c:149
#define if_debug3(c, s, a1, a2, a3)
Definition: pts_fax.c:61
const stream_template s_CFE_template
Definition: pts_fax.c:1098
const cfe_run cf2_run_eol_2d
Definition: pts_fax.c:1149
const cfe_run cf2_run_pass
Definition: pts_fax.c:1128
#define run_eol_code_value
Definition: pts_fax.c:433
#define s_hcd_init_inline(ss)
Definition: pts_fax.c:180
struct cf_runs_s cf_runs
const unsigned char byte_bit_run_length_1[256]
Definition: pts_fax.c:146
#define t8(n)
Definition: pts_fax.c:3136
hcd_code cfd_node
Definition: pts_fax.c:467
const unsigned char byte_acegbdfh_to_abcdefgh[256]
Definition: pts_fax.c:3206
static void s_CFE_release()
#define if_debug8(c, s, a1, a2, a3, a4, a5, a6, a7, a8)
Definition: pts_fax.c:66
#define if_debug5(c, s, a1, a2, a3, a4, a5)
Definition: pts_fax.c:63
#define cb(n)
const unsigned char byte_bit_run_length_5[256]
Definition: pts_fax.c:148
#define skip_black_pixels(data, p, count, white_byte, rlen)
Definition: pts_fax.c:561
#define cfd_black_min_bits
Definition: pts_fax.c:487
#define r16(n)
Definition: pts_fax.c:3138
#define gs_alloc_bytes(a, n, c)
Definition: pts_fax.c:92
#define b1
static void cf_encode_2d()
#define hce_declare_state
Definition: pts_fax.c:253
#define cfe_max_width
Definition: pts_fax.c:421
#define hcd_declare_state
Definition: pts_fax.c:316
#define hc_bits_size
Definition: pts_fax.c:177
#define hc_put_last_bits(ss, q)
Definition: pts_fax.c:287
#define hcd_store_state()
Definition: pts_fax.c:333
const cf_runs cf_white_runs
Definition: pts_fax.c:1153
#define skip_white_pixels(data, p, count, white_byte, rlen)
Definition: pts_fax.c:516
#define r32(n)
Definition: pts_fax.c:3139
#define run2_pass
Definition: pts_fax.c:479
#define RUN(c, len)
Definition: pts_fax.c:1116
#define if_debug9(c, s, a1, a2, a3, a4, a5, a6, a7, a8, a9)
Definition: pts_fax.c:67
#define bit_table_8(v0, v80, v40, v20, v10, v8, v4, v2, v1)
Definition: pts_fax.c:119
struct hcd_table_s hcd_table
const cfe_run cf_uncompressed[6]
Definition: pts_fax.c:1225
hce_code cfe_run
Definition: pts_fax.c:428
static void cf_encode_1d()
struct hcd_code_s hcd_code
#define if_debug4(c, s, a1, a2, a3, a4)
Definition: pts_fax.c:62
const unsigned char byte_reverse_bits[256]
Definition: pts_fax.c:3108
#define cf2_run_pass_length
Definition: pts_fax.c:451
#define r8(n)
Definition: pts_fax.c:3137
static unsigned char * hc_put_last_bits_proc()
#define if_debug6(c, s, a1, a2, a3, a4, a5, a6)
Definition: pts_fax.c:64
const unsigned char byte_bit_run_length_2[256]
Definition: pts_fax.c:147
const cfe_run cf2_run_horizontal
Definition: pts_fax.c:1140
static unsigned char * cf_put_long_run(stream_CFE_state *ss, unsigned char *q, int lenv, const cf_runs *prt)
Definition: pts_fax.c:654
#define cf2_run_pass_value
Definition: pts_fax.c:452
#define cfd_white_initial_bits
Definition: pts_fax.c:482
#define cfd_black_initial_bits
Definition: pts_fax.c:486
#define if_debug1(c, s, a1)
Definition: pts_fax.c:59
#define r128(n)
Definition: pts_fax.c:3141
#define hce_store_state()
Definition: pts_fax.c:264
#define DO_NOTHING
Definition: pts_fax.c:55
static int s_CFE_process(stream_state *st, stream_cursor_read *pr, stream_cursor_write *pw, bool last)
Definition: pts_fax.c:772
#define if_debug0(c, s)
Definition: pts_fax.c:58
const unsigned char byte_bit_run_length_0[256]
Definition: pts_fax.c:3142
#define cfd_uncompressed_initial_bits
Definition: pts_fax.c:494
#define hce_load_state()
Definition: pts_fax.c:259
const unsigned char byte_bit_run_length_6[256]
Definition: pts_fax.c:149
#define s_hce_init_inline(ss)
Definition: pts_fax.c:178
#define gs_free_object(a, ptr, c)
Definition: pts_fax.c:93
#define min(a, b)
Definition: pts_fax.c:74
#define cf2_run_horizontal_length
Definition: pts_fax.c:458
#define cfd_2d_min_bits
Definition: pts_fax.c:491
#define rr8(a, b, c, d, e, f, g, h)
Definition: pts_fax.c:3168
struct hce_table_s hce_table
#define if_debug2(c, s, a1, a2)
Definition: pts_fax.c:60
const cfe_run cf1_run_uncompressed
Definition: pts_fax.c:1124
const cfe_run cf2_run_uncompressed
Definition: pts_fax.c:1142
const unsigned char byte_right_mask[9]
Definition: pts_fax.c:3115
#define hcd_load_state()
Definition: pts_fax.c:324
#define run_eol_code_length
Definition: pts_fax.c:432
#define ROUND_UP(value, modulus)
Definition: pts_fax.c:85
#define hc_put_value(ss, q, code, clen)
Definition: pts_fax.c:270
const cfe_run cf_run_eol
Definition: pts_fax.c:1120
#define CF_PUT_BLACK_RUN(ss, lenv)
Definition: pts_fax.c:682
const unsigned char byte_bit_run_length_3[256]
Definition: pts_fax.c:147
const cfe_run cf2_run_eol_1d
Definition: pts_fax.c:1147
#define COUNT_RUN(cnt, i)
Definition: pts_fax.c:631
const cf_runs cf_black_runs
Definition: pts_fax.c:440
const unsigned char *const byte_bit_run_length[8]
Definition: pts_fax.c:3189
const unsigned char byte_count_bits[256]
Definition: pts_fax.c:3122
const cfe_run cf2_run_vertical[7]
Definition: pts_fax.c:1130
#define s_CFE_set_defaults_inline(ss)
Definition: pts_fax.h:460
#define PTSFAX_ERRC
Definition: pts_fax.h:123
struct stream_s stream
Definition: pts_fax.h:93
#define s_CFD_set_defaults_inline(ss)
Definition: pts_fax.h:509
#define status
Definition: namelist.c:170
cfe_run make_up[41]
Definition: pts_fax.c:437
cfe_run termination[64]
Definition: pts_fax.c:436
unsigned short * values
Definition: pts_fax.c:208
unsigned int num_values
Definition: pts_fax.c:209
unsigned int num_counts
Definition: pts_fax.c:207
unsigned short * counts
Definition: pts_fax.c:206
short value
Definition: pts_fax.c:305
unsigned short code_length
Definition: pts_fax.c:306
hcd_code * codes
Definition: pts_fax.c:312
unsigned int initial_bits
Definition: pts_fax.c:311
unsigned int count
Definition: pts_fax.c:310
unsigned short code_length
Definition: pts_fax.c:221
unsigned short code
Definition: pts_fax.c:220
unsigned int count
Definition: pts_fax.c:227
hce_code * codes
Definition: pts_fax.c:228
Definition: stemdb.c:56
unsigned char * lbuf
Definition: pts_fax.h:479
unsigned char * lprev
Definition: pts_fax.h:479
int DamagedRowsBeforeError
Definition: pts_fax.h:479
unsigned char invert
Definition: pts_fax.h:487
bool EncodedByteAlign
Definition: pts_fax.h:479
gssss_memset_t memset_
Definition: pts_fax.h:479
unsigned int raster
Definition: pts_fax.h:479
bool skipping_damage
Definition: pts_fax.h:495
unsigned char * lprev
Definition: pts_fax.h:447
unsigned char * lbuf
Definition: pts_fax.h:447
gssss_memset_t memset_
Definition: pts_fax.h:447
unsigned int raster
Definition: pts_fax.h:447
unsigned char * lcode
Definition: pts_fax.h:450
bool EncodedByteAlign
Definition: pts_fax.h:447
gssss_memcpy_t memcpy_
Definition: pts_fax.h:447
unsigned char * ptr
Definition: pts_fax.h:145
unsigned char * limit
Definition: pts_fax.h:146
bool FirstBitLowOrder
Definition: pts_fax.h:397
unsigned int bits
Definition: pts_fax.h:397
back
Definition: tex4ht.c:3533
int diff
Definition: tex4ht.c:3815
int run(char *cmd)
Definition: texdocc.c:233
#define U(a)
Definition: twiddle.h:1
char cr[]
Definition: vlna.c:107
#define end(cp)
Definition: zic.c:71