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