]> 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
doc view code inteprets wxSTREAM_EOF as correct,
[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
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
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
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
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
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
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(nruns*sizeof (uint16));
503 if (dsp->runs == NULL) {
504 TIFFError("Fax3SetupState",
505 "%s: No space for Group 3/4 run arrays",
506 tif->tif_name);
507 return (0);
508 }
509 dsp->curruns = dsp->runs;
510 if (needsRefLine)
511 dsp->refruns = dsp->runs + (nruns>>1);
512 else
513 dsp->refruns = NULL;
514 if (is2DEncoding(dsp)) { /* NB: default is 1D routine */
515 tif->tif_decoderow = Fax3Decode2D;
516 tif->tif_decodestrip = Fax3Decode2D;
517 tif->tif_decodetile = Fax3Decode2D;
518 }
519 } else if (needsRefLine) { /* 2d encoding */
520 Fax3EncodeState* esp = EncoderState(tif);
521 /*
522 * 2d encoding requires a scanline
523 * buffer for the ``reference line''; the
524 * scanline against which delta encoding
525 * is referenced. The reference line must
526 * be initialized to be ``white'' (done elsewhere).
527 */
528 esp->refline = (u_char*) _TIFFmalloc(rowbytes);
529 if (esp->refline == NULL) {
530 TIFFError("Fax3SetupState",
531 "%s: No space for Group 3/4 reference line",
532 tif->tif_name);
533 return (0);
534 }
535 } else /* 1d encoding */
536 EncoderState(tif)->refline = NULL;
537 return (1);
538 }
539
540 /*
541 * CCITT Group 3 FAX Encoding.
542 */
543
544 #define Fax3FlushBits(tif, sp) { \
545 if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \
546 (void) TIFFFlushData1(tif); \
547 *(tif)->tif_rawcp++ = (sp)->data; \
548 (tif)->tif_rawcc++; \
549 (sp)->data = 0, (sp)->bit = 8; \
550 }
551 #define _FlushBits(tif) { \
552 if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \
553 (void) TIFFFlushData1(tif); \
554 *(tif)->tif_rawcp++ = data; \
555 (tif)->tif_rawcc++; \
556 data = 0, bit = 8; \
557 }
558 static const int _msbmask[9] =
559 { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
560 #define _PutBits(tif, bits, length) { \
561 while (length > bit) { \
562 data |= bits >> (length - bit); \
563 length -= bit; \
564 _FlushBits(tif); \
565 } \
566 data |= (bits & _msbmask[length]) << (bit - length); \
567 bit -= length; \
568 if (bit == 0) \
569 _FlushBits(tif); \
570 }
571
572 /*
573 * Write a variable-length bit-value to
574 * the output stream. Values are
575 * assumed to be at most 16 bits.
576 */
577 static void
578 Fax3PutBits(TIFF* tif, u_int bits, u_int length)
579 {
580 Fax3EncodeState* sp = EncoderState(tif);
581 int bit = sp->bit;
582 int data = sp->data;
583
584 _PutBits(tif, bits, length);
585
586 sp->data = data;
587 sp->bit = bit;
588 }
589
590 /*
591 * Write a code to the output stream.
592 */
593 #define putcode(tif, te) Fax3PutBits(tif, (te)->code, (te)->length)
594
595 #ifdef FAX3_DEBUG
596 #define DEBUG_COLOR(w) (tab == TIFFFaxWhiteCodes ? w "W" : w "B")
597 #define DEBUG_PRINT(what,len) { \
598 int t; \
599 printf("%08X/%-2d: %s%5d\t", data, bit, DEBUG_COLOR(what), len); \
600 for (t = length-1; t >= 0; t--) \
601 putchar(code & (1<<t) ? '1' : '0'); \
602 putchar('\n'); \
603 }
604 #endif
605
606 /*
607 * Write the sequence of codes that describes
608 * the specified span of zero's or one's. The
609 * appropriate table that holds the make-up and
610 * terminating codes is supplied.
611 */
612 static void
613 putspan(TIFF* tif, int32 span, const tableentry* tab)
614 {
615 Fax3EncodeState* sp = EncoderState(tif);
616 int bit = sp->bit;
617 int data = sp->data;
618 u_int code, length;
619
620 while (span >= 2624) {
621 const tableentry* te = &tab[63 + (2560>>6)];
622 code = te->code, length = te->length;
623 #ifdef FAX3_DEBUG
624 DEBUG_PRINT("MakeUp", te->runlen);
625 #endif
626 _PutBits(tif, code, length);
627 span -= te->runlen;
628 }
629 if (span >= 64) {
630 const tableentry* te = &tab[63 + (span>>6)];
631 assert(te->runlen == 64*(span>>6));
632 code = te->code, length = te->length;
633 #ifdef FAX3_DEBUG
634 DEBUG_PRINT("MakeUp", te->runlen);
635 #endif
636 _PutBits(tif, code, length);
637 span -= te->runlen;
638 }
639 code = tab[span].code, length = tab[span].length;
640 #ifdef FAX3_DEBUG
641 DEBUG_PRINT(" Term", tab[span].runlen);
642 #endif
643 _PutBits(tif, code, length);
644
645 sp->data = data;
646 sp->bit = bit;
647 }
648
649 /*
650 * Write an EOL code to the output stream. The zero-fill
651 * logic for byte-aligning encoded scanlines is handled
652 * here. We also handle writing the tag bit for the next
653 * scanline when doing 2d encoding.
654 */
655 static void
656 Fax3PutEOL(TIFF* tif)
657 {
658 Fax3EncodeState* sp = EncoderState(tif);
659 int bit = sp->bit;
660 int data = sp->data;
661 u_int code, length;
662
663 if (sp->b.groupoptions & GROUP3OPT_FILLBITS) {
664 /*
665 * Force bit alignment so EOL will terminate on
666 * a byte boundary. That is, force the bit alignment
667 * to 16-12 = 4 before putting out the EOL code.
668 */
669 int align = 8 - 4;
670 if (align != sp->bit) {
671 if (align > sp->bit)
672 align = sp->bit + (8 - align);
673 else
674 align = sp->bit - align;
675 code = 0;
676 _PutBits(tif, 0, align);
677 }
678 }
679 code = EOL, length = 12;
680 if (is2DEncoding(sp))
681 code = (code<<1) | (sp->tag == G3_1D), length++;
682 _PutBits(tif, code, length);
683
684 sp->data = data;
685 sp->bit = bit;
686 }
687
688 /*
689 * Reset encoding state at the start of a strip.
690 */
691 static int
692 Fax3PreEncode(TIFF* tif, tsample_t s)
693 {
694 Fax3EncodeState* sp = EncoderState(tif);
695
696 (void) s;
697 assert(sp != NULL);
698 sp->bit = 8;
699 sp->data = 0;
700 sp->tag = G3_1D;
701 /*
702 * This is necessary for Group 4; otherwise it isn't
703 * needed because the first scanline of each strip ends
704 * up being copied into the refline.
705 */
706 if (sp->refline)
707 _TIFFmemset(sp->refline, 0x00, sp->b.rowbytes);
708 if (is2DEncoding(sp)) {
709 float res = tif->tif_dir.td_yresolution;
710 /*
711 * The CCITT spec says that when doing 2d encoding, you
712 * should only do it on K consecutive scanlines, where K
713 * depends on the resolution of the image being encoded
714 * (2 for <= 200 lpi, 4 for > 200 lpi). Since the directory
715 * code initializes td_yresolution to 0, this code will
716 * select a K of 2 unless the YResolution tag is set
717 * appropriately. (Note also that we fudge a little here
718 * and use 150 lpi to avoid problems with units conversion.)
719 */
720 if (tif->tif_dir.td_resolutionunit == RESUNIT_CENTIMETER)
721 res *= 2.54f; /* convert to inches */
722 sp->maxk = (res > 150 ? 4 : 2);
723 sp->k = sp->maxk-1;
724 } else
725 sp->k = sp->maxk = 0;
726 return (1);
727 }
728
729 static const u_char zeroruns[256] = {
730 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, /* 0x00 - 0x0f */
731 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0x10 - 0x1f */
732 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x20 - 0x2f */
733 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x30 - 0x3f */
734 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 - 0x4f */
735 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x50 - 0x5f */
736 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 - 0x6f */
737 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x70 - 0x7f */
738 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x80 - 0x8f */
739 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x90 - 0x9f */
740 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xa0 - 0xaf */
741 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xb0 - 0xbf */
742 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xc0 - 0xcf */
743 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xd0 - 0xdf */
744 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe0 - 0xef */
745 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xf0 - 0xff */
746 };
747 static const u_char oneruns[256] = {
748 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 - 0x0f */
749 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 - 0x1f */
750 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 - 0x2f */
751 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 - 0x3f */
752 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 - 0x4f */
753 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 - 0x5f */
754 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 - 0x6f */
755 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x70 - 0x7f */
756 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x80 - 0x8f */
757 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x90 - 0x9f */
758 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xa0 - 0xaf */
759 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xb0 - 0xbf */
760 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xc0 - 0xcf */
761 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xd0 - 0xdf */
762 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xe0 - 0xef */
763 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8, /* 0xf0 - 0xff */
764 };
765
766 /*
767 * On certain systems it pays to inline
768 * the routines that find pixel spans.
769 */
770 #ifdef VAXC
771 static int32 find0span(u_char*, int32, int32);
772 static int32 find1span(u_char*, int32, int32);
773 #pragma inline(find0span,find1span)
774 #endif
775
776 /*
777 * Find a span of ones or zeros using the supplied
778 * table. The ``base'' of the bit string is supplied
779 * along with the start+end bit indices.
780 */
781 INLINE static int32
782 find0span(u_char* bp, int32 bs, int32 be)
783 {
784 int32 bits = be - bs;
785 int32 n, span;
786
787 bp += bs>>3;
788 /*
789 * Check partial byte on lhs.
790 */
791 if (bits > 0 && (n = (bs & 7))) {
792 span = zeroruns[(*bp << n) & 0xff];
793 if (span > 8-n) /* table value too generous */
794 span = 8-n;
795 if (span > bits) /* constrain span to bit range */
796 span = bits;
797 if (n+span < 8) /* doesn't extend to edge of byte */
798 return (span);
799 bits -= span;
800 bp++;
801 } else
802 span = 0;
803 if (bits >= 2*8*sizeof (long)) {
804 long* lp;
805 /*
806 * Align to longword boundary and check longwords.
807 */
808 while (!isAligned(bp, long)) {
809 if (*bp != 0x00)
810 return (span + zeroruns[*bp]);
811 span += 8, bits -= 8;
812 bp++;
813 }
814 lp = (long*) bp;
815 while (bits >= 8*sizeof (long) && *lp == 0) {
816 span += 8*sizeof (long), bits -= 8*sizeof (long);
817 lp++;
818 }
819 bp = (u_char*) lp;
820 }
821 /*
822 * Scan full bytes for all 0's.
823 */
824 while (bits >= 8) {
825 if (*bp != 0x00) /* end of run */
826 return (span + zeroruns[*bp]);
827 span += 8, bits -= 8;
828 bp++;
829 }
830 /*
831 * Check partial byte on rhs.
832 */
833 if (bits > 0) {
834 n = zeroruns[*bp];
835 span += (n > bits ? bits : n);
836 }
837 return (span);
838 }
839
840 INLINE static int32
841 find1span(u_char* bp, int32 bs, int32 be)
842 {
843 int32 bits = be - bs;
844 int32 n, span;
845
846 bp += bs>>3;
847 /*
848 * Check partial byte on lhs.
849 */
850 if (bits > 0 && (n = (bs & 7))) {
851 span = oneruns[(*bp << n) & 0xff];
852 if (span > 8-n) /* table value too generous */
853 span = 8-n;
854 if (span > bits) /* constrain span to bit range */
855 span = bits;
856 if (n+span < 8) /* doesn't extend to edge of byte */
857 return (span);
858 bits -= span;
859 bp++;
860 } else
861 span = 0;
862 if (bits >= 2*8*sizeof (long)) {
863 long* lp;
864 /*
865 * Align to longword boundary and check longwords.
866 */
867 while (!isAligned(bp, long)) {
868 if (*bp != 0xff)
869 return (span + oneruns[*bp]);
870 span += 8, bits -= 8;
871 bp++;
872 }
873 lp = (long*) bp;
874 while (bits >= 8*sizeof (long) && *lp == ~0) {
875 span += 8*sizeof (long), bits -= 8*sizeof (long);
876 lp++;
877 }
878 bp = (u_char*) lp;
879 }
880 /*
881 * Scan full bytes for all 1's.
882 */
883 while (bits >= 8) {
884 if (*bp != 0xff) /* end of run */
885 return (span + oneruns[*bp]);
886 span += 8, bits -= 8;
887 bp++;
888 }
889 /*
890 * Check partial byte on rhs.
891 */
892 if (bits > 0) {
893 n = oneruns[*bp];
894 span += (n > bits ? bits : n);
895 }
896 return (span);
897 }
898
899 /*
900 * Return the offset of the next bit in the range
901 * [bs..be] that is different from the specified
902 * color. The end, be, is returned if no such bit
903 * exists.
904 */
905 #define finddiff(_cp, _bs, _be, _color) \
906 (_bs + (_color ? find1span(_cp,_bs,_be) : find0span(_cp,_bs,_be)))
907 /*
908 * Like finddiff, but also check the starting bit
909 * against the end in case start > end.
910 */
911 #define finddiff2(_cp, _bs, _be, _color) \
912 (_bs < _be ? finddiff(_cp,_bs,_be,_color) : _be)
913
914 /*
915 * 1d-encode a row of pixels. The encoding is
916 * a sequence of all-white or all-black spans
917 * of pixels encoded with Huffman codes.
918 */
919 static int
920 Fax3Encode1DRow(TIFF* tif, u_char* bp, uint32 bits)
921 {
922 Fax3EncodeState* sp = EncoderState(tif);
923 int32 bs = 0, span;
924
925 for (;;) {
926 span = find0span(bp, bs, bits); /* white span */
927 putspan(tif, span, TIFFFaxWhiteCodes);
928 bs += span;
929 if (bs >= bits)
930 break;
931 span = find1span(bp, bs, bits); /* black span */
932 putspan(tif, span, TIFFFaxBlackCodes);
933 bs += span;
934 if (bs >= bits)
935 break;
936 }
937 if (sp->b.mode & (FAXMODE_BYTEALIGN|FAXMODE_WORDALIGN)) {
938 if (sp->bit != 8) /* byte-align */
939 Fax3FlushBits(tif, sp);
940 if ((sp->b.mode&FAXMODE_WORDALIGN) &&
941 !isAligned(tif->tif_rawcp, uint16))
942 Fax3FlushBits(tif, sp);
943 }
944 return (1);
945 }
946
947 static const tableentry horizcode =
948 { 3, 0x1 }; /* 001 */
949 static const tableentry passcode =
950 { 4, 0x1 }; /* 0001 */
951 static const tableentry vcodes[7] = {
952 { 7, 0x03 }, /* 0000 011 */
953 { 6, 0x03 }, /* 0000 11 */
954 { 3, 0x03 }, /* 011 */
955 { 1, 0x1 }, /* 1 */
956 { 3, 0x2 }, /* 010 */
957 { 6, 0x02 }, /* 0000 10 */
958 { 7, 0x02 } /* 0000 010 */
959 };
960
961 /*
962 * 2d-encode a row of pixels. Consult the CCITT
963 * documentation for the algorithm.
964 */
965 static int
966 Fax3Encode2DRow(TIFF* tif, u_char* bp, u_char* rp, uint32 bits)
967 {
968 #define PIXEL(buf,ix) ((((buf)[(ix)>>3]) >> (7-((ix)&7))) & 1)
969 int32 a0 = 0;
970 int32 a1 = (PIXEL(bp, 0) != 0 ? 0 : finddiff(bp, 0, bits, 0));
971 int32 b1 = (PIXEL(rp, 0) != 0 ? 0 : finddiff(rp, 0, bits, 0));
972 int32 a2, b2;
973
974 for (;;) {
975 b2 = finddiff2(rp, b1, bits, PIXEL(rp,b1));
976 if (b2 >= a1) {
977 int32 d = b1 - a1;
978 if (!(-3 <= d && d <= 3)) { /* horizontal mode */
979 a2 = finddiff2(bp, a1, bits, PIXEL(bp,a1));
980 putcode(tif, &horizcode);
981 if (a0+a1 == 0 || PIXEL(bp, a0) == 0) {
982 putspan(tif, a1-a0, TIFFFaxWhiteCodes);
983 putspan(tif, a2-a1, TIFFFaxBlackCodes);
984 } else {
985 putspan(tif, a1-a0, TIFFFaxBlackCodes);
986 putspan(tif, a2-a1, TIFFFaxWhiteCodes);
987 }
988 a0 = a2;
989 } else { /* vertical mode */
990 putcode(tif, &vcodes[d+3]);
991 a0 = a1;
992 }
993 } else { /* pass mode */
994 putcode(tif, &passcode);
995 a0 = b2;
996 }
997 if (a0 >= bits)
998 break;
999 a1 = finddiff(bp, a0, bits, PIXEL(bp,a0));
1000 b1 = finddiff(rp, a0, bits, !PIXEL(bp,a0));
1001 b1 = finddiff(rp, b1, bits, PIXEL(bp,a0));
1002 }
1003 return (1);
1004 #undef PIXEL
1005 }
1006
1007 /*
1008 * Encode a buffer of pixels.
1009 */
1010 static int
1011 Fax3Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
1012 {
1013 Fax3EncodeState* sp = EncoderState(tif);
1014
1015 (void) s;
1016 while ((long)cc > 0) {
1017 if ((sp->b.mode & FAXMODE_NOEOL) == 0)
1018 Fax3PutEOL(tif);
1019 if (is2DEncoding(sp)) {
1020 if (sp->tag == G3_1D) {
1021 if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
1022 return (0);
1023 sp->tag = G3_2D;
1024 } else {
1025 if (!Fax3Encode2DRow(tif, bp, sp->refline, sp->b.rowpixels))
1026 return (0);
1027 sp->k--;
1028 }
1029 if (sp->k == 0) {
1030 sp->tag = G3_1D;
1031 sp->k = sp->maxk-1;
1032 } else
1033 _TIFFmemcpy(sp->refline, bp, sp->b.rowbytes);
1034 } else {
1035 if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
1036 return (0);
1037 }
1038 bp += sp->b.rowbytes;
1039 cc -= sp->b.rowbytes;
1040 if (cc != 0)
1041 tif->tif_row++;
1042 }
1043 return (1);
1044 }
1045
1046 static int
1047 Fax3PostEncode(TIFF* tif)
1048 {
1049 Fax3EncodeState* sp = EncoderState(tif);
1050
1051 if (sp->bit != 8)
1052 Fax3FlushBits(tif, sp);
1053 return (1);
1054 }
1055
1056 static void
1057 Fax3Close(TIFF* tif)
1058 {
1059 if ((Fax3State(tif)->mode & FAXMODE_NORTC) == 0) {
1060 Fax3EncodeState* sp = EncoderState(tif);
1061 u_int code = EOL;
1062 u_int length = 12;
1063 int i;
1064
1065 if (is2DEncoding(sp))
1066 code = (code<<1) | (sp->tag == G3_1D), length++;
1067 for (i = 0; i < 6; i++)
1068 Fax3PutBits(tif, code, length);
1069 Fax3FlushBits(tif, sp);
1070 }
1071 }
1072
1073 static void
1074 Fax3Cleanup(TIFF* tif)
1075 {
1076 if (tif->tif_data) {
1077 if (tif->tif_mode == O_RDONLY) {
1078 Fax3DecodeState* sp = DecoderState(tif);
1079 if (sp->runs)
1080 _TIFFfree(sp->runs);
1081 } else {
1082 Fax3EncodeState* sp = EncoderState(tif);
1083 if (sp->refline)
1084 _TIFFfree(sp->refline);
1085 }
1086 if (Fax3State(tif)->subaddress)
1087 _TIFFfree(Fax3State(tif)->subaddress);
1088 _TIFFfree(tif->tif_data);
1089 tif->tif_data = NULL;
1090 }
1091 }
1092
1093 #define FIELD_BADFAXLINES (FIELD_CODEC+0)
1094 #define FIELD_CLEANFAXDATA (FIELD_CODEC+1)
1095 #define FIELD_BADFAXRUN (FIELD_CODEC+2)
1096 #define FIELD_RECVPARAMS (FIELD_CODEC+3)
1097 #define FIELD_SUBADDRESS (FIELD_CODEC+4)
1098 #define FIELD_RECVTIME (FIELD_CODEC+5)
1099
1100 #define FIELD_OPTIONS (FIELD_CODEC+6)
1101
1102 static const TIFFFieldInfo faxFieldInfo[] = {
1103 { TIFFTAG_FAXMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO,
1104 FALSE, FALSE, "FaxMode" },
1105 { TIFFTAG_FAXFILLFUNC, 0, 0, TIFF_ANY, FIELD_PSEUDO,
1106 FALSE, FALSE, "FaxFillFunc" },
1107 { TIFFTAG_BADFAXLINES, 1, 1, TIFF_LONG, FIELD_BADFAXLINES,
1108 TRUE, FALSE, "BadFaxLines" },
1109 { TIFFTAG_BADFAXLINES, 1, 1, TIFF_SHORT, FIELD_BADFAXLINES,
1110 TRUE, FALSE, "BadFaxLines" },
1111 { TIFFTAG_CLEANFAXDATA, 1, 1, TIFF_SHORT, FIELD_CLEANFAXDATA,
1112 TRUE, FALSE, "CleanFaxData" },
1113 { TIFFTAG_CONSECUTIVEBADFAXLINES,1,1, TIFF_LONG, FIELD_BADFAXRUN,
1114 TRUE, FALSE, "ConsecutiveBadFaxLines" },
1115 { TIFFTAG_CONSECUTIVEBADFAXLINES,1,1, TIFF_SHORT, FIELD_BADFAXRUN,
1116 TRUE, FALSE, "ConsecutiveBadFaxLines" },
1117 { TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, FIELD_RECVPARAMS,
1118 TRUE, FALSE, "FaxRecvParams" },
1119 { TIFFTAG_FAXSUBADDRESS, -1,-1, TIFF_ASCII, FIELD_SUBADDRESS,
1120 TRUE, FALSE, "FaxSubAddress" },
1121 { TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, FIELD_RECVTIME,
1122 TRUE, FALSE, "FaxRecvTime" },
1123 };
1124 static const TIFFFieldInfo fax3FieldInfo[] = {
1125 { TIFFTAG_GROUP3OPTIONS, 1, 1, TIFF_LONG, FIELD_OPTIONS,
1126 FALSE, FALSE, "Group3Options" },
1127 };
1128 static const TIFFFieldInfo fax4FieldInfo[] = {
1129 { TIFFTAG_GROUP4OPTIONS, 1, 1, TIFF_LONG, FIELD_OPTIONS,
1130 FALSE, FALSE, "Group4Options" },
1131 };
1132 #define N(a) (sizeof (a) / sizeof (a[0]))
1133
1134 static int
1135 Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap)
1136 {
1137 Fax3BaseState* sp = Fax3State(tif);
1138
1139 switch (tag) {
1140 case TIFFTAG_FAXMODE:
1141 sp->mode = va_arg(ap, int);
1142 return (1); /* NB: pseudo tag */
1143 case TIFFTAG_FAXFILLFUNC:
1144 if (tif->tif_mode == O_RDONLY)
1145 DecoderState(tif)->fill = va_arg(ap, TIFFFaxFillFunc);
1146 return (1); /* NB: pseudo tag */
1147 case TIFFTAG_GROUP3OPTIONS:
1148 case TIFFTAG_GROUP4OPTIONS:
1149 sp->groupoptions = va_arg(ap, uint32);
1150 break;
1151 case TIFFTAG_BADFAXLINES:
1152 sp->badfaxlines = va_arg(ap, uint32);
1153 break;
1154 case TIFFTAG_CLEANFAXDATA:
1155 sp->cleanfaxdata = (uint16) va_arg(ap, int);
1156 break;
1157 case TIFFTAG_CONSECUTIVEBADFAXLINES:
1158 sp->badfaxrun = va_arg(ap, uint32);
1159 break;
1160 case TIFFTAG_FAXRECVPARAMS:
1161 sp->recvparams = va_arg(ap, uint32);
1162 break;
1163 case TIFFTAG_FAXSUBADDRESS:
1164 _TIFFsetString(&sp->subaddress, va_arg(ap, char*));
1165 break;
1166 case TIFFTAG_FAXRECVTIME:
1167 sp->recvtime = va_arg(ap, uint32);
1168 break;
1169 default:
1170 return (*sp->vsetparent)(tif, tag, ap);
1171 }
1172 TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit);
1173 tif->tif_flags |= TIFF_DIRTYDIRECT;
1174 return (1);
1175 }
1176
1177 static int
1178 Fax3VGetField(TIFF* tif, ttag_t tag, va_list ap)
1179 {
1180 Fax3BaseState* sp = Fax3State(tif);
1181
1182 switch (tag) {
1183 case TIFFTAG_FAXMODE:
1184 *va_arg(ap, int*) = sp->mode;
1185 break;
1186 case TIFFTAG_FAXFILLFUNC:
1187 if (tif->tif_mode == O_RDONLY)
1188 *va_arg(ap, TIFFFaxFillFunc*) = DecoderState(tif)->fill;
1189 break;
1190 case TIFFTAG_GROUP3OPTIONS:
1191 case TIFFTAG_GROUP4OPTIONS:
1192 *va_arg(ap, uint32*) = sp->groupoptions;
1193 break;
1194 case TIFFTAG_BADFAXLINES:
1195 *va_arg(ap, uint32*) = sp->badfaxlines;
1196 break;
1197 case TIFFTAG_CLEANFAXDATA:
1198 *va_arg(ap, uint16*) = sp->cleanfaxdata;
1199 break;
1200 case TIFFTAG_CONSECUTIVEBADFAXLINES:
1201 *va_arg(ap, uint32*) = sp->badfaxrun;
1202 break;
1203 case TIFFTAG_FAXRECVPARAMS:
1204 *va_arg(ap, uint32*) = sp->recvparams;
1205 break;
1206 case TIFFTAG_FAXSUBADDRESS:
1207 *va_arg(ap, char**) = sp->subaddress;
1208 break;
1209 case TIFFTAG_FAXRECVTIME:
1210 *va_arg(ap, uint32*) = sp->recvtime;
1211 break;
1212 default:
1213 return (*sp->vgetparent)(tif, tag, ap);
1214 }
1215 return (1);
1216 }
1217
1218 static void
1219 Fax3PrintDir(TIFF* tif, FILE* fd, long flags)
1220 {
1221 Fax3BaseState* sp = Fax3State(tif);
1222
1223 (void) flags;
1224 if (TIFFFieldSet(tif,FIELD_OPTIONS)) {
1225 const char* sep = " ";
1226 if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX4) {
1227 fprintf(fd, " Group 4 Options:");
1228 if (sp->groupoptions & GROUP4OPT_UNCOMPRESSED)
1229 fprintf(fd, "%suncompressed data", sep);
1230 } else {
1231
1232 fprintf(fd, " Group 3 Options:");
1233 if (sp->groupoptions & GROUP3OPT_2DENCODING)
1234 fprintf(fd, "%s2-d encoding", sep), sep = "+";
1235 if (sp->groupoptions & GROUP3OPT_FILLBITS)
1236 fprintf(fd, "%sEOL padding", sep), sep = "+";
1237 if (sp->groupoptions & GROUP3OPT_UNCOMPRESSED)
1238 fprintf(fd, "%suncompressed data", sep);
1239 }
1240 fprintf(fd, " (%lu = 0x%lx)\n",
1241 (u_long) sp->groupoptions, (u_long) sp->groupoptions);
1242 }
1243 if (TIFFFieldSet(tif,FIELD_CLEANFAXDATA)) {
1244 fprintf(fd, " Fax Data:");
1245 switch (sp->cleanfaxdata) {
1246 case CLEANFAXDATA_CLEAN:
1247 fprintf(fd, " clean");
1248 break;
1249 case CLEANFAXDATA_REGENERATED:
1250 fprintf(fd, " receiver regenerated");
1251 break;
1252 case CLEANFAXDATA_UNCLEAN:
1253 fprintf(fd, " uncorrected errors");
1254 break;
1255 }
1256 fprintf(fd, " (%u = 0x%x)\n",
1257 sp->cleanfaxdata, sp->cleanfaxdata);
1258 }
1259 if (TIFFFieldSet(tif,FIELD_BADFAXLINES))
1260 fprintf(fd, " Bad Fax Lines: %lu\n", (u_long) sp->badfaxlines);
1261 if (TIFFFieldSet(tif,FIELD_BADFAXRUN))
1262 fprintf(fd, " Consecutive Bad Fax Lines: %lu\n",
1263 (u_long) sp->badfaxrun);
1264 if (TIFFFieldSet(tif,FIELD_RECVPARAMS))
1265 fprintf(fd, " Fax Receive Parameters: %08lx\n",
1266 (u_long) sp->recvparams);
1267 if (TIFFFieldSet(tif,FIELD_SUBADDRESS))
1268 fprintf(fd, " Fax SubAddress: %s\n", sp->subaddress);
1269 if (TIFFFieldSet(tif,FIELD_RECVTIME))
1270 fprintf(fd, " Fax Receive Time: %lu secs\n",
1271 (u_long) sp->recvtime);
1272 }
1273
1274 static int
1275 InitCCITTFax3(TIFF* tif)
1276 {
1277 Fax3BaseState* sp;
1278
1279 /*
1280 * Allocate state block so tag methods have storage to record values.
1281 */
1282 if (tif->tif_mode == O_RDONLY)
1283 tif->tif_data = _TIFFmalloc(sizeof (Fax3DecodeState));
1284 else
1285 tif->tif_data = _TIFFmalloc(sizeof (Fax3EncodeState));
1286 if (tif->tif_data == NULL) {
1287 TIFFError("TIFFInitCCITTFax3",
1288 "%s: No space for state block", tif->tif_name);
1289 return (0);
1290 }
1291 sp = Fax3State(tif);
1292
1293 /*
1294 * Merge codec-specific tag information and
1295 * override parent get/set field methods.
1296 */
1297 _TIFFMergeFieldInfo(tif, faxFieldInfo, N(faxFieldInfo));
1298 sp->vgetparent = tif->tif_vgetfield;
1299 tif->tif_vgetfield = Fax3VGetField; /* hook for codec tags */
1300 sp->vsetparent = tif->tif_vsetfield;
1301 tif->tif_vsetfield = Fax3VSetField; /* hook for codec tags */
1302 tif->tif_printdir = Fax3PrintDir; /* hook for codec tags */
1303 sp->groupoptions = 0;
1304 sp->recvparams = 0;
1305 sp->subaddress = NULL;
1306
1307 if (tif->tif_mode == O_RDONLY) {
1308 tif->tif_flags |= TIFF_NOBITREV;/* decoder does bit reversal */
1309 DecoderState(tif)->runs = NULL;
1310 TIFFSetField(tif, TIFFTAG_FAXFILLFUNC, _TIFFFax3fillruns);
1311 } else
1312 EncoderState(tif)->refline = NULL;
1313
1314 /*
1315 * Install codec methods.
1316 */
1317 tif->tif_setupdecode = Fax3SetupState;
1318 tif->tif_predecode = Fax3PreDecode;
1319 tif->tif_decoderow = Fax3Decode1D;
1320 tif->tif_decodestrip = Fax3Decode1D;
1321 tif->tif_decodetile = Fax3Decode1D;
1322 tif->tif_setupencode = Fax3SetupState;
1323 tif->tif_preencode = Fax3PreEncode;
1324 tif->tif_postencode = Fax3PostEncode;
1325 tif->tif_encoderow = Fax3Encode;
1326 tif->tif_encodestrip = Fax3Encode;
1327 tif->tif_encodetile = Fax3Encode;
1328 tif->tif_close = Fax3Close;
1329 tif->tif_cleanup = Fax3Cleanup;
1330
1331 return (1);
1332 }
1333
1334 int
1335 TIFFInitCCITTFax3(TIFF* tif, int scheme)
1336 {
1337 if (InitCCITTFax3(tif)) {
1338 _TIFFMergeFieldInfo(tif, fax3FieldInfo, N(fax3FieldInfo));
1339
1340 /*
1341 * The default format is Class/F-style w/o RTC.
1342 */
1343 return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_CLASSF);
1344 } else
1345 return (0);
1346 }
1347
1348 /*
1349 * CCITT Group 4 (T.6) Facsimile-compatible
1350 * Compression Scheme Support.
1351 */
1352
1353 #define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; }
1354 /*
1355 * Decode the requested amount of G4-encoded data.
1356 */
1357 static int
1358 Fax4Decode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
1359 {
1360 DECLARE_STATE_2D(tif, sp, "Fax4Decode");
1361
1362 (void) s;
1363 CACHE_STATE(tif, sp);
1364 while ((long)occ > 0) {
1365 a0 = 0;
1366 RunLength = 0;
1367 pa = thisrun = sp->curruns;
1368 pb = sp->refruns;
1369 b1 = *pb++;
1370 #ifdef FAX3_DEBUG
1371 printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail);
1372 printf("-------------------- %d\n", tif->tif_row);
1373 fflush(stdout);
1374 #endif
1375 EXPAND2D(EOFG4);
1376 (*sp->fill)(buf, thisrun, pa, lastx);
1377 SETVAL(0); /* imaginary change for reference */
1378 SWAP(uint32*, sp->curruns, sp->refruns);
1379 buf += sp->b.rowbytes;
1380 occ -= sp->b.rowbytes;
1381 if (occ != 0)
1382 tif->tif_row++;
1383 continue;
1384 EOFG4:
1385 (*sp->fill)(buf, thisrun, pa, lastx);
1386 UNCACHE_STATE(tif, sp);
1387 return (-1);
1388 }
1389 UNCACHE_STATE(tif, sp);
1390 return (1);
1391 }
1392 #undef SWAP
1393
1394 /*
1395 * Encode the requested amount of data.
1396 */
1397 static int
1398 Fax4Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
1399 {
1400 Fax3EncodeState *sp = EncoderState(tif);
1401
1402 (void) s;
1403 while ((long)cc > 0) {
1404 if (!Fax3Encode2DRow(tif, bp, sp->refline, sp->b.rowpixels))
1405 return (0);
1406 _TIFFmemcpy(sp->refline, bp, sp->b.rowbytes);
1407 bp += sp->b.rowbytes;
1408 cc -= sp->b.rowbytes;
1409 if (cc != 0)
1410 tif->tif_row++;
1411 }
1412 return (1);
1413 }
1414
1415 static int
1416 Fax4PostEncode(TIFF* tif)
1417 {
1418 Fax3EncodeState *sp = EncoderState(tif);
1419
1420 /* terminate strip w/ EOFB */
1421 Fax3PutBits(tif, EOL, 12);
1422 Fax3PutBits(tif, EOL, 12);
1423 if (sp->bit != 8)
1424 Fax3FlushBits(tif, sp);
1425 return (1);
1426 }
1427
1428 int
1429 TIFFInitCCITTFax4(TIFF* tif, int scheme)
1430 {
1431 if (InitCCITTFax3(tif)) { /* reuse G3 support */
1432 _TIFFMergeFieldInfo(tif, fax4FieldInfo, N(fax4FieldInfo));
1433
1434 tif->tif_decoderow = Fax4Decode;
1435 tif->tif_decodestrip = Fax4Decode;
1436 tif->tif_decodetile = Fax4Decode;
1437 tif->tif_encoderow = Fax4Encode;
1438 tif->tif_encodestrip = Fax4Encode;
1439 tif->tif_encodetile = Fax4Encode;
1440 tif->tif_postencode = Fax4PostEncode;
1441 /*
1442 * Suppress RTC at the end of each strip.
1443 */
1444 return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_NORTC);
1445 } else
1446 return (0);
1447 }
1448
1449 /*
1450 * CCITT Group 3 1-D Modified Huffman RLE Compression Support.
1451 * (Compression algorithms 2 and 32771)
1452 */
1453
1454 /*
1455 * Decode the requested amount of RLE-encoded data.
1456 */
1457 static int
1458 Fax3DecodeRLE(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
1459 {
1460 DECLARE_STATE(tif, sp, "Fax3DecodeRLE");
1461 int mode = sp->b.mode;
1462
1463 (void) s;
1464 CACHE_STATE(tif, sp);
1465 thisrun = sp->curruns;
1466 while ((long)occ > 0) {
1467 a0 = 0;
1468 RunLength = 0;
1469 pa = thisrun;
1470 #ifdef FAX3_DEBUG
1471 printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail);
1472 printf("-------------------- %d\n", tif->tif_row);
1473 fflush(stdout);
1474 #endif
1475 EXPAND1D(EOFRLE);
1476 (*sp->fill)(buf, thisrun, pa, lastx);
1477 /*
1478 * Cleanup at the end of the row.
1479 */
1480 if (mode & FAXMODE_BYTEALIGN) {
1481 int n = BitsAvail - (BitsAvail &~ 7);
1482 ClrBits(n);
1483 } else if (mode & FAXMODE_WORDALIGN) {
1484 int n = BitsAvail - (BitsAvail &~ 15);
1485 ClrBits(n);
1486 if (BitsAvail == 0 && !isAligned(cp, uint16))
1487 cp++;
1488 }
1489 buf += sp->b.rowbytes;
1490 occ -= sp->b.rowbytes;
1491 if (occ != 0)
1492 tif->tif_row++;
1493 continue;
1494 EOFRLE: /* premature EOF */
1495 (*sp->fill)(buf, thisrun, pa, lastx);
1496 UNCACHE_STATE(tif, sp);
1497 return (-1);
1498 }
1499 UNCACHE_STATE(tif, sp);
1500 return (1);
1501 }
1502
1503 int
1504 TIFFInitCCITTRLE(TIFF* tif, int scheme)
1505 {
1506 if (InitCCITTFax3(tif)) { /* reuse G3 support */
1507 tif->tif_decoderow = Fax3DecodeRLE;
1508 tif->tif_decodestrip = Fax3DecodeRLE;
1509 tif->tif_decodetile = Fax3DecodeRLE;
1510 /*
1511 * Suppress RTC+EOLs when encoding and byte-align data.
1512 */
1513 return TIFFSetField(tif, TIFFTAG_FAXMODE,
1514 FAXMODE_NORTC|FAXMODE_NOEOL|FAXMODE_BYTEALIGN);
1515 } else
1516 return (0);
1517 }
1518
1519 int
1520 TIFFInitCCITTRLEW(TIFF* tif, int scheme)
1521 {
1522 if (InitCCITTFax3(tif)) { /* reuse G3 support */
1523 tif->tif_decoderow = Fax3DecodeRLE;
1524 tif->tif_decodestrip = Fax3DecodeRLE;
1525 tif->tif_decodetile = Fax3DecodeRLE;
1526 /*
1527 * Suppress RTC+EOLs when encoding and word-align data.
1528 */
1529 return TIFFSetField(tif, TIFFTAG_FAXMODE,
1530 FAXMODE_NORTC|FAXMODE_NOEOL|FAXMODE_WORDALIGN);
1531 } else
1532 return (0);
1533 }
1534 #endif /* CCITT_SUPPORT */
wxWidgets (Impactor)