1 #ifndef lint
2 static char rcsid[] = "$Header: /usr/people/sam/tiff/libtiff/RCS/tif_fax3.c,v 1.60 92/02/10 19:06:36 sam Exp $";
3 #endif
4 
5 /*
6  * Copyright (c) 1990, 1991, 1992 Sam Leffler
7  * Copyright (c) 1991, 1992 Silicon Graphics, Inc.
8  *
9  * Permission to use, copy, modify, distribute, and sell this software and
10  * its documentation for any purpose is hereby granted without fee, provided
11  * that (i) the above copyright notices and this permission notice appear in
12  * all copies of the software and related documentation, and (ii) the names of
13  * Sam Leffler and Silicon Graphics may not be used in any advertising or
14  * publicity relating to the software without the specific, prior written
15  * permission of Sam Leffler and Silicon Graphics.
16  *
17  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
18  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
19  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
20  *
21  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
22  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
23  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
24  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
25  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
26  * OF THIS SOFTWARE.
27  */
28 
29 /*
30  * TIFF Library.
31  *
32  * CCITT Group 3 and Group 4 Compression Support.
33  */
34 #include "tiffioP.h"
35 #include <stdio.h>
36 #include <assert.h>
37 #include "tif_fax3.h"
38 #define	G3CODES
39 #include "t4.h"
40 #define	G3STATES
41 #include "g3states.h"
42 
43 typedef struct {
44 	Fax3BaseState b;
45 } Fax3DecodeState;
46 
47 typedef struct {
48 	Fax3BaseState b;
49 	u_char	*wruns;
50 	u_char	*bruns;
51 	short	k;			/* #rows left that can be 2d encoded */
52 	short	maxk;			/* max #rows that can be 2d encoded */
53 } Fax3EncodeState;
54 
55 #if USE_PROTOTYPES
56 static	Fax3PreDecode(TIFF *);
57 static	Fax3Decode(TIFF*, u_char *, int, u_int);
58 static	int Fax3Decode1DRow(TIFF*, u_char *, int);
59 static	Fax3PreEncode(TIFF *);
60 static	Fax3PostEncode(TIFF *);
61 static	Fax3Encode(TIFF*, u_char *, int, u_int);
62 static	int Fax3Encode1DRow(TIFF *, u_char *, int);
63 static	Fax3Close(TIFF *);
64 static	Fax3Cleanup(TIFF *);
65 static	void *Fax3SetupState(TIFF *, int);
66 static	void fillspan(char *, int, int);
67 static	int findspan(u_char **, int, int, u_char const *);
68 static	int finddiff(u_char *, int, int, int);
69 static	void skiptoeol(TIFF *, int);
70 static	void putbits(TIFF *, u_int, u_int);
71 static	void putcode(TIFF *, tableentry const *);
72 static	void putspan(TIFF *, int, tableentry const *);
73 extern	int TIFFFlushData1(TIFF *);
74 #else
75 static	int Fax3PreEncode(), Fax3Encode(), Fax3PostEncode();
76 static	int Fax3Encode1DRow();
77 static	int Fax3Decode(), Fax3PreDecode();
78 static	int Fax3Decode1DRow();
79 static	int Fax3Close(), Fax3Cleanup();
80 static	void *Fax3SetupState();
81 static	void fillspan();
82 static	int findspan();
83 static	int finddiff();
84 static	void skiptoeol();
85 static	void putbits();
86 static	void putcode();
87 static	void putspan();
88 extern	int TIFFFlushData1();
89 #endif
90 
TIFFInitCCITTFax3(tif)91 TIFFInitCCITTFax3(tif)
92 	TIFF *tif;
93 {
94 	tif->tif_predecode = Fax3PreDecode;
95 	tif->tif_decoderow = Fax3Decode;
96 	tif->tif_decodestrip = Fax3Decode;
97 	tif->tif_decodetile = Fax3Decode;
98 	tif->tif_preencode = Fax3PreEncode;
99 	tif->tif_postencode = Fax3PostEncode;
100 	tif->tif_encoderow = Fax3Encode;
101 	tif->tif_encodestrip = Fax3Encode;
102 	tif->tif_encodetile = Fax3Encode;
103 	tif->tif_close = Fax3Close;
104 	tif->tif_cleanup = Fax3Cleanup;
105 	tif->tif_options |= FAX3_CLASSF;	/* default */
106 	tif->tif_flags |= TIFF_NOBITREV;	/* we handle bit reversal */
107 	return (1);
108 }
109 
TIFFModeCCITTFax3(tif,isClassF)110 TIFFModeCCITTFax3(tif, isClassF)
111 	TIFF *tif;
112 	int isClassF;
113 {
114 	if (isClassF)
115 		tif->tif_options |= FAX3_CLASSF;
116 	else
117 		tif->tif_options &= ~FAX3_CLASSF;
118 }
119 
120 static u_char bitMask[8] =
121     { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
122 #define	isBitSet(sp)	((sp)->b.data & bitMask[(sp)->b.bit])
123 
124 #define	is2DEncoding(tif) \
125 	(tif->tif_dir.td_group3options & GROUP3OPT_2DENCODING)
126 #define	fetchByte(tif, sp) \
127 	((tif)->tif_rawcc--, (sp)->b.bitmap[*(u_char *)(tif)->tif_rawcp++])
128 
129 #define	BITCASE(b)			\
130     case b:				\
131 	code <<= 1;			\
132 	if (data & (1<<(7-b))) code |= 1;\
133 	len++;				\
134 	if (code > 0) { bit = b+1; break; }
135 
136 /*
137  * Skip over input until an EOL code is found.  The
138  * value of len is passed as 0 except during error
139  * recovery when decoding 2D data.  Note also that
140  * we don't use the optimized state tables to locate
141  * an EOL because we can't assume much of anything
142  * about our state (e.g. bit position).
143  */
144 static void
skiptoeol(tif,len)145 skiptoeol(tif, len)
146 	TIFF *tif;
147 	int len;
148 {
149 	Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
150 	register int bit = sp->b.bit;
151 	register int data = sp->b.data;
152 	int code = 0;
153 
154 	/*
155 	 * Our handling of ``bit'' is painful because
156 	 * the rest of the code does not maintain it as
157 	 * exactly the bit offset in the current data
158 	 * byte (bit == 0 means refill the data byte).
159 	 * Thus we have to be careful on entry and
160 	 * exit to insure that we maintain a value that's
161 	 * understandable elsewhere in the decoding logic.
162 	 */
163 	if (bit == 0)			/* force refill */
164 		bit = 8;
165 	for (;;) {
166 		switch (bit) {
167 	again:	BITCASE(0);
168 		BITCASE(1);
169 		BITCASE(2);
170 		BITCASE(3);
171 		BITCASE(4);
172 		BITCASE(5);
173 		BITCASE(6);
174 		BITCASE(7);
175 		default:
176 			if (tif->tif_rawcc <= 0)
177 				return;
178 			data = fetchByte(tif, sp);
179 			goto again;
180 		}
181 		if (len >= 12 && code == EOL)
182 			break;
183 		code = len = 0;
184 	}
185 	sp->b.bit = bit > 7 ? 0 : bit;	/* force refill */
186 	sp->b.data = data;
187 }
188 
189 /*
190  * Return the next bit in the input stream.  This is
191  * used to extract 2D tag values and the color tag
192  * at the end of a terminating uncompressed data code.
193  */
194 static int
nextbit(tif)195 nextbit(tif)
196 	TIFF *tif;
197 {
198 	Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
199 	int bit;
200 
201 	if (sp->b.bit == 0 && tif->tif_rawcc > 0)
202 		sp->b.data = fetchByte(tif, sp);
203 	bit = isBitSet(sp);
204 	if (++(sp->b.bit) > 7)
205 		sp->b.bit = 0;
206 	return (bit);
207 }
208 
209 static void
bset(cp,n,v)210 bset(cp, n, v)
211 	register unsigned char *cp;
212 	register int n;
213 	register int v;
214 {
215 	while (n-- > 0)
216 		*cp++ = v;
217 }
218 
219 /*
220  * Setup G3-related compression/decompression
221  * state before data is processed.  This routine
222  * is called once per image -- it sets up different
223  * state based on whether or not 2D encoding is used.
224  */
225 static void *
Fax3SetupState(tif,space)226 Fax3SetupState(tif, space)
227 	TIFF *tif;
228 	int space;
229 {
230 	TIFFDirectory *td = &tif->tif_dir;
231 	Fax3BaseState *sp;
232 	int cc = space;
233 	long rowbytes, rowpixels;
234 
235 	if (td->td_bitspersample != 1) {
236 		TIFFError(tif->tif_name,
237 		    "Bits/sample must be 1 for Group 3/4 encoding/decoding");
238 		return (0);
239 	}
240 	/*
241 	 * Calculate the scanline/tile widths.
242 	 */
243 	if (isTiled(tif)) {
244 		rowbytes = TIFFTileRowSize(tif);
245 		rowpixels = tif->tif_dir.td_tilewidth;
246 	} else {
247 		rowbytes = TIFFScanlineSize(tif);
248 		rowpixels = tif->tif_dir.td_imagewidth;
249 	}
250 	if (is2DEncoding(tif) || td->td_compression == COMPRESSION_CCITTFAX4)
251 		cc += rowbytes+1;
252 	tif->tif_data = malloc(cc);
253 	if (tif->tif_data == NULL) {
254 		TIFFError("Fax3SetupState",
255 		    "%s: No space for Fax3 state block", tif->tif_name);
256 		return (0);
257 	}
258 	sp = (Fax3BaseState *)tif->tif_data;
259 	sp->rowbytes = rowbytes;
260 	sp->rowpixels = rowpixels;
261 	sp->bitmap = (tif->tif_fillorder != td->td_fillorder ?
262 	    TIFFBitRevTable : TIFFNoBitRevTable);
263 	sp->white = (td->td_photometric == PHOTOMETRIC_MINISBLACK);
264 	if (is2DEncoding(tif) || td->td_compression == COMPRESSION_CCITTFAX4) {
265 		/*
266 		 * 2d encoding/decoding requires a scanline
267 		 * buffer for the ``reference line''; the
268 		 * scanline against which delta encoding
269 		 * is referenced.  The reference line must
270 		 * be initialized to be ``white'' (done elsewhere).
271 		 */
272 		sp->refline = (u_char *)tif->tif_data + space + 1;
273 		/*
274 		 * Initialize pixel just to the left of the
275 		 * reference line to white.  This extra pixel
276 		 * simplifies the edge-condition logic.
277 		 */
278 		sp->refline[-1] = sp->white ? 0xff : 0x00;
279 	} else
280 		sp->refline = 0;
281 	return (sp);
282 }
283 
284 /*
285  * Setup state for decoding a strip.
286  */
287 static
Fax3PreDecode(tif)288 Fax3PreDecode(tif)
289 	TIFF *tif;
290 {
291 	Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
292 
293 	if (sp == NULL) {
294 		sp = (Fax3DecodeState *)Fax3SetupState(tif, sizeof (*sp));
295 		if (!sp)
296 			return (0);
297 	}
298 	sp->b.bit = 0;			/* force initial read */
299 	sp->b.data = 0;
300 	sp->b.tag = G3_1D;
301 	if (sp->b.refline)
302 		bset(sp->b.refline, sp->b.rowbytes, sp->b.white ? 0xff : 0x00);
303 	/*
304 	 * If image has EOL codes, they precede each line
305 	 * of data.  We skip over the first one here so that
306 	 * when we decode rows, we can use an EOL to signal
307 	 * that less than the expected number of pixels are
308 	 * present for the scanline.
309 	 */
310 	if ((tif->tif_options & FAX3_NOEOL) == 0) {
311 		skiptoeol(tif, 0);
312 		if (is2DEncoding(tif))
313 			/* tag should always be 1D! */
314 			sp->b.tag = nextbit(tif) ? G3_1D : G3_2D;
315 	}
316 	return (1);
317 }
318 
319 /*
320  * Fill a span with ones.
321  */
322 static void
fillspan(cp,x,count)323 fillspan(cp, x, count)
324 	register char *cp;
325 	register int x, count;
326 {
327 	static const unsigned char masks[] =
328 	    { 0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
329 
330 	if (count <= 0)
331 		return;
332 	cp += x>>3;
333 	if (x &= 7) {			/* align to byte boundary */
334 		if (count < 8 - x) {
335 			*cp++ |= masks[count] >> x;
336 			return;
337 		}
338 		*cp++ |= 0xff >> x;
339 		count -= 8 - x;
340 	}
341 	while (count >= 8) {
342 		*cp++ = 0xff;
343 		count -= 8;
344 	}
345 	*cp |= masks[count];
346 }
347 
348 /*
349  * Decode the requested amount of data.
350  */
351 static
Fax3Decode(tif,buf,occ,s)352 Fax3Decode(tif, buf, occ, s)
353 	TIFF *tif;
354 	u_char *buf;
355 	int occ;
356 	u_int s;
357 {
358 	Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
359 
360 	bzero(buf, occ);		/* decoding only sets non-zero bits */
361 	while (occ > 0) {
362 		if (sp->b.tag == G3_1D) {
363 			if (!Fax3Decode1DRow(tif, buf, sp->b.rowpixels))
364 				return (0);
365 		} else {
366 			if (!Fax3Decode2DRow(tif, buf, sp->b.rowpixels))
367 				return (0);
368 		}
369 		if (is2DEncoding(tif)) {
370 			/*
371 			 * Fetch the tag bit that indicates
372 			 * whether the next row is 1d or 2d
373 			 * encoded.  If 2d-encoded, then setup
374 			 * the reference line from the decoded
375 			 * scanline just completed.
376 			 */
377 			sp->b.tag = nextbit(tif) ? G3_1D : G3_2D;
378 			if (sp->b.tag == G3_2D)
379 				bcopy(buf, sp->b.refline, sp->b.rowbytes);
380 		}
381 		buf += sp->b.rowbytes;
382 		occ -= sp->b.rowbytes;
383 	}
384 	return (1);
385 }
386 
387 /*
388  * Decode a run of white.
389  */
390 static int
decode_white_run(tif)391 decode_white_run(tif)
392 	TIFF *tif;
393 {
394 	Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
395 	short state = sp->b.bit;
396 	short action;
397 	int runlen = 0;
398 
399 	for (;;) {
400 		if (sp->b.bit == 0) {
401 	nextbyte:
402 			if (tif->tif_rawcc <= 0)
403 				return (G3CODE_EOF);
404 			sp->b.data = fetchByte(tif, sp);
405 		}
406 		action = TIFFFax1DAction[state][sp->b.data];
407 		state = TIFFFax1DNextState[state][sp->b.data];
408 		if (action == ACT_INCOMP)
409 			goto nextbyte;
410 		if (action == ACT_INVALID)
411 			return (G3CODE_INVALID);
412 		if (action == ACT_EOL)
413 			return (G3CODE_EOL);
414 		sp->b.bit = state;
415 		action = RUNLENGTH(action - ACT_WRUNT);
416 		runlen += action;
417 		if (action < 64)
418 			return (runlen);
419 	}
420 	/*NOTREACHED*/
421 }
422 
423 /*
424  * Decode a run of black.
425  */
426 static int
decode_black_run(tif)427 decode_black_run(tif)
428 	TIFF *tif;
429 {
430 	Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
431 	short state = sp->b.bit + 8;
432 	short action;
433 	int runlen = 0;
434 
435 	for (;;) {
436 		if (sp->b.bit == 0) {
437 	nextbyte:
438 			if (tif->tif_rawcc <= 0)
439 				return (G3CODE_EOF);
440 			sp->b.data = fetchByte(tif, sp);
441 		}
442 		action = TIFFFax1DAction[state][sp->b.data];
443 		state = TIFFFax1DNextState[state][sp->b.data];
444 		if (action == ACT_INCOMP)
445 			goto nextbyte;
446 		if (action == ACT_INVALID)
447 			return (G3CODE_INVALID);
448 		if (action == ACT_EOL)
449 			return (G3CODE_EOL);
450 		sp->b.bit = state;
451 		action = RUNLENGTH(action - ACT_BRUNT);
452 		runlen += action;
453 		if (action < 64)
454 			return (runlen);
455 		state += 8;
456 	}
457 	/*NOTREACHED*/
458 }
459 
460 /*
461  * Process one row of 1d Huffman-encoded data.
462  */
463 static int
Fax3Decode1DRow(tif,buf,npels)464 Fax3Decode1DRow(tif, buf, npels)
465 	TIFF *tif;
466 	u_char *buf;
467 	int npels;
468 {
469 	Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
470 	int x = 0;
471 	int runlen;
472 	short action;
473 	short color = sp->b.white;
474 	static char module[] = "Fax3Decode1D";
475 
476 	for (;;) {
477 		if (color == sp->b.white)
478 			runlen = decode_white_run(tif);
479 		else
480 			runlen = decode_black_run(tif);
481 		switch (runlen) {
482 		case G3CODE_EOF:
483 			TIFFError(module,
484 			    "%s: Premature EOF at scanline %d (x %d)",
485 			    tif->tif_name, tif->tif_row, x);
486 			return (0);
487 		case G3CODE_INVALID:	/* invalid code */
488 			/*
489 			 * An invalid code was encountered.
490 			 * Flush the remainder of the line
491 			 * and allow the caller to decide whether
492 			 * or not to continue.  Note that this
493 			 * only works if we have a G3 image
494 			 * with EOL markers.
495 			 */
496 			TIFFError(module,
497 			   "%s: Bad code word at scanline %d (x %d)",
498 			   tif->tif_name, tif->tif_row, x);
499 			goto done;
500 		case G3CODE_EOL:	/* premature end-of-line code */
501 			TIFFWarning(module,
502 			    "%s: Premature EOL at scanline %d (x %d)",
503 			    tif->tif_name, tif->tif_row, x);
504 			return (1);	/* try to resynchronize... */
505 		}
506 		if (x+runlen > npels)
507 			runlen = npels-x;
508 		if (runlen > 0) {
509 			if (color)
510 				fillspan((char *)buf, x, runlen);
511 			x += runlen;
512 			if (x >= npels)
513 				break;
514 		}
515 		color = !color;
516 	}
517 done:
518 	/*
519 	 * Cleanup at the end of the row.  This convoluted
520 	 * logic is merely so that we can reuse the code with
521 	 * two other related compression algorithms (2 & 32771).
522 	 *
523 	 * Note also that our handling of word alignment assumes
524 	 * that the buffer is at least word aligned.  This is
525 	 * the case for most all versions of malloc (typically
526 	 * the buffer is returned longword aligned).
527 	 */
528 	if ((tif->tif_options & FAX3_NOEOL) == 0)
529 		skiptoeol(tif, 0);
530 	if (tif->tif_options & FAX3_BYTEALIGN)
531 		sp->b.bit = 0;
532 	if ((tif->tif_options & FAX3_WORDALIGN) && ((long)tif->tif_rawcp & 1))
533 		(void) fetchByte(tif, sp);
534 	return (x == npels);
535 }
536 
537 /*
538  * Group 3 2d Decoding support.
539  */
540 
541 /*
542  * Return the next uncompressed mode code word.
543  */
544 static int
decode_uncomp_code(tif)545 decode_uncomp_code(tif)
546 	TIFF *tif;
547 {
548 	Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
549 	short code;
550 
551 	do {
552 		if (sp->b.bit == 0 || sp->b.bit > 7) {
553 			if (tif->tif_rawcc <= 0)
554 				return (UNCOMP_EOF);
555 			sp->b.data = fetchByte(tif, sp);
556 		}
557 		code = TIFFFaxUncompAction[sp->b.bit][sp->b.data];
558 		sp->b.bit = TIFFFaxUncompNextState[sp->b.bit][sp->b.data];
559 	} while (code == ACT_INCOMP);
560 	return (code);
561 }
562 
563 /*
564  * Process one row of 2d encoded data.
565  */
566 int
Fax3Decode2DRow(tif,buf,npels)567 Fax3Decode2DRow(tif, buf, npels)
568 	TIFF *tif;
569 	u_char *buf;
570 	int npels;
571 {
572 #define	PIXEL(buf,ix)	((((buf)[(ix)>>3]) >> (7-((ix)&7))) & 1)
573 	Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
574 	int a0 = -1;
575 	int b1, b2;
576 	int run1, run2;		/* for horizontal mode */
577 	short mode;
578 	short color = sp->b.white;
579 	static char module[] = "Fax3Decode2D";
580 
581 	do {
582 		if (sp->b.bit == 0 || sp->b.bit > 7) {
583 			if (tif->tif_rawcc <= 0) {
584 			    TIFFError(module,
585 				"%s: Premature EOF at scanline %d",
586 			        tif->tif_name, tif->tif_row);
587 			    return (0);
588 			}
589 			sp->b.data = fetchByte(tif, sp);
590 		}
591 		mode = TIFFFax2DMode[sp->b.bit][sp->b.data];
592 		sp->b.bit = TIFFFax2DNextState[sp->b.bit][sp->b.data];
593 		switch (mode) {
594 		case MODE_NULL:
595 			break;
596 		case MODE_PASS:
597 			b2 = finddiff(sp->b.refline, a0, npels, !color);
598 			b1 = finddiff(sp->b.refline, b2, npels, color);
599 			b2 = finddiff(sp->b.refline, b1, npels, !color);
600 			if (color) {
601 				if (a0 < 0)
602 					a0 = 0;
603 				fillspan((char *)buf, a0, b2 - a0);
604 			}
605 			a0 = b2;
606 			break;
607 		case MODE_HORIZ:
608 			if (color == sp->b.white) {
609 				run1 = decode_white_run(tif);
610 				run2 = decode_black_run(tif);
611 			} else {
612 				run1 = decode_black_run(tif);
613 				run2 = decode_white_run(tif);
614 			}
615 			/*
616 			 * Do the appropriate fill.  Note that we exit
617 			 * this logic with the same color that we enter
618 			 * with since we do 2 fills.  This explains the
619 			 * somewhat obscure logic below.
620 			 */
621 			if (a0 < 0)
622 				a0 = 0;
623 			if (a0 + run1 > npels)
624 				run1 = npels - a0;
625 			if (color)
626 				fillspan((char *)buf, a0, run1);
627 			a0 += run1;
628 			if (a0 + run2 > npels)
629 				run2 = npels - a0;
630 			if (!color)
631 				fillspan((char *)buf, a0, run2);
632 			a0 += run2;
633 			break;
634 		case MODE_VERT_V0:
635 		case MODE_VERT_VR1:
636 		case MODE_VERT_VR2:
637 		case MODE_VERT_VR3:
638 		case MODE_VERT_VL1:
639 		case MODE_VERT_VL2:
640 		case MODE_VERT_VL3:
641 			b2 = finddiff(sp->b.refline, a0, npels, !color);
642 			b1 = finddiff(sp->b.refline, b2, npels, color);
643 			b1 += mode - MODE_VERT_V0;
644 			if (color) {
645 				if (a0 < 0)
646 					a0 = 0;
647 				fillspan((char *)buf, a0, b1 - a0);
648 			}
649 			color = !color;
650 			a0 = b1;
651 			break;
652 	        case MODE_UNCOMP:
653 			/*
654 			 * Uncompressed mode: select from the
655 			 * special set of code words.
656 			 */
657 			if (a0 < 0)
658 				a0 = 0;
659 			do {
660 				mode = decode_uncomp_code(tif);
661 				switch (mode) {
662 				case UNCOMP_RUN1:
663 				case UNCOMP_RUN2:
664 				case UNCOMP_RUN3:
665 				case UNCOMP_RUN4:
666 				case UNCOMP_RUN5:
667 					run1 = mode - UNCOMP_RUN0;
668 					fillspan((char *)buf, a0+run1-1, 1);
669 					a0 += run1;
670 					break;
671 				case UNCOMP_RUN6:
672 					a0 += 5;
673 					break;
674 				case UNCOMP_TRUN0:
675 				case UNCOMP_TRUN1:
676 				case UNCOMP_TRUN2:
677 				case UNCOMP_TRUN3:
678 				case UNCOMP_TRUN4:
679 					run1 = mode - UNCOMP_TRUN0;
680 					a0 += run1;
681 					color = nextbit(tif) ?
682 					    !sp->b.white : sp->b.white;
683 					break;
684 				case UNCOMP_INVALID:
685 					TIFFError(module,
686 				"%s: Bad uncompressed code word at scanline %d",
687 					    tif->tif_name, tif->tif_row);
688 					goto bad;
689 				case UNCOMP_EOF:
690 					TIFFError(module,
691 					    "%s: Premature EOF at scanline %d",
692 					    tif->tif_name, tif->tif_row);
693 					return (0);
694 				}
695 			} while (mode < UNCOMP_EXIT);
696 			break;
697 	        case MODE_ERROR_1:
698 			if ((tif->tif_options & FAX3_NOEOL) == 0) {
699 				TIFFWarning(module,
700 				    "%s: Premature EOL at scanline %d (x %d)",
701 				    tif->tif_name, tif->tif_row, a0);
702 				skiptoeol(tif, 7);	/* seen 7 0's already */
703 				return (1);		/* try to synchronize */
704 			}
705 			/* fall thru... */
706 	        case MODE_ERROR:
707 			TIFFError(module,
708 			    "%s: Bad 2D code word at scanline %d",
709 			    tif->tif_name, tif->tif_row);
710 			goto bad;
711 	        default:
712 			TIFFError(module,
713 			    "%s: Panic, bad decoding state at scanline %d",
714 			    tif->tif_name, tif->tif_row);
715 			return (0);
716 		}
717 	} while (a0 < npels);
718 bad:
719 	/*
720 	 * Cleanup at the end of row.  We check for
721 	 * EOL separately so that this code can be
722 	 * reused by the Group 4 decoding routine.
723 	 */
724 	if ((tif->tif_options & FAX3_NOEOL) == 0)
725 		skiptoeol(tif, 0);
726 	return (a0 >= npels);
727 #undef	PIXEL
728 }
729 
730 /*
731  * CCITT Group 3 FAX Encoding.
732  */
733 
734 /*
735  * Write a variable-length bit-value to
736  * the output stream.  Values are
737  * assumed to be at most 16 bits.
738  */
739 static void
putbits(tif,bits,length)740 putbits(tif, bits, length)
741 	TIFF *tif;
742 	u_int bits, length;
743 {
744 	Fax3BaseState *sp = (Fax3BaseState *)tif->tif_data;
745 	static const int mask[9] =
746 	    { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
747 
748 	while (length > sp->bit) {
749 		sp->data |= bits >> (length - sp->bit);
750 		length -= sp->bit;
751 		Fax3FlushBits(tif, sp);
752 	}
753 	sp->data |= (bits & mask[length]) << (sp->bit - length);
754 	sp->bit -= length;
755 	if (sp->bit == 0)
756 		Fax3FlushBits(tif, sp);
757 }
758 
759 /*
760  * Write a code to the output stream.
761  */
762 static void
putcode(tif,te)763 putcode(tif, te)
764 	TIFF *tif;
765 	tableentry const *te;
766 {
767 	putbits(tif, te->code, te->length);
768 }
769 
770 /*
771  * Write the sequence of codes that describes
772  * the specified span of zero's or one's.  The
773  * appropriate table that holds the make-up and
774  * terminating codes is supplied.
775  */
776 static void
putspan(tif,span,tab)777 putspan(tif, span, tab)
778 	TIFF *tif;
779 	int span;
780 	tableentry const *tab;
781 {
782 	while (span >= 2624) {
783 		tableentry const *te = &tab[63 + (2560>>6)];
784 		putcode(tif, te);
785 		span -= te->runlen;
786 	}
787 	if (span >= 64) {
788 		tableentry const *te = &tab[63 + (span>>6)];
789 		assert(te->runlen == 64*(span>>6));
790 		putcode(tif, te);
791 		span -= te->runlen;
792 	}
793 	putcode(tif, &tab[span]);
794 }
795 
796 /*
797  * Write an EOL code to the output stream.  The zero-fill
798  * logic for byte-aligning encoded scanlines is handled
799  * here.  We also handle writing the tag bit for the next
800  * scanline when doing 2d encoding.
801  */
802 void
Fax3PutEOL(tif)803 Fax3PutEOL(tif)
804 	TIFF *tif;
805 {
806 	Fax3BaseState *sp = (Fax3BaseState *)tif->tif_data;
807 
808 	if (tif->tif_dir.td_group3options & GROUP3OPT_FILLBITS) {
809 		/*
810 		 * Force bit alignment so EOL will terminate on
811 		 * a byte boundary.  That is, force the bit alignment
812 		 * to 16-12 = 4 before putting out the EOL code.
813 		 */
814 		int align = 8 - 4;
815 		if (align != sp->bit) {
816 			if (align > sp->bit)
817 				align = sp->bit + (8 - align);
818 			else
819 				align = sp->bit - align;
820 			putbits(tif, 0, align);
821 		}
822 	}
823 	putbits(tif, EOL, 12);
824 	if (is2DEncoding(tif))
825 		putbits(tif, sp->tag == G3_1D, 1);
826 }
827 
828 static const u_char zeroruns[256] = {
829     8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,	/* 0x00 - 0x0f */
830     3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,	/* 0x10 - 0x1f */
831     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	/* 0x20 - 0x2f */
832     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	/* 0x30 - 0x3f */
833     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	/* 0x40 - 0x4f */
834     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	/* 0x50 - 0x5f */
835     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	/* 0x60 - 0x6f */
836     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	/* 0x70 - 0x7f */
837     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0x80 - 0x8f */
838     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0x90 - 0x9f */
839     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0xa0 - 0xaf */
840     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0xb0 - 0xbf */
841     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0xc0 - 0xcf */
842     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0xd0 - 0xdf */
843     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0xe0 - 0xef */
844     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0xf0 - 0xff */
845 };
846 static const u_char oneruns[256] = {
847     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0x00 - 0x0f */
848     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0x10 - 0x1f */
849     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0x20 - 0x2f */
850     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0x30 - 0x3f */
851     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0x40 - 0x4f */
852     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0x50 - 0x5f */
853     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0x60 - 0x6f */
854     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* 0x70 - 0x7f */
855     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	/* 0x80 - 0x8f */
856     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	/* 0x90 - 0x9f */
857     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	/* 0xa0 - 0xaf */
858     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	/* 0xb0 - 0xbf */
859     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	/* 0xc0 - 0xcf */
860     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,	/* 0xd0 - 0xdf */
861     3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,	/* 0xe0 - 0xef */
862     4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8,	/* 0xf0 - 0xff */
863 };
864 
865 /*
866  * Reset encoding state at the start of a strip.
867  */
868 static
Fax3PreEncode(tif)869 Fax3PreEncode(tif)
870 	TIFF *tif;
871 {
872 	Fax3EncodeState *sp = (Fax3EncodeState *)tif->tif_data;
873 
874 	if (sp == NULL) {
875 		sp = (Fax3EncodeState *)Fax3SetupState(tif, sizeof (*sp));
876 		if (!sp)
877 			return (0);
878 		if (sp->b.white == 0) {
879 			sp->wruns = zeroruns;
880 			sp->bruns = oneruns;
881 		} else {
882 			sp->wruns = oneruns;
883 			sp->bruns = zeroruns;
884 		}
885 	}
886 	sp->b.bit = 8;
887 	sp->b.data = 0;
888 	sp->b.tag = G3_1D;
889 	/*
890 	 * This is necessary for Group 4; otherwise it isn't
891 	 * needed because the first scanline of each strip ends
892 	 * up being copied into the refline.
893 	 */
894 	if (sp->b.refline)
895 		bset(sp->b.refline, sp->b.rowbytes, sp->b.white ? 0xff : 0x00);
896 	if (is2DEncoding(tif)) {
897 		float res = tif->tif_dir.td_yresolution;
898 		/*
899 		 * The CCITT spec says that when doing 2d encoding, you
900 		 * should only do it on K consecutive scanlines, where K
901 		 * depends on the resolution of the image being encoded
902 		 * (2 for <= 200 lpi, 4 for > 200 lpi).  Since the directory
903 		 * code initializes td_yresolution to 0, this code will
904 		 * select a K of 2 unless the YResolution tag is set
905 		 * appropriately.  (Note also that we fudge a little here
906 		 * and use 150 lpi to avoid problems with units conversion.)
907 		 */
908 		if (tif->tif_dir.td_resolutionunit == RESUNIT_CENTIMETER)
909 			res = (res * .3937) / 2.54;	/* convert to inches */
910 		sp->maxk = (res > 150 ? 4 : 2);
911 		sp->k = sp->maxk-1;
912 	} else
913 		sp->k = sp->maxk = 0;
914 	return (1);
915 }
916 
917 /*
918  * 1d-encode a row of pixels.  The encoding is
919  * a sequence of all-white or all-black spans
920  * of pixels encoded with Huffman codes.
921  */
922 static int
Fax3Encode1DRow(tif,bp,bits)923 Fax3Encode1DRow(tif, bp, bits)
924 	TIFF *tif;
925 	u_char *bp;
926 	int bits;
927 {
928 	Fax3EncodeState *sp = (Fax3EncodeState *)tif->tif_data;
929 	int bs = 0, span;
930 
931 	for (;;) {
932 		span = findspan(&bp, bs, bits, sp->wruns);	/* white span */
933 		putspan(tif, span, TIFFFaxWhiteCodes);
934 		bs += span;
935 		if (bs >= bits)
936 			break;
937 		span = findspan(&bp, bs, bits, sp->bruns);	/* black span */
938 		putspan(tif, span, TIFFFaxBlackCodes);
939 		bs += span;
940 		if (bs >= bits)
941 			break;
942 	}
943 	return (1);
944 }
945 
946 static const tableentry horizcode =
947     { 3, 0x1 };		/* 001 */
948 static const tableentry passcode =
949     { 4, 0x1 };		/* 0001 */
950 static const tableentry vcodes[7] = {
951     { 7, 0x03 },	/* 0000 011 */
952     { 6, 0x03 },	/* 0000 11 */
953     { 3, 0x03 },	/* 011 */
954     { 1, 0x1 },		/* 1 */
955     { 3, 0x2 },		/* 010 */
956     { 6, 0x02 },	/* 0000 10 */
957     { 7, 0x02 }		/* 0000 010 */
958 };
959 
960 /*
961  * 2d-encode a row of pixels.  Consult the CCITT
962  * documentation for the algorithm.
963  */
964 int
Fax3Encode2DRow(tif,bp,rp,bits)965 Fax3Encode2DRow(tif, bp, rp, bits)
966 	TIFF *tif;
967 	u_char *bp, *rp;
968 	int bits;
969 {
970 #define	PIXEL(buf,ix)	((((buf)[(ix)>>3]) >> (7-((ix)&7))) & 1)
971 	short white = ((Fax3BaseState *)tif->tif_data)->white;
972 	int a0 = 0;
973 	int a1 = (PIXEL(bp, 0) != white ? 0 : finddiff(bp, 0, bits, white));
974 	int b1 = (PIXEL(rp, 0) != white ? 0 : finddiff(rp, 0, bits, white));
975 	int a2, b2;
976 
977 	for (;;) {
978 		b2 = finddiff(rp, b1, bits, PIXEL(rp,b1));
979 		if (b2 >= a1) {
980 			int d = b1 - a1;
981 			if (!(-3 <= d && d <= 3)) {	/* horizontal mode */
982 				a2 = finddiff(bp, a1, bits, PIXEL(bp,a1));
983 				putcode(tif, &horizcode);
984 				if (a0+a1 == 0 || PIXEL(bp, a0) == white) {
985 					putspan(tif, a1-a0, TIFFFaxWhiteCodes);
986 					putspan(tif, a2-a1, TIFFFaxBlackCodes);
987 				} else {
988 					putspan(tif, a1-a0, TIFFFaxBlackCodes);
989 					putspan(tif, a2-a1, TIFFFaxWhiteCodes);
990 				}
991 				a0 = a2;
992 			} else {			/* vertical mode */
993 				putcode(tif, &vcodes[d+3]);
994 				a0 = a1;
995 			}
996 		} else {				/* pass mode */
997 			putcode(tif, &passcode);
998 			a0 = b2;
999 		}
1000 		if (a0 >= bits)
1001 			break;
1002 		a1 = finddiff(bp, a0, bits, PIXEL(bp,a0));
1003 		b1 = finddiff(rp, a0, bits, !PIXEL(bp,a0));
1004 		b1 = finddiff(rp, b1, bits, PIXEL(bp,a0));
1005 	}
1006 	return (1);
1007 #undef PIXEL
1008 }
1009 
1010 /*
1011  * Encode a buffer of pixels.
1012  */
1013 static int
Fax3Encode(tif,bp,cc,s)1014 Fax3Encode(tif, bp, cc, s)
1015 	TIFF *tif;
1016 	u_char *bp;
1017 	int cc;
1018 	u_int s;
1019 {
1020 	Fax3EncodeState *sp = (Fax3EncodeState *)tif->tif_data;
1021 
1022 	while (cc > 0) {
1023 		Fax3PutEOL(tif);
1024 		if (is2DEncoding(tif)) {
1025 			if (sp->b.tag == G3_1D) {
1026 				if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
1027 					return (0);
1028 				sp->b.tag = G3_2D;
1029 			} else {
1030 				if (!Fax3Encode2DRow(tif, bp, sp->b.refline, sp->b.rowpixels))
1031 					return (0);
1032 				sp->k--;
1033 			}
1034 			if (sp->k == 0) {
1035 				sp->b.tag = G3_1D;
1036 				sp->k = sp->maxk-1;
1037 			} else
1038 				bcopy(bp, sp->b.refline, sp->b.rowbytes);
1039 		} else {
1040 			if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
1041 				return (0);
1042 		}
1043 		bp += sp->b.rowbytes;
1044 		cc -= sp->b.rowbytes;
1045 	}
1046 	return (1);
1047 }
1048 
1049 static int
Fax3PostEncode(tif)1050 Fax3PostEncode(tif)
1051 	TIFF *tif;
1052 {
1053 	Fax3BaseState *sp = (Fax3BaseState *)tif->tif_data;
1054 
1055 	if (sp->bit != 8)
1056 		Fax3FlushBits(tif, sp);
1057 	return (1);
1058 }
1059 
1060 static
Fax3Close(tif)1061 Fax3Close(tif)
1062 	TIFF *tif;
1063 {
1064 	if ((tif->tif_options & FAX3_CLASSF) == 0) {	/* append RTC */
1065 		int i;
1066 		for (i = 0; i < 6; i++)
1067 			Fax3PutEOL(tif);
1068 		(void) Fax3PostEncode(tif);
1069 	}
1070 }
1071 
1072 static
Fax3Cleanup(tif)1073 Fax3Cleanup(tif)
1074 	TIFF *tif;
1075 {
1076 	if (tif->tif_data) {
1077 		free(tif->tif_data);
1078 		tif->tif_data = NULL;
1079 	}
1080 }
1081 
1082 /*
1083  * Bit handling utilities.
1084  */
1085 
1086 /*
1087  * Find a span of ones or zeros using the supplied
1088  * table.  The byte-aligned start of the bit string
1089  * is supplied along with the start+end bit indices.
1090  * The table gives the number of consecutive ones or
1091  * zeros starting from the msb and is indexed by byte
1092  * value.
1093  */
1094 static int
findspan(bpp,bs,be,tab)1095 findspan(bpp, bs, be, tab)
1096 	u_char **bpp;
1097 	int bs, be;
1098 	register u_char const *tab;
1099 {
1100 	register u_char *bp = *bpp;
1101 	register int bits = be - bs;
1102 	register int n, span;
1103 
1104 	/*
1105 	 * Check partial byte on lhs.
1106 	 */
1107 	if (bits > 0 && (n = (bs & 7))) {
1108 		span = tab[(*bp << n) & 0xff];
1109 		if (span > 8-n)		/* table value too generous */
1110 			span = 8-n;
1111 		if (span > bits)	/* constrain span to bit range */
1112 			span = bits;
1113 		if (n+span < 8)		/* doesn't extend to edge of byte */
1114 			goto done;
1115 		bits -= span;
1116 		bp++;
1117 	} else
1118 		span = 0;
1119 	/*
1120 	 * Scan full bytes for all 1's or all 0's.
1121 	 */
1122 	while (bits >= 8) {
1123 		n = tab[*bp];
1124 		span += n;
1125 		bits -= n;
1126 		if (n < 8)		/* end of run */
1127 			goto done;
1128 		bp++;
1129 	}
1130 	/*
1131 	 * Check partial byte on rhs.
1132 	 */
1133 	if (bits > 0) {
1134 		n = tab[*bp];
1135 		span += (n > bits ? bits : n);
1136 	}
1137 done:
1138 	*bpp = bp;
1139 	return (span);
1140 }
1141 
1142 /*
1143  * Return the offset of the next bit in the range
1144  * [bs..be] that is different from the specified
1145  * color.  The end, be, is returned if no such bit
1146  * exists.
1147  */
1148 static int
finddiff(cp,bs,be,color)1149 finddiff(cp, bs, be, color)
1150 	u_char *cp;
1151 	int bs, be, color;
1152 {
1153 	cp += bs >> 3;			/* adjust byte offset */
1154 	return (bs + findspan(&cp, bs, be, color ? oneruns : zeroruns));
1155 }
1156