home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 2 / goldfish_vol2_cd1.bin / files / comm / misc / elcheapofax / rcs / fax2iff.c,v < prev    next >
Text File  |  1993-12-21  |  8KB  |  415 lines
  1. head    1.5;
  2. access;
  3. symbols
  4.     OCT93:1.5;
  5. locks;
  6. comment    @ * @;
  7.  
  8.  
  9. 1.5
  10. date    93.10.25.02.14.27;    author Rhialto;    state Exp;
  11. branches;
  12. next    1.4;
  13.  
  14. 1.4
  15. date    93.08.20.02.48.24;    author Rhialto;    state Exp;
  16. branches;
  17. next    1.3;
  18.  
  19. 1.3
  20. date    93.07.01.00.44.20;    author Rhialto;    state Exp;
  21. branches;
  22. next    1.2;
  23.  
  24. 1.2
  25. date    93.06.11.16.33.37;    author Rhialto;    state Exp;
  26. branches;
  27. next    1.1;
  28.  
  29. 1.1
  30. date    93.06.11.14.53.53;    author Rhialto;    state Exp;
  31. branches;
  32. next    ;
  33.  
  34.  
  35. desc
  36. @Convert g3 files to IFF ILBM
  37. @
  38.  
  39.  
  40. 1.5
  41. log
  42. @Make +FBOR flexible; fix RTC detection bug.
  43. @
  44. text
  45. @/*
  46.  * fax2iff.c
  47.  *
  48.  * $Id: fax2iff.c,v 1.4 1993/08/20 02:48:24 Rhialto Exp $
  49.  * $Log: fax2iff.c,v $
  50.  * Revision 1.4  1993/08/20  02:48:24  Rhialto
  51.  * Add hack for auto-detecting fax bit order, and an option
  52.  * to specify it explicitly.
  53.  *
  54.  * Revision 1.3  1993/07/01  00:44:20  Rhialto
  55.  * Add CMAP and CAMG chunk. Create CAT only for multiple input files.
  56.  *
  57.  * Revision 1.2  1993/06/11  16:33:37  Rhialto
  58.  * First real RCS checkin
  59.  *
  60.  */
  61.  
  62. #include <stdlib.h>
  63.  
  64. #include "iffp/iff.h"
  65. #include "iffp/ilbm.h"
  66. #include "iffp/packer.h"
  67. #include "faxfile.h"
  68.  
  69. #ifdef DEBUG
  70. #define debug(x)    printf x
  71. #else
  72. #define debug(x)
  73. #endif
  74.  
  75. void           *IFFParseBase;
  76. struct ParseInfo ParseInfo;
  77. int        verbose;
  78. int        invert;
  79. int        bitorder = -1;
  80. int        nocat;
  81.  
  82. /* Assumes malloc()ed pointer */
  83. void
  84. meminvert(unsigned char *d, int size)
  85. {
  86.     while (size >= 4) {
  87.     *(long *)d ^= 0xFFFFFFFF;
  88.     d += 4;
  89.     size -= 4;
  90.     }
  91.     while (size > 0) {
  92.     *d++ ^= 0xFF;
  93.     size--;
  94.     }
  95. }
  96.  
  97. long
  98. dobody(FILE *faxfile, struct ParseInfo *pi)
  99. {
  100.     unsigned char  *planedata;
  101.     unsigned char  *bodydata;
  102.     int         planedatasize;
  103.     int         bodydatasize;
  104.     int         lines;
  105.  
  106.     planedatasize = BytesPerRow(LINE_BITS);
  107.     bodydatasize  = MaxPackedSize(BytesPerRow(LINE_BITS));
  108.     planedata = malloc(4 + planedatasize);
  109.     bodydata  = malloc(4 + bodydatasize);
  110.  
  111.     for (lines=0;;lines++) {
  112.     unsigned char  *p, *b;
  113.     long        size;
  114.  
  115.     memset(planedata, 0, planedatasize);
  116.     size = fromfax(faxfile, planedata);
  117.     if (size == -1) {
  118.         debug(("size = -1 = fromfax()\n"));
  119.         break;
  120.     }
  121.     if (invert)
  122.         meminvert(planedata, planedatasize);
  123.     p = planedata;
  124.     b = bodydata;
  125.     size = PackRow(&p, &b, LINE_BITS / 8);
  126.     WriteChunkBytes(pi->iff, bodydata, size);
  127.     }
  128.  
  129.     free(bodydata);
  130.     free(planedata);
  131.  
  132.     return lines;
  133. }
  134.  
  135. long
  136. dopage(FILE *faxfile, struct ParseInfo *pi)
  137. {
  138.     long        bmhdpos;
  139.     long        currpos;
  140.     int         lines;
  141.     FILE       *ifffile;
  142.     UBYTE        cm[] = {
  143.             255, 255, 255,        /* color 0: white */
  144.             0,   0,   0,        /* color 1: black */
  145.             };
  146.     CamgChunk        camg = { HIRES | LACE };
  147.     BitMapHeader    bmhd = {
  148.             LINE_BITS, 9999,    /* w, h (unknown yet) */
  149.             0, 0,            /* x, y */
  150.             1,            /* nPlanes */
  151.             mskNone,        /* masking */
  152.             cmpByteRun1,        /* compression */
  153.             0,            /* reserved1 */
  154.             0,            /* transparentcolor */
  155.             Y_DPI, X_DPI,        /* xAspect, yAspect */
  156.             LINE_BITS, 9999,    /* pageWidth, pageHeight */
  157.             };
  158.  
  159.     PushChunk(pi->iff, ID_ILBM, ID_FORM, IFFSIZE_UNKNOWN);
  160.     PutCk(pi->iff, ID_CMAP, sizeof(cm), (BYTE *)cm);
  161.     PutCk(pi->iff, ID_CAMG, sizeof(camg), (BYTE *)&camg);
  162.  
  163.     /*
  164.      * This is DIRTY DIRTY DIRTY!!
  165.      * We need to update the BitMapHeader later on because we
  166.      * don't know the y size yet.
  167.      */
  168.     ifffile = (FILE *)pi->iff->iff_Stream;
  169.     bmhdpos = ftell(ifffile) + 8;
  170.     putbmhd(pi->iff, &bmhd);
  171.  
  172.     PushChunk(pi->iff, ID_ILBM, ID_BODY, IFFSIZE_UNKNOWN);
  173.  
  174.     lines = dobody(faxfile, pi);
  175.     debug(("lines = %d = dobody()\n", lines));
  176.  
  177.     PopChunk(pi->iff);  /* BODY */
  178.     PopChunk(pi->iff);  /* FORM ILBM */
  179.  
  180.     /* Update BMHD */
  181.     bmhd.h = lines;
  182.     bmhd.pageHeight = lines;
  183.     currpos = ftell(ifffile);
  184.     if (fseek(ifffile, bmhdpos, SEEK_SET) == 0) {
  185.     fwrite(&bmhd, sizeof(bmhd), 1, ifffile);
  186.     fseek(ifffile, currpos, SEEK_SET);
  187.     } else {
  188.     fprintf(stderr, "fseek on iff-file failed\n");
  189.     }
  190.  
  191.     return 0;
  192. }
  193.  
  194. long
  195. dofile(char *faxname, struct ParseInfo *pi)
  196. {
  197.     FILE       *faxfile;
  198.     long        error;
  199.  
  200.     faxfile = fopen(faxname, "rb");
  201.     if (faxfile == NULL)
  202.     return 1;
  203.  
  204.     error = faxin_open_fp(faxfile, 0, bitorder);
  205.     debug(("%d = faxin_open_fp(%s)\n", error, faxname));
  206.  
  207.     while (error == 0 && faxin_begin_page(faxfile) == 0) {
  208.     debug(("0 = faxin_begin_page\n"));
  209.     error = dopage(faxfile, pi);
  210.     debug(("%d = dopage()\n", error));
  211.     }
  212.  
  213. error:
  214.     fclose(faxfile);
  215.     return error;
  216. }
  217.  
  218.  
  219. /*
  220.  * Clean up system stuff in case of exit
  221.  */
  222. void
  223. cleanup(void)
  224. {
  225.     if (IFFParseBase) {
  226.     if (ParseInfo.iff) {
  227.         closeifile(&ParseInfo);
  228.         FreeIFF(ParseInfo.iff);
  229.     }
  230.     CloseLibrary(IFFParseBase);
  231.     }
  232. }
  233.  
  234. int
  235. main(int argc, char **argv)
  236. {
  237.     struct IFFHandle *iff;
  238.     char       *outfile = "fax.iff";
  239.     extern char    *optarg;
  240.     extern int        optind;
  241.     extern int        getopt(int, char **, char *);
  242.     int         errflg = 0;
  243.     int         c;
  244.  
  245.     while ((c = getopt(argc, argv, "1b:io:v")) != -1) {
  246.     switch (c) {
  247.     case '1':
  248.         nocat = 1;
  249.         break;
  250.     case 'b':
  251.         bitorder = *optarg ? atoi(optarg) : 1;
  252.         break;
  253.     case 'i':
  254.         invert = 1;
  255.         break;
  256.     case 'o':
  257.         outfile = optarg;
  258.         break;
  259.     case 'v':
  260.         verbose = TRUE;
  261.         break;
  262.     case '?':
  263.         errflg++;
  264.         break;
  265.     }
  266.     }
  267.  
  268.     if (errflg || optind >= argc) {
  269.     printf(
  270. "Usage: fax2iff [-o iff-file (fax.iff)] [-v] [-i (invert)] [-1]\n"
  271. "       [-b0/1 (bitorder)] fax-files\n");
  272.     exit(EXIT_FAILURE);
  273.     }
  274.  
  275.     atexit(cleanup);
  276.  
  277.     IFFParseBase = OpenLibrary("iffparse.library", 0);
  278.     if (IFFParseBase == NULL) {
  279.     printf("Needs iffparse.library.\n");
  280.     exit(10);
  281.     }
  282.  
  283.     if (optind == argc - 1)
  284.     nocat = !nocat;
  285.     iff = AllocIFF();
  286.     ParseInfo.iff = iff;
  287.     openifile(&ParseInfo, outfile, IFFF_WRITE);
  288.     if (!nocat)
  289.     PushChunk(iff, ID_ILBM, ID_CAT, IFFSIZE_UNKNOWN);
  290.  
  291.     while (optind < argc) {
  292.     debug(("calling dofile '%s'\n", argv[optind]));
  293.     dofile(argv[optind], &ParseInfo);
  294.     optind++;
  295.     if (nocat)
  296.         break;
  297.     }
  298.  
  299.     if (!nocat)
  300.     PopChunk(iff);          /* CAT  */
  301.     closeifile(&ParseInfo);
  302.     FreeIFF(iff);
  303.     ParseInfo.iff = NULL;
  304.  
  305.     /*CloseLibrary(IFFParseBase);*/
  306. }
  307. @
  308.  
  309.  
  310. 1.4
  311. log
  312. @Add hack for auto-detecting fax bit order, and an option
  313. to specify it explicitly.
  314. @
  315. text
  316. @d4 1
  317. a4 1
  318.  * $Id: fax2iff.c,v 1.3 1993/07/01 00:44:20 Rhialto Exp $
  319. d6 4
  320. d35 1
  321. a35 1
  322. int        reverse = -1;
  323. d160 1
  324. a160 1
  325.     error = faxin_open_fp(faxfile, 0, reverse);
  326. d201 1
  327. a201 1
  328.     while ((c = getopt(argc, argv, "1io:r:v")) != -1) {
  329. d206 3
  330. a214 3
  331.     case 'r':
  332.         reverse = *optarg ? atoi(optarg) : 1;
  333.         break;
  334. d227 1
  335. a227 1
  336. "       [-r0/1 (reverse bits)] fax-files\n");
  337. @
  338.  
  339.  
  340. 1.3
  341. log
  342. @Add CMAP and CAMG chunk. Create CAT only for multiple input files.
  343. @
  344. text
  345. @d4 1
  346. a4 1
  347.  * $Id: fax2iff.c,v 1.2 1993/06/11 16:33:37 Rhialto Exp $
  348. d6 3
  349. d21 6
  350. d31 1
  351. d69 2
  352. a70 1
  353.     if (size == -1)
  354. d72 1
  355. d127 1
  356. d156 2
  357. a157 1
  358.     error = faxin_open_fp(faxfile, 0);
  359. d160 1
  360. d162 1
  361. d197 1
  362. a197 1
  363.     while ((c = getopt(argc, argv, "1io:v")) != -1) {
  364. d208 3
  365. d222 2
  366. a223 1
  367. "Usage: fax2iff [-o iff-file (fax.iff)] [-v] [-i (invert)] [-1] fax-files\n");
  368. d231 1
  369. a231 1
  370.     printf("Needs iffparse.\n");
  371. d244 1
  372. d252 1
  373. a252 1
  374.     PopChunk(iff);        /* CAT  */
  375. @
  376.  
  377.  
  378. 1.2
  379. log
  380. @First real RCS checkin
  381. @
  382. text
  383. @d4 5
  384. a8 2
  385.  * $Id$
  386.  * $Log$
  387. d22 1
  388. d82 5
  389. d100 2
  390. d181 1
  391. a181 1
  392.     while ((c = getopt(argc, argv, "io:v")) != -1) {
  393. d183 3
  394. d203 1
  395. a203 1
  396. "Usage: fax2iff [-o iff-file (fax.iff)] [-v] [-i (invert)] fax-files\n");
  397. d215 2
  398. d220 2
  399. a221 1
  400.     PushChunk(iff, ID_ILBM, ID_CAT, IFFSIZE_UNKNOWN);
  401. d226 2
  402. d230 2
  403. a231 1
  404.     PopChunk(iff);
  405. @
  406.  
  407.  
  408. 1.1
  409. log
  410. @Initial revision
  411. @
  412. text
  413. @d3 3
  414. @
  415.