1 : /* $Id: tif_fax3.c,v 1.72 2010-06-09 17:17:13 bfriesen 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 12 : Fax3PreDecode(TIFF* tif, uint16 s)
148 : {
149 12 : Fax3CodecState* sp = DecoderState(tif);
150 :
151 : (void) s;
152 12 : assert(sp != NULL);
153 12 : sp->bit = 0; /* force initial read */
154 12 : sp->data = 0;
155 12 : 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 12 : sp->bitmap =
164 12 : TIFFGetBitRevTable(tif->tif_dir.td_fillorder != FILLORDER_LSB2MSB);
165 12 : if (sp->refruns) { /* init reference line to white */
166 12 : sp->refruns[0] = (uint32) sp->b.rowpixels;
167 12 : sp->refruns[1] = 0;
168 : }
169 12 : sp->line = 0;
170 12 : 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 2 : Fax3Decode2D(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
271 : {
272 2 : DECLARE_STATE_2D(tif, sp, "Fax3Decode2D");
273 : int is1D; /* current line is 1d/2d-encoded */
274 : (void) s;
275 2 : if (occ % sp->b.rowbytes)
276 : {
277 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
278 0 : return (-1);
279 : }
280 2 : CACHE_STATE(tif, sp);
281 2052 : while (occ > 0) {
282 2048 : a0 = 0;
283 2048 : RunLength = 0;
284 2048 : pa = thisrun = sp->curruns;
285 : #ifdef FAX3_DEBUG
286 : printf("\nBitAcc=%08X, BitsAvail = %d EOLcnt = %d",
287 : BitAcc, BitsAvail, EOLcnt);
288 : #endif
289 2048 : SYNC_EOL(EOF2D);
290 2048 : NeedBits8(1, EOF2D);
291 2048 : is1D = GetBits(1); /* 1D/2D-encoding tag bit */
292 2048 : 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 2048 : pb = sp->refruns;
299 2048 : b1 = *pb++;
300 2048 : if (is1D)
301 994 : EXPAND1D(EOF2Da);
302 : else
303 1536 : EXPAND2D(EOF2Da);
304 2048 : (*sp->fill)(buf, thisrun, pa, lastx);
305 2048 : SETVALUE(0); /* imaginary change for reference */
306 2048 : SWAP(uint32*, sp->curruns, sp->refruns);
307 2048 : buf += sp->b.rowbytes;
308 2048 : occ -= sp->b.rowbytes;
309 2048 : sp->line++;
310 2048 : 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 2 : UNCACHE_STATE(tif, sp);
319 2 : 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 45716 : _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 45716 : if ((erun-runs)&1)
378 166 : *erun++ = 0;
379 45716 : x = 0;
380 146984 : for (; runs < erun; runs += 2) {
381 101268 : run = runs[0];
382 101268 : if (x+run > lastx || run > lastx )
383 0 : run = runs[0] = (uint32) (lastx - x);
384 101268 : if (run) {
385 57742 : cp = buf + (x>>3);
386 57742 : bx = x&7;
387 57742 : if (run > 8-bx) {
388 41478 : if (bx) { /* align to byte boundary */
389 35328 : *cp++ &= 0xff << (8-bx);
390 35328 : run -= 8-bx;
391 : }
392 41478 : if( (n = run >> 3) != 0 ) { /* multiple bytes to fill */
393 24998 : if ((n/sizeof (long)) > 1) {
394 : /*
395 : * Align to longword boundary and fill.
396 : */
397 1794 : for (; n && !isAligned(cp, long); n--)
398 0 : *cp++ = 0x00;
399 1794 : lp = (long*) cp;
400 1794 : nw = (int32)(n / sizeof (long));
401 1794 : n -= nw * sizeof (long);
402 : do {
403 15264 : *lp++ = 0L;
404 15264 : } while (--nw);
405 1794 : cp = (unsigned char*) lp;
406 : }
407 24998 : ZERO(n, cp);
408 24998 : run &= 7;
409 : }
410 41478 : if (run)
411 38054 : cp[0] &= 0xff >> run;
412 : } else
413 16264 : cp[0] &= ~(_fillmasks[run]>>bx);
414 57742 : x += runs[0];
415 : }
416 101268 : run = runs[1];
417 101268 : if (x+run > lastx || run > lastx )
418 0 : run = runs[1] = lastx - x;
419 101268 : if (run) {
420 101102 : cp = buf + (x>>3);
421 101102 : bx = x&7;
422 101102 : if (run > 8-bx) {
423 91184 : if (bx) { /* align to byte boundary */
424 43246 : *cp++ |= 0xff >> bx;
425 43246 : run -= 8-bx;
426 : }
427 91184 : if( (n = run>>3) != 0 ) { /* multiple bytes to fill */
428 84214 : if ((n/sizeof (long)) > 1) {
429 : /*
430 : * Align to longword boundary and fill.
431 : */
432 108954 : for (; n && !isAligned(cp, long); n--)
433 52838 : *cp++ = 0xff;
434 56116 : lp = (long*) cp;
435 56116 : nw = (int32)(n / sizeof (long));
436 56116 : n -= nw * sizeof (long);
437 : do {
438 622786 : *lp++ = -1L;
439 622786 : } while (--nw);
440 56116 : cp = (unsigned char*) lp;
441 : }
442 84214 : FILL(n, cp);
443 84214 : run &= 7;
444 : }
445 91184 : if (run)
446 40732 : cp[0] |= 0xff00 >> run;
447 : } else
448 9918 : cp[0] |= _fillmasks[run]>>bx;
449 101102 : x += runs[1];
450 : }
451 : }
452 45716 : assert(x == lastx);
453 45716 : }
454 : #undef ZERO
455 : #undef FILL
456 :
457 : static int
458 20 : Fax3FixupTags(TIFF* tif)
459 : {
460 : (void) tif;
461 20 : 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 16 : Fax3SetupState(TIFF* tif)
473 : {
474 : static const char module[] = "Fax3SetupState";
475 16 : TIFFDirectory* td = &tif->tif_dir;
476 16 : Fax3BaseState* sp = Fax3State(tif);
477 : int needsRefLine;
478 16 : Fax3CodecState* dsp = (Fax3CodecState*) Fax3State(tif);
479 : tmsize_t rowbytes;
480 : uint32 rowpixels, nruns;
481 :
482 16 : 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 16 : if (isTiled(tif)) {
491 0 : rowbytes = TIFFTileRowSize(tif);
492 0 : rowpixels = td->td_tilewidth;
493 : } else {
494 16 : rowbytes = TIFFScanlineSize(tif);
495 16 : rowpixels = td->td_imagewidth;
496 : }
497 16 : sp->rowbytes = rowbytes;
498 16 : sp->rowpixels = rowpixels;
499 : /*
500 : * Allocate any additional space required for decoding/encoding.
501 : */
502 30 : needsRefLine = (
503 16 : (sp->groupoptions & GROUP3OPT_2DENCODING) ||
504 14 : td->td_compression == COMPRESSION_CCITTFAX4
505 : );
506 :
507 : /*
508 : Assure that allocation computations do not overflow.
509 :
510 : TIFFroundup and TIFFSafeMultiply return zero on integer overflow
511 : */
512 16 : dsp->runs=(uint32*) NULL;
513 16 : nruns = TIFFroundup_32(rowpixels,32);
514 16 : if (needsRefLine) {
515 16 : nruns = TIFFSafeMultiply(uint32,nruns,2);
516 : }
517 16 : if ((nruns == 0) || (TIFFSafeMultiply(uint32,nruns,2) == 0)) {
518 0 : TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
519 : "Row pixels integer overflow (rowpixels %u)",
520 : rowpixels);
521 0 : return (0);
522 : }
523 32 : dsp->runs = (uint32*) _TIFFCheckMalloc(tif,
524 32 : TIFFSafeMultiply(uint32,nruns,2),
525 : sizeof (uint32),
526 : "for Group 3/4 run arrays");
527 16 : if (dsp->runs == NULL)
528 0 : return (0);
529 16 : dsp->curruns = dsp->runs;
530 16 : if (needsRefLine)
531 16 : dsp->refruns = dsp->runs + nruns;
532 : else
533 0 : dsp->refruns = NULL;
534 18 : if (td->td_compression == COMPRESSION_CCITTFAX3
535 18 : && is2DEncoding(dsp)) { /* NB: default is 1D routine */
536 2 : tif->tif_decoderow = Fax3Decode2D;
537 2 : tif->tif_decodestrip = Fax3Decode2D;
538 2 : tif->tif_decodetile = Fax3Decode2D;
539 : }
540 :
541 16 : if (needsRefLine) { /* 2d encoding */
542 16 : Fax3CodecState* esp = EncoderState(tif);
543 : /*
544 : * 2d encoding requires a scanline
545 : * buffer for the ``reference line''; the
546 : * scanline against which delta encoding
547 : * is referenced. The reference line must
548 : * be initialized to be ``white'' (done elsewhere).
549 : */
550 16 : esp->refline = (unsigned char*) _TIFFmalloc(rowbytes);
551 16 : if (esp->refline == NULL) {
552 0 : TIFFErrorExt(tif->tif_clientdata, module,
553 : "No space for Group 3/4 reference line");
554 0 : return (0);
555 : }
556 : } else /* 1d encoding */
557 0 : EncoderState(tif)->refline = NULL;
558 :
559 16 : return (1);
560 : }
561 :
562 : /*
563 : * CCITT Group 3 FAX Encoding.
564 : */
565 :
566 : #define Fax3FlushBits(tif, sp) { \
567 : if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \
568 : (void) TIFFFlushData1(tif); \
569 : *(tif)->tif_rawcp++ = (uint8) (sp)->data; \
570 : (tif)->tif_rawcc++; \
571 : (sp)->data = 0, (sp)->bit = 8; \
572 : }
573 : #define _FlushBits(tif) { \
574 : if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \
575 : (void) TIFFFlushData1(tif); \
576 : *(tif)->tif_rawcp++ = (uint8) data; \
577 : (tif)->tif_rawcc++; \
578 : data = 0, bit = 8; \
579 : }
580 : static const int _msbmask[9] =
581 : { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
582 : #define _PutBits(tif, bits, length) { \
583 : while (length > bit) { \
584 : data |= bits >> (length - bit); \
585 : length -= bit; \
586 : _FlushBits(tif); \
587 : } \
588 : assert( length < 9 ); \
589 : data |= (bits & _msbmask[length]) << (bit - length); \
590 : bit -= length; \
591 : if (bit == 0) \
592 : _FlushBits(tif); \
593 : }
594 :
595 : /*
596 : * Write a variable-length bit-value to
597 : * the output stream. Values are
598 : * assumed to be at most 16 bits.
599 : */
600 : static void
601 65438 : Fax3PutBits(TIFF* tif, unsigned int bits, unsigned int length)
602 : {
603 65438 : Fax3CodecState* sp = EncoderState(tif);
604 65438 : unsigned int bit = sp->bit;
605 65438 : int data = sp->data;
606 :
607 65438 : _PutBits(tif, bits, length);
608 :
609 65438 : sp->data = data;
610 65438 : sp->bit = bit;
611 65438 : }
612 :
613 : /*
614 : * Write a code to the output stream.
615 : */
616 : #define putcode(tif, te) Fax3PutBits(tif, (te)->code, (te)->length)
617 :
618 : #ifdef FAX3_DEBUG
619 : #define DEBUG_COLOR(w) (tab == TIFFFaxWhiteCodes ? w "W" : w "B")
620 : #define DEBUG_PRINT(what,len) { \
621 : int t; \
622 : printf("%08X/%-2d: %s%5d\t", data, bit, DEBUG_COLOR(what), len); \
623 : for (t = length-1; t >= 0; t--) \
624 : putchar(code & (1<<t) ? '1' : '0'); \
625 : putchar('\n'); \
626 : }
627 : #endif
628 :
629 : /*
630 : * Write the sequence of codes that describes
631 : * the specified span of zero's or one's. The
632 : * appropriate table that holds the make-up and
633 : * terminating codes is supplied.
634 : */
635 : static void
636 9536 : putspan(TIFF* tif, int32 span, const tableentry* tab)
637 : {
638 9536 : Fax3CodecState* sp = EncoderState(tif);
639 9536 : unsigned int bit = sp->bit;
640 9536 : int data = sp->data;
641 : unsigned int code, length;
642 :
643 19072 : while (span >= 2624) {
644 0 : const tableentry* te = &tab[63 + (2560>>6)];
645 0 : code = te->code, length = te->length;
646 : #ifdef FAX3_DEBUG
647 : DEBUG_PRINT("MakeUp", te->runlen);
648 : #endif
649 0 : _PutBits(tif, code, length);
650 0 : span -= te->runlen;
651 : }
652 9536 : if (span >= 64) {
653 794 : const tableentry* te = &tab[63 + (span>>6)];
654 794 : assert(te->runlen == 64*(span>>6));
655 794 : code = te->code, length = te->length;
656 : #ifdef FAX3_DEBUG
657 : DEBUG_PRINT("MakeUp", te->runlen);
658 : #endif
659 794 : _PutBits(tif, code, length);
660 794 : span -= te->runlen;
661 : }
662 9536 : code = tab[span].code, length = tab[span].length;
663 : #ifdef FAX3_DEBUG
664 : DEBUG_PRINT(" Term", tab[span].runlen);
665 : #endif
666 9536 : _PutBits(tif, code, length);
667 :
668 9536 : sp->data = data;
669 9536 : sp->bit = bit;
670 9536 : }
671 :
672 : /*
673 : * Write an EOL code to the output stream. The zero-fill
674 : * logic for byte-aligning encoded scanlines is handled
675 : * here. We also handle writing the tag bit for the next
676 : * scanline when doing 2d encoding.
677 : */
678 : static void
679 0 : Fax3PutEOL(TIFF* tif)
680 : {
681 0 : Fax3CodecState* sp = EncoderState(tif);
682 0 : unsigned int bit = sp->bit;
683 0 : int data = sp->data;
684 : unsigned int code, length, tparm;
685 :
686 0 : if (sp->b.groupoptions & GROUP3OPT_FILLBITS) {
687 : /*
688 : * Force bit alignment so EOL will terminate on
689 : * a byte boundary. That is, force the bit alignment
690 : * to 16-12 = 4 before putting out the EOL code.
691 : */
692 0 : int align = 8 - 4;
693 0 : if (align != sp->bit) {
694 0 : if (align > sp->bit)
695 0 : align = sp->bit + (8 - align);
696 : else
697 0 : align = sp->bit - align;
698 0 : code = 0;
699 0 : tparm=align;
700 0 : _PutBits(tif, 0, tparm);
701 : }
702 : }
703 0 : code = EOL, length = 12;
704 0 : if (is2DEncoding(sp))
705 0 : code = (code<<1) | (sp->tag == G3_1D), length++;
706 0 : _PutBits(tif, code, length);
707 :
708 0 : sp->data = data;
709 0 : sp->bit = bit;
710 0 : }
711 :
712 : /*
713 : * Reset encoding state at the start of a strip.
714 : */
715 : static int
716 4 : Fax3PreEncode(TIFF* tif, uint16 s)
717 : {
718 4 : Fax3CodecState* sp = EncoderState(tif);
719 :
720 : (void) s;
721 4 : assert(sp != NULL);
722 4 : sp->bit = 8;
723 4 : sp->data = 0;
724 4 : sp->tag = G3_1D;
725 : /*
726 : * This is necessary for Group 4; otherwise it isn't
727 : * needed because the first scanline of each strip ends
728 : * up being copied into the refline.
729 : */
730 4 : if (sp->refline)
731 4 : _TIFFmemset(sp->refline, 0x00, sp->b.rowbytes);
732 4 : if (is2DEncoding(sp)) {
733 0 : float res = tif->tif_dir.td_yresolution;
734 : /*
735 : * The CCITT spec says that when doing 2d encoding, you
736 : * should only do it on K consecutive scanlines, where K
737 : * depends on the resolution of the image being encoded
738 : * (2 for <= 200 lpi, 4 for > 200 lpi). Since the directory
739 : * code initializes td_yresolution to 0, this code will
740 : * select a K of 2 unless the YResolution tag is set
741 : * appropriately. (Note also that we fudge a little here
742 : * and use 150 lpi to avoid problems with units conversion.)
743 : */
744 0 : if (tif->tif_dir.td_resolutionunit == RESUNIT_CENTIMETER)
745 0 : res *= 2.54f; /* convert to inches */
746 0 : sp->maxk = (res > 150 ? 4 : 2);
747 0 : sp->k = sp->maxk-1;
748 : } else
749 4 : sp->k = sp->maxk = 0;
750 4 : sp->line = 0;
751 4 : return (1);
752 : }
753 :
754 : static const unsigned char zeroruns[256] = {
755 : 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, /* 0x00 - 0x0f */
756 : 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0x10 - 0x1f */
757 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x20 - 0x2f */
758 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x30 - 0x3f */
759 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 - 0x4f */
760 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x50 - 0x5f */
761 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 - 0x6f */
762 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x70 - 0x7f */
763 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x80 - 0x8f */
764 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x90 - 0x9f */
765 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xa0 - 0xaf */
766 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xb0 - 0xbf */
767 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xc0 - 0xcf */
768 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xd0 - 0xdf */
769 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe0 - 0xef */
770 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xf0 - 0xff */
771 : };
772 : static const unsigned char oneruns[256] = {
773 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 - 0x0f */
774 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 - 0x1f */
775 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 - 0x2f */
776 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 - 0x3f */
777 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 - 0x4f */
778 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 - 0x5f */
779 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 - 0x6f */
780 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x70 - 0x7f */
781 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x80 - 0x8f */
782 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x90 - 0x9f */
783 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xa0 - 0xaf */
784 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xb0 - 0xbf */
785 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xc0 - 0xcf */
786 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xd0 - 0xdf */
787 : 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xe0 - 0xef */
788 : 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8, /* 0xf0 - 0xff */
789 : };
790 :
791 : /*
792 : * On certain systems it pays to inline
793 : * the routines that find pixel spans.
794 : */
795 : #ifdef VAXC
796 : static int32 find0span(unsigned char*, int32, int32);
797 : static int32 find1span(unsigned char*, int32, int32);
798 : #pragma inline(find0span,find1span)
799 : #endif
800 :
801 : /*
802 : * Find a span of ones or zeros using the supplied
803 : * table. The ``base'' of the bit string is supplied
804 : * along with the start+end bit indices.
805 : */
806 : inline static int32
807 89846 : find0span(unsigned char* bp, int32 bs, int32 be)
808 : {
809 89846 : int32 bits = be - bs;
810 : int32 n, span;
811 :
812 89846 : bp += bs>>3;
813 : /*
814 : * Check partial byte on lhs.
815 : */
816 129744 : if (bits > 0 && (n = (bs & 7))) {
817 65886 : span = zeroruns[(*bp << n) & 0xff];
818 65886 : if (span > 8-n) /* table value too generous */
819 39996 : span = 8-n;
820 65886 : if (span > bits) /* constrain span to bit range */
821 98 : span = bits;
822 65886 : if (n+span < 8) /* doesn't extend to edge of byte */
823 25988 : return (span);
824 39898 : bits -= span;
825 39898 : bp++;
826 : } else
827 23960 : span = 0;
828 63858 : if (bits >= (int32)(2 * 8 * sizeof(long))) {
829 : long* lp;
830 : /*
831 : * Align to longword boundary and check longwords.
832 : */
833 147396 : while (!isAligned(bp, long)) {
834 63236 : if (*bp != 0x00)
835 28904 : return (span + zeroruns[*bp]);
836 34332 : span += 8, bits -= 8;
837 34332 : bp++;
838 : }
839 27628 : lp = (long*) bp;
840 55576 : while ((bits >= (int32)(8 * sizeof(long))) && (0 == *lp)) {
841 320 : span += 8*sizeof (long), bits -= 8*sizeof (long);
842 320 : lp++;
843 : }
844 27628 : bp = (unsigned char*) lp;
845 : }
846 : /*
847 : * Scan full bytes for all 0's.
848 : */
849 85914 : while (bits >= 8) {
850 50472 : if (*bp != 0x00) /* end of run */
851 34466 : return (span + zeroruns[*bp]);
852 16006 : span += 8, bits -= 8;
853 16006 : bp++;
854 : }
855 : /*
856 : * Check partial byte on rhs.
857 : */
858 488 : if (bits > 0) {
859 294 : n = zeroruns[*bp];
860 294 : span += (n > bits ? bits : n);
861 : }
862 488 : return (span);
863 : }
864 :
865 : inline static int32
866 118186 : find1span(unsigned char* bp, int32 bs, int32 be)
867 : {
868 118186 : int32 bits = be - bs;
869 : int32 n, span;
870 :
871 118186 : bp += bs>>3;
872 : /*
873 : * Check partial byte on lhs.
874 : */
875 162564 : if (bits > 0 && (n = (bs & 7))) {
876 66472 : span = oneruns[(*bp << n) & 0xff];
877 66472 : if (span > 8-n) /* table value too generous */
878 0 : span = 8-n;
879 66472 : if (span > bits) /* constrain span to bit range */
880 0 : span = bits;
881 66472 : if (n+span < 8) /* doesn't extend to edge of byte */
882 22094 : return (span);
883 44378 : bits -= span;
884 44378 : bp++;
885 : } else
886 51714 : span = 0;
887 96092 : if (bits >= (int32)(2 * 8 * sizeof(long))) {
888 : long* lp;
889 : /*
890 : * Align to longword boundary and check longwords.
891 : */
892 317836 : while (!isAligned(bp, long)) {
893 164016 : if (*bp != 0xff)
894 20156 : return (span + oneruns[*bp]);
895 143860 : span += 8, bits -= 8;
896 143860 : bp++;
897 : }
898 66832 : lp = (long*) bp;
899 740164 : while ((bits >= (int32)(8 * sizeof(long))) && (~0 == *lp)) {
900 606500 : span += 8*sizeof (long), bits -= 8*sizeof (long);
901 606500 : lp++;
902 : }
903 66832 : bp = (unsigned char*) lp;
904 : }
905 : /*
906 : * Scan full bytes for all 1's.
907 : */
908 443722 : while (bits >= 8) {
909 323808 : if (*bp != 0xff) /* end of run */
910 31958 : return (span + oneruns[*bp]);
911 291850 : span += 8, bits -= 8;
912 291850 : bp++;
913 : }
914 : /*
915 : * Check partial byte on rhs.
916 : */
917 43978 : if (bits > 0) {
918 576 : n = oneruns[*bp];
919 576 : span += (n > bits ? bits : n);
920 : }
921 43978 : return (span);
922 : }
923 :
924 : /*
925 : * Return the offset of the next bit in the range
926 : * [bs..be] that is different from the specified
927 : * color. The end, be, is returned if no such bit
928 : * exists.
929 : */
930 : #define finddiff(_cp, _bs, _be, _color) \
931 : (_bs + (_color ? find1span(_cp,_bs,_be) : find0span(_cp,_bs,_be)))
932 : /*
933 : * Like finddiff, but also check the starting bit
934 : * against the end in case start > end.
935 : */
936 : #define finddiff2(_cp, _bs, _be, _color) \
937 : (_bs < _be ? finddiff(_cp,_bs,_be,_color) : _be)
938 :
939 : /*
940 : * 1d-encode a row of pixels. The encoding is
941 : * a sequence of all-white or all-black spans
942 : * of pixels encoded with Huffman codes.
943 : */
944 : static int
945 0 : Fax3Encode1DRow(TIFF* tif, unsigned char* bp, uint32 bits)
946 : {
947 0 : Fax3CodecState* sp = EncoderState(tif);
948 : int32 span;
949 0 : uint32 bs = 0;
950 :
951 : for (;;) {
952 0 : span = find0span(bp, bs, bits); /* white span */
953 0 : putspan(tif, span, TIFFFaxWhiteCodes);
954 0 : bs += span;
955 0 : if (bs >= bits)
956 0 : break;
957 0 : span = find1span(bp, bs, bits); /* black span */
958 0 : putspan(tif, span, TIFFFaxBlackCodes);
959 0 : bs += span;
960 0 : if (bs >= bits)
961 0 : break;
962 0 : }
963 0 : if (sp->b.mode & (FAXMODE_BYTEALIGN|FAXMODE_WORDALIGN)) {
964 0 : if (sp->bit != 8) /* byte-align */
965 0 : Fax3FlushBits(tif, sp);
966 0 : if ((sp->b.mode&FAXMODE_WORDALIGN) &&
967 0 : !isAligned(tif->tif_rawcp, uint16))
968 0 : Fax3FlushBits(tif, sp);
969 : }
970 0 : return (1);
971 : }
972 :
973 : static const tableentry horizcode =
974 : { 3, 0x1, 0 }; /* 001 */
975 : static const tableentry passcode =
976 : { 4, 0x1, 0 }; /* 0001 */
977 : static const tableentry vcodes[7] = {
978 : { 7, 0x03, 0 }, /* 0000 011 */
979 : { 6, 0x03, 0 }, /* 0000 11 */
980 : { 3, 0x03, 0 }, /* 011 */
981 : { 1, 0x1, 0 }, /* 1 */
982 : { 3, 0x2, 0 }, /* 010 */
983 : { 6, 0x02, 0 }, /* 0000 10 */
984 : { 7, 0x02, 0 } /* 0000 010 */
985 : };
986 :
987 : /*
988 : * 2d-encode a row of pixels. Consult the CCITT
989 : * documentation for the algorithm.
990 : */
991 : static int
992 14598 : Fax3Encode2DRow(TIFF* tif, unsigned char* bp, unsigned char* rp, uint32 bits)
993 : {
994 : #define PIXEL(buf,ix) ((((buf)[(ix)>>3]) >> (7-((ix)&7))) & 1)
995 14598 : uint32 a0 = 0;
996 14598 : uint32 a1 = (PIXEL(bp, 0) != 0 ? 0 : finddiff(bp, 0, bits, 0));
997 14598 : uint32 b1 = (PIXEL(rp, 0) != 0 ? 0 : finddiff(rp, 0, bits, 0));
998 : uint32 a2, b2;
999 :
1000 : for (;;) {
1001 65430 : b2 = finddiff2(rp, b1, bits, PIXEL(rp,b1));
1002 65430 : if (b2 >= a1) {
1003 62424 : int32 d = b1 - a1;
1004 67192 : if (!(-3 <= d && d <= 3)) { /* horizontal mode */
1005 4768 : a2 = finddiff2(bp, a1, bits, PIXEL(bp,a1));
1006 4768 : putcode(tif, &horizcode);
1007 6874 : if (a0+a1 == 0 || PIXEL(bp, a0) == 0) {
1008 2106 : putspan(tif, a1-a0, TIFFFaxWhiteCodes);
1009 2106 : putspan(tif, a2-a1, TIFFFaxBlackCodes);
1010 : } else {
1011 2662 : putspan(tif, a1-a0, TIFFFaxBlackCodes);
1012 2662 : putspan(tif, a2-a1, TIFFFaxWhiteCodes);
1013 : }
1014 4768 : a0 = a2;
1015 : } else { /* vertical mode */
1016 57656 : putcode(tif, &vcodes[d+3]);
1017 57656 : a0 = a1;
1018 : }
1019 : } else { /* pass mode */
1020 3006 : putcode(tif, &passcode);
1021 3006 : a0 = b2;
1022 : }
1023 65430 : if (a0 >= bits)
1024 : break;
1025 50832 : a1 = finddiff(bp, a0, bits, PIXEL(bp,a0));
1026 50832 : b1 = finddiff(rp, a0, bits, !PIXEL(bp,a0));
1027 50832 : b1 = finddiff(rp, b1, bits, PIXEL(bp,a0));
1028 50832 : }
1029 14598 : return (1);
1030 : #undef PIXEL
1031 : }
1032 :
1033 : /*
1034 : * Encode a buffer of pixels.
1035 : */
1036 : static int
1037 0 : Fax3Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
1038 : {
1039 : static const char module[] = "Fax3Encode";
1040 0 : Fax3CodecState* sp = EncoderState(tif);
1041 : (void) s;
1042 0 : if (cc % sp->b.rowbytes)
1043 : {
1044 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be written");
1045 0 : return (0);
1046 : }
1047 0 : while (cc > 0) {
1048 0 : if ((sp->b.mode & FAXMODE_NOEOL) == 0)
1049 0 : Fax3PutEOL(tif);
1050 0 : if (is2DEncoding(sp)) {
1051 0 : if (sp->tag == G3_1D) {
1052 0 : if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
1053 0 : return (0);
1054 0 : sp->tag = G3_2D;
1055 : } else {
1056 0 : if (!Fax3Encode2DRow(tif, bp, sp->refline,
1057 : sp->b.rowpixels))
1058 0 : return (0);
1059 0 : sp->k--;
1060 : }
1061 0 : if (sp->k == 0) {
1062 0 : sp->tag = G3_1D;
1063 0 : sp->k = sp->maxk-1;
1064 : } else
1065 0 : _TIFFmemcpy(sp->refline, bp, sp->b.rowbytes);
1066 : } else {
1067 0 : if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
1068 0 : return (0);
1069 : }
1070 0 : bp += sp->b.rowbytes;
1071 0 : cc -= sp->b.rowbytes;
1072 : }
1073 0 : return (1);
1074 : }
1075 :
1076 : static int
1077 0 : Fax3PostEncode(TIFF* tif)
1078 : {
1079 0 : Fax3CodecState* sp = EncoderState(tif);
1080 :
1081 0 : if (sp->bit != 8)
1082 0 : Fax3FlushBits(tif, sp);
1083 0 : return (1);
1084 : }
1085 :
1086 : static void
1087 8 : Fax3Close(TIFF* tif)
1088 : {
1089 8 : if ((Fax3State(tif)->mode & FAXMODE_NORTC) == 0) {
1090 0 : Fax3CodecState* sp = EncoderState(tif);
1091 0 : unsigned int code = EOL;
1092 0 : unsigned int length = 12;
1093 : int i;
1094 :
1095 0 : if (is2DEncoding(sp))
1096 0 : code = (code<<1) | (sp->tag == G3_1D), length++;
1097 0 : for (i = 0; i < 6; i++)
1098 0 : Fax3PutBits(tif, code, length);
1099 0 : Fax3FlushBits(tif, sp);
1100 : }
1101 8 : }
1102 :
1103 : static void
1104 28 : Fax3Cleanup(TIFF* tif)
1105 : {
1106 28 : Fax3CodecState* sp = DecoderState(tif);
1107 :
1108 28 : assert(sp != 0);
1109 :
1110 28 : tif->tif_tagmethods.vgetfield = sp->b.vgetparent;
1111 28 : tif->tif_tagmethods.vsetfield = sp->b.vsetparent;
1112 28 : tif->tif_tagmethods.printdir = sp->b.printdir;
1113 :
1114 28 : if (sp->runs)
1115 16 : _TIFFfree(sp->runs);
1116 28 : if (sp->refline)
1117 16 : _TIFFfree(sp->refline);
1118 :
1119 28 : _TIFFfree(tif->tif_data);
1120 28 : tif->tif_data = NULL;
1121 :
1122 28 : _TIFFSetDefaultCompressionState(tif);
1123 28 : }
1124 :
1125 : #define FIELD_BADFAXLINES (FIELD_CODEC+0)
1126 : #define FIELD_CLEANFAXDATA (FIELD_CODEC+1)
1127 : #define FIELD_BADFAXRUN (FIELD_CODEC+2)
1128 :
1129 : #define FIELD_OPTIONS (FIELD_CODEC+7)
1130 :
1131 : static const TIFFField faxFields[] = {
1132 : { TIFFTAG_FAXMODE, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "FaxMode", NULL },
1133 : { TIFFTAG_FAXFILLFUNC, 0, 0, TIFF_ANY, 0, TIFF_SETGET_OTHER, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "FaxFillFunc", NULL },
1134 : { TIFFTAG_BADFAXLINES, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_BADFAXLINES, TRUE, FALSE, "BadFaxLines", NULL },
1135 : { TIFFTAG_CLEANFAXDATA, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UINT16, FIELD_CLEANFAXDATA, TRUE, FALSE, "CleanFaxData", NULL },
1136 : { TIFFTAG_CONSECUTIVEBADFAXLINES, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_BADFAXRUN, TRUE, FALSE, "ConsecutiveBadFaxLines", NULL }};
1137 : static const TIFFField fax3Fields[] = {
1138 : { TIFFTAG_GROUP3OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_OPTIONS, FALSE, FALSE, "Group3Options", NULL },
1139 : };
1140 : static const TIFFField fax4Fields[] = {
1141 : { TIFFTAG_GROUP4OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_OPTIONS, FALSE, FALSE, "Group4Options", NULL },
1142 : };
1143 :
1144 : static int
1145 280 : Fax3VSetField(TIFF* tif, uint32 tag, va_list ap)
1146 : {
1147 280 : Fax3BaseState* sp = Fax3State(tif);
1148 : const TIFFField* fip;
1149 :
1150 280 : assert(sp != 0);
1151 280 : assert(sp->vsetparent != 0);
1152 :
1153 280 : switch (tag) {
1154 : case TIFFTAG_FAXMODE:
1155 28 : sp->mode = (int) va_arg(ap, int);
1156 28 : return 1; /* NB: pseudo tag */
1157 : case TIFFTAG_FAXFILLFUNC:
1158 28 : DecoderState(tif)->fill = va_arg(ap, TIFFFaxFillFunc);
1159 28 : return 1; /* NB: pseudo tag */
1160 : case TIFFTAG_GROUP3OPTIONS:
1161 : /* XXX: avoid reading options if compression mismatches. */
1162 4 : if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX3)
1163 4 : sp->groupoptions = (uint32) va_arg(ap, uint32);
1164 4 : break;
1165 : case TIFFTAG_GROUP4OPTIONS:
1166 : /* XXX: avoid reading options if compression mismatches. */
1167 0 : if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX4)
1168 0 : sp->groupoptions = (uint32) va_arg(ap, uint32);
1169 0 : break;
1170 : case TIFFTAG_BADFAXLINES:
1171 0 : sp->badfaxlines = (uint32) va_arg(ap, uint32);
1172 0 : break;
1173 : case TIFFTAG_CLEANFAXDATA:
1174 0 : sp->cleanfaxdata = (uint16) va_arg(ap, uint16_vap);
1175 0 : break;
1176 : case TIFFTAG_CONSECUTIVEBADFAXLINES:
1177 0 : sp->badfaxrun = (uint32) va_arg(ap, uint32);
1178 0 : break;
1179 : default:
1180 220 : return (*sp->vsetparent)(tif, tag, ap);
1181 : }
1182 :
1183 4 : if ((fip = TIFFFieldWithTag(tif, tag)))
1184 4 : TIFFSetFieldBit(tif, fip->field_bit);
1185 : else
1186 0 : return 0;
1187 :
1188 4 : tif->tif_flags |= TIFF_DIRTYDIRECT;
1189 4 : return 1;
1190 : }
1191 :
1192 : static int
1193 412 : Fax3VGetField(TIFF* tif, uint32 tag, va_list ap)
1194 : {
1195 412 : Fax3BaseState* sp = Fax3State(tif);
1196 :
1197 412 : assert(sp != 0);
1198 :
1199 412 : switch (tag) {
1200 : case TIFFTAG_FAXMODE:
1201 0 : *va_arg(ap, int*) = sp->mode;
1202 0 : break;
1203 : case TIFFTAG_FAXFILLFUNC:
1204 0 : *va_arg(ap, TIFFFaxFillFunc*) = DecoderState(tif)->fill;
1205 0 : break;
1206 : case TIFFTAG_GROUP3OPTIONS:
1207 : case TIFFTAG_GROUP4OPTIONS:
1208 4 : *va_arg(ap, uint32*) = sp->groupoptions;
1209 4 : break;
1210 : case TIFFTAG_BADFAXLINES:
1211 0 : *va_arg(ap, uint32*) = sp->badfaxlines;
1212 0 : break;
1213 : case TIFFTAG_CLEANFAXDATA:
1214 0 : *va_arg(ap, uint16*) = sp->cleanfaxdata;
1215 0 : break;
1216 : case TIFFTAG_CONSECUTIVEBADFAXLINES:
1217 0 : *va_arg(ap, uint32*) = sp->badfaxrun;
1218 0 : break;
1219 : default:
1220 408 : return (*sp->vgetparent)(tif, tag, ap);
1221 : }
1222 4 : return (1);
1223 : }
1224 :
1225 : static void
1226 0 : Fax3PrintDir(TIFF* tif, FILE* fd, long flags)
1227 : {
1228 0 : Fax3BaseState* sp = Fax3State(tif);
1229 :
1230 0 : assert(sp != 0);
1231 :
1232 : (void) flags;
1233 0 : if (TIFFFieldSet(tif,FIELD_OPTIONS)) {
1234 0 : const char* sep = " ";
1235 0 : if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX4) {
1236 0 : fprintf(fd, " Group 4 Options:");
1237 0 : if (sp->groupoptions & GROUP4OPT_UNCOMPRESSED)
1238 0 : fprintf(fd, "%suncompressed data", sep);
1239 : } else {
1240 :
1241 0 : fprintf(fd, " Group 3 Options:");
1242 0 : if (sp->groupoptions & GROUP3OPT_2DENCODING)
1243 0 : fprintf(fd, "%s2-d encoding", sep), sep = "+";
1244 0 : if (sp->groupoptions & GROUP3OPT_FILLBITS)
1245 0 : fprintf(fd, "%sEOL padding", sep), sep = "+";
1246 0 : if (sp->groupoptions & GROUP3OPT_UNCOMPRESSED)
1247 0 : fprintf(fd, "%suncompressed data", sep);
1248 : }
1249 0 : fprintf(fd, " (%lu = 0x%lx)\n",
1250 : (unsigned long) sp->groupoptions,
1251 : (unsigned long) sp->groupoptions);
1252 : }
1253 0 : if (TIFFFieldSet(tif,FIELD_CLEANFAXDATA)) {
1254 0 : fprintf(fd, " Fax Data:");
1255 0 : switch (sp->cleanfaxdata) {
1256 : case CLEANFAXDATA_CLEAN:
1257 0 : fprintf(fd, " clean");
1258 0 : break;
1259 : case CLEANFAXDATA_REGENERATED:
1260 0 : fprintf(fd, " receiver regenerated");
1261 0 : break;
1262 : case CLEANFAXDATA_UNCLEAN:
1263 0 : fprintf(fd, " uncorrected errors");
1264 : break;
1265 : }
1266 0 : fprintf(fd, " (%u = 0x%x)\n",
1267 0 : sp->cleanfaxdata, sp->cleanfaxdata);
1268 : }
1269 0 : if (TIFFFieldSet(tif,FIELD_BADFAXLINES))
1270 0 : fprintf(fd, " Bad Fax Lines: %lu\n",
1271 : (unsigned long) sp->badfaxlines);
1272 0 : if (TIFFFieldSet(tif,FIELD_BADFAXRUN))
1273 0 : fprintf(fd, " Consecutive Bad Fax Lines: %lu\n",
1274 : (unsigned long) sp->badfaxrun);
1275 0 : if (sp->printdir)
1276 0 : (*sp->printdir)(tif, fd, flags);
1277 0 : }
1278 :
1279 : static int
1280 28 : InitCCITTFax3(TIFF* tif)
1281 : {
1282 : static const char module[] = "InitCCITTFax3";
1283 : Fax3BaseState* sp;
1284 :
1285 : /*
1286 : * Merge codec-specific tag information.
1287 : */
1288 28 : if (!_TIFFMergeFields(tif, faxFields, TIFFArrayCount(faxFields))) {
1289 0 : TIFFErrorExt(tif->tif_clientdata, "InitCCITTFax3",
1290 : "Merging common CCITT Fax codec-specific tags failed");
1291 0 : return 0;
1292 : }
1293 :
1294 : /*
1295 : * Allocate state block so tag methods have storage to record values.
1296 : */
1297 28 : tif->tif_data = (uint8*)
1298 : _TIFFmalloc(sizeof (Fax3CodecState));
1299 :
1300 28 : if (tif->tif_data == NULL) {
1301 0 : TIFFErrorExt(tif->tif_clientdata, module,
1302 : "No space for state block");
1303 0 : return (0);
1304 : }
1305 :
1306 28 : sp = Fax3State(tif);
1307 28 : sp->rw_mode = tif->tif_mode;
1308 :
1309 : /*
1310 : * Override parent get/set field methods.
1311 : */
1312 28 : sp->vgetparent = tif->tif_tagmethods.vgetfield;
1313 28 : tif->tif_tagmethods.vgetfield = Fax3VGetField; /* hook for codec tags */
1314 28 : sp->vsetparent = tif->tif_tagmethods.vsetfield;
1315 28 : tif->tif_tagmethods.vsetfield = Fax3VSetField; /* hook for codec tags */
1316 28 : sp->printdir = tif->tif_tagmethods.printdir;
1317 28 : tif->tif_tagmethods.printdir = Fax3PrintDir; /* hook for codec tags */
1318 28 : sp->groupoptions = 0;
1319 :
1320 28 : if (sp->rw_mode == O_RDONLY) /* FIXME: improve for in place update */
1321 16 : tif->tif_flags |= TIFF_NOBITREV; /* decoder does bit reversal */
1322 28 : DecoderState(tif)->runs = NULL;
1323 28 : TIFFSetField(tif, TIFFTAG_FAXFILLFUNC, _TIFFFax3fillruns);
1324 28 : EncoderState(tif)->refline = NULL;
1325 :
1326 : /*
1327 : * Install codec methods.
1328 : */
1329 28 : tif->tif_fixuptags = Fax3FixupTags;
1330 28 : tif->tif_setupdecode = Fax3SetupState;
1331 28 : tif->tif_predecode = Fax3PreDecode;
1332 28 : tif->tif_decoderow = Fax3Decode1D;
1333 28 : tif->tif_decodestrip = Fax3Decode1D;
1334 28 : tif->tif_decodetile = Fax3Decode1D;
1335 28 : tif->tif_setupencode = Fax3SetupState;
1336 28 : tif->tif_preencode = Fax3PreEncode;
1337 28 : tif->tif_postencode = Fax3PostEncode;
1338 28 : tif->tif_encoderow = Fax3Encode;
1339 28 : tif->tif_encodestrip = Fax3Encode;
1340 28 : tif->tif_encodetile = Fax3Encode;
1341 28 : tif->tif_close = Fax3Close;
1342 28 : tif->tif_cleanup = Fax3Cleanup;
1343 :
1344 28 : return (1);
1345 : }
1346 :
1347 : int
1348 4 : TIFFInitCCITTFax3(TIFF* tif, int scheme)
1349 : {
1350 : (void) scheme;
1351 4 : if (InitCCITTFax3(tif)) {
1352 : /*
1353 : * Merge codec-specific tag information.
1354 : */
1355 4 : if (!_TIFFMergeFields(tif, fax3Fields,
1356 : TIFFArrayCount(fax3Fields))) {
1357 0 : TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax3",
1358 : "Merging CCITT Fax 3 codec-specific tags failed");
1359 0 : return 0;
1360 : }
1361 :
1362 : /*
1363 : * The default format is Class/F-style w/o RTC.
1364 : */
1365 4 : return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_CLASSF);
1366 : } else
1367 0 : return 01;
1368 : }
1369 :
1370 : /*
1371 : * CCITT Group 4 (T.6) Facsimile-compatible
1372 : * Compression Scheme Support.
1373 : */
1374 :
1375 : #define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; }
1376 : /*
1377 : * Decode the requested amount of G4-encoded data.
1378 : */
1379 : static int
1380 43204 : Fax4Decode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
1381 : {
1382 43204 : DECLARE_STATE_2D(tif, sp, "Fax4Decode");
1383 : (void) s;
1384 43204 : if (occ % sp->b.rowbytes)
1385 : {
1386 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
1387 0 : return (-1);
1388 : }
1389 43204 : CACHE_STATE(tif, sp);
1390 130076 : while (occ > 0) {
1391 43668 : a0 = 0;
1392 43668 : RunLength = 0;
1393 43668 : pa = thisrun = sp->curruns;
1394 43668 : pb = sp->refruns;
1395 43668 : b1 = *pb++;
1396 : #ifdef FAX3_DEBUG
1397 : printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail);
1398 : printf("-------------------- %d\n", tif->tif_row);
1399 : fflush(stdout);
1400 : #endif
1401 43668 : EXPAND2D(EOFG4);
1402 43668 : if (EOLcnt)
1403 0 : goto EOFG4;
1404 43668 : (*sp->fill)(buf, thisrun, pa, lastx);
1405 43668 : SETVALUE(0); /* imaginary change for reference */
1406 43668 : SWAP(uint32*, sp->curruns, sp->refruns);
1407 43668 : buf += sp->b.rowbytes;
1408 43668 : occ -= sp->b.rowbytes;
1409 43668 : sp->line++;
1410 43668 : continue;
1411 : EOFG4:
1412 0 : NeedBits16( 13, BADG4 );
1413 : BADG4:
1414 : #ifdef FAX3_DEBUG
1415 : if( GetBits(13) != 0x1001 )
1416 : fputs( "Bad EOFB\n", stderr );
1417 : #endif
1418 0 : ClrBits( 13 );
1419 0 : (*sp->fill)(buf, thisrun, pa, lastx);
1420 0 : UNCACHE_STATE(tif, sp);
1421 0 : return ( sp->line ? 1 : -1); /* don't error on badly-terminated strips */
1422 : }
1423 43204 : UNCACHE_STATE(tif, sp);
1424 43204 : return (1);
1425 : }
1426 : #undef SWAP
1427 :
1428 : /*
1429 : * Encode the requested amount of data.
1430 : */
1431 : static int
1432 4 : Fax4Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
1433 : {
1434 : static const char module[] = "Fax4Encode";
1435 4 : Fax3CodecState *sp = EncoderState(tif);
1436 : (void) s;
1437 4 : if (cc % sp->b.rowbytes)
1438 : {
1439 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be written");
1440 0 : return (0);
1441 : }
1442 14606 : while (cc > 0) {
1443 14598 : if (!Fax3Encode2DRow(tif, bp, sp->refline, sp->b.rowpixels))
1444 0 : return (0);
1445 14598 : _TIFFmemcpy(sp->refline, bp, sp->b.rowbytes);
1446 14598 : bp += sp->b.rowbytes;
1447 14598 : cc -= sp->b.rowbytes;
1448 : }
1449 4 : return (1);
1450 : }
1451 :
1452 : static int
1453 4 : Fax4PostEncode(TIFF* tif)
1454 : {
1455 4 : Fax3CodecState *sp = EncoderState(tif);
1456 :
1457 : /* terminate strip w/ EOFB */
1458 4 : Fax3PutBits(tif, EOL, 12);
1459 4 : Fax3PutBits(tif, EOL, 12);
1460 4 : if (sp->bit != 8)
1461 4 : Fax3FlushBits(tif, sp);
1462 4 : return (1);
1463 : }
1464 :
1465 : int
1466 24 : TIFFInitCCITTFax4(TIFF* tif, int scheme)
1467 : {
1468 : (void) scheme;
1469 24 : if (InitCCITTFax3(tif)) { /* reuse G3 support */
1470 : /*
1471 : * Merge codec-specific tag information.
1472 : */
1473 24 : if (!_TIFFMergeFields(tif, fax4Fields,
1474 : TIFFArrayCount(fax4Fields))) {
1475 0 : TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax4",
1476 : "Merging CCITT Fax 4 codec-specific tags failed");
1477 0 : return 0;
1478 : }
1479 :
1480 24 : tif->tif_decoderow = Fax4Decode;
1481 24 : tif->tif_decodestrip = Fax4Decode;
1482 24 : tif->tif_decodetile = Fax4Decode;
1483 24 : tif->tif_encoderow = Fax4Encode;
1484 24 : tif->tif_encodestrip = Fax4Encode;
1485 24 : tif->tif_encodetile = Fax4Encode;
1486 24 : tif->tif_postencode = Fax4PostEncode;
1487 : /*
1488 : * Suppress RTC at the end of each strip.
1489 : */
1490 24 : return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_NORTC);
1491 : } else
1492 0 : return (0);
1493 : }
1494 :
1495 : /*
1496 : * CCITT Group 3 1-D Modified Huffman RLE Compression Support.
1497 : * (Compression algorithms 2 and 32771)
1498 : */
1499 :
1500 : /*
1501 : * Decode the requested amount of RLE-encoded data.
1502 : */
1503 : static int
1504 0 : Fax3DecodeRLE(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
1505 : {
1506 0 : DECLARE_STATE(tif, sp, "Fax3DecodeRLE");
1507 0 : int mode = sp->b.mode;
1508 : (void) s;
1509 0 : if (occ % sp->b.rowbytes)
1510 : {
1511 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
1512 0 : return (-1);
1513 : }
1514 0 : CACHE_STATE(tif, sp);
1515 0 : thisrun = sp->curruns;
1516 0 : while (occ > 0) {
1517 0 : a0 = 0;
1518 0 : RunLength = 0;
1519 0 : pa = thisrun;
1520 : #ifdef FAX3_DEBUG
1521 : printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail);
1522 : printf("-------------------- %d\n", tif->tif_row);
1523 : fflush(stdout);
1524 : #endif
1525 0 : EXPAND1D(EOFRLE);
1526 0 : (*sp->fill)(buf, thisrun, pa, lastx);
1527 : /*
1528 : * Cleanup at the end of the row.
1529 : */
1530 0 : if (mode & FAXMODE_BYTEALIGN) {
1531 0 : int n = BitsAvail - (BitsAvail &~ 7);
1532 0 : ClrBits(n);
1533 0 : } else if (mode & FAXMODE_WORDALIGN) {
1534 0 : int n = BitsAvail - (BitsAvail &~ 15);
1535 0 : ClrBits(n);
1536 0 : if (BitsAvail == 0 && !isAligned(cp, uint16))
1537 0 : cp++;
1538 : }
1539 0 : buf += sp->b.rowbytes;
1540 0 : occ -= sp->b.rowbytes;
1541 0 : sp->line++;
1542 0 : continue;
1543 : EOFRLE: /* premature EOF */
1544 0 : (*sp->fill)(buf, thisrun, pa, lastx);
1545 0 : UNCACHE_STATE(tif, sp);
1546 0 : return (-1);
1547 : }
1548 0 : UNCACHE_STATE(tif, sp);
1549 0 : return (1);
1550 : }
1551 :
1552 : int
1553 0 : TIFFInitCCITTRLE(TIFF* tif, int scheme)
1554 : {
1555 : (void) scheme;
1556 0 : if (InitCCITTFax3(tif)) { /* reuse G3 support */
1557 0 : tif->tif_decoderow = Fax3DecodeRLE;
1558 0 : tif->tif_decodestrip = Fax3DecodeRLE;
1559 0 : tif->tif_decodetile = Fax3DecodeRLE;
1560 : /*
1561 : * Suppress RTC+EOLs when encoding and byte-align data.
1562 : */
1563 0 : return TIFFSetField(tif, TIFFTAG_FAXMODE,
1564 : FAXMODE_NORTC|FAXMODE_NOEOL|FAXMODE_BYTEALIGN);
1565 : } else
1566 0 : return (0);
1567 : }
1568 :
1569 : int
1570 0 : TIFFInitCCITTRLEW(TIFF* tif, int scheme)
1571 : {
1572 : (void) scheme;
1573 0 : if (InitCCITTFax3(tif)) { /* reuse G3 support */
1574 0 : tif->tif_decoderow = Fax3DecodeRLE;
1575 0 : tif->tif_decodestrip = Fax3DecodeRLE;
1576 0 : tif->tif_decodetile = Fax3DecodeRLE;
1577 : /*
1578 : * Suppress RTC+EOLs when encoding and word-align data.
1579 : */
1580 0 : return TIFFSetField(tif, TIFFTAG_FAXMODE,
1581 : FAXMODE_NORTC|FAXMODE_NOEOL|FAXMODE_WORDALIGN);
1582 : } else
1583 0 : return (0);
1584 : }
1585 : #endif /* CCITT_SUPPORT */
1586 :
1587 : /* vim: set ts=8 sts=8 sw=8 noet: */
1588 : /*
1589 : * Local Variables:
1590 : * mode: c
1591 : * c-basic-offset: 8
1592 : * fill-column: 78
1593 : * End:
1594 : */
|
