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