| 2 |
- |
1 |
/* Copyright (C) 1992, 1995, 1997, 1998, 1999 Aladdin Enterprises. All rights reserved.
|
|
|
2 |
|
|
|
3 |
This software is provided AS-IS with no warranty, either express or
|
|
|
4 |
implied.
|
|
|
5 |
|
|
|
6 |
This software is distributed under license and may not be copied,
|
|
|
7 |
modified or distributed except as expressly authorized under the terms
|
|
|
8 |
of the license contained in the file LICENSE in this distribution.
|
|
|
9 |
|
|
|
10 |
For more information about licensing, please refer to
|
|
|
11 |
http://www.ghostscript.com/licensing/. For information on
|
|
|
12 |
commercial licensing, go to http://www.artifex.com/licensing/ or
|
|
|
13 |
contact Artifex Software, Inc., 101 Lucas Valley Road #110,
|
|
|
14 |
San Rafael, CA 94903, U.S.A., +1(415)492-9861.
|
|
|
15 |
*/
|
|
|
16 |
|
|
|
17 |
/* $Id: scf.h,v 1.4 2002/02/21 22:24:53 giles Exp $ */
|
|
|
18 |
/* Common definitions for CCITTFax encoding and decoding filters */
|
|
|
19 |
|
|
|
20 |
#ifndef scf_INCLUDED
|
|
|
21 |
# define scf_INCLUDED
|
|
|
22 |
|
|
|
23 |
#include "shc.h"
|
|
|
24 |
|
|
|
25 |
/*
|
|
|
26 |
* The CCITT Group 3 (T.4) and Group 4 (T.6) fax specifications map
|
|
|
27 |
* run lengths to Huffman codes. White and black have different mappings.
|
|
|
28 |
* If the run length is 64 or greater, two or more codes are needed:
|
|
|
29 |
* - One or more 'make-up' codes for 2560 pixels;
|
|
|
30 |
* - A 'make-up' code that encodes the multiple of 64;
|
|
|
31 |
* - A 'termination' code for the remainder.
|
|
|
32 |
* For runs of 63 or less, only the 'termination' code is needed.
|
|
|
33 |
*/
|
|
|
34 |
|
|
|
35 |
/* ------ Encoding tables ------ */
|
|
|
36 |
|
|
|
37 |
/*
|
|
|
38 |
* The maximum possible length of a scan line is determined by the
|
|
|
39 |
* requirement that 3 runs have to fit into the stream buffer.
|
|
|
40 |
* A run of length N requires approximately ceil(N / 2560) makeup codes,
|
|
|
41 |
* hence 1.5 * ceil(N / 2560) bytes. Taking the largest safe stream
|
|
|
42 |
* buffer size as 32K, we arrive at the following maximum width:
|
|
|
43 |
*/
|
|
|
44 |
#if arch_sizeof_int > 2
|
|
|
45 |
# define cfe_max_width (2560 * 32000 * 2 / 3)
|
|
|
46 |
#else
|
|
|
47 |
# define cfe_max_width (max_int - 40) /* avoid overflows */
|
|
|
48 |
#endif
|
|
|
49 |
/* The +5 in cfe_max_code_bytes is a little conservative. */
|
|
|
50 |
#define cfe_max_code_bytes(width) ((width) / 2560 * 3 / 2 + 5)
|
|
|
51 |
|
|
|
52 |
typedef hce_code cfe_run;
|
|
|
53 |
|
|
|
54 |
/* Codes common to 1-D and 2-D encoding. */
|
|
|
55 |
/* The decoding algorithms know that EOL is 0....01. */
|
|
|
56 |
#define run_eol_code_length 12
|
|
|
57 |
#define run_eol_code_value 1
|
|
|
58 |
extern const cfe_run cf_run_eol;
|
|
|
59 |
typedef struct cf_runs_s {
|
|
|
60 |
cfe_run termination[64];
|
|
|
61 |
cfe_run make_up[41];
|
|
|
62 |
} cf_runs;
|
|
|
63 |
extern const cf_runs
|
|
|
64 |
cf_white_runs, cf_black_runs;
|
|
|
65 |
extern const cfe_run cf_uncompressed[6];
|
|
|
66 |
extern const cfe_run cf_uncompressed_exit[10]; /* indexed by 2 x length of */
|
|
|
67 |
|
|
|
68 |
/* white run + (1 if next run black, 0 if white) */
|
|
|
69 |
/* 1-D encoding. */
|
|
|
70 |
extern const cfe_run cf1_run_uncompressed;
|
|
|
71 |
|
|
|
72 |
/* 2-D encoding. */
|
|
|
73 |
extern const cfe_run cf2_run_pass;
|
|
|
74 |
|
|
|
75 |
#define cf2_run_pass_length 4
|
|
|
76 |
#define cf2_run_pass_value 0x1
|
|
|
77 |
#define cf2_run_vertical_offset 3
|
|
|
78 |
extern const cfe_run cf2_run_vertical[7]; /* indexed by b1 - a1 + offset */
|
|
|
79 |
extern const cfe_run cf2_run_horizontal;
|
|
|
80 |
|
|
|
81 |
#define cf2_run_horizontal_value 1
|
|
|
82 |
#define cf2_run_horizontal_length 3
|
|
|
83 |
extern const cfe_run cf2_run_uncompressed;
|
|
|
84 |
|
|
|
85 |
/* 2-D Group 3 encoding. */
|
|
|
86 |
extern const cfe_run cf2_run_eol_1d;
|
|
|
87 |
extern const cfe_run cf2_run_eol_2d;
|
|
|
88 |
|
|
|
89 |
/* ------ Decoding tables ------ */
|
|
|
90 |
|
|
|
91 |
typedef hcd_code cfd_node;
|
|
|
92 |
|
|
|
93 |
#define run_length value
|
|
|
94 |
|
|
|
95 |
/*
|
|
|
96 |
* The value in the decoding tables is either a white or black run length,
|
|
|
97 |
* or a (negative) exceptional value.
|
|
|
98 |
*/
|
|
|
99 |
#define run_error (-1)
|
|
|
100 |
#define run_zeros (-2) /* EOL follows, possibly with more padding first */
|
|
|
101 |
#define run_uncompressed (-3)
|
|
|
102 |
/* 2-D codes */
|
|
|
103 |
#define run2_pass (-4)
|
|
|
104 |
#define run2_horizontal (-5)
|
|
|
105 |
|
|
|
106 |
#define cfd_white_initial_bits 8
|
|
|
107 |
#define cfd_white_min_bits 4 /* shortest white run */
|
|
|
108 |
extern const cfd_node cf_white_decode[];
|
|
|
109 |
|
|
|
110 |
#define cfd_black_initial_bits 7
|
|
|
111 |
#define cfd_black_min_bits 2 /* shortest black run */
|
|
|
112 |
extern const cfd_node cf_black_decode[];
|
|
|
113 |
|
|
|
114 |
#define cfd_2d_initial_bits 7
|
|
|
115 |
#define cfd_2d_min_bits 4 /* shortest non-H/V 2-D run */
|
|
|
116 |
extern const cfd_node cf_2d_decode[];
|
|
|
117 |
|
|
|
118 |
#define cfd_uncompressed_initial_bits 6 /* must be 6 */
|
|
|
119 |
extern const cfd_node cf_uncompressed_decode[];
|
|
|
120 |
|
|
|
121 |
/* ------ Run detection macros ------ */
|
|
|
122 |
|
|
|
123 |
/*
|
|
|
124 |
* For the run detection macros:
|
|
|
125 |
* white_byte is 0 or 0xff for BlackIs1 or !BlackIs1 respectively;
|
|
|
126 |
* data holds p[-1], inverted if !BlackIs1;
|
|
|
127 |
* count is the number of valid bits remaining in the scan line.
|
|
|
128 |
*/
|
|
|
129 |
|
|
|
130 |
/* Aliases for bit processing tables. */
|
|
|
131 |
#define cf_byte_run_length byte_bit_run_length_neg
|
|
|
132 |
#define cf_byte_run_length_0 byte_bit_run_length_0
|
|
|
133 |
|
|
|
134 |
/* Skip over white pixels to find the next black pixel in the input. */
|
|
|
135 |
/* Store the run length in rlen, and update data, p, and count. */
|
|
|
136 |
/* There are many more white pixels in typical input than black pixels, */
|
|
|
137 |
/* and the runs of white pixels tend to be much longer, so we use */
|
|
|
138 |
/* substantially different loops for the two cases. */
|
|
|
139 |
|
|
|
140 |
#define skip_white_pixels(data, p, count, white_byte, rlen)\
|
|
|
141 |
BEGIN\
|
|
|
142 |
rlen = cf_byte_run_length[count & 7][data ^ 0xff];\
|
|
|
143 |
if ( rlen >= 8 ) { /* run extends past byte boundary */\
|
|
|
144 |
if ( white_byte == 0 ) {\
|
|
|
145 |
if ( p[0] ) { data = p[0]; p += 1; rlen -= 8; }\
|
|
|
146 |
else if ( p[1] ) { data = p[1]; p += 2; }\
|
|
|
147 |
else {\
|
|
|
148 |
while ( !(p[2] | p[3] | p[4] | p[5]) )\
|
|
|
149 |
p += 4, rlen += 32;\
|
|
|
150 |
if ( p[2] ) {\
|
|
|
151 |
data = p[2]; p += 3; rlen += 8;\
|
|
|
152 |
} else if ( p[3] ) {\
|
|
|
153 |
data = p[3]; p += 4; rlen += 16;\
|
|
|
154 |
} else if ( p[4] ) {\
|
|
|
155 |
data = p[4]; p += 5; rlen += 24;\
|
|
|
156 |
} else /* p[5] */ {\
|
|
|
157 |
data = p[5]; p += 6; rlen += 32;\
|
|
|
158 |
}\
|
|
|
159 |
}\
|
|
|
160 |
} else {\
|
|
|
161 |
if ( p[0] != 0xff ) { data = (byte)~p[0]; p += 1; rlen -= 8; }\
|
|
|
162 |
else if ( p[1] != 0xff ) { data = (byte)~p[1]; p += 2; }\
|
|
|
163 |
else {\
|
|
|
164 |
while ( (p[2] & p[3] & p[4] & p[5]) == 0xff )\
|
|
|
165 |
p += 4, rlen += 32;\
|
|
|
166 |
if ( p[2] != 0xff ) {\
|
|
|
167 |
data = (byte)~p[2]; p += 3; rlen += 8;\
|
|
|
168 |
} else if ( p[3] != 0xff ) {\
|
|
|
169 |
data = (byte)~p[3]; p += 4; rlen += 16;\
|
|
|
170 |
} else if ( p[4] != 0xff ) {\
|
|
|
171 |
data = (byte)~p[4]; p += 5; rlen += 24;\
|
|
|
172 |
} else /* p[5] != 0xff */ {\
|
|
|
173 |
data = (byte)~p[5]; p += 6; rlen += 32;\
|
|
|
174 |
}\
|
|
|
175 |
}\
|
|
|
176 |
}\
|
|
|
177 |
rlen += cf_byte_run_length_0[data ^ 0xff];\
|
|
|
178 |
}\
|
|
|
179 |
count -= rlen;\
|
|
|
180 |
END
|
|
|
181 |
|
|
|
182 |
/* Skip over black pixels to find the next white pixel in the input. */
|
|
|
183 |
/* Store the run length in rlen, and update data, p, and count. */
|
|
|
184 |
|
|
|
185 |
#define skip_black_pixels(data, p, count, white_byte, rlen)\
|
|
|
186 |
BEGIN\
|
|
|
187 |
rlen = cf_byte_run_length[count & 7][data];\
|
|
|
188 |
if ( rlen >= 8 ) {\
|
|
|
189 |
if ( white_byte == 0 )\
|
|
|
190 |
for ( ; ; p += 4, rlen += 32 ) {\
|
|
|
191 |
if ( p[0] != 0xff ) { data = p[0]; p += 1; rlen -= 8; break; }\
|
|
|
192 |
if ( p[1] != 0xff ) { data = p[1]; p += 2; break; }\
|
|
|
193 |
if ( p[2] != 0xff ) { data = p[2]; p += 3; rlen += 8; break; }\
|
|
|
194 |
if ( p[3] != 0xff ) { data = p[3]; p += 4; rlen += 16; break; }\
|
|
|
195 |
}\
|
|
|
196 |
else\
|
|
|
197 |
for ( ; ; p += 4, rlen += 32 ) {\
|
|
|
198 |
if ( p[0] ) { data = (byte)~p[0]; p += 1; rlen -= 8; break; }\
|
|
|
199 |
if ( p[1] ) { data = (byte)~p[1]; p += 2; break; }\
|
|
|
200 |
if ( p[2] ) { data = (byte)~p[2]; p += 3; rlen += 8; break; }\
|
|
|
201 |
if ( p[3] ) { data = (byte)~p[3]; p += 4; rlen += 16; break; }\
|
|
|
202 |
}\
|
|
|
203 |
rlen += cf_byte_run_length_0[data];\
|
|
|
204 |
}\
|
|
|
205 |
count -= rlen;\
|
|
|
206 |
END
|
|
|
207 |
|
|
|
208 |
#endif /* scf_INCLUDED */
|