home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / Fax / AVMA&GPFax-V1,33Sources.LHA / fromfax.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-25  |  12.0 KB  |  586 lines
  1. /* Derived from: */
  2. /* g3topbm.c - read a Group 3 FAX file and produce a portable bitmap
  3. **
  4. ** Copyright (C) 1989 by Paul Haeberli <paul@manray.sgi.com>.
  5. **
  6. ** Permission to use, copy, modify, and distribute this software and its
  7. ** documentation for any purpose and without fee is hereby granted, provided
  8. ** that the above copyright notice appear in all copies and that both that
  9. ** copyright notice and this permission notice appear in supporting
  10. ** documentation.  This software is provided "as is" without express or
  11. ** implied warranty.
  12. */
  13. /* $Id: fromfax.c,v 1.5 1993/10/25 02:14:27 Rhialto Exp $
  14.  * $Log: fromfax.c,v $
  15.  * Revision 1.5  1993/10/25  02:14:27  Rhialto
  16.  * Make +FBOR flexible; fix RTC detection bug.
  17.  *
  18.  * Revision 1.4  1993/09/18  22:41:27  Rhialto
  19.  * Improve on bit order terminology: use msb/lsb first.
  20.  *
  21.  * Revision 1.3  1993/08/20  03:45:27  Rhialto
  22.  * Add hack for auto-detecting fax bit order.
  23.  *
  24.  * Revision 1.2  1993/06/11  16:33:37  Rhialto
  25.  * First real RCS checkin
  26.  *
  27.  */
  28.  
  29. #include <stdio.h>
  30. #include <string.h>
  31. #include <ctype.h>
  32. #include "g3.h"
  33. #include "faxfile.h"
  34.  
  35. #ifdef DEBUG
  36. #define debug(x)    printf x
  37. #else
  38. #define debug(x)
  39. #endif
  40.  
  41. #define TABSIZE(tab) (sizeof(tab)/sizeof(struct tableentry))
  42. #define MAXCOLS LINE_BITS
  43. #define MAXROWS 4300        /* up to two pages long */
  44.  
  45. typedef struct faxin {
  46.     int     raw;
  47.     FAXHDR     faxhdr;
  48.     FAXHDR     pagehdr;
  49.     int     row;
  50.     int     endoffile;
  51.     int     eols;
  52.     int     rawzeros;
  53.     int     shdata;
  54.     int     shbit;
  55.     int     kludge;
  56.     int     reversebits;
  57.     int     stretch;
  58.     unsigned char  *bitp;
  59.     unsigned char    bitval;
  60.  
  61. } FAXIN;
  62.  
  63. FAXIN faxin;
  64.  
  65. #define WHASHA 3510
  66. #define WHASHB 1178
  67.  
  68. #define BHASHA 293
  69. #define BHASHB 2695
  70.  
  71. #define HASHSIZE 1021
  72. static tableentry *whash[HASHSIZE];
  73. static tableentry *bhash[HASHSIZE];
  74.  
  75. static void addtohash(tableentry *hash[], tableentry* te, int n, int a, int b);
  76. static tableentry *hashfind(tableentry *hash[], int length, int code, int a, int b);
  77. static int getfaxrow(FILE *inf, int row, unsigned char *bitrow);
  78. static void skiptoeol(FILE *file);
  79. static int rawgetbit(FILE *file);
  80. extern int verbose;
  81.  
  82. int
  83. memisprint(unsigned char *s, int len)
  84. {
  85.     while (len > 0) {
  86.     if (s[0] && !isprint((s[0])))
  87.         return 0;
  88.     s++;
  89.     len--;
  90.     }
  91.     return 1;
  92. }
  93.  
  94. int
  95. try_line(FILE *ifp)
  96. {
  97.     int         col;
  98.     int         curlen,
  99.             curcode,
  100.             nextbit;
  101.     int         count,
  102.             color;
  103.     tableentry       *te;
  104.  
  105.     col = 0;
  106.     curlen = 0;
  107.     curcode = 0;
  108.     color = 1;        /* 1=white, 0=black */
  109.     count = 0;
  110.  
  111.     while (!faxin.endoffile) {
  112.     if (col >= MAXCOLS) {
  113.         skiptoeol(ifp);
  114.         return col;
  115.     }
  116.     do {
  117.         if (faxin.rawzeros >= 11) {
  118.         nextbit = rawgetbit(ifp);
  119.         if (nextbit) {
  120.             if (col && col < LINE_BITS)
  121.             return -1;
  122.             return (col);
  123.         }
  124.         if (feof(ifp)) {
  125.             return -1;
  126.         }
  127.         } else
  128.         nextbit = rawgetbit(ifp);
  129.         curcode = (curcode << 1) + nextbit;
  130.         curlen++;
  131.     } while (curcode <= 0);
  132.     if (curlen > 13) {
  133.         skiptoeol(ifp);
  134.         return -1;
  135.     }
  136.     if (color) {
  137.         if (curlen < 4)
  138.         continue;
  139.         te = hashfind(whash, curlen, curcode, WHASHA, WHASHB);
  140.     } else {
  141.         if (curlen < 2)
  142.         continue;
  143.         te = hashfind(bhash, curlen, curcode, BHASHA, BHASHB);
  144.     }
  145.     if (!te)
  146.         continue;
  147.     switch (te->tabid) {
  148.     case TWTABLE:
  149.     case TBTABLE:
  150.         count += te->count;
  151.         if (col + count > MAXCOLS)
  152.         count = MAXCOLS - col;
  153.         if (count > 0) {
  154.         col += count;
  155.         count = 0;
  156.         }
  157.         curcode = 0;
  158.         curlen = 0;
  159.         color = !color;
  160.         break;
  161.     case MWTABLE:
  162.     case MBTABLE:
  163.         count += te->count;
  164.         curcode = 0;
  165.         curlen = 0;
  166.         break;
  167.     case EXTABLE:
  168.         count += te->count;
  169.         curcode = 0;
  170.         curlen = 0;
  171.         break;
  172.     default:
  173.         fprintf(stderr, "internal bad poop\n");
  174.     }
  175.     }
  176. }
  177.  
  178. int
  179. infer_bitorder(FILE *f)
  180. {
  181.     int         normerrors = 0;
  182.     int         reverrors = 0;
  183.     int         i;
  184.     long        pos;
  185.  
  186.     pos = ftell(f);
  187.  
  188.     if (verbose)
  189.     printf("try MSB first...");
  190.     faxin.reversebits = 0;
  191.     faxin.shbit = 0;
  192.     skiptoeol(f);
  193.     for (i = 0; i < 10; i++)
  194.     if (try_line(f) == -1)
  195.         normerrors++;
  196.     fseek(f, pos, SEEK_SET);
  197.     if (verbose)
  198.     printf(" %d errors\n", normerrors);
  199.  
  200.     if (verbose)
  201.     printf("try LSB first...");
  202.     faxin.reversebits = 1;
  203.     faxin.shbit = 0;
  204.     skiptoeol(f);
  205.     for (i = 0; i < 10; i++)
  206.     if (try_line(f) == -1)
  207.         reverrors++;
  208.     fseek(f, pos, SEEK_SET);
  209.     if (verbose)
  210.     printf(" %d errors\n", reverrors);
  211.  
  212.     if (normerrors < reverrors) {
  213.     return faxin.reversebits = 0;
  214.     } else {
  215.     fprintf(stderr, "Warning: this file has its bits the wrong way!\n");
  216.     return faxin.reversebits = 1;
  217.     }
  218. }
  219.  
  220. /*
  221.  * Prepare for reading a faxfile.
  222.  * dostretch (ignored) indicates we must repeat each scan line.
  223.  * bitorder indicates bit order: 0=normal: lsb first, 1=reversed: msb first.
  224.  *                 -1: auto-detect.
  225.  *    For understandable reasons, the designer of this decoder had
  226.  *    the opposite idea of what was normal and reversed, hence
  227.  *    some confusion.
  228.  */
  229.  
  230. long    /* error code */
  231. faxin_open_fp(FILE *ifp, int dostretch, int bitorder)
  232. {
  233.     int         i;
  234.  
  235.     faxin.stretch = dostretch;
  236.  
  237.     for (i = 0; i < HASHSIZE; ++i)
  238.     whash[i] = bhash[i] = (tableentry *) 0;
  239.     addtohash(whash, twtable, TABSIZE(twtable), WHASHA, WHASHB);
  240.     addtohash(whash, mwtable, TABSIZE(mwtable), WHASHA, WHASHB);
  241.     addtohash(whash, extable, TABSIZE(extable), WHASHA, WHASHB);
  242.     addtohash(bhash, tbtable, TABSIZE(tbtable), BHASHA, BHASHB);
  243.     addtohash(bhash, mbtable, TABSIZE(mbtable), BHASHA, BHASHB);
  244.     addtohash(bhash, extable, TABSIZE(extable), BHASHA, BHASHB);
  245.  
  246. #ifdef _DCC
  247.     setvbuf(ifp, NULL, _IOFBF, 16384);
  248. #endif
  249.     /* Attempt to read file/page header */
  250.     if (fread(&faxin.faxhdr, sizeof(faxin.faxhdr), 1, ifp) == 1) {
  251.     fseek(ifp, -sizeof(faxin.faxhdr), SEEK_CUR);
  252. #if 0
  253.     faxin.raw = 1;
  254. #else
  255.     faxin.raw = !memisprint(&faxin.faxhdr.id.magic[0], sizeof(faxin.faxhdr.id.magic));
  256.     debug(("assume faxin.raw = %d\n", faxin.raw));
  257. #endif
  258.     /* If fax is raw, try to infer bit order */
  259.     if (faxin.raw) {
  260.         faxin.reversebits = !bitorder;    /* swap 0 and 1 */
  261.         if (bitorder < 0)
  262.         bitorder = infer_bitorder(ifp);
  263.         if (bitorder < 0) {
  264.         debug(("fail on bit order\n"));
  265.         return 1;
  266.         }
  267.     }
  268.  
  269.     return 0;
  270.     }
  271.     fprintf(stderr, "file too short\n");
  272.  
  273.     return 1;
  274. }
  275.  
  276. int
  277. faxin_begin_page(FILE *ifp)
  278. {
  279.     if (faxin.raw && ftell(ifp) != 0) {
  280.     /* Raw files contain only one page and no header */
  281.     return 1;
  282.     }
  283.  
  284.     if (faxin.raw == 0) {
  285.     int        bytes;
  286.     int        byte;
  287.  
  288.     /* Skip past page header by finding magic id */
  289.     retry:
  290.     bytes = 0;
  291.     /* Shortcut for first byte */
  292.     while ((byte = getc(ifp)) != faxin.faxhdr.id.magic[0]) {
  293.         if (feof(ifp)) {
  294.         return 1;
  295.         }
  296.     }
  297.     faxin.pagehdr.id.magic[0] = byte;
  298.     bytes = 1;
  299.  
  300.     while (bytes < sizeof(faxin.faxhdr.id)) {
  301.         /* Do we have a matching prefix? */
  302.         if (memcmp(faxin.pagehdr.id.magic, faxin.faxhdr.id.magic, bytes) == 0) {
  303.         /* Yes, read one more byte and continue */
  304.         byte = getc(ifp);
  305.         if (feof(ifp))
  306.             return 1;
  307.         faxin.pagehdr.id.magic[bytes] = byte;
  308.         bytes++;
  309.         } else {
  310.         /* Shift everything down and reduce match length */
  311.         bytes--;
  312.         if (bytes == 0)
  313.             goto retry;
  314.         memmove(faxin.pagehdr.id.magic, faxin.pagehdr.id.magic + 1, bytes);
  315.         }
  316.     }
  317.  
  318.     fread(&faxin.pagehdr.info, sizeof(faxin.pagehdr) - sizeof(faxin.pagehdr.id), 1, ifp);
  319.     if (feof(ifp)) {
  320.         fprintf(stderr, "Premature EOF after header\n");
  321.         return 1;
  322.     }
  323.  
  324.     /* "Normal" bit ordering is MSB first */
  325.     faxin.reversebits = !faxin.pagehdr.info.msbfirst;
  326.     }
  327.  
  328.     faxin.eols = 0;
  329.     faxin.rawzeros = 0;
  330.     faxin.endoffile = 0;
  331.     faxin.row = 0;
  332.     faxin.shbit = 0;
  333.  
  334.     if (faxin.raw && feof(ifp)) {
  335.     return 1;
  336.     }
  337.  
  338. #ifdef KLUDGE
  339.     if (faxin.kludge) {
  340.     /* Skip extra lines to get in sync. */
  341.     skiptoeol(ifp);
  342.     skiptoeol(ifp);
  343.     skiptoeol(ifp);
  344.     }
  345. #endif
  346.     skiptoeol(ifp);
  347.     if (feof(ifp)) {
  348.     return 1;
  349.     }
  350.  
  351.     return 0;
  352. }
  353.  
  354. static void
  355. addtohash(hash, te, n, a, b)
  356. tableentry     *hash[];
  357. tableentry     *te;
  358. int        n,
  359.         a,
  360.         b;
  361.  
  362. {
  363.     unsigned int    pos;
  364.  
  365.     while (n--) {
  366.     pos = ((te->length + a) * (te->code + b)) % HASHSIZE;
  367.     if (hash[pos] != 0)
  368.         fprintf(stderr, "internal error: addtohash fatal hash collision\n");
  369.     hash[pos] = te;
  370.     te++;
  371.     }
  372. }
  373.  
  374. static tableentry *
  375. hashfind(hash, length, code, a, b)
  376. tableentry     *hash[];
  377. int        length,
  378.         code;
  379. int        a,
  380.         b;
  381.  
  382. {
  383.     unsigned int    pos;
  384.     tableentry       *te;
  385.  
  386.     pos = ((length + a) * (code + b)) % HASHSIZE;
  387.     if (pos >= HASHSIZE)
  388.     fprintf(stderr,
  389.        "internal error: bad hash position, length %d code %d pos %d\n",
  390.          length, code, pos);
  391.     te = hash[pos];
  392.     return ((te && te->length == length && te->code == code) ? te : 0);
  393. }
  394.  
  395. /* Put some black (color 1) bits in IFF bitmap format */
  396. void
  397. putblackbits(int count)
  398. {
  399.     while (count > 0) {
  400.     *faxin.bitp |= faxin.bitval;    /* Set a single bit */
  401.     count--;
  402.     faxin.bitval >>= 1;
  403.     if (faxin.bitval == 0) {
  404.         faxin.bitval = 0x80;
  405.         faxin.bitp++;
  406.         /* While we're byte-aligned, do 8 bits at a time */
  407.         while (count >= 8) {
  408.         *faxin.bitp++ = 0xFF;
  409.         count -= 8;
  410.         }
  411.     }
  412.     }
  413. }
  414.  
  415. /* Put some white (color 0) bits in IFF bitmap format */
  416. void
  417. putwhitebits(int count)
  418. {
  419.     while (count > 0) {
  420.     /* don't set a bit */
  421.     count--;
  422.     faxin.bitval >>= 1;
  423.     if (faxin.bitval == 0) {
  424.         faxin.bitval = 0x80;
  425.         faxin.bitp++;
  426.         /* While we're byte-aligned, do 8 bits at a time */
  427.         while (count >= 8) {
  428.         faxin.bitp++;
  429.         count -= 8;
  430.         }
  431.     }
  432.     }
  433. }
  434.  
  435. int
  436. fromfax(ifp, bitrow)
  437. FILE           *ifp;
  438. unsigned char *bitrow;
  439. {
  440.     int         col;
  441.     int         curlen,
  442.             curcode,
  443.             nextbit;
  444.     int         count,
  445.             color;
  446.     tableentry       *te;
  447.  
  448.     col = 0;
  449.     curlen = 0;
  450.     curcode = 0;
  451.     color = 1;        /* 1=white, 0=black */
  452.     count = 0;
  453.     faxin.bitp = bitrow;
  454.     faxin.bitval = 0x80;
  455.     faxin.row++;
  456.  
  457.     while (!faxin.endoffile) {
  458.     if (col >= MAXCOLS) {
  459.         skiptoeol(ifp);
  460.         return (col);
  461.     }
  462.     do {
  463.         if (faxin.rawzeros >= 11) {
  464.         nextbit = rawgetbit(ifp);
  465.         if (nextbit) {
  466.             if (col == 0) {
  467.             /* XXX should be 6 */
  468.             faxin.endoffile = (++faxin.eols == 3);
  469.             if (verbose) {
  470.                 fprintf(stderr, "empty row %d: found %d so far, eof=%d\n",
  471.                 faxin.row, faxin.eols, faxin.endoffile);
  472.             }
  473.             }
  474. #ifndef notdef
  475.             if (col && col < LINE_BITS)
  476.             fprintf(stderr, "warning, row %d short (len %d)\n",
  477.                    faxin.row, col);
  478. #endif                /* notdef */
  479.             return col;
  480.         }
  481.         if (feof(ifp)) {
  482.             faxin.endoffile = 1;
  483.             return col;
  484.         }
  485.         } else
  486.         nextbit = rawgetbit(ifp);
  487.         curcode = (curcode << 1) + nextbit;
  488.         curlen++;
  489.     } while (curcode <= 0);
  490.     if (col != 0)
  491.         faxin.eols = 0;
  492.     if (curlen > 13) {
  493.         fprintf(stderr, "bad code word at row %d, col %d (len %d code 0x%x), skipping to EOL\n",
  494.                faxin.row, col, curlen, curcode);
  495.         skiptoeol(ifp);
  496.         return (col);
  497.     }
  498.     if (color) {
  499.         if (curlen < 4)
  500.         continue;
  501.         te = hashfind(whash, curlen, curcode, WHASHA, WHASHB);
  502.     } else {
  503.         if (curlen < 2)
  504.         continue;
  505.         te = hashfind(bhash, curlen, curcode, BHASHA, BHASHB);
  506.     }
  507.     if (!te)
  508.         continue;
  509.     switch (te->tabid) {
  510.     case TWTABLE:
  511.     case TBTABLE:
  512.         count += te->count;
  513.         if (col + count > MAXCOLS)
  514.         count = MAXCOLS - col;
  515.         if (count > 0) {
  516.         if (color) {
  517.             putwhitebits(count);
  518.         } else {
  519.             putblackbits(count);
  520.         }
  521.         col += count;
  522.         count = 0;
  523.         }
  524.         curcode = 0;
  525.         curlen = 0;
  526.         color = !color;
  527.         break;
  528.     case MWTABLE:
  529.     case MBTABLE:
  530.         count += te->count;
  531.         curcode = 0;
  532.         curlen = 0;
  533.         break;
  534.     case EXTABLE:
  535.         count += te->count;
  536.         curcode = 0;
  537.         curlen = 0;
  538.         break;
  539.     default:
  540.         fprintf(stderr, "internal bad poop\n");
  541.     }
  542.     }
  543.     return -1;        /* End of page */
  544. }
  545.  
  546. static void
  547. skiptoeol(ifp)
  548. FILE           *ifp;
  549. {
  550.     while (faxin.rawzeros < 11)
  551.     (void) rawgetbit(ifp);
  552.     for (;;) {
  553.     if (feof(ifp) || rawgetbit(ifp))
  554.         break;
  555.     }
  556. }
  557.  
  558.  
  559. static int
  560. rawgetbit(ifp)
  561. FILE           *ifp;
  562. {
  563.     int         b;
  564.  
  565.     if ((faxin.shbit & 0xff) == 0) {
  566.     faxin.shdata = getc(ifp);
  567.     if (faxin.shdata == EOF) {
  568.         fprintf(stderr, "EOF / read error at line %d\n", faxin.eols);
  569.         faxin.shdata = 0;
  570.     }
  571.     faxin.shbit = faxin.reversebits ? 0x01 : 0x80;
  572.     }
  573.     if (faxin.shdata & faxin.shbit) {
  574.     faxin.rawzeros = 0;
  575.     b = 1;
  576.     } else {
  577.     faxin.rawzeros++;
  578.     b = 0;
  579.     }
  580.     if (faxin.reversebits)
  581.     faxin.shbit <<= 1;
  582.     else
  583.     faxin.shbit >>= 1;
  584.     return b;
  585. }
  586.