1 : /* $Id: tif_fax3.c,v 1.67 2009-03-13 02:02:51 fwarmerdam Exp $ */
2 :
3 : /*
4 : * Copyright (c) 1990-1997 Sam Leffler
5 : * Copyright (c) 1991-1997 Silicon Graphics, Inc.
6 : *
7 : * Permission to use, copy, modify, distribute, and sell this software and
8 : * its documentation for any purpose is hereby granted without fee, provided
9 : * that (i) the above copyright notices and this permission notice appear in
10 : * all copies of the software and related documentation, and (ii) the names of
11 : * Sam Leffler and Silicon Graphics may not be used in any advertising or
12 : * publicity relating to the software without the specific, prior written
13 : * permission of Sam Leffler and Silicon Graphics.
14 : *
15 : * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
16 : * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
17 : * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
18 : *
19 : * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
20 : * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
21 : * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
22 : * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
23 : * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24 : * OF THIS SOFTWARE.
25 : */
26 :
27 : #include "tiffiop.h"
28 : #ifdef CCITT_SUPPORT
29 : /*
30 : * TIFF Library.
31 : *
32 : * CCITT Group 3 (T.4) and Group 4 (T.6) Compression Support.
33 : *
34 : * This file contains support for decoding and encoding TIFF
35 : * compression algorithms 2, 3, 4, and 32771.
36 : *
37 : * Decoder support is derived, with permission, from the code
38 : * in Frank Cringle's viewfax program;
39 : * Copyright (C) 1990, 1995 Frank D. Cringle.
40 : */
41 : #include "tif_fax3.h"
42 : #define G3CODES
43 : #include "t4.h"
44 : #include <stdio.h>
45 :
46 : /*
47 : * Compression+decompression state blocks are
48 : * derived from this ``base state'' block.
49 : */
50 : typedef struct {
51 : int rw_mode; /* O_RDONLY for decode, else encode */
52 : int mode; /* operating mode */
53 : tmsize_t rowbytes; /* bytes in a decoded scanline */
54 : uint32 rowpixels; /* pixels in a scanline */
55 :
56 : uint16 cleanfaxdata; /* CleanFaxData tag */
57 : uint32 badfaxrun; /* BadFaxRun tag */
58 : uint32 badfaxlines; /* BadFaxLines tag */
59 : uint32 groupoptions; /* Group 3/4 options tag */
60 :
61 : TIFFVGetMethod vgetparent; /* super-class method */
62 : TIFFVSetMethod vsetparent; /* super-class method */
63 : TIFFPrintMethod printdir; /* super-class method */
64 : } Fax3BaseState;
65 : #define Fax3State(tif) ((Fax3BaseState*) (tif)->tif_data)
66 :
67 : typedef enum { G3_1D, G3_2D } Ttag;
68 : typedef struct {
69 : Fax3BaseState b;
70 :
71 : /* Decoder state info */
72 : const unsigned char* bitmap; /* bit reversal table */
73 : uint32 data; /* current i/o byte/word */
74 : int bit; /* current i/o bit in byte */
75 : int EOLcnt; /* count of EOL codes recognized */
76 : TIFFFaxFillFunc fill; /* fill routine */
77 : uint32* runs; /* b&w runs for current/previous row */
78 : uint32* refruns; /* runs for reference line */
79 : uint32* curruns; /* runs for current line */
80 :
81 : /* Encoder state info */
82 : Ttag tag; /* encoding state */
83 : unsigned char* refline; /* reference line for 2d decoding */
84 : int k; /* #rows left that can be 2d encoded */
85 : int maxk; /* max #rows that can be 2d encoded */
86 :
87 : int line;
88 : } Fax3CodecState;
89 : #define DecoderState(tif) ((Fax3CodecState*) Fax3State(tif))
90 : #define EncoderState(tif) ((Fax3CodecState*) Fax3State(tif))
91 :
92 : #define is2DEncoding(sp) (sp->b.groupoptions & GROUP3OPT_2DENCODING)
93 : #define isAligned(p,t) ((((size_t)(p)) & (sizeof (t)-1)) == 0)
94 :
95 : /*
96 : * Group 3 and Group 4 Decoding.
97 : */
98 :
99 : /*
100 : * These macros glue the TIFF library state to
101 : * the state expected by Frank's decoder.
102 : */
103 : #define DECLARE_STATE(tif, sp, mod) \
104 : static const char module[] = mod; \
105 : Fax3CodecState* sp = DecoderState(tif); \
106 : int a0; /* reference element */ \
107 : int lastx = sp->b.rowpixels; /* last element in row */ \
108 : uint32 BitAcc; /* bit accumulator */ \
109 : int BitsAvail; /* # valid bits in BitAcc */ \
110 : int RunLength; /* length of current run */ \
111 : unsigned char* cp; /* next byte of input data */ \
112 : unsigned char* ep; /* end of input data */ \
113 : uint32* pa; /* place to stuff next run */ \
114 : uint32* thisrun; /* current row's run array */ \
115 : int EOLcnt; /* # EOL codes recognized */ \
116 : const unsigned char* bitmap = sp->bitmap; /* input data bit reverser */ \
117 : const TIFFFaxTabEnt* TabEnt
118 : #define DECLARE_STATE_2D(tif, sp, mod) \
119 : DECLARE_STATE(tif, sp, mod); \
120 : int b1; /* next change on prev line */ \
121 : uint32* pb /* next run in reference line */\
122 : /*
123 : * Load any state that may be changed during decoding.
124 : */
125 : #define CACHE_STATE(tif, sp) do { \
126 : BitAcc = sp->data; \
127 : BitsAvail = sp->bit; \
128 : EOLcnt = sp->EOLcnt; \
129 : cp = (unsigned char*) tif->tif_rawcp; \
130 : ep = cp + tif->tif_rawcc; \
131 : } while (0)
132 : /*
133 : * Save state possibly changed during decoding.
134 : */
135 : #define UNCACHE_STATE(tif, sp) do { \
136 : sp->bit = BitsAvail; \
137 : sp->data = BitAcc; \
138 : sp->EOLcnt = EOLcnt; \
139 : tif->tif_rawcc -= (tmsize_t)((uint8*) cp - tif->tif_rawcp); \
140 : tif->tif_rawcp = (uint8*) cp; \
141 : } while (0)
142 :
143 : /*
144 : * Setup state for decoding a strip.
145 : */
146 : static int
147 6 : Fax3PreDecode(TIFF* tif, uint16 s)
148 : {
149 6 : Fax3CodecState* sp = DecoderState(tif);
150 :
151 : (void) s;
152 6 : assert(sp != NULL);
153 6 : sp->bit = 0; /* force initial read */
154 6 : sp->data = 0;
155 6 : sp->EOLcnt = 0; /* force initial scan for EOL */
156 : /*
157 : * Decoder assumes lsb-to-msb bit order. Note that we select
158 : * this here rather than in Fax3SetupState so that viewers can
159 : * hold the image open, fiddle with the FillOrder tag value,
160 : * and then re-decode the image. Otherwise they'd need to close
161 : * and open the image to get the state reset.
162 : */
163 6 : sp->bitmap =
164 6 : TIFFGetBitRevTable(tif->tif_dir.td_fillorder != FILLORDER_LSB2MSB);
165 6 : if (sp->refruns) { /* init reference line to white */
166 6 : sp->refruns[0] = (uint32) sp->b.rowpixels;
167 6 : sp->refruns[1] = 0;
168 : }
169 6 : sp->line = 0;
170 6 : return (1);
171 : }
172 :
173 : /*
174 : * Routine for handling various errors/conditions.
175 : * Note how they are "glued into the decoder" by
176 : * overriding the definitions used by the decoder.
177 : */
178 :
179 : static void
180 0 : Fax3Unexpected(const char* module, TIFF* tif, uint32 line, uint32 a0)
181 : {
182 0 : TIFFErrorExt(tif->tif_clientdata, module, "Bad code word at line %u of %s %u (x %u)",
183 0 : line, isTiled(tif) ? "tile" : "strip",
184 0 : (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
185 : a0);
186 0 : }
187 : #define unexpected(table, a0) Fax3Unexpected(module, tif, sp->line, a0)
188 :
189 : static void
190 0 : Fax3Extension(const char* module, TIFF* tif, uint32 line, uint32 a0)
191 : {
192 0 : TIFFErrorExt(tif->tif_clientdata, module,
193 : "Uncompressed data (not supported) at line %u of %s %u (x %u)",
194 0 : line, isTiled(tif) ? "tile" : "strip",
195 0 : (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
196 : a0);
197 0 : }
198 : #define extension(a0) Fax3Extension(module, tif, sp->line, a0)
199 :
200 : static void
201 0 : Fax3BadLength(const char* module, TIFF* tif, uint32 line, uint32 a0, uint32 lastx)
202 : {
203 0 : TIFFWarningExt(tif->tif_clientdata, module, "%s at line %u of %s %u (got %u, expected %u)",
204 : a0 < lastx ? "Premature EOL" : "Line length mismatch",
205 0 : line, isTiled(tif) ? "tile" : "strip",
206 0 : (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
207 : a0, lastx);
208 0 : }
209 : #define badlength(a0,lastx) Fax3BadLength(module, tif, sp->line, a0, lastx)
210 :
211 : static void
212 0 : Fax3PrematureEOF(const char* module, TIFF* tif, uint32 line, uint32 a0)
213 : {
214 0 : TIFFWarningExt(tif->tif_clientdata, module, "Premature EOF at line %u of %s %u (x %u)",
215 0 : line, isTiled(tif) ? "tile" : "strip",
216 0 : (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
217 : a0);
218 0 : }
219 : #define prematureEOF(a0) Fax3PrematureEOF(module, tif, sp->line, a0)
220 :
221 : #define Nop
222 :
223 : /*
224 : * Decode the requested amount of G3 1D-encoded data.
225 : */
226 : static int
227 0 : Fax3Decode1D(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
228 : {
229 0 : DECLARE_STATE(tif, sp, "Fax3Decode1D");
230 : (void) s;
231 0 : if (occ % sp->b.rowbytes)
232 : {
233 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
234 0 : return (-1);
235 : }
236 0 : CACHE_STATE(tif, sp);
237 0 : thisrun = sp->curruns;
238 0 : while (occ > 0) {
239 0 : a0 = 0;
240 0 : RunLength = 0;
241 0 : pa = thisrun;
242 : #ifdef FAX3_DEBUG
243 : printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail);
244 : printf("-------------------- %d\n", tif->tif_row);
245 : fflush(stdout);
246 : #endif
247 0 : SYNC_EOL(EOF1D);
248 0 : EXPAND1D(EOF1Da);
249 0 : (*sp->fill)(buf, thisrun, pa, lastx);
250 0 : buf += sp->b.rowbytes;
251 0 : occ -= sp->b.rowbytes;
252 0 : sp->line++;
253 0 : continue;
254 : EOF1D: /* premature EOF */
255 0 : CLEANUP_RUNS();
256 : EOF1Da: /* premature EOF */
257 0 : (*sp->fill)(buf, thisrun, pa, lastx);
258 0 : UNCACHE_STATE(tif, sp);
259 0 : return (-1);
260 : }
261 0 : UNCACHE_STATE(tif, sp);
262 0 : return (1);
263 : }
264 :
265 : #define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; }
266 : /*
267 : * Decode the requested amount of G3 2D-encoded data.
268 : */
269 : static int
270 1 : Fax3Decode2D(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
271 : {
272 1 : DECLARE_STATE_2D(tif, sp, "Fax3Decode2D");
273 : int is1D; /* current line is 1d/2d-encoded */
274 : (void) s;
275 1 : if (occ % sp->b.rowbytes)
276 : {
277 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
278 0 : return (-1);
279 : }
280 1 : CACHE_STATE(tif, sp);
281 1026 : while (occ > 0) {
282 1024 : a0 = 0;
283 1024 : RunLength = 0;
284 1024 : pa = thisrun = sp->curruns;
285 : #ifdef FAX3_DEBUG
286 : printf("\nBitAcc=%08X, BitsAvail = %d EOLcnt = %d",
287 : BitAcc, BitsAvail, EOLcnt);
288 : #endif
289 1024 : SYNC_EOL(EOF2D);
290 1024 : NeedBits8(1, EOF2D);
291 1024 : is1D = GetBits(1); /* 1D/2D-encoding tag bit */
292 1024 : ClrBits(1);
293 : #ifdef FAX3_DEBUG
294 : printf(" %s\n-------------------- %d\n",
295 : is1D ? "1D" : "2D", tif->tif_row);
296 : fflush(stdout);
297 : #endif
298 1024 : pb = sp->refruns;
299 1024 : b1 = *pb++;
300 1024 : if (is1D)
301 497 : EXPAND1D(EOF2Da);
302 : else
303 768 : EXPAND2D(EOF2Da);
304 1024 : (*sp->fill)(buf, thisrun, pa, lastx);
305 1024 : SETVALUE(0); /* imaginary change for reference */
306 1024 : SWAP(uint32*, sp->curruns, sp->refruns);
307 1024 : buf += sp->b.rowbytes;
308 1024 : occ -= sp->b.rowbytes;
309 1024 : sp->line++;
310 1024 : continue;
311 : EOF2D: /* premature EOF */
312 0 : CLEANUP_RUNS();
313 : EOF2Da: /* premature EOF */
314 0 : (*sp->fill)(buf, thisrun, pa, lastx);
315 0 : UNCACHE_STATE(tif, sp);
316 0 : return (-1);
317 : }
318 1 : UNCACHE_STATE(tif, sp);
319 1 : return (1);
320 : }
321 : #undef SWAP
322 :
323 : /*
324 : * The ZERO & FILL macros must handle spans < 2*sizeof(long) bytes.
325 : * For machines with 64-bit longs this is <16 bytes; otherwise
326 : * this is <8 bytes. We optimize the code here to reflect the
327 : * machine characteristics.
328 : */
329 : #if SIZEOF_UNSIGNED_LONG == 8
330 : # define FILL(n, cp) \
331 : switch (n) { \
332 : case 15:(cp)[14] = 0xff; case 14:(cp)[13] = 0xff; case 13: (cp)[12] = 0xff;\
333 : case 12:(cp)[11] = 0xff; case 11:(cp)[10] = 0xff; case 10: (cp)[9] = 0xff;\
334 : case 9: (cp)[8] = 0xff; case 8: (cp)[7] = 0xff; case 7: (cp)[6] = 0xff;\
335 : case 6: (cp)[5] = 0xff; case 5: (cp)[4] = 0xff; case 4: (cp)[3] = 0xff;\
336 : case 3: (cp)[2] = 0xff; case 2: (cp)[1] = 0xff; \
337 : case 1: (cp)[0] = 0xff; (cp) += (n); case 0: ; \
338 : }
339 : # define ZERO(n, cp) \
340 : switch (n) { \
341 : case 15:(cp)[14] = 0; case 14:(cp)[13] = 0; case 13: (cp)[12] = 0; \
342 : case 12:(cp)[11] = 0; case 11:(cp)[10] = 0; case 10: (cp)[9] = 0; \
343 : case 9: (cp)[8] = 0; case 8: (cp)[7] = 0; case 7: (cp)[6] = 0; \
344 : case 6: (cp)[5] = 0; case 5: (cp)[4] = 0; case 4: (cp)[3] = 0; \
345 : case 3: (cp)[2] = 0; case 2: (cp)[1] = 0; \
346 : case 1: (cp)[0] = 0; (cp) += (n); case 0: ; \
347 : }
348 : #else
349 : # define FILL(n, cp) \
350 : switch (n) { \
351 : case 7: (cp)[6] = 0xff; case 6: (cp)[5] = 0xff; case 5: (cp)[4] = 0xff; \
352 : case 4: (cp)[3] = 0xff; case 3: (cp)[2] = 0xff; case 2: (cp)[1] = 0xff; \
353 : case 1: (cp)[0] = 0xff; (cp) += (n); case 0: ; \
354 : }
355 : # define ZERO(n, cp) \
356 : switch (n) { \
357 : case 7: (cp)[6] = 0; case 6: (cp)[5] = 0; case 5: (cp)[4] = 0; \
358 : case 4: (cp)[3] = 0; case 3: (cp)[2] = 0; case 2: (cp)[1] = 0; \
359 : case 1: (cp)[0] = 0; (cp) += (n); case 0: ; \
360 : }
361 : #endif
362 :
363 : /*
364 : * Bit-fill a row according to the white/black
365 : * runs generated during G3/G4 decoding.
366 : */
367 : void
368 22858 : _TIFFFax3fillruns(unsigned char* buf, uint32* runs, uint32* erun, uint32 lastx)
369 : {
370 : static const unsigned char _fillmasks[] =
371 : { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
372 : unsigned char* cp;
373 : uint32 x, bx, run;
374 : int32 n, nw;
375 : long* lp;
376 :
377 22858 : if ((erun-runs)&1)
378 83 : *erun++ = 0;
379 22858 : x = 0;
380 73492 : for (; runs < erun; runs += 2) {
381 50634 : run = runs[0];
382 50634 : if (x+run > lastx || run > lastx )
383 0 : run = runs[0] = (uint32) (lastx - x);
384 50634 : if (run) {
385 28871 : cp = buf + (x>>3);
386 28871 : bx = x&7;
387 28871 : if (run > 8-bx) {
388 20739 : if (bx) { /* align to byte boundary */
389 17664 : *cp++ &= 0xff << (8-bx);
390 17664 : run -= 8-bx;
391 : }
392 20739 : if( (n = run >> 3) != 0 ) { /* multiple bytes to fill */
393 12499 : if ((n/sizeof (long)) > 1) {
394 : /*
395 : * Align to longword boundary and fill.
396 : */
397 1759 : for (; n && !isAligned(cp, long); n--)
398 474 : *cp++ = 0x00;
399 1285 : lp = (long*) cp;
400 1285 : nw = (int32)(n / sizeof (long));
401 1285 : n -= nw * sizeof (long);
402 : do {
403 16388 : *lp++ = 0L;
404 16388 : } while (--nw);
405 1285 : cp = (unsigned char*) lp;
406 : }
407 12499 : ZERO(n, cp);
408 12499 : run &= 7;
409 : }
410 20739 : if (run)
411 19027 : cp[0] &= 0xff >> run;
412 : } else
413 8132 : cp[0] &= ~(_fillmasks[run]>>bx);
414 28871 : x += runs[0];
415 : }
416 50634 : run = runs[1];
417 50634 : if (x+run > lastx || run > lastx )
418 0 : run = runs[1] = lastx - x;
419 50634 : if (run) {
420 50551 : cp = buf + (x>>3);
421 50551 : bx = x&7;
422 50551 : if (run > 8-bx) {
423 45592 : if (bx) { /* align to byte boundary */
424 21623 : *cp++ |= 0xff >> bx;
425 21623 : run -= 8-bx;
426 : }
427 45592 : if( (n = run>>3) != 0 ) { /* multiple bytes to fill */
428 42107 : if ((n/sizeof (long)) > 1) {
429 : /*
430 : * Align to longword boundary and fill.
431 : */
432 43931 : for (; n && !isAligned(cp, long); n--)
433 14020 : *cp++ = 0xff;
434 29911 : lp = (long*) cp;
435 29911 : nw = (int32)(n / sizeof (long));
436 29911 : n -= nw * sizeof (long);
437 : do {
438 655480 : *lp++ = -1L;
439 655480 : } while (--nw);
440 29911 : cp = (unsigned char*) lp;
441 : }
442 42107 : FILL(n, cp);
443 42107 : run &= 7;
444 : }
445 45592 : if (run)
446 20366 : cp[0] |= 0xff00 >> run;
447 : } else
448 4959 : cp[0] |= _fillmasks[run]>>bx;
449 50551 : x += runs[1];
450 : }
451 : }
452 22858 : assert(x == lastx);
453 22858 : }
454 : #undef ZERO
455 : #undef FILL
456 :
457 : static int
458 10 : Fax3FixupTags(TIFF* tif)
459 : {
460 : (void) tif;
461 10 : return (1);
462 : }
463 :
464 : /*
465 : * Setup G3/G4-related compression/decompression state
466 : * before data is processed. This routine is called once
467 : * per image -- it sets up different state based on whether
468 : * or not decoding or encoding is being done and whether
469 : * 1D- or 2D-encoded data is involved.
470 : */
471 : static int
472 8 : Fax3SetupState(TIFF* tif)
473 : {
474 : static const char module[] = "Fax3SetupState";
475 8 : TIFFDirectory* td = &tif->tif_dir;
476 8 : Fax3BaseState* sp = Fax3State(tif);
477 : int needsRefLine;
478 8 : Fax3CodecState* dsp = (Fax3CodecState*) Fax3State(tif);
479 : tmsize_t rowbytes;
480 : uint32 rowpixels, nruns;
481 :
482 8 : if (td->td_bitspersample != 1) {
483 0 : TIFFErrorExt(tif->tif_clientdata, module,
484 : "Bits/sample must be 1 for Group 3/4 encoding/decoding");
485 0 : return (0);
486 : }
487 : /*
488 : * Calculate the scanline/tile widths.
489 : */
490 8 : if (isTiled(tif)) {
491 0 : rowbytes = TIFFTileRowSize(tif);
492 0 : rowpixels = td->td_tilewidth;
493 : } else {
494 8 : rowbytes = TIFFScanlineSize(tif);
495 8 : rowpixels = td->td_imagewidth;
496 : }
497 8 : sp->rowbytes = rowbytes;
498 8 : sp->rowpixels = rowpixels;
499 : /*
500 : * Allocate any additional space required for decoding/encoding.
501 : */
502 15 : needsRefLine = (
503 8 : (sp->groupoptions & GROUP3OPT_2DENCODING) ||
504 7 : td->td_compression == COMPRESSION_CCITTFAX4
505 : );
506 :
507 8 : nruns = needsRefLine ? 2*TIFFroundup_32(rowpixels,32) : rowpixels;
508 8 : nruns += 3;
509 8 : dsp->runs = (uint32*) _TIFFCheckMalloc(tif, 2*nruns, sizeof (uint32),
510 : "for Group 3/4 run arrays");
511 8 : if (dsp->runs == NULL)
512 0 : return (0);
513 8 : dsp->curruns = dsp->runs;
514 8 : if (needsRefLine)
515 8 : dsp->refruns = dsp->runs + nruns;
516 : else
517 0 : dsp->refruns = NULL;
518 9 : if (td->td_compression == COMPRESSION_CCITTFAX3
519 9 : && is2DEncoding(dsp)) { /* NB: default is 1D routine */
520 1 : tif->tif_decoderow = Fax3Decode2D;
521 1 : tif->tif_decodestrip = Fax3Decode2D;
522 1 : tif->tif_decodetile = Fax3Decode2D;
523 : }
524 :
525 8 : if (needsRefLine) { /* 2d encoding */
526 8 : Fax3CodecState* esp = EncoderState(tif);
527 : /*
528 : * 2d encoding requires a scanline
529 : * buffer for the ``reference line''; the
530 : * scanline against which delta encoding
531 : * is referenced. The reference line must
532 : * be initialized to be ``white'' (done elsewhere).
533 : */
534 8 : esp->refline = (unsigned char*) _TIFFmalloc(rowbytes);
535 8 : if (esp->refline == NULL) {
536 0 : TIFFErrorExt(tif->tif_clientdata, module,
537 : "No space for Group 3/4 reference line");
538 0 : return (0);
539 : }
540 : } else /* 1d encoding */
541 0 : EncoderState(tif)->refline = NULL;
542 :
543 8 : return (1);
544 : }
545 :
546 : /*
547 : * CCITT Group 3 FAX Encoding.
548 : */
549 :
550 : #define Fax3FlushBits(tif, sp) { \
551 : if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \
552 : (void) TIFFFlushData1(tif); \
553 : *(tif)->tif_rawcp++ = (uint8) (sp)->data; \
554 : (tif)->tif_rawcc++; \
555 : (sp)->data = 0, (sp)->bit = 8; \
556 : }
557 : #define _FlushBits(tif) { \
558 : if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \
559 : (void) TIFFFlushData1(tif); \
560 : *(tif)->tif_rawcp++ = (uint8) data; \
561 : (tif)->tif_rawcc++; \
562 : data = 0, bit = 8; \
563 : }
564 : static const int _msbmask[9] =
565 : { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
566 : #define _PutBits(tif, bits, length) { \
567 : while (length > bit) { \
568 : data |= bits >> (length - bit); \
569 : length -= bit; \
570 : _FlushBits(tif); \
571 : } \
572 : assert( length < 9 ); \
573 : data |= (bits & _msbmask[length]) << (bit - length); \
574 : bit -= length; \
575 : if (bit == 0) \
576 : _FlushBits(tif); \
577 : }
578 :
579 : /*
580 : * Write a variable-length bit-value to
581 : * the output stream. Values are
582 : * assumed to be at most 16 bits.
583 : */
584 : static void
585 32719 : Fax3PutBits(TIFF* tif, unsigned int bits, unsigned int length)
586 : {
587 32719 : Fax3CodecState* sp = EncoderState(tif);
588 32719 : unsigned int bit = sp->bit;
589 32719 : int data = sp->data;
590 :
591 32719 : _PutBits(tif, bits, length);
592 :
593 32719 : sp->data = data;
594 32719 : sp->bit = bit;
595 32719 : }
596 :
597 : /*
598 : * Write a code to the output stream.
599 : */
600 : #define putcode(tif, te) Fax3PutBits(tif, (te)->code, (te)->length)
601 :
602 : #ifdef FAX3_DEBUG
603 : #define DEBUG_COLOR(w) (tab == TIFFFaxWhiteCodes ? w "W" : w "B")
604 : #define DEBUG_PRINT(what,len) { \
605 : int t; \
606 : printf("%08X/%-2d: %s%5d\t", data, bit, DEBUG_COLOR(what), len); \
607 : for (t = length-1; t >= 0; t--) \
608 : putchar(code & (1<<t) ? '1' : '0'); \
609 : putchar('\n'); \
610 : }
611 : #endif
612 :
613 : /*
614 : * Write the sequence of codes that describes
615 : * the specified span of zero's or one's. The
616 : * appropriate table that holds the make-up and
617 : * terminating codes is supplied.
618 : */
619 : static void
620 4768 : putspan(TIFF* tif, int32 span, const tableentry* tab)
621 : {
622 4768 : Fax3CodecState* sp = EncoderState(tif);
623 4768 : unsigned int bit = sp->bit;
624 4768 : int data = sp->data;
625 : unsigned int code, length;
626 :
627 9536 : while (span >= 2624) {
628 0 : const tableentry* te = &tab[63 + (2560>>6)];
629 0 : code = te->code, length = te->length;
630 : #ifdef FAX3_DEBUG
631 : DEBUG_PRINT("MakeUp", te->runlen);
632 : #endif
633 0 : _PutBits(tif, code, length);
634 0 : span -= te->runlen;
635 : }
636 4768 : if (span >= 64) {
637 397 : const tableentry* te = &tab[63 + (span>>6)];
638 397 : assert(te->runlen == 64*(span>>6));
639 397 : code = te->code, length = te->length;
640 : #ifdef FAX3_DEBUG
641 : DEBUG_PRINT("MakeUp", te->runlen);
642 : #endif
643 397 : _PutBits(tif, code, length);
644 397 : span -= te->runlen;
645 : }
646 4768 : code = tab[span].code, length = tab[span].length;
647 : #ifdef FAX3_DEBUG
648 : DEBUG_PRINT(" Term", tab[span].runlen);
649 : #endif
650 4768 : _PutBits(tif, code, length);
651 :
652 4768 : sp->data = data;
653 4768 : sp->bit = bit;
654 4768 : }
655 :
656 : /*
657 : * Write an EOL code to the output stream. The zero-fill
658 : * logic for byte-aligning encoded scanlines is handled
659 : * here. We also handle writing the tag bit for the next
660 : * scanline when doing 2d encoding.
661 : */
662 : static void
663 0 : Fax3PutEOL(TIFF* tif)
664 : {
665 0 : Fax3CodecState* sp = EncoderState(tif);
666 0 : unsigned int bit = sp->bit;
667 0 : int data = sp->data;
668 : unsigned int code, length, tparm;
669 :
670 0 : if (sp->b.groupoptions & GROUP3OPT_FILLBITS) {
671 : /*
672 : * Force bit alignment so EOL will terminate on
673 : * a byte boundary. That is, force the bit alignment
674 : * to 16-12 = 4 before putting out the EOL code.
675 : */
676 0 : int align = 8 - 4;
677 0 : if (align != sp->bit) {
678 0 : if (align > sp->bit)
679 0 : align = sp->bit + (8 - align);
680 : else
681 0 : align = sp->bit - align;
682 0 : code = 0;
683 0 : tparm=align;
684 0 : _PutBits(tif, 0, tparm);
685 : }
686 : }
687 0 : code = EOL, length = 12;
688 0 : if (is2DEncoding(sp))
689 0 : code = (code<<1) | (sp->tag == G3_1D), length++;
690 0 : _PutBits(tif, code, length);
691 :
692 0 : sp->data = data;
693 0 : sp->bit = bit;
694 0 : }
695 :
696 : /*
697 : * Reset encoding state at the start of a strip.
698 : */
699 : static int
700 2 : Fax3PreEncode(TIFF* tif, uint16 s)
701 : {
702 2 : Fax3CodecState* sp = EncoderState(tif);
703 :
704 : (void) s;
705 2 : assert(sp != NULL);
706 2 : sp->bit = 8;
707 2 : sp->data = 0;
708 2 : sp->tag = G3_1D;
709 : /*
710 : * This is necessary for Group 4; otherwise it isn't
711 : * needed because the first scanline of each strip ends
712 : * up being copied into the refline.
713 : */
714 2 : if (sp->refline)
715 2 : _TIFFmemset(sp->refline, 0x00, sp->b.rowbytes);
716 2 : if (is2DEncoding(sp)) {
717 0 : float res = tif->tif_dir.td_yresolution;
718 : /*
719 : * The CCITT spec says that when doing 2d encoding, you
720 : * should only do it on K consecutive scanlines, where K
721 : * depends on the resolution of the image being encoded
722 : * (2 for <= 200 lpi, 4 for > 200 lpi). Since the directory
723 : * code initializes td_yresolution to 0, this code will
724 : * select a K of 2 unless the YResolution tag is set
725 : * appropriately. (Note also that we fudge a little here
726 : * and use 150 lpi to avoid problems with units conversion.)
727 : */
728 0 : if (tif->tif_dir.td_resolutionunit == RESUNIT_CENTIMETER)
729 0 : res *= 2.54f; /* convert to inches */
730 0 : sp->maxk = (res > 150 ? 4 : 2);
731 0 : sp->k = sp->maxk-1;
732 : } else
733 2 : sp->k = sp->maxk = 0;
734 2 : sp->line = 0;
735 2 : return (1);
736 : }
737 :
738 : static const unsigned char zeroruns[256] = {
739 : 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, /* 0x00 - 0x0f */
740 : 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0x10 - 0x1f */
741 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x20 - 0x2f */
742 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x30 - 0x3f */
743 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 - 0x4f */
744 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x50 - 0x5f */
745 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 - 0x6f */
746 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x70 - 0x7f */
747 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x80 - 0x8f */
748 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x90 - 0x9f */
749 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xa0 - 0xaf */
750 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xb0 - 0xbf */
751 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xc0 - 0xcf */
752 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xd0 - 0xdf */
753 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe0 - 0xef */
754 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xf0 - 0xff */
755 : };
756 : static const unsigned char oneruns[256] = {
757 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 - 0x0f */
758 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 - 0x1f */
759 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 - 0x2f */
760 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 - 0x3f */
761 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 - 0x4f */
762 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 - 0x5f */
763 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 - 0x6f */
764 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x70 - 0x7f */
765 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x80 - 0x8f */
766 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x90 - 0x9f */
767 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xa0 - 0xaf */
768 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xb0 - 0xbf */
769 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xc0 - 0xcf */
770 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xd0 - 0xdf */
771 : 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xe0 - 0xef */
772 : 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8, /* 0xf0 - 0xff */
773 : };
774 :
775 : /*
776 : * On certain systems it pays to inline
777 : * the routines that find pixel spans.
778 : */
779 : #ifdef VAXC
780 : static int32 find0span(unsigned char*, int32, int32);
781 : static int32 find1span(unsigned char*, int32, int32);
782 : #pragma inline(find0span,find1span)
783 : #endif
784 :
785 : /*
786 : * Find a span of ones or zeros using the supplied
787 : * table. The ``base'' of the bit string is supplied
788 : * along with the start+end bit indices.
789 : */
790 : inline static int32
791 44923 : find0span(unsigned char* bp, int32 bs, int32 be)
792 : {
793 44923 : int32 bits = be - bs;
794 : int32 n, span;
795 :
796 44923 : bp += bs>>3;
797 : /*
798 : * Check partial byte on lhs.
799 : */
800 64872 : if (bits > 0 && (n = (bs & 7))) {
801 32943 : span = zeroruns[(*bp << n) & 0xff];
802 32943 : if (span > 8-n) /* table value too generous */
803 19998 : span = 8-n;
804 32943 : if (span > bits) /* constrain span to bit range */
805 49 : span = bits;
806 32943 : if (n+span < 8) /* doesn't extend to edge of byte */
807 12994 : return (span);
808 19949 : bits -= span;
809 19949 : bp++;
810 : } else
811 11980 : span = 0;
812 31929 : if (bits >= (int32)(2 * 8 * sizeof(long))) {
813 : long* lp;
814 : /*
815 : * Align to longword boundary and check longwords.
816 : */
817 71062 : while (!isAligned(bp, long)) {
818 23105 : if (*bp != 0x00)
819 11471 : return (span + zeroruns[*bp]);
820 11634 : span += 8, bits -= 8;
821 11634 : bp++;
822 : }
823 18243 : lp = (long*) bp;
824 37724 : while ((bits >= (int32)(8 * sizeof(long))) && (0 == *lp)) {
825 1238 : span += 8*sizeof (long), bits -= 8*sizeof (long);
826 1238 : lp++;
827 : }
828 18243 : bp = (unsigned char*) lp;
829 : }
830 : /*
831 : * Scan full bytes for all 0's.
832 : */
833 50779 : while (bits >= 8) {
834 30077 : if (*bp != 0x00) /* end of run */
835 20214 : return (span + zeroruns[*bp]);
836 9863 : span += 8, bits -= 8;
837 9863 : bp++;
838 : }
839 : /*
840 : * Check partial byte on rhs.
841 : */
842 244 : if (bits > 0) {
843 147 : n = zeroruns[*bp];
844 147 : span += (n > bits ? bits : n);
845 : }
846 244 : return (span);
847 : }
848 :
849 : inline static int32
850 59093 : find1span(unsigned char* bp, int32 bs, int32 be)
851 : {
852 59093 : int32 bits = be - bs;
853 : int32 n, span;
854 :
855 59093 : bp += bs>>3;
856 : /*
857 : * Check partial byte on lhs.
858 : */
859 81282 : if (bits > 0 && (n = (bs & 7))) {
860 33236 : span = oneruns[(*bp << n) & 0xff];
861 33236 : if (span > 8-n) /* table value too generous */
862 0 : span = 8-n;
863 33236 : if (span > bits) /* constrain span to bit range */
864 0 : span = bits;
865 33236 : if (n+span < 8) /* doesn't extend to edge of byte */
866 11047 : return (span);
867 22189 : bits -= span;
868 22189 : bp++;
869 : } else
870 25857 : span = 0;
871 48046 : if (bits >= (int32)(2 * 8 * sizeof(long))) {
872 : long* lp;
873 : /*
874 : * Align to longword boundary and check longwords.
875 : */
876 127568 : while (!isAligned(bp, long)) {
877 43093 : if (*bp != 0xff)
878 6477 : return (span + oneruns[*bp]);
879 36616 : span += 8, bits -= 8;
880 36616 : bp++;
881 : }
882 38999 : lp = (long*) bp;
883 717410 : while ((bits >= (int32)(8 * sizeof(long))) && (~0 == *lp)) {
884 639412 : span += 8*sizeof (long), bits -= 8*sizeof (long);
885 639412 : lp++;
886 : }
887 38999 : bp = (unsigned char*) lp;
888 : }
889 : /*
890 : * Scan full bytes for all 1's.
891 : */
892 132729 : while (bits >= 8) {
893 69171 : if (*bp != 0xff) /* end of run */
894 19580 : return (span + oneruns[*bp]);
895 49591 : span += 8, bits -= 8;
896 49591 : bp++;
897 : }
898 : /*
899 : * Check partial byte on rhs.
900 : */
901 21989 : if (bits > 0) {
902 288 : n = oneruns[*bp];
903 288 : span += (n > bits ? bits : n);
904 : }
905 21989 : return (span);
906 : }
907 :
908 : /*
909 : * Return the offset of the next bit in the range
910 : * [bs..be] that is different from the specified
911 : * color. The end, be, is returned if no such bit
912 : * exists.
913 : */
914 : #define finddiff(_cp, _bs, _be, _color) \
915 : (_bs + (_color ? find1span(_cp,_bs,_be) : find0span(_cp,_bs,_be)))
916 : /*
917 : * Like finddiff, but also check the starting bit
918 : * against the end in case start > end.
919 : */
920 : #define finddiff2(_cp, _bs, _be, _color) \
921 : (_bs < _be ? finddiff(_cp,_bs,_be,_color) : _be)
922 :
923 : /*
924 : * 1d-encode a row of pixels. The encoding is
925 : * a sequence of all-white or all-black spans
926 : * of pixels encoded with Huffman codes.
927 : */
928 : static int
929 0 : Fax3Encode1DRow(TIFF* tif, unsigned char* bp, uint32 bits)
930 : {
931 0 : Fax3CodecState* sp = EncoderState(tif);
932 : int32 span;
933 0 : uint32 bs = 0;
934 :
935 : for (;;) {
936 0 : span = find0span(bp, bs, bits); /* white span */
937 0 : putspan(tif, span, TIFFFaxWhiteCodes);
938 0 : bs += span;
939 0 : if (bs >= bits)
940 0 : break;
941 0 : span = find1span(bp, bs, bits); /* black span */
942 0 : putspan(tif, span, TIFFFaxBlackCodes);
943 0 : bs += span;
944 0 : if (bs >= bits)
945 0 : break;
946 0 : }
947 0 : if (sp->b.mode & (FAXMODE_BYTEALIGN|FAXMODE_WORDALIGN)) {
948 0 : if (sp->bit != 8) /* byte-align */
949 0 : Fax3FlushBits(tif, sp);
950 0 : if ((sp->b.mode&FAXMODE_WORDALIGN) &&
951 0 : !isAligned(tif->tif_rawcp, uint16))
952 0 : Fax3FlushBits(tif, sp);
953 : }
954 0 : return (1);
955 : }
956 :
957 : static const tableentry horizcode =
958 : { 3, 0x1, 0 }; /* 001 */
959 : static const tableentry passcode =
960 : { 4, 0x1, 0 }; /* 0001 */
961 : static const tableentry vcodes[7] = {
962 : { 7, 0x03, 0 }, /* 0000 011 */
963 : { 6, 0x03, 0 }, /* 0000 11 */
964 : { 3, 0x03, 0 }, /* 011 */
965 : { 1, 0x1, 0 }, /* 1 */
966 : { 3, 0x2, 0 }, /* 010 */
967 : { 6, 0x02, 0 }, /* 0000 10 */
968 : { 7, 0x02, 0 } /* 0000 010 */
969 : };
970 :
971 : /*
972 : * 2d-encode a row of pixels. Consult the CCITT
973 : * documentation for the algorithm.
974 : */
975 : static int
976 7299 : Fax3Encode2DRow(TIFF* tif, unsigned char* bp, unsigned char* rp, uint32 bits)
977 : {
978 : #define PIXEL(buf,ix) ((((buf)[(ix)>>3]) >> (7-((ix)&7))) & 1)
979 7299 : uint32 a0 = 0;
980 7299 : uint32 a1 = (PIXEL(bp, 0) != 0 ? 0 : finddiff(bp, 0, bits, 0));
981 7299 : uint32 b1 = (PIXEL(rp, 0) != 0 ? 0 : finddiff(rp, 0, bits, 0));
982 : uint32 a2, b2;
983 :
984 : for (;;) {
985 32715 : b2 = finddiff2(rp, b1, bits, PIXEL(rp,b1));
986 32715 : if (b2 >= a1) {
987 31212 : int32 d = b1 - a1;
988 33596 : if (!(-3 <= d && d <= 3)) { /* horizontal mode */
989 2384 : a2 = finddiff2(bp, a1, bits, PIXEL(bp,a1));
990 2384 : putcode(tif, &horizcode);
991 3437 : if (a0+a1 == 0 || PIXEL(bp, a0) == 0) {
992 1053 : putspan(tif, a1-a0, TIFFFaxWhiteCodes);
993 1053 : putspan(tif, a2-a1, TIFFFaxBlackCodes);
994 : } else {
995 1331 : putspan(tif, a1-a0, TIFFFaxBlackCodes);
996 1331 : putspan(tif, a2-a1, TIFFFaxWhiteCodes);
997 : }
998 2384 : a0 = a2;
999 : } else { /* vertical mode */
1000 28828 : putcode(tif, &vcodes[d+3]);
1001 28828 : a0 = a1;
1002 : }
1003 : } else { /* pass mode */
1004 1503 : putcode(tif, &passcode);
1005 1503 : a0 = b2;
1006 : }
1007 32715 : if (a0 >= bits)
1008 : break;
1009 25416 : a1 = finddiff(bp, a0, bits, PIXEL(bp,a0));
1010 25416 : b1 = finddiff(rp, a0, bits, !PIXEL(bp,a0));
1011 25416 : b1 = finddiff(rp, b1, bits, PIXEL(bp,a0));
1012 25416 : }
1013 7299 : return (1);
1014 : #undef PIXEL
1015 : }
1016 :
1017 : /*
1018 : * Encode a buffer of pixels.
1019 : */
1020 : static int
1021 0 : Fax3Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
1022 : {
1023 : static const char module[] = "Fax3Encode";
1024 0 : Fax3CodecState* sp = EncoderState(tif);
1025 : (void) s;
1026 0 : if (cc % sp->b.rowbytes)
1027 : {
1028 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be written");
1029 0 : return (0);
1030 : }
1031 0 : while (cc > 0) {
1032 0 : if ((sp->b.mode & FAXMODE_NOEOL) == 0)
1033 0 : Fax3PutEOL(tif);
1034 0 : if (is2DEncoding(sp)) {
1035 0 : if (sp->tag == G3_1D) {
1036 0 : if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
1037 0 : return (0);
1038 0 : sp->tag = G3_2D;
1039 : } else {
1040 0 : if (!Fax3Encode2DRow(tif, bp, sp->refline,
1041 : sp->b.rowpixels))
1042 0 : return (0);
1043 0 : sp->k--;
1044 : }
1045 0 : if (sp->k == 0) {
1046 0 : sp->tag = G3_1D;
1047 0 : sp->k = sp->maxk-1;
1048 : } else
1049 0 : _TIFFmemcpy(sp->refline, bp, sp->b.rowbytes);
1050 : } else {
1051 0 : if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
1052 0 : return (0);
1053 : }
1054 0 : bp += sp->b.rowbytes;
1055 0 : cc -= sp->b.rowbytes;
1056 : }
1057 0 : return (1);
1058 : }
1059 :
1060 : static int
1061 0 : Fax3PostEncode(TIFF* tif)
1062 : {
1063 0 : Fax3CodecState* sp = EncoderState(tif);
1064 :
1065 0 : if (sp->bit != 8)
1066 0 : Fax3FlushBits(tif, sp);
1067 0 : return (1);
1068 : }
1069 :
1070 : static void
1071 4 : Fax3Close(TIFF* tif)
1072 : {
1073 4 : if ((Fax3State(tif)->mode & FAXMODE_NORTC) == 0) {
1074 0 : Fax3CodecState* sp = EncoderState(tif);
1075 0 : unsigned int code = EOL;
1076 0 : unsigned int length = 12;
1077 : int i;
1078 :
1079 0 : if (is2DEncoding(sp))
1080 0 : code = (code<<1) | (sp->tag == G3_1D), length++;
1081 0 : for (i = 0; i < 6; i++)
1082 0 : Fax3PutBits(tif, code, length);
1083 0 : Fax3FlushBits(tif, sp);
1084 : }
1085 4 : }
1086 :
1087 : static void
1088 14 : Fax3Cleanup(TIFF* tif)
1089 : {
1090 14 : Fax3CodecState* sp = DecoderState(tif);
1091 :
1092 14 : assert(sp != 0);
1093 :
1094 14 : tif->tif_tagmethods.vgetfield = sp->b.vgetparent;
1095 14 : tif->tif_tagmethods.vsetfield = sp->b.vsetparent;
1096 14 : tif->tif_tagmethods.printdir = sp->b.printdir;
1097 :
1098 14 : if (sp->runs)
1099 8 : _TIFFfree(sp->runs);
1100 14 : if (sp->refline)
1101 8 : _TIFFfree(sp->refline);
1102 :
1103 14 : _TIFFfree(tif->tif_data);
1104 14 : tif->tif_data = NULL;
1105 :
1106 14 : _TIFFSetDefaultCompressionState(tif);
1107 14 : }
1108 :
1109 : #define FIELD_BADFAXLINES (FIELD_CODEC+0)
1110 : #define FIELD_CLEANFAXDATA (FIELD_CODEC+1)
1111 : #define FIELD_BADFAXRUN (FIELD_CODEC+2)
1112 :
1113 : #define FIELD_OPTIONS (FIELD_CODEC+7)
1114 :
1115 : static const TIFFField faxFields[] = {
1116 : { TIFFTAG_FAXMODE, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "FaxMode", NULL },
1117 : { TIFFTAG_FAXFILLFUNC, 0, 0, TIFF_ANY, 0, TIFF_SETGET_OTHER, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "FaxFillFunc", NULL },
1118 : { TIFFTAG_BADFAXLINES, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_BADFAXLINES, TRUE, FALSE, "BadFaxLines", NULL },
1119 : { TIFFTAG_CLEANFAXDATA, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UINT16, FIELD_CLEANFAXDATA, TRUE, FALSE, "CleanFaxData", NULL },
1120 : { TIFFTAG_CONSECUTIVEBADFAXLINES, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_BADFAXRUN, TRUE, FALSE, "ConsecutiveBadFaxLines", NULL }};
1121 : static const TIFFField fax3Fields[] = {
1122 : { TIFFTAG_GROUP3OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_OPTIONS, FALSE, FALSE, "Group3Options", NULL },
1123 : };
1124 : static const TIFFField fax4Fields[] = {
1125 : { TIFFTAG_GROUP4OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_OPTIONS, FALSE, FALSE, "Group4Options", NULL },
1126 : };
1127 :
1128 : static int
1129 140 : Fax3VSetField(TIFF* tif, uint32 tag, va_list ap)
1130 : {
1131 140 : Fax3BaseState* sp = Fax3State(tif);
1132 : const TIFFField* fip;
1133 :
1134 140 : assert(sp != 0);
1135 140 : assert(sp->vsetparent != 0);
1136 :
1137 140 : switch (tag) {
1138 : case TIFFTAG_FAXMODE:
1139 14 : sp->mode = (int) va_arg(ap, int);
1140 14 : return 1; /* NB: pseudo tag */
1141 : case TIFFTAG_FAXFILLFUNC:
1142 14 : DecoderState(tif)->fill = va_arg(ap, TIFFFaxFillFunc);
1143 14 : return 1; /* NB: pseudo tag */
1144 : case TIFFTAG_GROUP3OPTIONS:
1145 : /* XXX: avoid reading options if compression mismatches. */
1146 2 : if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX3)
1147 2 : sp->groupoptions = (uint32) va_arg(ap, uint32);
1148 2 : break;
1149 : case TIFFTAG_GROUP4OPTIONS:
1150 : /* XXX: avoid reading options if compression mismatches. */
1151 0 : if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX4)
1152 0 : sp->groupoptions = (uint32) va_arg(ap, uint32);
1153 0 : break;
1154 : case TIFFTAG_BADFAXLINES:
1155 0 : sp->badfaxlines = (uint32) va_arg(ap, uint32);
1156 0 : break;
1157 : case TIFFTAG_CLEANFAXDATA:
1158 0 : sp->cleanfaxdata = (uint16) va_arg(ap, uint16_vap);
1159 0 : break;
1160 : case TIFFTAG_CONSECUTIVEBADFAXLINES:
1161 0 : sp->badfaxrun = (uint32) va_arg(ap, uint32);
1162 0 : break;
1163 : default:
1164 110 : return (*sp->vsetparent)(tif, tag, ap);
1165 : }
1166 :
1167 2 : if ((fip = TIFFFieldWithTag(tif, tag)))
1168 2 : TIFFSetFieldBit(tif, fip->field_bit);
1169 : else
1170 0 : return 0;
1171 :
1172 2 : tif->tif_flags |= TIFF_DIRTYDIRECT;
1173 2 : return 1;
1174 : }
1175 :
1176 : static int
1177 188 : Fax3VGetField(TIFF* tif, uint32 tag, va_list ap)
1178 : {
1179 188 : Fax3BaseState* sp = Fax3State(tif);
1180 :
1181 188 : assert(sp != 0);
1182 :
1183 188 : switch (tag) {
1184 : case TIFFTAG_FAXMODE:
1185 0 : *va_arg(ap, int*) = sp->mode;
1186 0 : break;
1187 : case TIFFTAG_FAXFILLFUNC:
1188 0 : *va_arg(ap, TIFFFaxFillFunc*) = DecoderState(tif)->fill;
1189 0 : break;
1190 : case TIFFTAG_GROUP3OPTIONS:
1191 : case TIFFTAG_GROUP4OPTIONS:
1192 2 : *va_arg(ap, uint32*) = sp->groupoptions;
1193 2 : break;
1194 : case TIFFTAG_BADFAXLINES:
1195 0 : *va_arg(ap, uint32*) = sp->badfaxlines;
1196 0 : break;
1197 : case TIFFTAG_CLEANFAXDATA:
1198 0 : *va_arg(ap, uint16*) = sp->cleanfaxdata;
1199 0 : break;
1200 : case TIFFTAG_CONSECUTIVEBADFAXLINES:
1201 0 : *va_arg(ap, uint32*) = sp->badfaxrun;
1202 0 : break;
1203 : default:
1204 186 : return (*sp->vgetparent)(tif, tag, ap);
1205 : }
1206 2 : return (1);
1207 : }
1208 :
1209 : static void
1210 0 : Fax3PrintDir(TIFF* tif, FILE* fd, long flags)
1211 : {
1212 0 : Fax3BaseState* sp = Fax3State(tif);
1213 :
1214 0 : assert(sp != 0);
1215 :
1216 : (void) flags;
1217 0 : if (TIFFFieldSet(tif,FIELD_OPTIONS)) {
1218 0 : const char* sep = " ";
1219 0 : if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX4) {
1220 0 : fprintf(fd, " Group 4 Options:");
1221 0 : if (sp->groupoptions & GROUP4OPT_UNCOMPRESSED)
1222 0 : fprintf(fd, "%suncompressed data", sep);
1223 : } else {
1224 :
1225 0 : fprintf(fd, " Group 3 Options:");
1226 0 : if (sp->groupoptions & GROUP3OPT_2DENCODING)
1227 0 : fprintf(fd, "%s2-d encoding", sep), sep = "+";
1228 0 : if (sp->groupoptions & GROUP3OPT_FILLBITS)
1229 0 : fprintf(fd, "%sEOL padding", sep), sep = "+";
1230 0 : if (sp->groupoptions & GROUP3OPT_UNCOMPRESSED)
1231 0 : fprintf(fd, "%suncompressed data", sep);
1232 : }
1233 0 : fprintf(fd, " (%lu = 0x%lx)\n",
1234 : (unsigned long) sp->groupoptions,
1235 : (unsigned long) sp->groupoptions);
1236 : }
1237 0 : if (TIFFFieldSet(tif,FIELD_CLEANFAXDATA)) {
1238 0 : fprintf(fd, " Fax Data:");
1239 0 : switch (sp->cleanfaxdata) {
1240 : case CLEANFAXDATA_CLEAN:
1241 0 : fprintf(fd, " clean");
1242 0 : break;
1243 : case CLEANFAXDATA_REGENERATED:
1244 0 : fprintf(fd, " receiver regenerated");
1245 0 : break;
1246 : case CLEANFAXDATA_UNCLEAN:
1247 0 : fprintf(fd, " uncorrected errors");
1248 : break;
1249 : }
1250 0 : fprintf(fd, " (%u = 0x%x)\n",
1251 0 : sp->cleanfaxdata, sp->cleanfaxdata);
1252 : }
1253 0 : if (TIFFFieldSet(tif,FIELD_BADFAXLINES))
1254 0 : fprintf(fd, " Bad Fax Lines: %lu\n",
1255 : (unsigned long) sp->badfaxlines);
1256 0 : if (TIFFFieldSet(tif,FIELD_BADFAXRUN))
1257 0 : fprintf(fd, " Consecutive Bad Fax Lines: %lu\n",
1258 : (unsigned long) sp->badfaxrun);
1259 0 : if (sp->printdir)
1260 0 : (*sp->printdir)(tif, fd, flags);
1261 0 : }
1262 :
1263 : static int
1264 14 : InitCCITTFax3(TIFF* tif)
1265 : {
1266 : static const char module[] = "InitCCITTFax3";
1267 : Fax3BaseState* sp;
1268 :
1269 : /*
1270 : * Merge codec-specific tag information.
1271 : */
1272 14 : if (!_TIFFMergeFields(tif, faxFields, TIFFArrayCount(faxFields))) {
1273 0 : TIFFErrorExt(tif->tif_clientdata, "InitCCITTFax3",
1274 : "Merging common CCITT Fax codec-specific tags failed");
1275 0 : return 0;
1276 : }
1277 :
1278 : /*
1279 : * Allocate state block so tag methods have storage to record values.
1280 : */
1281 14 : tif->tif_data = (uint8*)
1282 : _TIFFmalloc(sizeof (Fax3CodecState));
1283 :
1284 14 : if (tif->tif_data == NULL) {
1285 0 : TIFFErrorExt(tif->tif_clientdata, module,
1286 : "No space for state block");
1287 0 : return (0);
1288 : }
1289 :
1290 14 : sp = Fax3State(tif);
1291 14 : sp->rw_mode = tif->tif_mode;
1292 :
1293 : /*
1294 : * Override parent get/set field methods.
1295 : */
1296 14 : sp->vgetparent = tif->tif_tagmethods.vgetfield;
1297 14 : tif->tif_tagmethods.vgetfield = Fax3VGetField; /* hook for codec tags */
1298 14 : sp->vsetparent = tif->tif_tagmethods.vsetfield;
1299 14 : tif->tif_tagmethods.vsetfield = Fax3VSetField; /* hook for codec tags */
1300 14 : sp->printdir = tif->tif_tagmethods.printdir;
1301 14 : tif->tif_tagmethods.printdir = Fax3PrintDir; /* hook for codec tags */
1302 14 : sp->groupoptions = 0;
1303 :
1304 14 : if (sp->rw_mode == O_RDONLY) /* FIXME: improve for in place update */
1305 8 : tif->tif_flags |= TIFF_NOBITREV; /* decoder does bit reversal */
1306 14 : DecoderState(tif)->runs = NULL;
1307 14 : TIFFSetField(tif, TIFFTAG_FAXFILLFUNC, _TIFFFax3fillruns);
1308 14 : EncoderState(tif)->refline = NULL;
1309 :
1310 : /*
1311 : * Install codec methods.
1312 : */
1313 14 : tif->tif_fixuptags = Fax3FixupTags;
1314 14 : tif->tif_setupdecode = Fax3SetupState;
1315 14 : tif->tif_predecode = Fax3PreDecode;
1316 14 : tif->tif_decoderow = Fax3Decode1D;
1317 14 : tif->tif_decodestrip = Fax3Decode1D;
1318 14 : tif->tif_decodetile = Fax3Decode1D;
1319 14 : tif->tif_setupencode = Fax3SetupState;
1320 14 : tif->tif_preencode = Fax3PreEncode;
1321 14 : tif->tif_postencode = Fax3PostEncode;
1322 14 : tif->tif_encoderow = Fax3Encode;
1323 14 : tif->tif_encodestrip = Fax3Encode;
1324 14 : tif->tif_encodetile = Fax3Encode;
1325 14 : tif->tif_close = Fax3Close;
1326 14 : tif->tif_cleanup = Fax3Cleanup;
1327 :
1328 14 : return (1);
1329 : }
1330 :
1331 : int
1332 2 : TIFFInitCCITTFax3(TIFF* tif, int scheme)
1333 : {
1334 : (void) scheme;
1335 2 : if (InitCCITTFax3(tif)) {
1336 : /*
1337 : * Merge codec-specific tag information.
1338 : */
1339 2 : if (!_TIFFMergeFields(tif, fax3Fields,
1340 : TIFFArrayCount(fax3Fields))) {
1341 0 : TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax3",
1342 : "Merging CCITT Fax 3 codec-specific tags failed");
1343 0 : return 0;
1344 : }
1345 :
1346 : /*
1347 : * The default format is Class/F-style w/o RTC.
1348 : */
1349 2 : return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_CLASSF);
1350 : } else
1351 0 : return 01;
1352 : }
1353 :
1354 : /*
1355 : * CCITT Group 4 (T.6) Facsimile-compatible
1356 : * Compression Scheme Support.
1357 : */
1358 :
1359 : #define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; }
1360 : /*
1361 : * Decode the requested amount of G4-encoded data.
1362 : */
1363 : static int
1364 21602 : Fax4Decode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
1365 : {
1366 21602 : DECLARE_STATE_2D(tif, sp, "Fax4Decode");
1367 : (void) s;
1368 21602 : if (occ % sp->b.rowbytes)
1369 : {
1370 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
1371 0 : return (-1);
1372 : }
1373 21602 : CACHE_STATE(tif, sp);
1374 65038 : while (occ > 0) {
1375 21834 : a0 = 0;
1376 21834 : RunLength = 0;
1377 21834 : pa = thisrun = sp->curruns;
1378 21834 : pb = sp->refruns;
1379 21834 : b1 = *pb++;
1380 : #ifdef FAX3_DEBUG
1381 : printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail);
1382 : printf("-------------------- %d\n", tif->tif_row);
1383 : fflush(stdout);
1384 : #endif
1385 21834 : EXPAND2D(EOFG4);
1386 21834 : if (EOLcnt)
1387 0 : goto EOFG4;
1388 21834 : (*sp->fill)(buf, thisrun, pa, lastx);
1389 21834 : SETVALUE(0); /* imaginary change for reference */
1390 21834 : SWAP(uint32*, sp->curruns, sp->refruns);
1391 21834 : buf += sp->b.rowbytes;
1392 21834 : occ -= sp->b.rowbytes;
1393 21834 : sp->line++;
1394 21834 : continue;
1395 : EOFG4:
1396 0 : NeedBits16( 13, BADG4 );
1397 : BADG4:
1398 : #ifdef FAX3_DEBUG
1399 : if( GetBits(13) != 0x1001 )
1400 : fputs( "Bad RTC\n", stderr );
1401 : #endif
1402 0 : ClrBits( 13 );
1403 0 : (*sp->fill)(buf, thisrun, pa, lastx);
1404 0 : UNCACHE_STATE(tif, sp);
1405 0 : return (-1);
1406 : }
1407 21602 : UNCACHE_STATE(tif, sp);
1408 21602 : return (1);
1409 : }
1410 : #undef SWAP
1411 :
1412 : /*
1413 : * Encode the requested amount of data.
1414 : */
1415 : static int
1416 2 : Fax4Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
1417 : {
1418 : static const char module[] = "Fax4Encode";
1419 2 : Fax3CodecState *sp = EncoderState(tif);
1420 : (void) s;
1421 2 : if (cc % sp->b.rowbytes)
1422 : {
1423 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be written");
1424 0 : return (0);
1425 : }
1426 7303 : while (cc > 0) {
1427 7299 : if (!Fax3Encode2DRow(tif, bp, sp->refline, sp->b.rowpixels))
1428 0 : return (0);
1429 7299 : _TIFFmemcpy(sp->refline, bp, sp->b.rowbytes);
1430 7299 : bp += sp->b.rowbytes;
1431 7299 : cc -= sp->b.rowbytes;
1432 : }
1433 2 : return (1);
1434 : }
1435 :
1436 : static int
1437 2 : Fax4PostEncode(TIFF* tif)
1438 : {
1439 2 : Fax3CodecState *sp = EncoderState(tif);
1440 :
1441 : /* terminate strip w/ EOFB */
1442 2 : Fax3PutBits(tif, EOL, 12);
1443 2 : Fax3PutBits(tif, EOL, 12);
1444 2 : if (sp->bit != 8)
1445 2 : Fax3FlushBits(tif, sp);
1446 2 : return (1);
1447 : }
1448 :
1449 : int
1450 12 : TIFFInitCCITTFax4(TIFF* tif, int scheme)
1451 : {
1452 : (void) scheme;
1453 12 : if (InitCCITTFax3(tif)) { /* reuse G3 support */
1454 : /*
1455 : * Merge codec-specific tag information.
1456 : */
1457 12 : if (!_TIFFMergeFields(tif, fax4Fields,
1458 : TIFFArrayCount(fax4Fields))) {
1459 0 : TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax4",
1460 : "Merging CCITT Fax 4 codec-specific tags failed");
1461 0 : return 0;
1462 : }
1463 :
1464 12 : tif->tif_decoderow = Fax4Decode;
1465 12 : tif->tif_decodestrip = Fax4Decode;
1466 12 : tif->tif_decodetile = Fax4Decode;
1467 12 : tif->tif_encoderow = Fax4Encode;
1468 12 : tif->tif_encodestrip = Fax4Encode;
1469 12 : tif->tif_encodetile = Fax4Encode;
1470 12 : tif->tif_postencode = Fax4PostEncode;
1471 : /*
1472 : * Suppress RTC at the end of each strip.
1473 : */
1474 12 : return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_NORTC);
1475 : } else
1476 0 : return (0);
1477 : }
1478 :
1479 : /*
1480 : * CCITT Group 3 1-D Modified Huffman RLE Compression Support.
1481 : * (Compression algorithms 2 and 32771)
1482 : */
1483 :
1484 : /*
1485 : * Decode the requested amount of RLE-encoded data.
1486 : */
1487 : static int
1488 0 : Fax3DecodeRLE(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
1489 : {
1490 0 : DECLARE_STATE(tif, sp, "Fax3DecodeRLE");
1491 0 : int mode = sp->b.mode;
1492 : (void) s;
1493 0 : if (occ % sp->b.rowbytes)
1494 : {
1495 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
1496 0 : return (-1);
1497 : }
1498 0 : CACHE_STATE(tif, sp);
1499 0 : thisrun = sp->curruns;
1500 0 : while (occ > 0) {
1501 0 : a0 = 0;
1502 0 : RunLength = 0;
1503 0 : pa = thisrun;
1504 : #ifdef FAX3_DEBUG
1505 : printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail);
1506 : printf("-------------------- %d\n", tif->tif_row);
1507 : fflush(stdout);
1508 : #endif
1509 0 : EXPAND1D(EOFRLE);
1510 0 : (*sp->fill)(buf, thisrun, pa, lastx);
1511 : /*
1512 : * Cleanup at the end of the row.
1513 : */
1514 0 : if (mode & FAXMODE_BYTEALIGN) {
1515 0 : int n = BitsAvail - (BitsAvail &~ 7);
1516 0 : ClrBits(n);
1517 0 : } else if (mode & FAXMODE_WORDALIGN) {
1518 0 : int n = BitsAvail - (BitsAvail &~ 15);
1519 0 : ClrBits(n);
1520 0 : if (BitsAvail == 0 && !isAligned(cp, uint16))
1521 0 : cp++;
1522 : }
1523 0 : buf += sp->b.rowbytes;
1524 0 : occ -= sp->b.rowbytes;
1525 0 : sp->line++;
1526 0 : continue;
1527 : EOFRLE: /* premature EOF */
1528 0 : (*sp->fill)(buf, thisrun, pa, lastx);
1529 0 : UNCACHE_STATE(tif, sp);
1530 0 : return (-1);
1531 : }
1532 0 : UNCACHE_STATE(tif, sp);
1533 0 : return (1);
1534 : }
1535 :
1536 : int
1537 0 : TIFFInitCCITTRLE(TIFF* tif, int scheme)
1538 : {
1539 : (void) scheme;
1540 0 : if (InitCCITTFax3(tif)) { /* reuse G3 support */
1541 0 : tif->tif_decoderow = Fax3DecodeRLE;
1542 0 : tif->tif_decodestrip = Fax3DecodeRLE;
1543 0 : tif->tif_decodetile = Fax3DecodeRLE;
1544 : /*
1545 : * Suppress RTC+EOLs when encoding and byte-align data.
1546 : */
1547 0 : return TIFFSetField(tif, TIFFTAG_FAXMODE,
1548 : FAXMODE_NORTC|FAXMODE_NOEOL|FAXMODE_BYTEALIGN);
1549 : } else
1550 0 : return (0);
1551 : }
1552 :
1553 : int
1554 0 : TIFFInitCCITTRLEW(TIFF* tif, int scheme)
1555 : {
1556 : (void) scheme;
1557 0 : if (InitCCITTFax3(tif)) { /* reuse G3 support */
1558 0 : tif->tif_decoderow = Fax3DecodeRLE;
1559 0 : tif->tif_decodestrip = Fax3DecodeRLE;
1560 0 : tif->tif_decodetile = Fax3DecodeRLE;
1561 : /*
1562 : * Suppress RTC+EOLs when encoding and word-align data.
1563 : */
1564 0 : return TIFFSetField(tif, TIFFTAG_FAXMODE,
1565 : FAXMODE_NORTC|FAXMODE_NOEOL|FAXMODE_WORDALIGN);
1566 : } else
1567 0 : return (0);
1568 : }
1569 : #endif /* CCITT_SUPPORT */
1570 :
1571 : /* vim: set ts=8 sts=8 sw=8 noet: */
|
