targatorle.c File Reference

#include <stdio.h>
#include <sys/types.h>
#include "rle.h"

Include dependency graph for targatorle.c:

Go to the source code of this file.

Data Structures
struct	targafile

Macros
#define	HEADSIZE   18
#define	GETSHORT(N)   (((unsigned short)(*(N+1))<<8) + (unsigned short)(*(N)))

Functions
void	targa_getrow ()
void	init_comp ()
unsigned char	getbyte ()
void	main (int argc, argv)

Variables
unsigned char *	outrows [4]
unsigned char *	redline
unsigned char *	grnline
unsigned char *	bluline
unsigned char *	alfline
FILE *	infile
int	bwimage =0
int	truecolor =0
int	cmapped =0
int	rlcomp =0
int	nchannels
int	cmapbytes
int	pixwidth
struct targafile	tga_head
int	havedata =0
int	rlcount
int	bufinx
unsigned char	rlbuf [4 *128]

Macro Definition Documentation

#define GETSHORT

(

N

)

(((unsigned short)(*(N+1))<<8) + (unsigned short)(*(N)))

Definition at line 78 of file targatorle.c.

#define HEADSIZE   18

Definition at line 77 of file targatorle.c.

Function Documentation

unsigned char getbyte

(

)

Definition at line 461 of file targatorle.c.

References bufinx, havedata, infile, pixwidth, rlbuf, rlcomp, and rlcount.

{
  int j,k;
  int pkhdr;
  unsigned char pixdata[4];
  unsigned char *pp;
  unsigned char next;

  if (!rlcomp)
  {
     next = (unsigned)getc(infile)&0xff;
     return next;
  }

  if (!havedata)
  {
    pkhdr = getc(infile);
    rlcount = (pkhdr & 0x7f) + 1;

    if (pkhdr & 0x80)   /* Run-length packet */
    {
      fread(pixdata,pixwidth,1,infile);
      pp = rlbuf;
      for(k=0; k<rlcount; k++)
      for(j=0; j<pixwidth; j++)
        *(pp++) = pixdata[j];
    }
    else        /* Raw packet */
    {
      fread(rlbuf,pixwidth,rlcount,infile);
    }
    rlcount *= pixwidth;
    bufinx = 0;
    havedata = 1;
  }

  next = rlbuf[bufinx];
  if (++bufinx == rlcount) havedata = 0;

  return next;
}

void init_comp

(

)

Definition at line 456 of file targatorle.c.

References havedata.

{
  havedata = 0;
}

void main	(	int	argc,
		argv
	)

Definition at line 123 of file targatorle.c.

