/* IFFTOPS - ILBM IFF format file to PostScript translator. */ /* Version 3.0 - LeRoy Fundingsland - 12/12/88 - SRC */ /* */ /* This code has been compiled and tested under both Sun */ /* UNIX (V3.5) and Commodore AmigaDOS (V1.2). On the */ /* Amiga the Lattice 4.0 compiler was used ("lc -Lm"). */ /* CLAZ.c v2.0 */ /* by Steve Ludtke */ /* Created : 05/31/87 */ /* Re-written Oct-Dec 1988 by LeRoy Fundingsland */ /* Supercomputing Research Center */ /* Lanham, MD */ /* funding@metropolis.super.org */ /* */ /* Changes: */ /* - code re-structured for readability and maintain- */ /* ability (my opinion (mostly:-)) */ /* - comments added for readability (but mostly just so I */ /* could understand the code) */ /* - code extended, with IFDEFs, to be compilable on SUN */ /* systems (or nearly any 4.2BSD derived system, */ /* I expect) */ /* - extended to generate color postscript output (as of */ /* the above date, color postscript output */ /* devices may be pretty rare but we have one and */ /* I think they will be be increasingly common in */ /* the future) */ /* - code extended, again with IFDEFs, to contain a rough */ /* attempt at reducing the grainyness of the */ /* output image (ref. "SMOOTH_INCLUDE") */ /* - added the function for the image to be arbitrarily */ /* rotated */ /* */ /* TODO: */ /* - place all of the initialization of default */ /* values to happen at compile time */ /* - make sure that every value in the "cmap" array is */ /* non-negative */ /* - QUESTION: when an Amiga process exits is the */ /* programmer guaranteed that all system resources */ /* are released? (specifically MALLOCed memory)? */ /* the following DEFINE is for /* 1 */ /* IFDEFing code which is specific to /* 1 */ /* the QMS ColorScript-100 laser /* 1 */ /* printer. /* 1 */ #define QMS /* 1 */ #define SMOOTH_INCLUDE /* 1 */ /* The code in this file has been /* 1 */ /* constructed so that one, and only /* 1 */ /* one, of the following "environment" /* 1 */ /* "define"s should be included in the /* 1 */ /* active code at any time. /* 1 */ /* /# 1 #/ #define AMIGA /* 1 */ #define SUN /* 1 */ #include #include #ifdef AMIGA /* 1 */ #undef NULL /* 1 */ #include #endif AMIGA /* 1 */ #ifdef SUN /* 1 */ #define BYTE char /* 1 */ #define UBYTE unsigned char /* 1 */ #define WORD short /* 1 */ #define UWORD unsigned short /* 1 */ #define LONG int /* 1 */ #endif SUN /* 1 */ /* define IFF structures */ struct CMAP { UBYTE r,g,b; }; struct BMHD { UWORD w,h; WORD x,y; UBYTE npl; UBYTE masking,compression,pad1; UWORD tcolor; UBYTE xas,yas; WORD pWid,pHig; }; char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', /* 1 */ '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; /* 1 */ /* 1 */ #ifdef SUN /* 1 */ #define TRUE 1 /* 1 */ #define FALSE 0 /* 1 */ #endif SUN /* 1 */ int blacknwhite = TRUE; /* 1 */ /* 1 */ char *filename_err1 = /* 1 */ "ERROR: Too many file names on the command line\n"; /* 1 */ char *filename_data1 = /* 1 */ "\t(input=\"%s\", output=\"%s\", error string=\"%s\")\n\n"; /* 1 */ /* smoothing related declarations /* 1 */ int smooth = 0; /* 1 */ int width, height; /* 1 */ /* pointers to storage where pixel /* 1 */ /* values are held during smoothing /* 1 */ char *pixelrow, *smoothrow; /* 1 */ char *malloc(); void putval1(); /* 1 */ void putval2(); /* 1 */ void /* 1 */ main(argc, argv) int argc; char *argv[];{ struct BMHD mhd; long len1, len2, cnt, m, h, i, j, k, lr, lb, lg, x1, x2, y1, y2, showpage; int fl1, b; int rotate = 0; /* 1 */ BYTE t; UBYTE cmap[100]; char *raster=NULL, *rp, *infile=NULL, inspace[80], /* 1 */ *outfile=NULL, c, *misc=NULL; /* 1 */ LONG msc1[3], msc2[2]; /* 1 */ FILE *fin, *fout; if(argc == 1){ /* 1 */ usage: /* 1 */ printf("Usage is: ifftops "); /* 1 */ printf("[-c] [-h]"); /* 1 */ #ifdef SMOOTH_INCLUDE /* 1 */ printf(" [-s]"); /* 1 */ #endif SMOOTH_INCLUDE /* 1 */ printf(" [-r ]\n"); /* 1 */ printf("\t\t[-p ,,"); /* 1 */ printf(",]\n"); /* 1 */ printf("\t\t []\n"); /* 1 */ if(raster != NULL) /* 1 */ free(raster); /* 1 */ if(misc != NULL) /* 1 */ free(misc); /* 1 */ exit(); /* 1 */ } /* 1 */ showpage=1; x1=10; y1=10; x2=550; y2=480; /* 1 */ #ifdef QMS /* 1 */ y1 = (14*72)/16; /* mechanical paper handlng */ /* 1 */ #endif QMS /* 1 */ /* Get enough memory, figure out filespecs */ raster = malloc(200000); if (raster == NULL) { printf("Not enough memory. (1)\n"); exit(0); }/* 1 */ misc = malloc(2000); if(misc == NULL) /* 1 */ { printf("Not enough memory. (2)\n"); exit(0); }/* 1 */ /* parse command line arguments */ for(argc--,argv++; argc > 0; argc--, argv++){ /* 1 */ if(argv[0][0] == '-'){ /* 1 */ switch(argv[0][1]){ /* 1 */ case 'c': /* "color" output */ /* 1 */ blacknwhite = FALSE; /* 1 */ break; /* 1 */ case 'h': /* "hold" printout */ /* 1 */ showpage = FALSE; /* 1 */ break; /* 1 */ case 'p': /* "position" image */ /* 1 */ if(argv[0][2] != 0) /* 1 */ goto bad_p_flag; /* 1 */ argc--; argv++; /* 1 */ if(argc < 1) /* 1 */ goto bad_p_flag; /* 1 */ i = /* 1 */ sscanf(argv[0],"%ld,%ld,%ld,%ld",/* 1 */ &x1, &y1, &x2, &y2); /* 1 */ if(i != 4){ /* 1 */ bad_p_flag: printf("Bad format "); /* 1 */ printf("for 'p' flag\n");/* 1 */ goto usage; /* 1 */ } /* 1 */ break; /* 1 */ case 'r': /* "rotate" image */ /* 1 */ if(argv[0][2] != 0) /* 1 */ goto bad_r_flag; /* 1 */ argc--; argv++; /* 1 */ if(argc < 1) /* 1 */ goto bad_r_flag; /* 1 */ i = /* 1 */ sscanf(argv[0],"%ld",&rotate); /* 1 */ if(i != 1){ /* 1 */ bad_r_flag: printf("Bad format "); /* 1 */ printf("for 'r' flag\n");/* 1 */ goto usage; /* 1 */ } /* 1 */ if(rotate >= 360 || /* 1 */ rotate <= -360) /* 1 */ goto bad_r_flag; /* 1 */ break; /* 1 */ #ifdef SMOOTH_INCLUDE /* 1 */ case 's': /* "smooth" image */ /* 1 */ /* if(argv[0][2] == 0){ /* 1 */ smooth = 1; /* 1 */ /* break; /* 1 */ /* } /* 1 */ #ifdef NEVERDEF sscanf(&argv[0][2], "%d", &smooth); if(smooth == 0) /* 1 */ goto usage; /* 1 */ if(smooth < 1 || smooth > 3){ /* 1 */ printf("Invalid \"smooth\" "); printf("value.\n"); /* 1 */ exit(1); /* 1 */ } /* 1 */ #endif NEVERDEF break; /* 1 */ #endif SMOOTH_INCLUDE /* 1 */ default: /* 1 */ printf("Unknown flag '%c'\n", /* 1 */ *argv[1]); /* 1 */ exit(1); /* 1 */ } /* 1 */ } /* 1 */ else { /* file designator */ /* 1 */ /* maximum of two files allowed /* 1 */ /* the first one is the input /* 1 */ /* file, the second, if it /* 1 */ /* exists is the output file /* 1 */ if(infile == NULL) /* 1 */ infile = *argv; /* 1 */ else if(outfile == NULL) /* 1 */ outfile = *argv; /* 1 */ else{ /* 1 */ printf(filename_err1); /* 1 */ printf(filename_data1, infile, /* 1 */ outfile, *argv); /* 1 */ goto usage; /* 1 */ } /* 1 */ } /* 1 */ } /* end of argument parsing FOR loop */ /* 1 */ if(infile == NULL){ /* 1 */ printf("ERROR: input file name required.\n\n"); /* 1 */ goto usage; /* 1 */ } /* 1 */ printf("\n\n IFFTOPS - IFF to POSTSCRIPT"); printf(" converter V3.0\n"); printf(" By LeRoy Fundingsland\n"); printf(" (via Steve Ludtke)\n"); printf(" N\251 - No Copyright 1988\n"); printf("\n"); printf("File in : "); if(infile != NULL) /* 1 */ printf("%s\n", infile); else{ /* no input file supplied */ infile = inspace; /* 1 */ scanf("%s", infile); } if(outfile == NULL) /* 1 */ outfile = "out.ps"; fin = fopen(infile, "r"); if(fin == NULL) { printf("Sorry, can't open input file.\n"); exit(0); } if ((fread((char *)msc1,12,1,fin)) == 0) /* 1 */ { printf("Sorry, input file problem #1\n"); exit (0); } /* /# 1 #/ len1 = (long *)&msc1[4]; */ /* 1 */ len1 = msc1[1]; /* 1 */ printf("main : %d,%4s\n", len1, (char *)&msc1[0]); /* 1 */ cnt = 14; /* len1=# bytes in file according to IFF */ /* msc2=the name of the current chunk */ /* len2=# bytes in current chunk */ /* by the way, UNID is symply any chunk the program */ /* doesn't deal with */ /* Reads in the IFF file : */ while(cnt < len1){ fl1 = 0; if ((fread((char *)msc2,8,1,fin)) == 0) /* 1 */ {printf("Sorry, bad input file. \n"); exit(0);} /* /# 1 #/ len2 = (long *)&msc2[4]; */ /* 1 */ len2 = msc2[1]; /* 1 */ if (strncmp((char *)msc2,"CMAP",4) == 0) { /* 1 */ if ((fread(cmap,len2,1,fin)) == 0) { printf("Sorry, bad CMAP. \n"); exit(0); } printf("CMAP\n"); fl1 = 1; } if (strncmp((char *)msc2,"BMHD",4) == 0) { /* 1 */ if ((fread((char *)&mhd,len2,1,fin)) == 0) { printf("Sorry, bad BMHD. \n"); exit(0); } printf("BMHD\n"); fl1 = 1; } if (strncmp((char *)msc2,"BODY",4) == 0) { /* 1 */ printf("BODY\n"); #ifdef DEBUG /* 1 */ printf("\t\tlength of BODY chunk (from file) = %d\n", len2); /*999*/ #endif DEBUG /* 1 */ fl1 = 1; m = 0; rp = raster; if (mhd.compression == 1) { while (m <= len2) { t = getc(fin); m++; if (t >= 0) { t++; fread(rp,(long) t,1,fin); rp += t; m += t; } if (t<0) { t=(-t)+1; c=getc(fin); m++; for (i=0; i 1) { printf("Sorry, unknown compression type.\n"); exit(0); } } /* end of "BODY" IF statement */ if (fl1 == 0) { if (len2 > 2000) { printf("Sorry, UNID too long.\n"); exit(0); } if ((fread(misc,len2,1,fin)) == 0) { printf("Sorry, UNID bad. \n"); exit(0); } printf("UNID\n"); } cnt += len2; cnt += 8; } /* end of IFF-file-reading WHILE loop */ #ifdef DEBUG /* 1 */ printf("Total bytes read into \"raster\" = %d\n", rp-raster); /*999*/ #endif DEBUG /* 1 */ fclose(fin); /* inform user if file already exists /* 1 */ /* and is being appended to /* 1 */ if((fout=fopen(outfile,"r")) != NULL){ /* 1 */ printf("Output file, \"%s\", already exists.\n",/* 1 */ outfile); /* 1 */ printf("Output is being appended to this file.\n"); fclose(fout); /* 1 */ } /* 1 */ if ((fout=fopen(outfile,"a")) == NULL) { printf("Sorry, cannot open output file.\n"); exit(0); } /* Standard POSTSCRIPT program, the only part following the data is */ /* the showpage command. */ if(smooth){ /* 1 */ width = mhd.w * 2; /* 1 */ height = mhd.h * 2; /* 1 */ /* the "pixelrow" array is sized at one /* 1 */ /* byte for each pixel because it will /* 1 */ /* hold the ASCII-HEX (see "hex" array) /* 1 */ /* value for each pixel. /* 1 */ /* (3 bytes for each pixel if color) /* 1 */ if(blacknwhite == TRUE) /* 1 */ pixelrow = malloc(width); /* 1 */ else /* color */ /* 1 */ pixelrow = malloc(width * 3); /* 1 */ if(pixelrow == NULL) /* 1 */ { printf("Not enough memory. (3)\n"); exit(0); }/* 1 */ /* the same for the "smoothrow" array /* 1 */ if(blacknwhite == TRUE) /* 1 */ smoothrow = malloc(width); /* 1 */ else /* color */ /* 1 */ smoothrow = malloc(width * 3); /* 1 */ if(smoothrow == NULL) /* 1 */ { printf("Not enough memory. (4)\n"); exit(0); }/* 1 */ } /* 1 */ else{ /* 1 */ width = mhd.w; /* 1 */ height = mhd.h; /* 1 */ } /* 1 */ /* 1 */ fprintf(fout, "%%!\r"); /* 1 */ fprintf(fout,"[0 0 0 0 0 0] defaultmatrix setmatrix\r");/* 1 */ /* the length of the postscript /* 1 */ /* "picture string" (picstr) must equal /* 1 */ /* the width of the picture in pixels /* 1 */ /* (mhd.w) times the number of bytes of /* 1 */ /* data supplyed per pixel (0.5 for /* 1 */ /* B&W, 1.5 for color). This is so that /* 1 */ /* every time the "image" command /* 1 */ /* invokes the reading procedure, all /* 1 */ /* N bytes representing one scan line /* 1 */ /* are read. /* 1 */ fprintf(fout,"/picstr %d string def\r", (int)(width * (blacknwhite ? 0.5 : 1.5))); /* 1 */ fprintf(fout,"%ld %ld translate\r",x1,y1); if(rotate) /* 1 */ fprintf(fout, "%d rotate\r", rotate); /* 1 */ fprintf(fout,"%ld %ld scale\r",x2,y2); fprintf(fout, "%d %d 4 [%d 0 0 -%d 0 %d]\r", width, height, width, height, height); /* 1 */ fprintf(fout,"{currentfile picstr readhexstring pop}"); #ifdef QMS /* 1 */ if(blacknwhite == FALSE) /* 1 */ fprintf(fout, " false 3 colorimage\r"); /* 1 */ else /* color! */ /* 1 */ #endif QMS /* 1 */ fprintf(fout, " image\r"); /* calculate and output file */ lb = lr = lg = 0; printf("rast size : %d #planes : %d\n", mhd.w*mhd.h/8, mhd.npl); /* 1 */ /* what does this do? */ for (h=0; h<96; h++) cmap[h] = cmap[h]/16; for (h=0; h=0;k--) { b=0; for(j=0; j>k; c &= 1; b |= c; b <<= 1; } b >>= 1; /* this is for HAM pictures */ if (mhd.npl == 6) { c = (b&48) >> 4; b &= 15; if (c == 0) { b *= 3; lr = cmap[b]; lb = cmap[b+1]; lg = cmap[b+2]; } if (c == 1) lb = b; if (c == 2) lr = b; if (c == 3) lg = b; } if (mhd.npl != 6) { b &= 31; b *= 3; lr = cmap[b]; lb = cmap[b+1]; lg = cmap[b+2]; } if(blacknwhite){ /* 1 */ m = lr+lb+lg; m = m/3; if (m < 0) m = 0; if (m > 14) m = 14; #ifdef SMOOTH_INCLUDE /* 1 */ putval1(m, fout, h, /* 1 */ (i*8) + (7-k)); /* 1 */ #else SMOOTH_INCLUDE /* 1 */ putc(hex[m], fout); #endif SMOOTH_INCLUDE /* 1 */ } /* 1 */ else{ /* color! */ /* 1 */ #ifdef SMOOTH_INCLUDE /* 1 */ putval2(lr,lg,lb,fout, /* 1 */ h,(i*8)+(7-k)); /* 1 */ #else SMOOTH_INCLUDE /* 1 */ putc(hex[lr], fout); putc(hex[lg], fout); putc(hex[lb], fout); #endif SMOOTH_INCLUDE /* 1 */ } /* 1 */ } } } /* end of map-header-count FOR loop */ fprintf(fout,"\r"); if(showpage) /* 1 */ fprintf(fout,"showpage\r"); fclose(fout); printf("Done !!!\n"); free(misc); free(raster); #ifdef DEBUG /* 1 */ printf("\n\tmhd.w = %d mhd.h = %d\n", mhd.w, mhd.h); /*999*/ printf("\twidth = %d height = %d\n", width, height); /*999*/ #endif DEBUG /* 1 */ } #ifdef SMOOTH_INCLUDE /* 1 */ void /* 1 */ putval1(pixelval, fout, rownum, pixelnum) /* 1 */ char pixelval; /* the binary value */ /* 1 */ int rownum, pixelnum; FILE *fout;{ int i; char tempval; /* NOTE: the raw values are placed in */ /* the odd numbered elements of the */ /* arrays and the averaged values are */ /* placed in the even numbered elements.*/ /* The exception to this is the zeroth */ /* pixels and row. Since these values */ /* cannot be produced (because there is */ /* no previous value to average with) */ /* they are initialized with the value */ /* of the zeroth pixel (which also */ /* exists in array element numbered "1")*/ if(smooth){ if(rownum == 0){ if(pixelnum == 0){ smoothrow[0] = pixelval; smoothrow[1] = pixelval; pixelrow[0] = pixelval; pixelrow[1] = pixelval; } else{ smoothrow[(2*pixelnum)+1] = pixelval; pixelrow[(2*pixelnum)+1] = pixelval; tempval = (pixelrow[(2*pixelnum)-1] + pixelval) / 2; smoothrow[2*pixelnum] = tempval; pixelrow[2*pixelnum] = tempval; } } else{ /* rownum != 0 */ if(pixelnum == 0){ smoothrow[1] = (pixelrow[1] + pixelval) / 2; pixelrow[1] = pixelval; smoothrow[0] = smoothrow[1]; pixelrow[0] = pixelval; } else{ smoothrow[(2*pixelnum)+1] = (pixelrow[(2*pixelnum)+1] + pixelval) / 2; pixelrow[(2*pixelnum)+1] = pixelval; tempval = (pixelrow[(2*pixelnum)-1] + pixelval) / 2; smoothrow[2*pixelnum] = (pixelrow[2*pixelnum] + tempval) / 2; pixelrow[2*pixelnum] = tempval; } } /* if the last pixel in the row has */ /* been processed then write the two */ /* rows to the output file. */ if(pixelnum == ((width/2) - 1)){ for(i=0; i < width; i++) putc(hex[smoothrow[i]], fout); for(i=0; i < width; i++) putc(hex[pixelrow[i]], fout); } } else /* no smoothing */ putc(hex[pixelval], fout); } #define SETPIXELS(array,index,r,g,b) /* 1 */\ array[(3*index)+0] = r; /* 1 */\ array[(3*index)+1] = g; /* 1 */\ array[(3*index)+2] = b; /* 1 */ #define AVE0PIX(array,index,val) /* 1 */\ ((array[(3*index)+0]+val)/2) #define AVE1PIX(array,index,val) /* 1 */\ ((array[(3*index)+1]+val)/2) #define AVE2PIX(array,index,val) /* 1 */\ ((array[(3*index)+2]+val)/2) void /* 1 */ putval2(redval, greenval, blueval, fout, rownum, pixelnum) /* 1 */ char redval, greenval, blueval; /* the binary value */ /* 1 */ int rownum, pixelnum; FILE *fout;{ int i; char tempred, tempgreen, tempblue; /* NOTE: the raw values are placed in */ /* the odd numbered elements of the */ /* arrays and the averaged values are */ /* placed in the even numbered elements.*/ /* The exception to this is the zeroth */ /* pixels and row. Since these values */ /* cannot be produced (because there is */ /* no previous value to average with) */ /* they are initialized with the value */ /* of the zeroth pixel (which also */ /* exists in array element numbered "1")*/ if(smooth){ if(rownum == 0){ if(pixelnum == 0){ SETPIXELS(smoothrow,0,redval, greenval,blueval) SETPIXELS(smoothrow,1,redval, greenval,blueval) SETPIXELS(pixelrow,0,redval, greenval,blueval) SETPIXELS(pixelrow,1,redval, greenval,blueval) } else{ /* store raw values */ SETPIXELS(smoothrow,((2*pixelnum)+1), redval,greenval,blueval) SETPIXELS(pixelrow,((2*pixelnum)+1), redval,greenval,blueval) /* calculate and store */ /* averaged values */ tempred = (pixelrow[(3*((2*pixelnum)-1))+0] + redval) / 2; tempgreen = (pixelrow[(3*((2*pixelnum)-1))+1] + greenval) / 2; tempblue = (pixelrow[(3*((2*pixelnum)-1))+2] + blueval) / 2; SETPIXELS(smoothrow,(2*pixelnum), tempred,tempgreen,tempblue) SETPIXELS(pixelrow,(2*pixelnum), tempred,tempgreen,tempblue) } } else{ /* rownum != 0 */ if(pixelnum == 0){ SETPIXELS(smoothrow,1, AVE0PIX(pixelrow,1,redval), AVE1PIX(pixelrow,1,greenval), AVE2PIX(pixelrow,1,blueval)) SETPIXELS(pixelrow,1,redval, greenval,blueval) SETPIXELS(smoothrow,0,smoothrow[3], smoothrow[4],smoothrow[5]) SETPIXELS(pixelrow,0,redval, greenval,blueval) } else{ SETPIXELS(smoothrow,((2*pixelnum)+1), AVE0PIX(pixelrow,((2*pixelnum)+1),redval), AVE1PIX(pixelrow,((2*pixelnum)+1),greenval), AVE2PIX(pixelrow,((2*pixelnum)+1),blueval)) /* smoothrow[(2*pixelnum)+1] = (pixelrow[(2*pixelnum)+1] + pixelval) / 2; */ SETPIXELS(pixelrow,((2*pixelnum)+1), redval,greenval,blueval) /* calculate and store */ /* averaged values */ tempred = (pixelrow[(3*((2*pixelnum)-1))+0] + redval) / 2; tempgreen = (pixelrow[(3*((2*pixelnum)-1))+1] + greenval) / 2; tempblue = (pixelrow[(3*((2*pixelnum)-1))+2] + blueval) / 2; SETPIXELS(smoothrow,(2*pixelnum), AVE0PIX(pixelrow,(2*pixelnum),tempred), AVE1PIX(pixelrow,(2*pixelnum),tempgreen), AVE2PIX(pixelrow,(2*pixelnum),tempblue)) /* smoothrow[2*pixelnum] = (pixelrow[2*pixelnum] + tempval) / 2; */ SETPIXELS(pixelrow,(2*pixelnum), tempred,tempgreen,tempblue) } } /* if the last pixel in the row has */ /* been processed then write the two */ /* rows to the output file. */ if(pixelnum == ((width/2) - 1)){ for(i=0; i < width; i++){ putc(hex[smoothrow[(3*i)+0]], fout); putc(hex[smoothrow[(3*i)+1]], fout); putc(hex[smoothrow[(3*i)+2]], fout); } for(i=0; i < width; i++){ putc(hex[pixelrow[(3*i)+0]], fout); putc(hex[pixelrow[(3*i)+1]], fout); putc(hex[pixelrow[(3*i)+2]], fout); } } } else{ /* no smoothing */ putc(hex[redval], fout); putc(hex[greenval], fout); putc(hex[blueval], fout); } } #endif SMOOTH_INCLUDE /* 1 */