sdk/include/reactos/libs/libtiff/tif_fax3.h

   1 /* $Id: tif_fax3.h,v 1.13 2016-12-14 18:36:27 faxguy 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 #ifndef _FAX3_
  28 #define _FAX3_
  29 /*
  30  * TIFF Library.
  31  *
  32  * CCITT Group 3 (T.4) and Group 4 (T.6) Decompression Support.
  33  *
  34  * Decoder support is derived, with permission, from the code
  35  * in Frank Cringle's viewfax program;
  36  *      Copyright (C) 1990, 1995  Frank D. Cringle.
  37  */
  38 #include "tiff.h"
  39
  40 /*
  41  * To override the default routine used to image decoded
  42  * spans one can use the pseudo tag TIFFTAG_FAXFILLFUNC.
  43  * The routine must have the type signature given below;
  44  * for example:
  45  *
  46  * fillruns(unsigned char* buf, uint32* runs, uint32* erun, uint32 lastx)
  47  *
  48  * where buf is place to set the bits, runs is the array of b&w run
  49  * lengths (white then black), erun is the last run in the array, and
  50  * lastx is the width of the row in pixels.  Fill routines can assume
  51  * the run array has room for at least lastx runs and can overwrite
  52  * data in the run array as needed (e.g. to append zero runs to bring
  53  * the count up to a nice multiple).
  54  */
  55 typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32);
  56
  57 /*
  58  * The default run filler; made external for other decoders.
  59  */
  60 #if defined(__cplusplus)
  61 extern "C" {
  62 #endif
  63 extern void _TIFFFax3fillruns(unsigned char*, uint32*, uint32*, uint32);
  64 #if defined(__cplusplus)
  65 }
  66 #endif
  67
  68
  69 /* finite state machine codes */
  70 #define S_Null     0
  71 #define S_Pass     1
  72 #define S_Horiz    2
  73 #define S_V0       3
  74 #define S_VR       4
  75 #define S_VL       5
  76 #define S_Ext      6
  77 #define S_TermW    7
  78 #define S_TermB    8
  79 #define S_MakeUpW  9
  80 #define S_MakeUpB  10
  81 #define S_MakeUp   11
  82 #define S_EOL      12
  83
  84 /* WARNING: do not change the layout of this structure as the HylaFAX software */
  85 /* really depends on it. See http://bugzilla.maptools.org/show_bug.cgi?id=2636 */
  86 typedef struct {                /* state table entry */
  87         unsigned char State;    /* see above */
  88         unsigned char Width;    /* width of code in bits */
  89         uint32 Param;           /* unsigned 32-bit run length in bits (holds on 16 bit actually, but cannot be changed. See above warning) */
  90 } TIFFFaxTabEnt;
  91
  92 extern const TIFFFaxTabEnt TIFFFaxMainTable[];
  93 extern const TIFFFaxTabEnt TIFFFaxWhiteTable[];
  94 extern const TIFFFaxTabEnt TIFFFaxBlackTable[];
  95
  96 /*
  97  * The following macros define the majority of the G3/G4 decoder
  98  * algorithm using the state tables defined elsewhere.  To build
  99  * a decoder you need some setup code and some glue code. Note
 100  * that you may also need/want to change the way the NeedBits*
 101  * macros get input data if, for example, you know the data to be
 102  * decoded is properly aligned and oriented (doing so before running
 103  * the decoder can be a big performance win).
 104  *
 105  * Consult the decoder in the TIFF library for an idea of what you
 106  * need to define and setup to make use of these definitions.
 107  *
 108  * NB: to enable a debugging version of these macros define FAX3_DEBUG
 109  *     before including this file.  Trace output goes to stdout.
 110  */
 111
 112 #ifndef EndOfData
 113 #define EndOfData()     (cp >= ep)
 114 #endif
 115 /*
 116  * Need <=8 or <=16 bits of input data.  Unlike viewfax we
 117  * cannot use/assume a word-aligned, properly bit swizzled
 118  * input data set because data may come from an arbitrarily
 119  * aligned, read-only source such as a memory-mapped file.
 120  * Note also that the viewfax decoder does not check for
 121  * running off the end of the input data buffer.  This is
 122  * possible for G3-encoded data because it prescans the input
 123  * data to count EOL markers, but can cause problems for G4
 124  * data.  In any event, we don't prescan and must watch for
 125  * running out of data since we can't permit the library to
 126  * scan past the end of the input data buffer.
 127  *
 128  * Finally, note that we must handle remaindered data at the end
 129  * of a strip specially.  The coder asks for a fixed number of
 130  * bits when scanning for the next code.  This may be more bits
 131  * than are actually present in the data stream.  If we appear
 132  * to run out of data but still have some number of valid bits
 133  * remaining then we makeup the requested amount with zeros and
 134  * return successfully.  If the returned data is incorrect then
 135  * we should be called again and get a premature EOF error;
 136  * otherwise we should get the right answer.
 137  */
 138 #ifndef NeedBits8
 139 #define NeedBits8(n,eoflab) do {                                        \
 140     if (BitsAvail < (n)) {                                              \
 141         if (EndOfData()) {                                              \
 142             if (BitsAvail == 0)                 /* no valid bits */     \
 143                 goto eoflab;                                            \
 144             BitsAvail = (n);                    /* pad with zeros */    \
 145         } else {                                                        \
 146             BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail;              \
 147             BitsAvail += 8;                                             \
 148         }                                                               \
 149     }                                                                   \
 150 } while (0)
 151 #endif
 152 #ifndef NeedBits16
 153 #define NeedBits16(n,eoflab) do {                                       \
 154     if (BitsAvail < (n)) {                                              \
 155         if (EndOfData()) {                                              \
 156             if (BitsAvail == 0)                 /* no valid bits */     \
 157                 goto eoflab;                                            \
 158             BitsAvail = (n);                    /* pad with zeros */    \
 159         } else {                                                        \
 160             BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail;              \
 161             if ((BitsAvail += 8) < (n)) {                               \
 162                 if (EndOfData()) {                                      \
 163                     /* NB: we know BitsAvail is non-zero here */        \
 164                     BitsAvail = (n);            /* pad with zeros */    \
 165                 } else {                                                \
 166                     BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail;      \
 167                     BitsAvail += 8;                                     \
 168                 }                                                       \
 169             }                                                           \
 170         }                                                               \
 171     }                                                                   \
 172 } while (0)
 173 #endif
 174 #define GetBits(n)      (BitAcc & ((1<<(n))-1))
 175 #define ClrBits(n) do {                                                 \
 176     BitsAvail -= (n);                                                   \
 177     BitAcc >>= (n);                                                     \
 178 } while (0)
 179
 180 #ifdef FAX3_DEBUG
 181 static const char* StateNames[] = {
 182     "Null   ",
 183     "Pass   ",
 184     "Horiz  ",
 185     "V0     ",
 186     "VR     ",
 187     "VL     ",
 188     "Ext    ",
 189     "TermW  ",
 190     "TermB  ",
 191     "MakeUpW",
 192     "MakeUpB",
 193     "MakeUp ",
 194     "EOL    ",
 195 };
 196 #define DEBUG_SHOW putchar(BitAcc & (1 << t) ? '1' : '0')
 197 #define LOOKUP8(wid,tab,eoflab) do {                                    \
 198     int t;                                                              \
 199     NeedBits8(wid,eoflab);                                              \
 200     TabEnt = tab + GetBits(wid);                                        \
 201     printf("%08lX/%d: %s%5d\t", (long) BitAcc, BitsAvail,               \
 202            StateNames[TabEnt->State], TabEnt->Param);                   \
 203     for (t = 0; t < TabEnt->Width; t++)                                 \
 204         DEBUG_SHOW;                                                     \
 205     putchar('\n');                                                      \
 206     fflush(stdout);                                                     \
 207     ClrBits(TabEnt->Width);                                             \
 208 } while (0)
 209 #define LOOKUP16(wid,tab,eoflab) do {                                   \
 210     int t;                                                              \
 211     NeedBits16(wid,eoflab);                                             \
 212     TabEnt = tab + GetBits(wid);                                        \
 213     printf("%08lX/%d: %s%5d\t", (long) BitAcc, BitsAvail,               \
 214            StateNames[TabEnt->State], TabEnt->Param);                   \
 215     for (t = 0; t < TabEnt->Width; t++)                                 \
 216         DEBUG_SHOW;                                                     \
 217     putchar('\n');                                                      \
 218     fflush(stdout);                                                     \
 219     ClrBits(TabEnt->Width);                                             \
 220 } while (0)
 221
 222 #define SETVALUE(x) do {                                                        \
 223     *pa++ = RunLength + (x);                                            \
 224     printf("SETVALUE: %d\t%d\n", RunLength + (x), a0);                  \
 225     a0 += x;                                                            \
 226     RunLength = 0;                                                      \
 227 } while (0)
 228 #else
 229 #define LOOKUP8(wid,tab,eoflab) do {                                    \
 230     NeedBits8(wid,eoflab);                                              \
 231     TabEnt = tab + GetBits(wid);                                        \
 232     ClrBits(TabEnt->Width);                                             \
 233 } while (0)
 234 #define LOOKUP16(wid,tab,eoflab) do {                                   \
 235     NeedBits16(wid,eoflab);                                             \
 236     TabEnt = tab + GetBits(wid);                                        \
 237     ClrBits(TabEnt->Width);                                             \
 238 } while (0)
 239
 240 /*
 241  * Append a run to the run length array for the
 242  * current row and reset decoding state.
 243  */
 244 #define SETVALUE(x) do {                                                        \
 245     *pa++ = RunLength + (x);                                            \
 246     a0 += (x);                                                          \
 247     RunLength = 0;                                                      \
 248 } while (0)
 249 #endif
 250
 251 /*
 252  * Synchronize input decoding at the start of each
 253  * row by scanning for an EOL (if appropriate) and
 254  * skipping any trash data that might be present
 255  * after a decoding error.  Note that the decoding
 256  * done elsewhere that recognizes an EOL only consumes
 257  * 11 consecutive zero bits.  This means that if EOLcnt
 258  * is non-zero then we still need to scan for the final flag
 259  * bit that is part of the EOL code.
 260  */
 261 #define SYNC_EOL(eoflab) do {                                           \
 262     if (EOLcnt == 0) {                                                  \
 263         for (;;) {                                                      \
 264             NeedBits16(11,eoflab);                                      \
 265             if (GetBits(11) == 0)                                       \
 266                 break;                                                  \
 267             ClrBits(1);                                                 \
 268         }                                                               \
 269     }                                                                   \
 270     for (;;) {                                                          \
 271         NeedBits8(8,eoflab);                                            \
 272         if (GetBits(8))                                                 \
 273             break;                                                      \
 274         ClrBits(8);                                                     \
 275     }                                                                   \
 276     while (GetBits(1) == 0)                                             \
 277         ClrBits(1);                                                     \
 278     ClrBits(1);                         /* EOL bit */                   \
 279     EOLcnt = 0;                         /* reset EOL counter/flag */    \
 280 } while (0)
 281
 282 /*
 283  * Cleanup the array of runs after decoding a row.
 284  * We adjust final runs to insure the user buffer is not
 285  * overwritten and/or undecoded area is white filled.
 286  */
 287 #define CLEANUP_RUNS() do {                                             \
 288     if (RunLength)                                                      \
 289         SETVALUE(0);                                                    \
 290     if (a0 != lastx) {                                                  \
 291         badlength(a0, lastx);                                           \
 292         while (a0 > lastx && pa > thisrun)                              \
 293             a0 -= *--pa;                                                \
 294         if (a0 < lastx) {                                               \
 295             if (a0 < 0)                                                 \
 296                 a0 = 0;                                                 \
 297             if ((pa-thisrun)&1)                                         \
 298                 SETVALUE(0);                                            \
 299             SETVALUE(lastx - a0);                                               \
 300         } else if (a0 > lastx) {                                        \
 301             SETVALUE(lastx);                                            \
 302             SETVALUE(0);                                                        \
 303         }                                                               \
 304     }                                                                   \
 305 } while (0)
 306
 307 /*
 308  * Decode a line of 1D-encoded data.
 309  *
 310  * The line expanders are written as macros so that they can be reused
 311  * but still have direct access to the local variables of the "calling"
 312  * function.
 313  *
 314  * Note that unlike the original version we have to explicitly test for
 315  * a0 >= lastx after each black/white run is decoded.  This is because
 316  * the original code depended on the input data being zero-padded to
 317  * insure the decoder recognized an EOL before running out of data.
 318  */
 319 #define EXPAND1D(eoflab) do {                                           \
 320     for (;;) {                                                          \
 321         for (;;) {                                                      \
 322             LOOKUP16(12, TIFFFaxWhiteTable, eof1d);                     \
 323             switch (TabEnt->State) {                                    \
 324             case S_EOL:                                                 \
 325                 EOLcnt = 1;                                             \
 326                 goto done1d;                                            \
 327             case S_TermW:                                               \
 328                 SETVALUE(TabEnt->Param);                                        \
 329                 goto doneWhite1d;                                       \
 330             case S_MakeUpW:                                             \
 331             case S_MakeUp:                                              \
 332                 a0 += TabEnt->Param;                                    \
 333                 RunLength += TabEnt->Param;                             \
 334                 break;                                                  \
 335             default:                                                    \
 336                 unexpected("WhiteTable", a0);                           \
 337                 goto done1d;                                            \
 338             }                                                           \
 339         }                                                               \
 340     doneWhite1d:                                                        \
 341         if (a0 >= lastx)                                                \
 342             goto done1d;                                                \
 343         for (;;) {                                                      \
 344             LOOKUP16(13, TIFFFaxBlackTable, eof1d);                     \
 345             switch (TabEnt->State) {                                    \
 346             case S_EOL:                                                 \
 347                 EOLcnt = 1;                                             \
 348                 goto done1d;                                            \
 349             case S_TermB:                                               \
 350                 SETVALUE(TabEnt->Param);                                        \
 351                 goto doneBlack1d;                                       \
 352             case S_MakeUpB:                                             \
 353             case S_MakeUp:                                              \
 354                 a0 += TabEnt->Param;                                    \
 355                 RunLength += TabEnt->Param;                             \
 356                 break;                                                  \
 357             default:                                                    \
 358                 unexpected("BlackTable", a0);                           \
 359                 goto done1d;                                            \
 360             }                                                           \
 361         }                                                               \
 362     doneBlack1d:                                                        \
 363         if (a0 >= lastx)                                                \
 364             goto done1d;                                                \
 365         if( *(pa-1) == 0 && *(pa-2) == 0 )                              \
 366             pa -= 2;                                                    \
 367     }                                                                   \
 368 eof1d:                                                                  \
 369     prematureEOF(a0);                                                   \
 370     CLEANUP_RUNS();                                                     \
 371     goto eoflab;                                                        \
 372 done1d:                                                                 \
 373     CLEANUP_RUNS();                                                     \
 374 } while (0)
 375
 376 /*
 377  * Update the value of b1 using the array
 378  * of runs for the reference line.
 379  */
 380 #define CHECK_b1 do {                                                   \
 381     if (pa != thisrun) while (b1 <= a0 && b1 < lastx) {                 \
 382         b1 += pb[0] + pb[1];                                            \
 383         pb += 2;                                                        \
 384     }                                                                   \
 385 } while (0)
 386
 387 /*
 388  * Expand a row of 2D-encoded data.
 389  */
 390 #define EXPAND2D(eoflab) do {                                           \
 391     while (a0 < lastx) {                                                \
 392         LOOKUP8(7, TIFFFaxMainTable, eof2d);                            \
 393         switch (TabEnt->State) {                                        \
 394         case S_Pass:                                                    \
 395             CHECK_b1;                                                   \
 396             b1 += *pb++;                                                \
 397             RunLength += b1 - a0;                                       \
 398             a0 = b1;                                                    \
 399             b1 += *pb++;                                                \
 400             break;                                                      \
 401         case S_Horiz:                                                   \
 402             if ((pa-thisrun)&1) {                                       \
 403                 for (;;) {      /* black first */                       \
 404                     LOOKUP16(13, TIFFFaxBlackTable, eof2d);             \
 405                     switch (TabEnt->State) {                            \
 406                     case S_TermB:                                       \
 407                         SETVALUE(TabEnt->Param);                                \
 408                         goto doneWhite2da;                              \
 409                     case S_MakeUpB:                                     \
 410                     case S_MakeUp:                                      \
 411                         a0 += TabEnt->Param;                            \
 412                         RunLength += TabEnt->Param;                     \
 413                         break;                                          \
 414                     default:                                            \
 415                         goto badBlack2d;                                \
 416                     }                                                   \
 417                 }                                                       \
 418             doneWhite2da:;                                              \
 419                 for (;;) {      /* then white */                        \
 420                     LOOKUP16(12, TIFFFaxWhiteTable, eof2d);             \
 421                     switch (TabEnt->State) {                            \
 422                     case S_TermW:                                       \
 423                         SETVALUE(TabEnt->Param);                                \
 424                         goto doneBlack2da;                              \
 425                     case S_MakeUpW:                                     \
 426                     case S_MakeUp:                                      \
 427                         a0 += TabEnt->Param;                            \
 428                         RunLength += TabEnt->Param;                     \
 429                         break;                                          \
 430                     default:                                            \
 431                         goto badWhite2d;                                \
 432                     }                                                   \
 433                 }                                                       \
 434             doneBlack2da:;                                              \
 435             } else {                                                    \
 436                 for (;;) {      /* white first */                       \
 437                     LOOKUP16(12, TIFFFaxWhiteTable, eof2d);             \
 438                     switch (TabEnt->State) {                            \
 439                     case S_TermW:                                       \
 440                         SETVALUE(TabEnt->Param);                                \
 441                         goto doneWhite2db;                              \
 442                     case S_MakeUpW:                                     \
 443                     case S_MakeUp:                                      \
 444                         a0 += TabEnt->Param;                            \
 445                         RunLength += TabEnt->Param;                     \
 446                         break;                                          \
 447                     default:                                            \
 448                         goto badWhite2d;                                \
 449                     }                                                   \
 450                 }                                                       \
 451             doneWhite2db:;                                              \
 452                 for (;;) {      /* then black */                        \
 453                     LOOKUP16(13, TIFFFaxBlackTable, eof2d);             \
 454                     switch (TabEnt->State) {                            \
 455                     case S_TermB:                                       \
 456                         SETVALUE(TabEnt->Param);                                \
 457                         goto doneBlack2db;                              \
 458                     case S_MakeUpB:                                     \
 459                     case S_MakeUp:                                      \
 460                         a0 += TabEnt->Param;                            \
 461                         RunLength += TabEnt->Param;                     \
 462                         break;                                          \
 463                     default:                                            \
 464                         goto badBlack2d;                                \
 465                     }                                                   \
 466                 }                                                       \
 467             doneBlack2db:;                                              \
 468             }                                                           \
 469             CHECK_b1;                                                   \
 470             break;                                                      \
 471         case S_V0:                                                      \
 472             CHECK_b1;                                                   \
 473             SETVALUE(b1 - a0);                                          \
 474             b1 += *pb++;                                                \
 475             break;                                                      \
 476         case S_VR:                                                      \
 477             CHECK_b1;                                                   \
 478             SETVALUE(b1 - a0 + TabEnt->Param);                          \
 479             b1 += *pb++;                                                \
 480             break;                                                      \
 481         case S_VL:                                                      \
 482             CHECK_b1;                                                   \
 483             if (b1 <= (int) (a0 + TabEnt->Param)) {                     \
 484                 if (b1 < (int) (a0 + TabEnt->Param) || pa != thisrun) { \
 485                     unexpected("VL", a0);                               \
 486                     goto eol2d;                                         \
 487                 }                                                       \
 488             }                                                           \
 489             SETVALUE(b1 - a0 - TabEnt->Param);                          \
 490             b1 -= *--pb;                                                \
 491             break;                                                      \
 492         case S_Ext:                                                     \
 493             *pa++ = lastx - a0;                                         \
 494             extension(a0);                                              \
 495             goto eol2d;                                                 \
 496         case S_EOL:                                                     \
 497             *pa++ = lastx - a0;                                         \
 498             NeedBits8(4,eof2d);                                         \
 499             if (GetBits(4))                                             \
 500                 unexpected("EOL", a0);                                  \
 501             ClrBits(4);                                                 \
 502             EOLcnt = 1;                                                 \
 503             goto eol2d;                                                 \
 504         default:                                                        \
 505         badMain2d:                                                      \
 506             unexpected("MainTable", a0);                                \
 507             goto eol2d;                                                 \
 508         badBlack2d:                                                     \
 509             unexpected("BlackTable", a0);                               \
 510             goto eol2d;                                                 \
 511         badWhite2d:                                                     \
 512             unexpected("WhiteTable", a0);                               \
 513             goto eol2d;                                                 \
 514         eof2d:                                                          \
 515             prematureEOF(a0);                                           \
 516             CLEANUP_RUNS();                                             \
 517             goto eoflab;                                                \
 518         }                                                               \
 519     }                                                                   \
 520     if (RunLength) {                                                    \
 521         if (RunLength + a0 < lastx) {                                   \
 522             /* expect a final V0 */                                     \
 523             NeedBits8(1,eof2d);                                         \
 524             if (!GetBits(1))                                            \
 525                 goto badMain2d;                                         \
 526             ClrBits(1);                                                 \
 527         }                                                               \
 528         SETVALUE(0);                                                    \
 529     }                                                                   \
 530 eol2d:                                                                  \
 531     CLEANUP_RUNS();                                                     \
 532 } while (0)
 533 #endif /* _FAX3_ */
 534 /*
 535  * Local Variables:
 536  * mode: c
 537  * c-basic-offset: 8
 538  * fill-column: 78
 539  * End:
 540  */