{ 
    FILE       *outfile;
    FILE       *hdrfile=NULL;
    char       *infname=NULL, 
               *outfname=NULL, 
               *hdrfname=NULL;
    int     oflag=0,
        nflag=0,
            hflag=0;
    int     i;
    unsigned char headbuf[HEADSIZE];
    rle_hdr out_hdr;

    if ( scanargs( argc,argv,
           "% h%-hdrfile!s n%-nchannels!d o%-outfile!s infile%s\n(\
\tConvert TARGA file to URT format.\n\
\t-h\tSpecify separate header file.\n\
\t-n\tNumber of channels to write, defaults to same as input.)",
           &hflag, &hdrfname, &nflag, &nchannels,
           &oflag, &outfname, &infname ) == 0 )
    exit(1);

    out_hdr = *rle_hdr_init( (rle_hdr *)NULL );
    rle_names( &out_hdr, cmd_name( argv ), outfname, 0 );

    infile  = rle_open_f(out_hdr.cmd, infname, "r");
    if ( hflag )
    hdrfile = rle_open_f(out_hdr.cmd, hdrfname, "w");
    outfile = rle_open_f(out_hdr.cmd, outfname, "w");

    /* Check that hdrfile and outfile aren't the same. */

    if ( hdrfile == outfile )
    {
    fprintf( stderr,
         "%s: Can't write header and RLE data to same file.\n",
         out_hdr.cmd );
    exit( 1 );
    }

    /* Read the image header */

    if (fread (headbuf, 1, HEADSIZE, infile)!=HEADSIZE)
    {
      fprintf(stderr,"targatorle: Read Error.\n");
      exit(1);
    }

    tga_head.num_char_id = headbuf[0];
    tga_head.cmap_type   = headbuf[1];
    tga_head.image_type  = headbuf[2];

    tga_head.cmap_origin = GETSHORT(headbuf+3);
    tga_head.cmap_length = GETSHORT(headbuf+5);
    tga_head.cmap_size   = headbuf[7];

    tga_head.image_x_origin = GETSHORT(headbuf+8);
    tga_head.image_y_origin = GETSHORT(headbuf+10);
    tga_head.image_width    = GETSHORT(headbuf+12);
    tga_head.image_height   = GETSHORT(headbuf+14);
    tga_head.image_pix_size = headbuf[16];

    tga_head.image_descriptor = headbuf[17];

    if (hflag) {
    fprintf (hdrfile, "num_char_id = %u \n", (unsigned)tga_head.num_char_id);
    fprintf (hdrfile, "cmap_type   = %u \n", (unsigned)tga_head.cmap_type);
    fprintf (hdrfile, "image_type  = %u \n", (unsigned)tga_head.image_type);
    }

    /* Check Color Map Type.  Currently, Truevision defines only 0 and 1 */

    if (tga_head.cmap_type==0) { 
    if (hflag) {
        fprintf (hdrfile, "Color Map Type = 0 \n");
    }
    }
    else if (tga_head.cmap_type==1) {
    cmapped = 1;
    if (hflag) {
        fprintf (hdrfile, "cmap_origin = %u \n",
             (unsigned)tga_head.cmap_origin);
        fprintf (hdrfile, "cmap_length = %u \n",
             (unsigned)tga_head.cmap_length);
        fprintf (hdrfile, "cmap_size   = %u \n",
             (unsigned)tga_head.cmap_size);
    }
    }
    else {
    fprintf (stderr,
          "%s: Invalid Color Map Type Code (%d)\n", out_hdr.cmd,
         tga_head.cmap_type);
    exit (1);
    }

    if (hflag) {
    fprintf (hdrfile, "image_x_origin = %u \n",
         (unsigned)tga_head.image_x_origin);
    fprintf (hdrfile, "image_y_origin = %u \n",
         (unsigned)tga_head.image_y_origin);
    fprintf (hdrfile, "image_width    = %u \n",
         (unsigned)tga_head.image_width);
    fprintf (hdrfile, "image_height   = %u \n",
         (unsigned)tga_head.image_height);
    fprintf (hdrfile, "image_pix_size = %u \n",
         (unsigned)tga_head.image_pix_size);
    }

    /* Is this a supported image type? */

    switch (tga_head.image_type)
    {
                /* Image type codes from imagefmt.h, */
                /*   by Truevision, Inc.             */

      case 0:           /* No Image Data */
        fprintf(stderr,"%s: Image file is header only, no data.\n",
        out_hdr.cmd);
        exit(1);
        break;

      case 2:           /* Uncompressed Real-Color Image */

                /* Check for special case of a B/W */
                /* pretending to be a color image  */
        if ((tga_head.image_pix_size==8) &&
            (tga_head.cmap_length==0))
        {
          bwimage = 1;
          nchannels = 1;
    }
        else
        {
          truecolor = 1;
    }
        break;

      case 3:           /* Uncompressed B/W Image */
        bwimage = 1;
        nchannels = 1;
        break;

      case 10:          /* Run-length Encoded, Real-Color Image */
        truecolor = 1;
        rlcomp = 1;
        break;

      case 11:          /* Run-length Encoded, B/W Image */
        bwimage = 1;
        nchannels = 1;
        rlcomp = 1;
        break;

      case 1:           /* Uncompressed, Color-Mapped Image */
      case 9:           /* Run-length Encoded, Color-Mapped Image */
      default:
        fprintf(stderr,"%s: Image type (%d) not supported by this program.\n",
                out_hdr.cmd, tga_head.image_type);
        exit(1);
    }

    /* Check limits on what this program can handle */

    if (bwimage)
    {
      if (tga_head.image_pix_size!=8)
      {
         fprintf(stderr,"%s: B/W image pixel size must be 8.\n", out_hdr.cmd);
         exit(1);
      }
    }
    else if (truecolor)
    {
      if ( !((tga_head.image_pix_size==16) ||
             (tga_head.image_pix_size==24) ||
             (tga_head.image_pix_size==32) ))
      {
         fprintf(stderr,
         "%s: Real-color image pixel size must be 16, 24 or 32.\n",
         out_hdr.cmd);
         exit(1);
      }
      if (tga_head.image_pix_size==24) nchannels = 3;
    }

    /* Read image ID field */

    if ((i=(unsigned)tga_head.num_char_id)>=1) {
    tga_head.image_id = (unsigned char *)malloc(i);
    fread (tga_head.image_id, i, 1, infile);
    }

   /* Read Color Map, if any.  Do this even if the image is "true-color", since  */
   /* Truevision and other developers use the colormap area for their own needs. */

    if ((unsigned)tga_head.cmap_type==1) {
    switch((unsigned)tga_head.cmap_size) {

      case 15:  /* Typical values for colormap width */
      case 16:
        cmapbytes = 2;
        break;
      case 24:
        cmapbytes = 3;
        break;
      case 32:
        cmapbytes = 4;
        break;

      default:
        fprintf (stderr,"%s: Invalid color map width (%u bits)\n",
             out_hdr.cmd, (unsigned)tga_head.cmap_size);
        exit(1);
    }
    tga_head.cmap_data = 
        (unsigned char *)calloc((unsigned)tga_head.cmap_length,cmapbytes);
    fread (tga_head.cmap_data, cmapbytes, (unsigned)tga_head.cmap_length, infile);

    }

    /* Build RLE image header */

    RLE_SET_BIT(out_hdr, RLE_RED);

    if (nchannels==1)
    {
      out_hdr.ncolors = 1;
    }
    else
    {
      RLE_SET_BIT(out_hdr, RLE_GREEN);
      RLE_SET_BIT(out_hdr, RLE_BLUE);
      out_hdr.ncolors = 3;

      if (nchannels==4)     /* Save the alpha channel? */
      {
        RLE_SET_BIT(out_hdr, RLE_ALPHA);
        out_hdr.alpha = 1;
      }
    }

    out_hdr.rle_file = outfile;
    out_hdr.xmax = (unsigned)tga_head.image_width-1;
    out_hdr.ymax = (unsigned)tga_head.image_height-1;

    /* Allocate pixel buffers */

    alfline = (unsigned char *)malloc(tga_head.image_width);
    redline = (unsigned char *)malloc(tga_head.image_width);
    grnline = (unsigned char *)malloc(tga_head.image_width);
    bluline = (unsigned char *)malloc(tga_head.image_width);

    if ((!alfline) || (!redline) || (!grnline) || (!bluline))
    {
      fprintf(stderr,"%s: Image is too large for this program.\n",
          out_hdr.cmd);
      exit(1);
    }

    outrows[0] = alfline;
    outrows[1] = redline;
    outrows[2] = grnline;
    outrows[3] = bluline;

    rle_addhist( argv, (rle_hdr *)NULL, &out_hdr );
    rle_put_setup( &out_hdr );

    /* Read and process each of the TARGA scan lines */

    pixwidth = ((unsigned)tga_head.image_pix_size+7)/8; /* Pixel size in bytes */
    init_comp();
    for (i=0;i<(unsigned)tga_head.image_height;i++)
    {
      targa_getrow();
      rle_putrow (&outrows[1], (unsigned)tga_head.image_width, &out_hdr);
    }
    rle_puteof( &out_hdr );

    free(alfline);
    free(redline);
    free(grnline);
    free(bluline);
}

