home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / src / tiff / tif_fax3.c < prev    next >
C/C++ Source or Header  |  2000-08-09  |  46KB  |  1,597 lines
  1. /* $Header: /home/wxcvs/wxWindows/src/tiff/tif_fax3.c,v 1.4 2000/08/09 10:15:58 SC 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 <assert.h>
  45. #include <stdio.h>
  46.  
  47. /*
  48.  * NB: define PURIFY if you're using purify and you want
  49.  * to avoid some harmless array bounds complaints that
  50.  * can happen in the _TIFFFax3fillruns routine.
  51.  */
  52.  
  53. /*
  54.  * Compression+decompression state blocks are
  55.  * derived from this ``base state'' block.
  56.  */
  57. typedef struct {
  58.     int    mode;            /* operating mode */
  59.     uint32    rowbytes;        /* bytes in a decoded scanline */
  60.     uint32    rowpixels;        /* pixels in a scanline */
  61.  
  62.     uint16    cleanfaxdata;        /* CleanFaxData tag */
  63.     uint32    badfaxrun;        /* BadFaxRun tag */
  64.     uint32    badfaxlines;        /* BadFaxLines tag */
  65.     uint32    groupoptions;        /* Group 3/4 options tag */
  66.     uint32    recvparams;        /* encoded Class 2 session params */
  67.     char*    subaddress;        /* subaddress string */
  68.     uint32    recvtime;        /* time spent receiving (secs) */
  69.     TIFFVGetMethod vgetparent;    /* super-class method */
  70.     TIFFVSetMethod vsetparent;    /* super-class method */
  71. } Fax3BaseState;
  72. #define    Fax3State(tif)        ((Fax3BaseState*) (tif)->tif_data)
  73.  
  74. typedef struct {
  75.     Fax3BaseState b;
  76.     const u_char* bitmap;        /* bit reversal table */
  77.     uint32    data;            /* current i/o byte/word */
  78.     int    bit;            /* current i/o bit in byte */
  79.     int    EOLcnt;            /* count of EOL codes recognized */
  80.     TIFFFaxFillFunc fill;        /* fill routine */
  81.     uint32*    runs;            /* b&w runs for current/previous row */
  82.     uint32*    refruns;        /* runs for reference line */
  83.     uint32*    curruns;        /* runs for current line */
  84. } Fax3DecodeState;
  85. #define    DecoderState(tif)    ((Fax3DecodeState*) Fax3State(tif))
  86.  
  87. typedef struct {
  88.     Fax3BaseState b;
  89.     int    data;                /* current i/o byte */
  90.     int    bit;                 /* current i/o bit in byte */
  91.     enum { G3_1D, G3_2D } tag;  /* encoding state */
  92.     u_char*    refline;         /* reference line for 2d decoding */
  93.     int    k;                   /* #rows left that can be 2d encoded */
  94.     int    maxk;                /* max #rows that can be 2d encoded */
  95. } Fax3EncodeState;
  96. #define    EncoderState(tif)    ((Fax3EncodeState*) Fax3State(tif))
  97.  
  98. #define    is2DEncoding(sp) \
  99.     (sp->b.groupoptions & GROUP3OPT_2DENCODING)
  100. #define    isAligned(p,t)    ((((u_long)(p)) & (sizeof (t)-1)) == 0)
  101.  
  102. /*
  103.  * Group 3 and Group 4 Decoding.
  104.  */
  105.  
  106. /*
  107.  * These macros glue the TIFF library state to
  108.  * the state expected by Frank's decoder.
  109.  */
  110. #define    DECLARE_STATE(tif, sp, mod)                    \
  111.     static const char module[] = mod;                    \
  112.     Fax3DecodeState* sp = DecoderState(tif);                \
  113.     int a0;                /* reference element */        \
  114.     int lastx = sp->b.rowpixels;    /* last element in row */    \
  115.     uint32 BitAcc;            /* bit accumulator */        \
  116.     int BitsAvail;            /* # valid bits in BitAcc */    \
  117.     int RunLength;            /* length of current run */    \
  118.     u_char* cp;                /* next byte of input data */    \
  119.     u_char* ep;                /* end of input data */        \
  120.     uint32* pa;                /* place to stuff next run */    \
  121.     uint32* thisrun;            /* current row's run array */    \
  122.     int EOLcnt;                /* # EOL codes recognized */    \
  123.     const u_char* bitmap = sp->bitmap;    /* input data bit reverser */    \
  124.     const TIFFFaxTabEnt* TabEnt
  125. #define    DECLARE_STATE_2D(tif, sp, mod)                    \
  126.     DECLARE_STATE(tif, sp, mod);                    \
  127.     int b1;                /* next change on prev line */    \
  128.     uint32* pb                /* next run in reference line */\
  129. /*
  130.  * Load any state that may be changed during decoding.
  131.  */
  132. #define    CACHE_STATE(tif, sp) do {                    \
  133.     BitAcc = sp->data;                            \
  134.     BitsAvail = sp->bit;                        \
  135.     EOLcnt = sp->EOLcnt;                        \
  136.     cp = (unsigned char*) tif->tif_rawcp;                \
  137.     ep = cp + tif->tif_rawcc;                        \
  138. } while (0)
  139. /*
  140.  * Save state possibly changed during decoding.
  141.  */
  142. #define    UNCACHE_STATE(tif, sp) do {                    \
  143.     sp->bit = BitsAvail;                        \
  144.     sp->data = BitAcc;                            \
  145.     sp->EOLcnt = EOLcnt;                        \
  146.     tif->tif_rawcc -= (tidata_t) cp - tif->tif_rawcp;            \
  147.     tif->tif_rawcp = (tidata_t) cp;                    \
  148. } while (0)
  149.  
  150. /*
  151.  * Setup state for decoding a strip.
  152.  */
  153. static int
  154. Fax3PreDecode(TIFF* tif, tsample_t s)
  155. {
  156.     Fax3DecodeState* sp = DecoderState(tif);
  157.  
  158.     (void) s;
  159.     assert(sp != NULL);
  160.     sp->bit = 0;            /* force initial read */
  161.     sp->data = 0;
  162.     sp->EOLcnt = 0;            /* force initial scan for EOL */
  163.     /*
  164.      * Decoder assumes lsb-to-msb bit order.  Note that we select
  165.      * this here rather than in Fax3SetupState so that viewers can
  166.      * hold the image open, fiddle with the FillOrder tag value,
  167.      * and then re-decode the image.  Otherwise they'd need to close
  168.      * and open the image to get the state reset.
  169.      */
  170.     sp->bitmap =
  171.         TIFFGetBitRevTable(tif->tif_dir.td_fillorder != FILLORDER_LSB2MSB);
  172.     if (sp->refruns) {        /* init reference line to white */
  173.         sp->refruns[0] = sp->b.rowpixels;
  174.         sp->refruns[1] = 0;
  175.     }
  176.     return (1);
  177. }
  178.  
  179. /*
  180.  * Routine for handling various errors/conditions.
  181.  * Note how they are "glued into the decoder" by
  182.  * overriding the definitions used by the decoder.
  183.  */
  184.  
  185. static void LINKAGEMODE
  186. Fax3Unexpected(const char* module, TIFF* tif, uint32 a0)
  187. {
  188.     TIFFError(module, "%s: Bad code word at scanline %d (x %lu)",
  189.         tif->tif_name, tif->tif_row, (u_long) a0);
  190. }
  191. #define    unexpected(table, a0)    Fax3Unexpected(module, tif, a0)
  192.  
  193. static void LINKAGEMODE
  194. Fax3Extension(const char* module, TIFF* tif, uint32 a0)
  195. {
  196.     TIFFError(module,
  197.         "%s: Uncompressed data (not supported) at scanline %d (x %lu)",
  198.         tif->tif_name, tif->tif_row, (u_long) a0);
  199. }
  200. #define    extension(a0)    Fax3Extension(module, tif, a0)
  201.  
  202. static void LINKAGEMODE
  203. Fax3BadLength(const char* module, TIFF* tif, uint32 a0, uint32 lastx)
  204. {
  205.     TIFFWarning(module, "%s: %s at scanline %d (got %lu, expected %lu)",
  206.         tif->tif_name,
  207.         a0 < lastx ? "Premature EOL" : "Line length mismatch",
  208.         tif->tif_row, (u_long) a0, (u_long) lastx);
  209. }
  210. #define    badlength(a0,lastx)    Fax3BadLength(module, tif, a0, lastx)
  211.  
  212. static void LINKAGEMODE
  213. Fax3PrematureEOF(const char* module, TIFF* tif, uint32 a0)
  214. {
  215.     TIFFWarning(module, "%s: Premature EOF at scanline %d (x %lu)",
  216.         tif->tif_name, tif->tif_row, (u_long) a0);
  217. }
  218. #define    prematureEOF(a0)    Fax3PrematureEOF(module, tif, a0)
  219.  
  220. #define    Nop
  221.  
  222. /*
  223.  * Decode the requested amount of G3 1D-encoded data.
  224.  */
  225. static int LINKAGEMODE
  226. Fax3Decode1D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
  227. {
  228.     DECLARE_STATE(tif, sp, "Fax3Decode1D");
  229.  
  230.     (void) s;
  231.     CACHE_STATE(tif, sp);
  232.     thisrun = sp->curruns;
  233.     while ((long)occ > 0) {
  234.         a0 = 0;
  235.         RunLength = 0;
  236.         pa = thisrun;
  237. #ifdef FAX3_DEBUG
  238.         printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail);
  239.         printf("-------------------- %d\n", tif->tif_row);
  240.         fflush(stdout);
  241. #endif
  242.         SYNC_EOL(EOF1D);
  243.         EXPAND1D(EOF1Da);
  244.         (*sp->fill)(buf, thisrun, pa, lastx);
  245.         buf += sp->b.rowbytes;
  246.         occ -= sp->b.rowbytes;
  247.         if (occ != 0)
  248.             tif->tif_row++;
  249.         continue;
  250.     EOF1D:                /* premature EOF */
  251.         CLEANUP_RUNS();
  252.     EOF1Da:                /* premature EOF */
  253.         (*sp->fill)(buf, thisrun, pa, lastx);
  254.         UNCACHE_STATE(tif, sp);
  255.         return (-1);
  256.     }
  257.     UNCACHE_STATE(tif, sp);
  258.     return (1);
  259. }
  260.  
  261. #define    SWAP(t,a,b)    { t x; x = (a); (a) = (b); (b) = x; }
  262. /*
  263.  * Decode the requested amount of G3 2D-encoded data.
  264.  */
  265. static int LINKAGEMODE
  266. Fax3Decode2D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
  267. {
  268.     DECLARE_STATE_2D(tif, sp, "Fax3Decode2D");
  269.     int is1D;            /* current line is 1d/2d-encoded */
  270.  
  271.     (void) s;
  272.     CACHE_STATE(tif, sp);
  273.     while ((long)occ > 0) {
  274.         a0 = 0;
  275.         RunLength = 0;
  276.         pa = thisrun = sp->curruns;
  277. #ifdef FAX3_DEBUG
  278.         printf("\nBitAcc=%08X, BitsAvail = %d EOLcnt = %d",
  279.             BitAcc, BitsAvail, EOLcnt);
  280. #endif
  281.         SYNC_EOL(EOF2D);
  282.         NeedBits8(1, EOF2D);
  283.         is1D = GetBits(1);    /* 1D/2D-encoding tag bit */
  284.         ClrBits(1);
  285. #ifdef FAX3_DEBUG
  286.         printf(" %s\n-------------------- %d\n",
  287.             is1D ? "1D" : "2D", tif->tif_row);
  288.         fflush(stdout);
  289. #endif
  290.         pb = sp->refruns;
  291.         b1 = *pb++;
  292.         if (is1D)
  293.             EXPAND1D(EOF2Da);
  294.         else
  295.             EXPAND2D(EOF2Da);
  296.         (*sp->fill)(buf, thisrun, pa, lastx);
  297.         SETVAL(0);        /* imaginary change for reference */
  298.         SWAP(uint32*, sp->curruns, sp->refruns);
  299.         buf += sp->b.rowbytes;
  300.         occ -= sp->b.rowbytes;
  301.         if (occ != 0)
  302.             tif->tif_row++;
  303.         continue;
  304.     EOF2D:                /* premature EOF */
  305.         CLEANUP_RUNS();
  306.     EOF2Da:                /* premature EOF */
  307.         (*sp->fill)(buf, thisrun, pa, lastx);
  308.         UNCACHE_STATE(tif, sp);
  309.         return (-1);
  310.     }
  311.     UNCACHE_STATE(tif, sp);
  312.     return (1);
  313. }
  314. #undef SWAP
  315.  
  316. /*
  317.  * The ZERO & FILL macros must handle spans < 2*sizeof(long) bytes.
  318.  * For machines with 64-bit longs this is <16 bytes; otherwise
  319.  * this is <8 bytes.  We optimize the code here to reflect the
  320.  * machine characteristics.
  321.  */
  322. #if defined(__alpha) || _MIPS_SZLONG == 64
  323. #define FILL(n, cp)                                \
  324.     switch (n) {                                \
  325.     case 15:(cp)[14] = 0xff; case 14:(cp)[13] = 0xff; case 13: (cp)[12] = 0xff;\
  326.     case 12:(cp)[11] = 0xff; case 11:(cp)[10] = 0xff; case 10: (cp)[9] = 0xff;\
  327.     case  9: (cp)[8] = 0xff; case  8: (cp)[7] = 0xff; case  7: (cp)[6] = 0xff;\
  328.     case  6: (cp)[5] = 0xff; case  5: (cp)[4] = 0xff; case  4: (cp)[3] = 0xff;\
  329.     case  3: (cp)[2] = 0xff; case  2: (cp)[1] = 0xff;                  \
  330.     case  1: (cp)[0] = 0xff; (cp) += (n); case 0:  ;                  \
  331.     }
  332. #define ZERO(n, cp)                            \
  333.     switch (n) {                            \
  334.     case 15:(cp)[14] = 0; case 14:(cp)[13] = 0; case 13: (cp)[12] = 0;    \
  335.     case 12:(cp)[11] = 0; case 11:(cp)[10] = 0; case 10: (cp)[9] = 0;    \
  336.     case  9: (cp)[8] = 0; case  8: (cp)[7] = 0; case  7: (cp)[6] = 0;    \
  337.     case  6: (cp)[5] = 0; case  5: (cp)[4] = 0; case  4: (cp)[3] = 0;    \
  338.     case  3: (cp)[2] = 0; case  2: (cp)[1] = 0;                      \
  339.     case  1: (cp)[0] = 0; (cp) += (n); case 0:  ;            \
  340.     }
  341. #else
  342. #define FILL(n, cp)                                \
  343.     switch (n) {                                \
  344.     case 7: (cp)[6] = 0xff; case 6: (cp)[5] = 0xff; case 5: (cp)[4] = 0xff; \
  345.     case 4: (cp)[3] = 0xff; case 3: (cp)[2] = 0xff; case 2: (cp)[1] = 0xff; \
  346.     case 1: (cp)[0] = 0xff; (cp) += (n); case 0:  ;                \
  347.     }
  348. #define ZERO(n, cp)                            \
  349.     switch (n) {                            \
  350.     case 7: (cp)[6] = 0; case 6: (cp)[5] = 0; case 5: (cp)[4] = 0;    \
  351.     case 4: (cp)[3] = 0; case 3: (cp)[2] = 0; case 2: (cp)[1] = 0;    \
  352.     case 1: (cp)[0] = 0; (cp) += (n); case 0:  ;            \
  353.     }
  354. #endif
  355.  
  356. /*
  357.  * Bit-fill a row according to the white/black
  358.  * runs generated during G3/G4 decoding.
  359.  */
  360. void
  361. _TIFFFax3fillruns(u_char* buf, uint32* runs, uint32* erun, uint32 lastx)
  362. {
  363.     static const unsigned char _fillmasks[] =
  364.         { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
  365.     u_char* cp;
  366.     uint32 x, bx, run;
  367.     int32 n, nw;
  368.     long* lp;
  369.  
  370.     if ((erun-runs)&1)
  371.         *erun++ = 0;
  372.     x = 0;
  373.     for (; runs < erun; runs += 2) {
  374.         run = runs[0];
  375.         if (x+run > lastx)
  376.         run = runs[0] = lastx - x;
  377.         if (run) {
  378.         cp = buf + (x>>3);
  379.         bx = x&7;
  380.         if (run > 8-bx) {
  381.             if (bx) {            /* align to byte boundary */
  382.             *cp++ &= 0xff << (8-bx);
  383.             run -= 8-bx;
  384.             }
  385.             if( (n = run >> 3) != 0 ) {    /* multiple bytes to fill */
  386.             if ((n/sizeof (long)) > 1) {
  387.                 /*
  388.                  * Align to longword boundary and fill.
  389.                  */
  390.                 for (; n && !isAligned(cp, long); n--)
  391.                     *cp++ = 0x00;
  392.                 lp = (long*) cp;
  393.                 nw = (int32)(n / sizeof (long));
  394.                 n -= nw * sizeof (long);
  395.                 do {
  396.                     *lp++ = 0L;
  397.                 } while (--nw);
  398.                 cp = (u_char*) lp;
  399.             }
  400.             ZERO(n, cp);
  401.             run &= 7;
  402.             }
  403. #ifdef PURIFY
  404.             if (run)
  405.             cp[0] &= 0xff >> run;
  406. #else
  407.             cp[0] &= 0xff >> run;
  408. #endif
  409.         } else
  410.             cp[0] &= ~(_fillmasks[run]>>bx);
  411.         x += runs[0];
  412.         }
  413.         run = runs[1];
  414.         if (x+run > lastx)
  415.         run = runs[1] = lastx - x;
  416.         if (run) {
  417.         cp = buf + (x>>3);
  418.         bx = x&7;
  419.         if (run > 8-bx) {
  420.             if (bx) {            /* align to byte boundary */
  421.             *cp++ |= 0xff >> bx;
  422.             run -= 8-bx;
  423.             }
  424.             if( (n = run>>3) != 0 ) {    /* multiple bytes to fill */
  425.             if ((n/sizeof (long)) > 1) {
  426.                 /*
  427.                  * Align to longword boundary and fill.
  428.                  */
  429.                 for (; n && !isAligned(cp, long); n--)
  430.                 *cp++ = 0xff;
  431.                 lp = (long*) cp;
  432.                 nw = (int32)(n / sizeof (long));
  433.                 n -= nw * sizeof (long);
  434.                 do {
  435.                 *lp++ = -1L;
  436.                 } while (--nw);
  437.                 cp = (u_char*) lp;
  438.             }
  439.             FILL(n, cp);
  440.             run &= 7;
  441.             }
  442. #ifdef PURIFY
  443.             if (run)
  444.             cp[0] |= 0xff00 >> run;
  445. #else
  446.             cp[0] |= 0xff00 >> run;
  447. #endif
  448.         } else
  449.             cp[0] |= _fillmasks[run]>>bx;
  450.         x += runs[1];
  451.         }
  452.     }
  453.     assert(x == lastx);
  454. }
  455. #undef    ZERO
  456. #undef    FILL
  457.  
  458. /*
  459.  * Setup G3/G4-related compression/decompression state
  460.  * before data is processed.  This routine is called once
  461.  * per image -- it sets up different state based on whether
  462.  * or not decoding or encoding is being done and whether
  463.  * 1D- or 2D-encoded data is involved.
  464.  */
  465. static int
  466. Fax3SetupState(TIFF* tif)
  467. {
  468.     TIFFDirectory* td = &tif->tif_dir;
  469.     Fax3BaseState* sp = Fax3State(tif);
  470.     long rowbytes, rowpixels;
  471.     int needsRefLine;
  472.  
  473.     if (td->td_bitspersample != 1) {
  474.         TIFFError(tif->tif_name,
  475.             "Bits/sample must be 1 for Group 3/4 encoding/decoding");
  476.         return (0);
  477.     }
  478.     /*
  479.      * Calculate the scanline/tile widths.
  480.      */
  481.     if (isTiled(tif)) {
  482.         rowbytes = TIFFTileRowSize(tif);
  483.         rowpixels = td->td_tilewidth;
  484.     } else {
  485.         rowbytes = TIFFScanlineSize(tif);
  486.         rowpixels = td->td_imagewidth;
  487.     }
  488.     sp->rowbytes = (uint32) rowbytes;
  489.     sp->rowpixels = (uint32) rowpixels;
  490.     /*
  491.      * Allocate any additional space required for decoding/encoding.
  492.      */
  493.     needsRefLine = (
  494.         (sp->groupoptions & GROUP3OPT_2DENCODING) ||
  495.         td->td_compression == COMPRESSION_CCITTFAX4
  496.     );
  497.     if (tif->tif_mode == O_RDONLY) {    /* 1d/2d decoding */
  498.         Fax3DecodeState* dsp = DecoderState(tif);
  499.         uint32 nruns = needsRefLine ?
  500.              2*TIFFroundup(rowpixels,32) : rowpixels;
  501.  
  502. #if 0
  503.         dsp->runs = (uint32*) _TIFFmalloc(nruns*sizeof (uint16));
  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.  
  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.  */
  603. static void LINKAGEMODE
  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.  */
  638. static void LINKAGEMODE
  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.  */
  681. static void LINKAGEMODE
  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))
  707. #if defined(__VISAGECPP30__)
  708. /* VA 3.0 is just plain wierd. */
  709.         code = (code<<1) | (sp->tag == Fax3EncodeState::G3_1D), length++;
  710. #else
  711.         code = (code<<1) | (sp->tag == G3_1D), length++;
  712. #endif
  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;
  731. #if defined(__VISAGECPP30__)
  732. /* VA 3.0 is just plain wierd. */
  733.     sp->tag = Fax3EncodeState::G3_1D;
  734. #else
  735.     sp->tag = G3_1D;
  736. #endif
  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.  */
  817. INLINE static int32 LINKAGEMODE
  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.  
  876. INLINE static int32 LINKAGEMODE
  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.  */
  955. static int LINKAGEMODE
  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.  */
  1001. static int LINKAGEMODE
  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.  */
  1046. static int LINKAGEMODE
  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)) {
  1056. #if defined(__VISAGECPP30__)
  1057. /* VA 3.0 is just plain wierd. */
  1058.             if (sp->tag == Fax3EncodeState::G3_1D) {
  1059. #else
  1060.             if (sp->tag == G3_1D) {
  1061. #endif
  1062.                 if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
  1063.                     return (0);
  1064. #if defined(__VISAGECPP30__)
  1065. /* VA 3.0 is just plain wierd. */
  1066.                 sp->tag = Fax3EncodeState::G3_2D;
  1067. #else
  1068.                 sp->tag = G3_2D;
  1069. #endif
  1070.             } else {
  1071.                 if (!Fax3Encode2DRow(tif, bp, sp->refline, sp->b.rowpixels))
  1072.                     return (0);
  1073.                 sp->k--;
  1074.             }
  1075.             if (sp->k == 0) {
  1076. #if defined(__VISAGECPP30__)
  1077. /* VA 3.0 is just plain wierd. */
  1078.                 sp->tag = Fax3EncodeState::G3_1D;
  1079. #else
  1080.                 sp->tag = G3_1D;
  1081. #endif
  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))
  1117. #if defined(__VISAGECPP30__)
  1118. /* VA 3.0 is just plain wierd. */
  1119.             code = (code<<1) | (sp->tag == Fax3EncodeState::G3_1D), length++;
  1120. #else
  1121.             code = (code<<1) | (sp->tag == G3_1D), length++;
  1122. #endif
  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.  
  1274. static void LINKAGEMODE
  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.  
  1330. static int LINKAGEMODE
  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)
  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
  1344.         tif->tif_data = _TIFFmalloc(sizeof (Fax3DecodeState));
  1345.     else
  1346.         tif->tif_data = _TIFFmalloc(sizeof (Fax3EncodeState));
  1347. #endif
  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.  */
  1419. static int LINKAGEMODE
  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.  */
  1459. static int LINKAGEMODE
  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.  */
  1519. static int LINKAGEMODE
  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 */
  1597.