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