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