home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / Fax / AVMA&GPFax-V1,33Sources.LHA / fax2iff.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-09  |  6.0 KB  |  295 lines
  1. /*
  2.  * fax2iff.c
  3.  *
  4.  * $Id: fax2iff.c,v 1.5 1993/10/25 02:14:27 Rhialto Exp $
  5.  * $Log: fax2iff.c,v $
  6.  * Revision 1.5  1993/10/25  02:14:27  Rhialto
  7.  * Make +FBOR flexible; fix RTC detection bug.
  8.  *
  9.  * Revision 1.4  1993/08/20  02:48:24  Rhialto
  10.  * Add hack for auto-detecting fax bit order, and an option
  11.  * to specify it explicitly.
  12.  *
  13.  * Revision 1.3  1993/07/01  00:44:20  Rhialto
  14.  * Add CMAP and CAMG chunk. Create CAT only for multiple input files.
  15.  *
  16.  * Revision 1.2  1993/06/11  16:33:37  Rhialto
  17.  * First real RCS checkin
  18.  *
  19.  */
  20.  
  21. #include <stdlib.h>
  22.  
  23. #include "iffp/iff.h"
  24. #include "iffp/ilbm.h"
  25. #include "iffp/packer.h"
  26. #include "faxfile.h"
  27.  
  28. #ifdef DEBUG
  29. #define debug(x)    printf x
  30. #else
  31. #define debug(x)
  32. #endif
  33.  
  34. typedef struct faxin {
  35.     int     raw;
  36.     FAXHDR     faxhdr;
  37.     FAXHDR     pagehdr;
  38.     int     row;
  39.     int     endoffile;
  40.     int     eols;
  41.     int     rawzeros;
  42.     int     shdata;
  43.     int     shbit;
  44.     int     kludge;
  45.     int     reversebits;
  46.     int     stretch;
  47.     unsigned char  *bitp;
  48.     unsigned char    bitval;
  49.  
  50. } FAXIN;
  51.  
  52. extern FAXIN faxin;
  53.  
  54. struct ParseInfo ParseInfo;
  55. int        verbose;
  56. int        invert;
  57. int        bitorder = -1;
  58. int        nocat;
  59.  
  60. /* Assumes malloc()ed pointer */
  61. void
  62. meminvert(unsigned char *d, int size)
  63. {
  64.     while (size >= 4) {
  65.     *(long *)d ^= 0xFFFFFFFF;
  66.     d += 4;
  67.     size -= 4;
  68.     }
  69.     while (size > 0) {
  70.     *d++ ^= 0xFF;
  71.     size--;
  72.     }
  73. }
  74.  
  75. long
  76. dobody(FILE *faxfile, struct ParseInfo *pi)
  77. {
  78.     unsigned char  *planedata;
  79.     unsigned char  *bodydata;
  80.     int         planedatasize;
  81.     int         bodydatasize;
  82.     int         lines;
  83.  
  84.     planedatasize = BytesPerRow(LINE_BITS);
  85.     bodydatasize  = MaxPackedSize(BytesPerRow(LINE_BITS));
  86.     planedata = malloc(4 + planedatasize);
  87.     bodydata  = malloc(4 + bodydatasize);
  88.  
  89.     for (lines=0;;lines++) {
  90.     unsigned char  *p, *b;
  91.     long        size;
  92.  
  93.     memset(planedata, 0, planedatasize);
  94.     size = fromfax(faxfile, planedata);
  95.     if (size == -1) {
  96.         debug(("size = -1 = fromfax()\n"));
  97.         break;
  98.     }
  99.     if (invert)
  100.         meminvert(planedata, planedatasize);
  101.     p = planedata;
  102.     b = bodydata;
  103.     size = PackRow(&p, &b, LINE_BITS / 8);
  104.     WriteChunkBytes(pi->iff, bodydata, size);
  105.     }
  106.  
  107.     free(bodydata);
  108.     free(planedata);
  109.  
  110.     return lines;
  111. }
  112.  
  113. long
  114. dopage(FILE *faxfile, struct ParseInfo *pi)
  115. {
  116.     long        bmhdpos;
  117.     long        currpos;
  118.     int         lines;
  119.     FILE       *ifffile;
  120.     UBYTE        cm[] = {
  121.             255, 255, 255,        /* color 0: white */
  122.             0,   0,   0,        /* color 1: black */
  123.             };
  124.     CamgChunk        camg = { HIRES | LACE };
  125.     BitMapHeader    bmhd = {
  126.             LINE_BITS, 9999,    /* w, h (unknown yet) */
  127.             0, 0,            /* x, y */
  128.             1,            /* nPlanes */
  129.             mskNone,        /* masking */
  130.             cmpByteRun1,        /* compression */
  131.             0,            /* reserved1 */
  132.             0,            /* transparentcolor */
  133.             X_DPI, Y_DPI,    /* xAspect, yAspect */
  134.             LINE_BITS, 9999,    /* pageWidth, pageHeight */
  135.             };
  136.  
  137.     if (faxin.faxhdr.info.hires) camg.ViewModes = HIRES | LACE;
  138.     else camg.ViewModes = HIRES;
  139.  
  140.     if (faxin.faxhdr.info.hires) bmhd.yAspect = Y_DPI;
  141.     else bmhd.yAspect = Y_DPI / 2;
  142.  
  143.     PushChunk(pi->iff, ID_ILBM, ID_FORM, IFFSIZE_UNKNOWN);
  144.     PutCk(pi->iff, ID_CMAP, sizeof(cm), (BYTE *)cm);
  145.     PutCk(pi->iff, ID_CAMG, sizeof(camg), (BYTE *)&camg);
  146.  
  147.     /*
  148.      * This is DIRTY DIRTY DIRTY!!
  149.      * We need to update the BitMapHeader later on because we
  150.      * don't know the y size yet.
  151.      */
  152.     ifffile = (FILE *)pi->iff->iff_Stream;
  153.     bmhdpos = ftell(ifffile) + 8;
  154.     putbmhd(pi->iff, &bmhd);
  155.  
  156.     PushChunk(pi->iff, ID_ILBM, ID_BODY, IFFSIZE_UNKNOWN);
  157.  
  158.     lines = dobody(faxfile, pi);
  159.     debug(("lines = %d = dobody()\n", lines));
  160.  
  161.     PopChunk(pi->iff);  /* BODY */
  162.     PopChunk(pi->iff);  /* FORM ILBM */
  163.  
  164.     /* Update BMHD */
  165.     bmhd.h = lines;
  166.     bmhd.pageHeight = lines;
  167.     currpos = ftell(ifffile);
  168.     if (fseek(ifffile, bmhdpos, SEEK_SET) == 0) {
  169.     fwrite(&bmhd, sizeof(bmhd), 1, ifffile);
  170.     fseek(ifffile, currpos, SEEK_SET);
  171.     } else {
  172.     fprintf(stderr, "fseek on iff-file failed\n");
  173.     }
  174.  
  175.     return 0;
  176. }
  177.  
  178. long
  179. dofile(char *faxname, struct ParseInfo *pi)
  180. {
  181.     FILE       *faxfile;
  182.     long        error;
  183.  
  184.     faxfile = fopen(faxname, "rb");
  185.     if (faxfile == NULL)
  186.     return 1;
  187.  
  188.     error = faxin_open_fp(faxfile, 0, bitorder);
  189.     debug(("%d = faxin_open_fp(%s)\n", error, faxname));
  190.  
  191.     while (error == 0 && faxin_begin_page(faxfile) == 0) {
  192.     debug(("0 = faxin_begin_page\n"));
  193.     error = dopage(faxfile, pi);
  194.     debug(("%d = dopage()\n", error));
  195.     }
  196.  
  197. error:
  198.     fclose(faxfile);
  199.     return error;
  200. }
  201.  
  202.  
  203. /*
  204.  * Clean up system stuff in case of exit
  205.  */
  206. void
  207. cleanup(void)
  208. {
  209.     if (IFFParseBase) {
  210.     if (ParseInfo.iff) {
  211.         closeifile(&ParseInfo);
  212.         FreeIFF(ParseInfo.iff);
  213.     }
  214.     CloseLibrary(IFFParseBase);
  215.     }
  216. }
  217.  
  218. int
  219. main(int argc, char **argv)
  220. {
  221.     struct IFFHandle *iff;
  222.     char       *outfile = "fax.iff";
  223.     extern char    *optarg;
  224.     extern int        optind;
  225.     extern int        getopt(int, char **, char *);
  226.     int         errflg = 0;
  227.     int         c;
  228.     int openError;
  229.  
  230.     while ((c = getopt(argc, argv, "1b:io:v")) != -1) {
  231.     switch (c) {
  232.     case '1':
  233.         nocat = 1;
  234.         break;
  235.     case 'b':
  236.         bitorder = *optarg ? atoi(optarg) : 1;
  237.         break;
  238.     case 'i':
  239.         invert = 1;
  240.         break;
  241.     case 'o':
  242.         outfile = optarg;
  243.         break;
  244.     case 'v':
  245.         verbose = TRUE;
  246.         break;
  247.     case '?':
  248.         errflg++;
  249.         break;
  250.     }
  251.     }
  252.  
  253.     if (errflg || optind >= argc) {
  254.     printf(
  255. "Usage: fax2iff [-o iff-file (fax.iff)] [-v] [-i (invert)] [-1]\n"
  256. "       [-b0/1 (bitorder)] fax-files\n");
  257.     exit(10);
  258.     }
  259.  
  260.     atexit(cleanup);
  261.  
  262.     IFFParseBase = OpenLibrary("iffparse.library", 0);
  263.     if (IFFParseBase == NULL) {
  264.     printf("Needs iffparse.library.\n");
  265.     exit(10);
  266.     }
  267.  
  268.     if (optind == argc - 1)
  269.     nocat = !nocat;
  270.     iff = AllocIFF();
  271.     ParseInfo.iff = iff;
  272.     openError = openifile(&ParseInfo, outfile, IFFF_WRITE);
  273.  
  274.     if (!nocat)
  275.     PushChunk(iff, ID_ILBM, ID_CAT, IFFSIZE_UNKNOWN);
  276.  
  277.     if (!openError)
  278.       while (optind < argc) {
  279.     debug(("calling dofile '%s'\n", argv[optind]));
  280.     dofile(argv[optind], &ParseInfo);
  281.     optind++;
  282.     if (nocat)
  283.       break;
  284.       }
  285.  
  286.     if (!nocat)
  287.     PopChunk(iff);          /* CAT  */
  288.     closeifile(&ParseInfo);
  289.     FreeIFF(iff);
  290.     ParseInfo.iff = NULL;
  291.  
  292.     /*CloseLibrary(IFFParseBase);*/
  293.     return 0;
  294. }
  295.