home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / prog / c / getimg.lha / gi.c < prev    next >
C/C++ Source or Header  |  1990-01-14  |  13KB  |  416 lines
  1. /**********************************************************
  2. *                                                         *
  3. *   gi - a DeluxePaint to C data converter                *
  4. *                                                         *
  5. *   Copyright (c) 1986,  Michael J. Farren                *
  6. *   This program may be freely distributed by any means   *
  7. *   desired, but may not be sold in any form.             *
  8. *                                                         *
  9. **********************************************************/
  10.  
  11. #include <stdio.h>
  12. #undef NULL
  13. #include <exec/types.h>
  14.  
  15. struct BitMapHeader {
  16.    UWORD w,h;      /* raster width, height, in pixels */
  17.    WORD  x,y;      /* pixel position for saved image  */
  18.    UBYTE nplanes;   /* number of bit planes in source  */
  19.    UBYTE masking;   /* masking technique         */
  20.    UBYTE compression;   /* compression algorithm      */
  21.    UBYTE pad1;      /* padding to justify next entry   */
  22.    UWORD transColor;   /* transparent "color number"      */
  23.    UBYTE xAsp, yAsp;   /* x:y aspect ratio         */
  24.    WORD  pageW, pageH;   /* source "page" size in pixels    */
  25.    }  bmhd;
  26. UBYTE Cmap[96],old_cmap[96];   /*  32 color storage */
  27. APTR *(raster_lines[400][6]);   /* pointers to raster lines in bit planes */
  28. LONG colors_in_byte[8], colors_used[32], tran_table[32];
  29. LONG twopowers[7] = { 1, 2, 4, 8, 16, 32, 64 };
  30. BOOL check;
  31.  
  32. main(argc, argv)
  33. int argc;
  34. char *argv[];
  35. {
  36.    WORD bytes_per_line;    /* Number of bytes per raster line */
  37.    FILE *i_file, *o_file;
  38.    UBYTE *buff_pointer, *body_data;    /* storage pointers */
  39.    UBYTE *data_pointer, *buff_pointer_save;
  40.    LONG body_data_size, buff_size;     /* size storage */
  41.    LONG i, j, k, temp;     /* various temporary variables */
  42.    UBYTE tempbyte;
  43.  
  44.    /*  Check arguments, and try to open i/o files  */
  45.  
  46.    if(argc != 3) {
  47.       printf("\nUsage -> getimage <input file> <output file>\n");
  48.       exit(20);
  49.    }
  50.  
  51.    if((i_file = fopen(argv[1], "r")) == 0 ) {
  52.       printf("\nCould not open input file %s!\n", argv[1]);
  53.       exit(20);
  54.    }
  55.  
  56.    if((o_file = fopen(argv[2], "w")) == 0 ) {
  57.       printf("\nCould not open output file %s!\n", argv[2]);
  58.       exit(20);
  59.    }
  60.  
  61.    /* Files are O.K. - skip over first 20 bytes ("FORM", length, "ILBM",
  62.       "BMHD", length) */
  63.  
  64.    printf("\nReading input file...\n");
  65.    if(fseek(i_file, 20L, 0)) read_error();
  66.  
  67.    /* Now, read in the BMHD structure */
  68.  
  69.    chkread(&bmhd, sizeof(struct BitMapHeader), i_file);
  70.  
  71.    /* Skip the CMAP label, and read in the color map length, then the color
  72.       map data.  We assume that the color map length accurately reflects
  73.       the number of bit planes, so don't bother to check the header entry
  74.       bmhd.nplanes.  Also, all Amiga color maps will have an even number of
  75.       entries, so don't bother padding the read out.  */
  76.  
  77.    if(fseek(i_file, 4L, 1)) read_error();    /* skip the label */
  78.    chkread(&temp, sizeof(LONG), i_file);          /* read the length */
  79.  
  80.    i = 0;                  /* and read in the map */
  81.    while( i < temp)
  82.       chkread(&Cmap[i++], 1, i_file);
  83.  
  84.    /* Now, check the next header.  If it isn't "GRAB", this isn't a
  85.       brush file, so get out  */
  86.  
  87.    chkread(&temp, sizeof(LONG), i_file);
  88.    if(temp != ('G'<<24 | 'R'<<16 | 'A'<<8 | 'B')) {
  89.       printf("\nThe input file is not a DeluxePaint brush file!\n");
  90.       exit(20);
  91.    }
  92.  
  93.    /* It's probably a brush file.  Search to find the BODY label, then
  94.       get the body length, then read the body data into body_data[] */
  95.  
  96.    check = FALSE;
  97.    while(check != TRUE) {
  98.       chkread(&temp, sizeof(LONG), i_file);
  99.       if(temp == ('B'<<24 | 'O'<<16 | 'D'<<8 | 'Y')) check = TRUE;
  100.    }
  101.  
  102.    chkread(&body_data_size, sizeof(LONG), i_file);
  103.    body_data = AllocMem(body_data_size, NULL);
  104.    chkread(body_data, body_data_size, i_file);
  105.  
  106.    /* Now, start the good stuff.  First, allocate enough memory to hold
  107.       the entire bitmap for the image. */
  108.  
  109.    bytes_per_line = (bmhd.w & 7 ? bmhd.w+8 : bmhd.w) >> 3;
  110.    if(bytes_per_line & 1) bytes_per_line++;
  111.  
  112.    buff_size = bytes_per_line * bmhd.h * bmhd.nplanes;
  113.    buff_pointer = AllocMem(buff_size, NULL );
  114.    buff_pointer_save = buff_pointer;
  115.    data_pointer = body_data;
  116.  
  117.    /* Next, go through the file line by line, bit plane by bit plane,
  118.       and extract the image data, putting it into bitmap.  As this is
  119.       being done, save pointers to each line in the raster_lines array. */
  120.  
  121.    for(i=0; i!=bmhd.h; i++) {         /* # of lines high */
  122.       for(j=0; j!=bmhd.nplanes; j++) {      /* # of planes      */
  123.          raster_lines[i][j] = buff_pointer;   /* set the pointer */
  124.          if(bmhd.compression == 1) {
  125.  
  126.     /* if compressed, decompress */
  127.  
  128.             expand_map(bytes_per_line, buff_pointer, &data_pointer);
  129.          }
  130.          else {
  131.             for(k=0; k!=bytes_per_line; k++) {
  132.                *(buff_pointer+k) = *(data_pointer++);
  133.             }
  134.          }
  135.          buff_pointer += bytes_per_line;
  136.       }
  137.    }
  138.  
  139.    FreeMem(body_data, body_data_size);   /* deallocate the body data block */
  140.  
  141. /* Now, go through the data, determining the different colors used  */
  142.  
  143. calc_color:
  144.  
  145.    printf("\nAnalyzing data...");
  146.    for(i=0; i!=twopowers[bmhd.nplanes]; colors_used[i++]=0);
  147.    for(i=0; i!=bmhd.h; i++) {
  148.       for(j=0; j!=bmhd.w; j++) {
  149.          colors_used[get_a_bit(i,j)] = 1;
  150.       }
  151.    }
  152.  
  153. /*  Show the current color register stuff */
  154.  
  155. start_over:
  156.  
  157.    printf("\nCurrent color register assignments for this picture are:\n");
  158.  
  159.    for(i=0; i!=twopowers[bmhd.nplanes]; i++) {
  160.       if(colors_used[i]) {
  161.          printf("%2d -> R:%2d G:%2d B:%2d      ",
  162.             i, Cmap[i*3]>>4, Cmap[i*3+1]>>4, Cmap[i*3+2]>>4);
  163.       }
  164.       else {
  165.          printf("%2d -> Not Used            ",i);
  166.       }
  167.       if(i&1) printf("\n");
  168.    }
  169.  
  170. /*  Check to see if the user wants to change any of the register assignments.
  171.     If so, do the appropriate transformations of the data base. */
  172.  
  173.    printf("\nDo you wish to change assignments (y or n)? ");
  174.    do {
  175.       tempbyte = getchar();
  176.    }
  177.    while( (tempbyte!='y')
  178.        && (tempbyte!='Y')
  179.        && (tempbyte!='n')
  180.        && (tempbyte!='N'));
  181.  
  182.    if((tempbyte == 'y') || (tempbyte == 'Y')) {
  183.       if(get_new_colors()) goto start_over; /* If invalid change, loop */
  184.       printf("\nProcessing color change...");
  185.       for(i=0; i!=96; old_cmap[i] = Cmap[i++]);   /* Save old colors */
  186.       for(i=0; i!=bmhd.h; i++) {      /* lines */
  187.          for(j=0; j!=bmhd.w; j++) {      /* bits */
  188.             temp = get_a_bit(i,j);
  189.             if(tran_table[temp]!=-1) {
  190.                put_a_bit(i,j,tran_table[temp]);
  191.                for(k=0; k!=3; k++) {            /* swap colors */
  192.                   Cmap[tran_table[temp]*3+k] = old_cmap[temp*3+k];
  193.                }
  194.             }
  195.          }
  196.       }
  197.       goto calc_color;    /* show the new arrangement */
  198.    }
  199.  
  200. /* Now, write the data to the output file, color map first, then data,
  201.    plane by plane, line by line */
  202.  
  203.    printf("\nWriting output file...");
  204.  
  205. /* Add #include, for compiler */
  206.  
  207.    fprintf(o_file,"#include <exec/types.h>\n");
  208.  
  209. /* Output a few statistics */
  210.  
  211.    fprintf(o_file, "/*   Image %s  \n",argv[1]);
  212.    fprintf(o_file, "     Width:    %d\n",bmhd.w);
  213.    fprintf(o_file, "     Height:   %d\n",bmhd.h);
  214.    fprintf(o_file, "     Depth:    %d  */\n",bmhd.nplanes);
  215.  
  216. /* Start with the color map */
  217.  
  218.    fprintf(o_file, "/* Color Map */\n\n");
  219.    fprintf(o_file, "USHORT map[] = {\n");
  220.    for(i=0; i!=twopowers[bmhd.nplanes]; i++) {
  221.       fprintf(o_file, "   ");
  222.       make_word((Cmap[i*3]<<4)+Cmap[i*3+1]+(Cmap[i*3+2]>>4), o_file);
  223.       if(i!=twopowers[bmhd.nplanes]-1) fprintf(o_file, ",");
  224.       if(colors_used[i]) fprintf(o_file, "    /* USED */");
  225.       fprintf(o_file, "\n");
  226.    }
  227.    fprintf(o_file, "};\n\n");
  228.  
  229. /* Now, do the data */
  230.  
  231.    fprintf(o_file, "/* Image Data */\n\n");
  232.    fprintf(o_file, "UWORD %s[%d] = {\n", argv[1], buff_size/2);
  233.    for(i=0; i!=bmhd.nplanes; i++) {
  234.       fprintf(o_file, "/* Bit Plane #%d */\n\n", i);
  235.       for(j=0; j!=bmhd.h; j++) {
  236.          fprintf(o_file, "   ");
  237.          buff_pointer = raster_lines[j][i];
  238.          for(k=0; k<bytes_per_line; ) {
  239.             tempbyte = *(buff_pointer+(k++));
  240.             make_word((tempbyte << 8) | *(buff_pointer+(k++)), o_file);
  241.             fprintf(o_file, ",");
  242.          }
  243.          fprintf(o_file, "\n");
  244.       }
  245.       fprintf(o_file, "\n");
  246.    }
  247.    fseek(o_file, -3, 1);     /* back up to wipe out the last comma */
  248.    fprintf(o_file, "\n};\n");
  249.  
  250. /* Close up, clean up, and get out */
  251.  
  252.    fclose(o_file);
  253.    fclose(i_file);
  254.    printf("\n");
  255.    FreeMem(buff_pointer_save, buff_size);
  256. }
  257.  
  258. /*  read_error - called if a read error occured */
  259.  
  260. read_error()
  261. {
  262.    printf("\nRead error in input file, aborting\n");
  263.    exit(20);
  264. }
  265.  
  266. /* chkread - reads from input file, checking for errors */
  267.  
  268. chkread(ptr, size, fd)
  269. APTR *ptr;
  270. WORD size;
  271. FILE *fd;
  272. {
  273.    WORD readin;
  274.    readin = fread(ptr, size, 1, fd);
  275.    if(readin != 1) read_error();
  276. }
  277.  
  278. /* expand_map - decompresses data compressed with the byte_run encoding
  279.                 scheme described in the IFF document.  A signed byte, x,
  280.                 is read from the input block.  If the signed value of x
  281.                 is negative, but not -128 ( 0x80 ), the next byte is read
  282.                 and is placed in the output block (-x+1) times.  If the
  283.                 signed value is positive, the next (x+1) bytes are copied
  284.                 directly to the output block.  If the signed value is -128,
  285.                 no operation is performed.
  286. */
  287.  
  288.  
  289. expand_map(length, pointer, data_pointer)
  290. WORD length;
  291. UBYTE *pointer;
  292. UBYTE **data_pointer;
  293. {
  294.  
  295.    WORD minus128 = -128;
  296.    WORD temp;
  297.    BYTE tempbyte;
  298.    UBYTE tempubyte;
  299.  
  300.    while( length > 0 )   {
  301.       tempbyte = *((*data_pointer)++);
  302.       temp = tempbyte;
  303.       if (temp >= 0) {
  304.          temp += 1;
  305.          length-=temp;
  306.          do {
  307.             *(pointer++) = *((*data_pointer)++);
  308.          }
  309.          while (--temp > 0);
  310.       }
  311.       else if (temp != minus128) {
  312.          temp = (-temp) + 1;
  313.          length -= temp;
  314.          tempubyte = *((*data_pointer)++);
  315.          do {
  316.             *(pointer++) = tempubyte;
  317.          }
  318.          while (--temp > 0);
  319.       }
  320.    }
  321. }
  322.  
  323. /* get_a_bit - returns the color value of the bit at location x,y in the
  324.                image.
  325. */
  326.  
  327. get_a_bit(y, x)
  328. LONG y, x;
  329. {
  330.    LONG xbyte, xbit,i;
  331.    UBYTE tempbyte, color;
  332.    UBYTE *pointer;
  333.  
  334.    color = 0;                         /* start with no color */
  335.    xbyte =x>>3;                       /* xbyte = the byte location of x */
  336.    xbit = (1<<(x&7));                 /* xbit = the mask for the bit */
  337.    for(i=0; i!=bmhd.nplanes; i++) {   /* do all the planes */
  338.       pointer = raster_lines[y][i];          /* get the base address */
  339.       tempbyte = *(pointer + xbyte);         /* get the proper byte  */
  340.       if(tempbyte & xbit) color |= (1 << i); /* OR in the color bit  */
  341.    }
  342.    return color;
  343. }
  344.  
  345. /* put_a_bit - sets a given bit to a given color */
  346.  
  347. put_a_bit(y, x, color)
  348. LONG y, x, color;
  349. {
  350.    LONG xbyte, xbit, i;
  351.    UBYTE *pointer;
  352.    UBYTE tempbyte;
  353.  
  354.    for(i=0; i!=bmhd.nplanes; i++) {
  355.       xbyte = x>>3;
  356.       xbit = (1 << (x & 7));
  357.       pointer = raster_lines[y][i];
  358.       tempbyte = *(pointer + xbyte);   /* get the appropriate byte */
  359.       tempbyte &= 0xff-xbit;           /* mask off the proper bit  */
  360.       if(color & twopowers[i]) {       /* if the color bit is set, */
  361.          tempbyte |= xbit;             /* set the bit in the byte  */
  362.       }
  363.       *(pointer + xbyte) = tempbyte;   /* save the modified byte   */
  364.    }
  365. }
  366.  
  367. /* get_new_colors - get the users choices for register assignments */
  368.  
  369. get_new_colors()
  370. {
  371.    int i,j;
  372.  
  373.    for(i=0; i!=twopowers[bmhd.nplanes]; tran_table[i++]=-1); /* reset */
  374.    for(i=1; i!=twopowers[bmhd.nplanes]; i++) {
  375.       if(colors_used[i]) {     /* for each color used in the original */
  376. getnew:
  377.          printf("\nOld color register %2d (R:%2d G:%2d B:%2d) new number:",
  378.             i, Cmap[i*3]>>4, Cmap[i*3+1]>>4, Cmap[i*3+2]>>4);
  379.          scanf("%d", &j);
  380.          if((j<1) || (j>=twopowers[bmhd.nplanes])) {
  381.             printf("\nRegister number must be greater than zero, and less than %2d.",
  382.                twopowers[bmhd.nplanes]);
  383.             printf("\nTry again.");
  384.             goto getnew;
  385.          }
  386.          tran_table[i] = j;
  387.       }
  388.    }
  389.  
  390. /* Check the translation table for duplicated register assignments. */
  391.  
  392.    for(i=1; i!=twopowers[bmhd.nplanes]-1; i++) {
  393.       for(j=i+1; j!=twopowers[bmhd.nplanes]; j++) {
  394.          if((tran_table[i]==-1) || (tran_table[j]==-1)) continue;
  395.          if(tran_table[i] == tran_table[j]) {
  396.             printf("\nDuplicate color register assignment - try again.");
  397.             return -1;
  398.          }
  399.       }
  400.    }
  401.    return 0;
  402. }
  403.  
  404. /* make_word - outputs a string representing a four-digit hex number */
  405.  
  406. make_word(num, fp)
  407. UWORD num;
  408. FILE *fp;
  409. {
  410.    char temp[10];
  411.  
  412.    sprintf(temp, "0000%x\0", num);
  413.    fprintf(fp, "0x%s", &temp[strlen(temp)-4]);
  414. }
  415.  
  416.