Graphics Plus/Graphics Plus.iso/general/raytrace/dkb/dkbutsrc.zoo/tga2dump.c

C/C++ Source or Header | 1991-05-16 | 4.9 KB | 183 lines

/***************************************************************

TGA2DUMP.C  - Converts a Targa-16/24/32 file to a DKB/QRT "Dump"
          format raw file.

          Version 1.1 By Aaron A. Collins, written on 1/1/91
          Version 1.2 By Aaron A. Collins, revised on 5/1/91
          Version 1.3 By Aaron A. Collins, revised on 5/15/91

          This file is released to the Public Domain.

 **************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif

#define MAXXRES 2048   /* huge max x resolution allowable, infinite y res. */

write_line(int, FILE *, int);

unsigned char linbuf[MAXXRES * 3];

void main(argc,argv)
int argc;
char *argv[];
{
    register int xres, yres, xhi, yhi;
    register int y, pixelsize, filetype;
    FILE *in, *out;

    printf("\n\nTarga-16/24/32 Image File to DKB/QRT Dump Format Converter\n");
    printf("Version 1.3  By Aaron A. Collins.  Written 1/1/91 Revised 5/15/91\n\n");

    if (argc != 3)
    {
        printf("Usage: %s InputFile OutputFile\n\n",argv[0]);
        exit(1);
    }

    if ((in = fopen(argv[1], "rb")) == NULL)  /* try opening input file */
    {
        printf("ERROR - Couldn't open file %s\n", argv[1]);
        exit(1);
    }

    if ((out = fopen(argv[2], "wb")) == NULL)
    {
        printf("ERROR - Couldn't create file %s\n", argv[2]);
        fclose(in);
        exit(1);
    }

    /** absorb 1st part of Targa header **/

    fgetc(in);        /* absorb 2 0's */
    fgetc(in);

    if ((filetype = fgetc(in)) != 2) /* Uncompressed, Unmapped TGA only */
    {
        printf("\nInvalid Targa File Type %d (Must be 2) - Aborting!\n\n", filetype);
        fclose(in);             /* close all files */
        fclose(out);
        unlink(argv[2]);
        exit(1);
    }

    for (y = 0; y < 9; y++)    /* discard 7 0's and file X/Y origin */
        fgetc(in);

    /** load x and y resolution from input Targa file while copying **/

    xres = fputc(fgetc(in), out);    /* lo order */
    xhi = fputc(fgetc(in), out);    /* hi order */
    xres += ((unsigned int) xhi) << 8;

    if (xres > MAXXRES)            /* too big? */
    {
        printf("ERROR - X res. of %s (%d) exceeds maximum (%d)!\n", argv[1], xres, MAXXRES);
        fclose(in);            /* close all files */
        fclose(out);
        unlink(argv[2]);        /* delete empty out files */
        exit(1);
    }

    yres = fputc(fgetc(in), out);        /* now do yres the same... */
    yhi = fputc(fgetc(in), out);
    yres += ((unsigned int) yhi) << 8;

    pixelsize = fgetc(in);    /* discard bits/pixel and display order */
    fgetc(in);        /* assume top-down display order */

    if (pixelsize != 16 && pixelsize != 24 && pixelsize != 32)
    {
        printf("\nInvalid Targa File Pixel Size %d (must be 16,24,32) - Aborting!\n\n", pixelsize);
        fclose(in);             /* close all files */
        fclose(out);
        unlink(argv[2]);
        exit(1);
    }

    printf("Input file         = %s\n", argv[1]);    /* show stats */
    printf("Bits per pixel     = %d\n", pixelsize);
    printf("Output file        = %s\n", argv[2]);
    printf("Image X resolution = %d\n", xres);
    printf("Image Y resolution = %d\n", yres);

    printf("\nProcessing Line:   0");

    for (y = 0; y < yres; y++)    /* for every line in the in file */
    {
        printf("\b\b\b%3d", y);        /* disp. current line # */

        if (feof(in))            /* stop if file truncated */
            break;

        fread(linbuf, 1, xres * (pixelsize/8), in); /* read a line */

        fputc(y & 0x00ff, out);        /* write line # out */
        fputc((y & 0xff00) >> 8, out);

        if (write_line(xres, out, pixelsize))
        {
            printf("File output error on %s.  Disk Full?\n", argv[2]);
            fclose(in);
            fflush(out);
            fclose(out);
            exit(1);
        }
    }
    printf("\n");
    fclose(in);                                 /* close all files */
    fflush(out);
    fclose(out);
    exit(0);
}

write_line(xres, out, pixelsize)
int xres, pixelsize;
FILE *out;
{
    register int idx, x;
    register unsigned int tmp_byte;

    switch (pixelsize)    /* Pixel ordering for Targa-16/24/32 files */
    {
        case 16:
        for (x = 0, idx = 1; x < xres; x++, idx += 2)
            fputc((linbuf[idx] & 0x7C) << 1, out);  /* write Red */
        for (x = 0, idx = 0; x < xres; x++, idx += 2)
        {
            tmp_byte = (linbuf[idx] & 0xE0) >> 2;
            tmp_byte |= (linbuf[idx + 1] & 0x03) << 6;
            fputc(tmp_byte, out);  /* write line of Green */
        }
        for (x = 0, idx = 0; x < xres; x++, idx += 2)
            fputc((linbuf[idx] & 0x1F) << 3, out);  /* write Blue */
        break;
        case 24:
        for (x = 0, idx = 2; x < xres; x++, idx += 3)
            fputc(linbuf[idx], out);  /* write line of Red */
        for (x = 0, idx = 1; x < xres; x++, idx += 3)
            fputc(linbuf[idx], out);  /* write line of Green */
        for (x = 0, idx = 0; x < xres; x++, idx += 3)
            fputc(linbuf[idx], out);  /* write line of Blue */
        break;
        case 32:
        for (x = 0, idx = 2; x < xres; x++, idx += 4)
            fputc(linbuf[idx], out);  /* write line of Red */
        for (x = 0, idx = 1; x < xres; x++, idx += 4)
            fputc(linbuf[idx], out);  /* write line of Green */
        for (x = 0, idx = 0; x < xres; x++, idx += 4)
            fputc(linbuf[idx], out);  /* write line of Blue */
        break;
    }
    return(ferror(out));
}