void targa_getrow

(

)

Definition at line 410 of file targatorle.c.

References alfline, bluline, grnline, targafile::image_width, pixwidth, redline, and tga_head.

{
  int j;
  int numpix;
  unsigned pxltmp;

  numpix = (unsigned)tga_head.image_width;

  switch (pixwidth) {

    case 1:                 /* 8-bit pixels */
      for (j=0;j<numpix;j++) redline[j] = getbyte();
      return;
      break;

    case 2:                 /* 16-bit pixels */
      for (j=0;j<numpix;j++)
      {
        pxltmp = (unsigned)getbyte();
        pxltmp |= ((unsigned)getbyte())<<8;

        bluline[j] =  (pxltmp        & 0x1f) << 3;
        grnline[j] = ((pxltmp >>  5) & 0x1f) << 3;
        redline[j] = ((pxltmp >> 10) & 0x1f) << 3;
        alfline[j] = ((pxltmp & 0x8000) ? 0xff : 0);
      }
      break;

    case 3:                 /* 24/32 bit pixels */
    case 4:
      for (j=0;j<numpix;j++)
      {
        bluline[j]=getbyte();
        grnline[j]=getbyte();
        redline[j]=getbyte();
        if (pixwidth==4)
          alfline[j]=getbyte();
      }
      break;

    default:
      fprintf(stderr,"targatorle: Invalid pixel size (%d bytes) for this program.\n",
          pixwidth);
  }
}

Variable Documentation

unsigned char * alfline

Definition at line 101 of file targatorle.c.

Referenced by targa_getrow().

unsigned char * bluline

Definition at line 101 of file targatorle.c.

Referenced by targa_getrow().

int bufinx

Definition at line 115 of file targatorle.c.

Referenced by getbyte().

int bwimage =0

Definition at line 104 of file targatorle.c.

int cmapbytes

Definition at line 109 of file targatorle.c.

int cmapped =0

Definition at line 106 of file targatorle.c.

unsigned char * grnline

Definition at line 101 of file targatorle.c.

Referenced by targa_getrow().

int havedata =0

Definition at line 113 of file targatorle.c.

Referenced by getbyte(), and init_comp().

FILE* infile

Definition at line 102 of file targatorle.c.

Referenced by getbyte().

int nchannels

Definition at line 108 of file targatorle.c.

unsigned char* outrows[4]

Definition at line 100 of file targatorle.c.

int pixwidth

Definition at line 110 of file targatorle.c.

Referenced by getbyte(), and targa_getrow().

unsigned char* redline

Definition at line 101 of file targatorle.c.

Referenced by targa_getrow().

unsigned char rlbuf[4 *128]

Definition at line 116 of file targatorle.c.

Referenced by getbyte().

int rlcomp =0

Definition at line 107 of file targatorle.c.

Referenced by getbyte().

int rlcount

Definition at line 114 of file targatorle.c.

Referenced by getbyte().

struct targafile tga_head

Definition at line 111 of file targatorle.c.

Referenced by targa_getrow().

int truecolor =0

Definition at line 105 of file targatorle.c.