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 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 897 : for (; n && !isAligned(cp, long); n--)
398 0 : *cp++ = 0x00;
399 897 : lp = (long*) cp;
400 897 : nw = (int32)(n / sizeof (long));
401 897 : n -= nw * sizeof (long);
402 : do {
403 7632 : *lp++ = 0L;
404 7632 : } while (--nw);
405 897 : 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 54477 : for (; n && !isAligned(cp, long); n--)
433 26419 : *cp++ = 0xff;
434 28058 : lp = (long*) cp;
435 28058 : nw = (int32)(n / sizeof (long));
436 28058 : n -= nw * sizeof (long);
437 : do {
438 311393 : *lp++ = -1L;
439 311393 : } while (--nw);
440 28058 : 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 : /*
508 : Assure that allocation computations do not overflow.
509 :
510 : TIFFroundup and TIFFSafeMultiply return zero on integer overflow
511 : */
512 8 : dsp->runs=(uint32*) NULL;
513 8 : nruns = TIFFroundup_32(rowpixels,32);
514 8 : if (needsRefLine) {
515 8 : nruns = TIFFSafeMultiply(uint32,nruns,2);
516 : }
517 8 : 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 16 : dsp->runs = (uint32*) _TIFFCheckMalloc(tif,
524 16 : TIFFSafeMultiply(uint32,nruns,2),
525 : sizeof (uint32),
526 : "for Group 3/4 run arrays");
527 8 : if (dsp->runs == NULL)
528 0 : return (0);
529 8 : dsp->curruns = dsp->runs;
530 8 : if (needsRefLine)
531 8 : dsp->refruns = dsp->runs + nruns;
532 : else
533 0 : dsp->refruns = NULL;
534 9 : if (td->td_compression == COMPRESSION_CCITTFAX3
535 9 : && is2DEncoding(dsp)) { /* NB: default is 1D routine */
536 1 : tif->tif_decoderow = Fax3Decode2D;
537 1 : tif->tif_decodestrip = Fax3Decode2D;
538 1 : tif->tif_decodetile = Fax3Decode2D;
539 : }
540 :
541 8 : if (needsRefLine) { /* 2d encoding */
542 8 : 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 8 : esp->refline = (unsigned char*) _TIFFmalloc(rowbytes);
551 8 : 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 8 : 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 32719 : Fax3PutBits(TIFF* tif, unsigned int bits, unsigned int length)
602 : {
603 32719 : Fax3CodecState* sp = EncoderState(tif);
604 32719 : unsigned int bit = sp->bit;
605 32719 : int data = sp->data;
606 :
607 32719 : _PutBits(tif, bits, length);
608 :
609 32719 : sp->data = data;
610 32719 : sp->bit = bit;
611 32719 : }
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 4768 : putspan(TIFF* tif, int32 span, const tableentry* tab)
637 : {
638 4768 : Fax3CodecState* sp = EncoderState(tif);
639 4768 : unsigned int bit = sp->bit;
640 4768 : int data = sp->data;
641 : unsigned int code, length;
642 :
643 9536 : 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 4768 : if (span >= 64) {
653 397 : const tableentry* te = &tab[63 + (span>>6)];
654 397 : assert(te->runlen == 64*(span>>6));
655 397 : code = te->code, length = te->length;
656 : #ifdef FAX3_DEBUG
657 : DEBUG_PRINT("MakeUp", te->runlen);
658 : #endif
659 397 : _PutBits(tif, code, length);
660 397 : span -= te->runlen;
661 : }
662 4768 : code = tab[span].code, length = tab[span].length;
663 : #ifdef FAX3_DEBUG
664 : DEBUG_PRINT(" Term", tab[span].runlen);
665 : #endif
666 4768 : _PutBits(tif, code, length);
667 :
668 4768 : sp->data = data;
669 4768 : sp->bit = bit;
670 4768 : }
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 2 : Fax3PreEncode(TIFF* tif, uint16 s)
717 : {
718 2 : Fax3CodecState* sp = EncoderState(tif);
719 :
720 : (void) s;
721 2 : assert(sp != NULL);
722 2 : sp->bit = 8;
723 2 : sp->data = 0;
724 2 : 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 2 : if (sp->refline)
731 2 : _TIFFmemset(sp->refline, 0x00, sp->b.rowbytes);
732 2 : 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 2 : sp->k = sp->maxk = 0;
750 2 : sp->line = 0;
751 2 : 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 44923 : find0span(unsigned char* bp, int32 bs, int32 be)
808 : {
809 44923 : int32 bits = be - bs;
810 : int32 n, span;
811 :
812 44923 : bp += bs>>3;
813 : /*
814 : * Check partial byte on lhs.
815 : */
816 64872 : if (bits > 0 && (n = (bs & 7))) {
817 32943 : span = zeroruns[(*bp << n) & 0xff];
818 32943 : if (span > 8-n) /* table value too generous */
819 19998 : span = 8-n;
820 32943 : if (span > bits) /* constrain span to bit range */
821 49 : span = bits;
822 32943 : if (n+span < 8) /* doesn't extend to edge of byte */
823 12994 : return (span);
824 19949 : bits -= span;
825 19949 : bp++;
826 : } else
827 11980 : span = 0;
828 31929 : if (bits >= (int32)(2 * 8 * sizeof(long))) {
829 : long* lp;
830 : /*
831 : * Align to longword boundary and check longwords.
832 : */
833 73698 : while (!isAligned(bp, long)) {
834 31618 : if (*bp != 0x00)
835 14452 : return (span + zeroruns[*bp]);
836 17166 : span += 8, bits -= 8;
837 17166 : bp++;
838 : }
839 13814 : lp = (long*) bp;
840 27788 : while ((bits >= (int32)(8 * sizeof(long))) && (0 == *lp)) {
841 160 : span += 8*sizeof (long), bits -= 8*sizeof (long);
842 160 : lp++;
843 : }
844 13814 : bp = (unsigned char*) lp;
845 : }
846 : /*
847 : * Scan full bytes for all 0's.
848 : */
849 42957 : while (bits >= 8) {
850 25236 : if (*bp != 0x00) /* end of run */
851 17233 : return (span + zeroruns[*bp]);
852 8003 : span += 8, bits -= 8;
853 8003 : bp++;
854 : }
855 : /*
856 : * Check partial byte on rhs.
857 : */
858 244 : if (bits > 0) {
859 147 : n = zeroruns[*bp];
860 147 : span += (n > bits ? bits : n);
861 : }
862 244 : return (span);
863 : }
864 :
865 : inline static int32
866 59093 : find1span(unsigned char* bp, int32 bs, int32 be)
867 : {
868 59093 : int32 bits = be - bs;
869 : int32 n, span;
870 :
871 59093 : bp += bs>>3;
872 : /*
873 : * Check partial byte on lhs.
874 : */
875 81282 : if (bits > 0 && (n = (bs & 7))) {
876 33236 : span = oneruns[(*bp << n) & 0xff];
877 33236 : if (span > 8-n) /* table value too generous */
878 0 : span = 8-n;
879 33236 : if (span > bits) /* constrain span to bit range */
880 0 : span = bits;
881 33236 : if (n+span < 8) /* doesn't extend to edge of byte */
882 11047 : return (span);
883 22189 : bits -= span;
884 22189 : bp++;
885 : } else
886 25857 : span = 0;
887 48046 : if (bits >= (int32)(2 * 8 * sizeof(long))) {
888 : long* lp;
889 : /*
890 : * Align to longword boundary and check longwords.
891 : */
892 158918 : while (!isAligned(bp, long)) {
893 82008 : if (*bp != 0xff)
894 10078 : return (span + oneruns[*bp]);
895 71930 : span += 8, bits -= 8;
896 71930 : bp++;
897 : }
898 33416 : lp = (long*) bp;
899 370082 : while ((bits >= (int32)(8 * sizeof(long))) && (~0 == *lp)) {
900 303250 : span += 8*sizeof (long), bits -= 8*sizeof (long);
901 303250 : lp++;
902 : }
903 33416 : bp = (unsigned char*) lp;
904 : }
905 : /*
906 : * Scan full bytes for all 1's.
907 : */
908 221861 : while (bits >= 8) {
909 161904 : if (*bp != 0xff) /* end of run */
910 15979 : return (span + oneruns[*bp]);
911 145925 : span += 8, bits -= 8;
912 145925 : bp++;
913 : }
914 : /*
915 : * Check partial byte on rhs.
916 : */
917 21989 : if (bits > 0) {
918 288 : n = oneruns[*bp];
919 288 : span += (n > bits ? bits : n);
920 : }
921 21989 : 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 7299 : 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 7299 : uint32 a0 = 0;
996 7299 : uint32 a1 = (PIXEL(bp, 0) != 0 ? 0 : finddiff(bp, 0, bits, 0));
997 7299 : uint32 b1 = (PIXEL(rp, 0) != 0 ? 0 : finddiff(rp, 0, bits, 0));
998 : uint32 a2, b2;
999 :
1000 : for (;;) {
1001 32715 : b2 = finddiff2(rp, b1, bits, PIXEL(rp,b1));
1002 32715 : if (b2 >= a1) {
1003 31212 : int32 d = b1 - a1;
1004 33596 : if (!(-3 <= d && d <= 3)) { /* horizontal mode */
1005 2384 : a2 = finddiff2(bp, a1, bits, PIXEL(bp,a1));
1006 2384 : putcode(tif, &horizcode);
1007 3437 : if (a0+a1 == 0 || PIXEL(bp, a0) == 0) {
1008 1053 : putspan(tif, a1-a0, TIFFFaxWhiteCodes);
1009 1053 : putspan(tif, a2-a1, TIFFFaxBlackCodes);
1010 : } else {
1011 1331 : putspan(tif, a1-a0, TIFFFaxBlackCodes);
1012 1331 : putspan(tif, a2-a1, TIFFFaxWhiteCodes);
1013 : }
1014 2384 : a0 = a2;
1015 : } else { /* vertical mode */
1016 28828 : putcode(tif, &vcodes[d+3]);
1017 28828 : a0 = a1;
1018 : }
1019 : } else { /* pass mode */
1020 1503 : putcode(tif, &passcode);
1021 1503 : a0 = b2;
1022 : }
1023 32715 : if (a0 >= bits)
1024 : break;
1025 25416 : a1 = finddiff(bp, a0, bits, PIXEL(bp,a0));
1026 25416 : b1 = finddiff(rp, a0, bits, !PIXEL(bp,a0));
1027 25416 : b1 = finddiff(rp, b1, bits, PIXEL(bp,a0));
1028 25416 : }
1029 7299 : 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 4 : Fax3Close(TIFF* tif)
1088 : {
1089 4 : 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 4 : }
1102 :
1103 : static void
1104 14 : Fax3Cleanup(TIFF* tif)
1105 : {
1106 14 : Fax3CodecState* sp = DecoderState(tif);
1107 :
1108 14 : assert(sp != 0);
1109 :
1110 14 : tif->tif_tagmethods.vgetfield = sp->b.vgetparent;
1111 14 : tif->tif_tagmethods.vsetfield = sp->b.vsetparent;
1112 14 : tif->tif_tagmethods.printdir = sp->b.printdir;
1113 :
1114 14 : if (sp->runs)
1115 8 : _TIFFfree(sp->runs);
1116 14 : if (sp->refline)
1117 8 : _TIFFfree(sp->refline);
1118 :
1119 14 : _TIFFfree(tif->tif_data);
1120 14 : tif->tif_data = NULL;
1121 :
1122 14 : _TIFFSetDefaultCompressionState(tif);
1123 14 : }
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 140 : Fax3VSetField(TIFF* tif, uint32 tag, va_list ap)
1146 : {
1147 140 : Fax3BaseState* sp = Fax3State(tif);
1148 : const TIFFField* fip;
1149 :
1150 140 : assert(sp != 0);
1151 140 : assert(sp->vsetparent != 0);
1152 :
1153 140 : switch (tag) {
1154 : case TIFFTAG_FAXMODE:
1155 14 : sp->mode = (int) va_arg(ap, int);
1156 14 : return 1; /* NB: pseudo tag */
1157 : case TIFFTAG_FAXFILLFUNC:
1158 14 : DecoderState(tif)->fill = va_arg(ap, TIFFFaxFillFunc);
1159 14 : return 1; /* NB: pseudo tag */
1160 : case TIFFTAG_GROUP3OPTIONS:
1161 : /* XXX: avoid reading options if compression mismatches. */
1162 2 : if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX3)
1163 2 : sp->groupoptions = (uint32) va_arg(ap, uint32);
1164 2 : 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 110 : return (*sp->vsetparent)(tif, tag, ap);
1181 : }
1182 :
1183 2 : if ((fip = TIFFFieldWithTag(tif, tag)))
1184 2 : TIFFSetFieldBit(tif, fip->field_bit);
1185 : else
1186 0 : return 0;
1187 :
1188 2 : tif->tif_flags |= TIFF_DIRTYDIRECT;
1189 2 : return 1;
1190 : }
1191 :
1192 : static int
1193 206 : Fax3VGetField(TIFF* tif, uint32 tag, va_list ap)
1194 : {
1195 206 : Fax3BaseState* sp = Fax3State(tif);
1196 :
1197 206 : assert(sp != 0);
1198 :
1199 206 : 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 2 : *va_arg(ap, uint32*) = sp->groupoptions;
1209 2 : 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 204 : return (*sp->vgetparent)(tif, tag, ap);
1221 : }
1222 2 : 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 14 : InitCCITTFax3(TIFF* tif)
1281 : {
1282 : static const char module[] = "InitCCITTFax3";
1283 : Fax3BaseState* sp;
1284 :
1285 : /*
1286 : * Merge codec-specific tag information.
1287 : */
1288 14 : 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 14 : tif->tif_data = (uint8*)
1298 : _TIFFmalloc(sizeof (Fax3CodecState));
1299 :
1300 14 : 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 14 : sp = Fax3State(tif);
1307 14 : sp->rw_mode = tif->tif_mode;
1308 :
1309 : /*
1310 : * Override parent get/set field methods.
1311 : */
1312 14 : sp->vgetparent = tif->tif_tagmethods.vgetfield;
1313 14 : tif->tif_tagmethods.vgetfield = Fax3VGetField; /* hook for codec tags */
1314 14 : sp->vsetparent = tif->tif_tagmethods.vsetfield;
1315 14 : tif->tif_tagmethods.vsetfield = Fax3VSetField; /* hook for codec tags */
1316 14 : sp->printdir = tif->tif_tagmethods.printdir;
1317 14 : tif->tif_tagmethods.printdir = Fax3PrintDir; /* hook for codec tags */
1318 14 : sp->groupoptions = 0;
1319 :
1320 14 : if (sp->rw_mode == O_RDONLY) /* FIXME: improve for in place update */
1321 8 : tif->tif_flags |= TIFF_NOBITREV; /* decoder does bit reversal */
1322 14 : DecoderState(tif)->runs = NULL;
1323 14 : TIFFSetField(tif, TIFFTAG_FAXFILLFUNC, _TIFFFax3fillruns);
1324 14 : EncoderState(tif)->refline = NULL;
1325 :
1326 : /*
1327 : * Install codec methods.
1328 : */
1329 14 : tif->tif_fixuptags = Fax3FixupTags;
1330 14 : tif->tif_setupdecode = Fax3SetupState;
1331 14 : tif->tif_predecode = Fax3PreDecode;
1332 14 : tif->tif_decoderow = Fax3Decode1D;
1333 14 : tif->tif_decodestrip = Fax3Decode1D;
1334 14 : tif->tif_decodetile = Fax3Decode1D;
1335 14 : tif->tif_setupencode = Fax3SetupState;
1336 14 : tif->tif_preencode = Fax3PreEncode;
1337 14 : tif->tif_postencode = Fax3PostEncode;
1338 14 : tif->tif_encoderow = Fax3Encode;
1339 14 : tif->tif_encodestrip = Fax3Encode;
1340 14 : tif->tif_encodetile = Fax3Encode;
1341 14 : tif->tif_close = Fax3Close;
1342 14 : tif->tif_cleanup = Fax3Cleanup;
1343 :
1344 14 : return (1);
1345 : }
1346 :
1347 : int
1348 2 : TIFFInitCCITTFax3(TIFF* tif, int scheme)
1349 : {
1350 : (void) scheme;
1351 2 : if (InitCCITTFax3(tif)) {
1352 : /*
1353 : * Merge codec-specific tag information.
1354 : */
1355 2 : 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 2 : 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 21602 : Fax4Decode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
1381 : {
1382 21602 : DECLARE_STATE_2D(tif, sp, "Fax4Decode");
1383 : (void) s;
1384 21602 : if (occ % sp->b.rowbytes)
1385 : {
1386 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
1387 0 : return (-1);
1388 : }
1389 21602 : CACHE_STATE(tif, sp);
1390 65038 : while (occ > 0) {
1391 21834 : a0 = 0;
1392 21834 : RunLength = 0;
1393 21834 : pa = thisrun = sp->curruns;
1394 21834 : pb = sp->refruns;
1395 21834 : 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 21834 : EXPAND2D(EOFG4);
1402 21834 : if (EOLcnt)
1403 0 : goto EOFG4;
1404 21834 : (*sp->fill)(buf, thisrun, pa, lastx);
1405 21834 : SETVALUE(0); /* imaginary change for reference */
1406 21834 : SWAP(uint32*, sp->curruns, sp->refruns);
1407 21834 : buf += sp->b.rowbytes;
1408 21834 : occ -= sp->b.rowbytes;
1409 21834 : sp->line++;
1410 21834 : 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 21602 : UNCACHE_STATE(tif, sp);
1424 21602 : return (1);
1425 : }
1426 : #undef SWAP
1427 :
1428 : /*
1429 : * Encode the requested amount of data.
1430 : */
1431 : static int
1432 2 : Fax4Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
1433 : {
1434 : static const char module[] = "Fax4Encode";
1435 2 : Fax3CodecState *sp = EncoderState(tif);
1436 : (void) s;
1437 2 : if (cc % sp->b.rowbytes)
1438 : {
1439 0 : TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be written");
1440 0 : return (0);
1441 : }
1442 7303 : while (cc > 0) {
1443 7299 : if (!Fax3Encode2DRow(tif, bp, sp->refline, sp->b.rowpixels))
1444 0 : return (0);
1445 7299 : _TIFFmemcpy(sp->refline, bp, sp->b.rowbytes);
1446 7299 : bp += sp->b.rowbytes;
1447 7299 : cc -= sp->b.rowbytes;
1448 : }
1449 2 : return (1);
1450 : }
1451 :
1452 : static int
1453 2 : Fax4PostEncode(TIFF* tif)
1454 : {
1455 2 : Fax3CodecState *sp = EncoderState(tif);
1456 :
1457 : /* terminate strip w/ EOFB */
1458 2 : Fax3PutBits(tif, EOL, 12);
1459 2 : Fax3PutBits(tif, EOL, 12);
1460 2 : if (sp->bit != 8)
1461 2 : Fax3FlushBits(tif, sp);
1462 2 : return (1);
1463 : }
1464 :
1465 : int
1466 12 : TIFFInitCCITTFax4(TIFF* tif, int scheme)
1467 : {
1468 : (void) scheme;
1469 12 : if (InitCCITTFax3(tif)) { /* reuse G3 support */
1470 : /*
1471 : * Merge codec-specific tag information.
1472 : */
1473 12 : 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 12 : tif->tif_decoderow = Fax4Decode;
1481 12 : tif->tif_decodestrip = Fax4Decode;
1482 12 : tif->tif_decodetile = Fax4Decode;
1483 12 : tif->tif_encoderow = Fax4Encode;
1484 12 : tif->tif_encodestrip = Fax4Encode;
1485 12 : tif->tif_encodetile = Fax4Encode;
1486 12 : tif->tif_postencode = Fax4PostEncode;
1487 : /*
1488 : * Suppress RTC at the end of each strip.
1489 : */
1490 12 : 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 : */
|
