rletoalias.c File Reference

#include <stdio.h>
#include <math.h>
#include "rle.h"

Include dependency graph for rletoalias.c:

Go to the source code of this file.

Data Structures
struct	alias_hdr
struct	bitmap_hdr

Macros
#define	byte   unsigned char
#define	Fread(p, s, n, f)    if ( fread(p, s, n, f) != n ) error(3)
#define	Fwrite(p, s, n, f)    if ( fwrite(p, s, n, f) != n ) error(4)
#define	VPRINTF   if (verbose) fprintf
#define	PSEUDOCOLOR   1
#define	DIRECTCOLOR   2
#define	TRUECOLOR   3
#define	GRAYSCALE   4

Typedefs
typedef unsigned char	color_map[3]

Functions
static void	read_rle (FILE *, bitmap_hdr *)
static void	write_alias (FILE *, bitmap_hdr *)
static void	error (int)
static void	rlecmap_to_bitmapcmap (rle_hdr *, bitmap_hdr *)
static void	code_alias24 (unsigned char *, unsigned char *, unsigned char *, int, FILE *)
static char *	Malloc (long int)
void	main (int argc, char **argv)

Variables
static char	rcs_id [] = "$Header: /l/spencer/src/urt/cnv/RCS/rletoalias.c,v 3.0.1.1 1992/04/30 13:58:47 spencer Exp $"
int	verbose = 0
rle_hdr	the_hdr

Macro Definition Documentation

#define byte   unsigned char

Definition at line 39 of file rletoalias.c.

#define DIRECTCOLOR   2

Definition at line 44 of file rletoalias.c.

#define Fread	(		p,
			s,
			n,
			f
	)		if ( fread(p, s, n, f) != n ) error(3)

Definition at line 40 of file rletoalias.c.

#define Fwrite	(		p,
			s,
			n,
			f
	)		if ( fwrite(p, s, n, f) != n ) error(4)

Definition at line 41 of file rletoalias.c.

#define GRAYSCALE   4

Definition at line 46 of file rletoalias.c.

#define PSEUDOCOLOR   1

Definition at line 43 of file rletoalias.c.

#define TRUECOLOR   3

Definition at line 45 of file rletoalias.c.

#define VPRINTF   if (verbose) fprintf

Definition at line 42 of file rletoalias.c.

Typedef Documentation

typedef unsigned char color_map[3]

Definition at line 69 of file rletoalias.c.

Function Documentation

static void code_alias24 ( unsigned char *  rbuf, unsigned char *  gbuf, unsigned char *  bbuf, int  xmax, FILE *  handle  )

static

Definition at line 371 of file rletoalias.c.

{
  byte r, g, b;
  unsigned int number= 0;
  int repeat= 1;
  static byte buf[5120];
  byte *bufptr, *end;

  bufptr= buf;
  end= rbuf + xmax;
  r= *rbuf++; g= *gbuf++; b= *bbuf++;

  while (rbuf < end)
    /*
     * While we have the same pattern ( and < 255 ), we continue
     * skipping bytes ( pixels ).
     */
    if (r== *rbuf && g== *gbuf && b== *bbuf && repeat < 255) {
      repeat++;
      rbuf++; gbuf++; bbuf++;
    }else {
      /*
       * A different triple or repeat == 255 was found, then we add
       * this to the output buffer.
       */
      *bufptr++ = repeat;
      *bufptr++ = b;
      *bufptr++ = g;
      *bufptr++ = r;
      number += 4;
      repeat  = 1;
      r= *rbuf++; g= *gbuf++; b= *bbuf++;
    }

  /*
   * We need add the last triplet.
   */
  *bufptr++ = repeat;
  *bufptr++ = b;
  *bufptr++ = g;
  *bufptr++ = r;
  number += 4;
  /*
   * And ... write it !
   */
  Fwrite(buf, number, 1, handle);
}

static void error ( int  code )

static

Definition at line 423 of file rletoalias.c.

{
  fprintf(stderr, "%s: ", the_hdr.cmd);
  switch (code) {
    case  0: fprintf(stderr, "Usage:  %s [-v] [-o outfile] [infile] \n", 
                     the_hdr.cmd);
             break;
    case  1: fprintf(stderr, "Cannot open file.\n");
             break;
    case  2: fprintf(stderr, "Out of memory.\n");
             break;
    case  3: fprintf(stderr, "Error while reading input file\n");
             break;
    case  4: fprintf(stderr, "Error while writing output file\n");
             break;
    case  5: fprintf(stderr, "Input file is not an Alias pix\n");
             break;
    case  6: fprintf(stderr, "Incorrect # of planes or # of colors\n");
             break;
    case 99: fprintf(stderr, "Not ready\n");
             break;
    default: fprintf(stderr, "Unknow erro code (%d)\n", code);
             break;
  }
  exit(1);
}

void main	(	int	argc,
		char **	argv
	)

Definition at line 112 of file rletoalias.c.

{
  char *inname  = NULL;
  char *outname = NULL;
  FILE *infile;
  FILE *outfile = stdout;
  int oflag = 0;
  bitmap_hdr bitmap;

  the_hdr = *rle_hdr_init( (rle_hdr *)NULL );
  /*
   * Get options
   */
  if ( !scanargs( argc, argv, "% v%- o%-outfile!s infile%s",
                  &verbose, &oflag, &outname, &inname ))
    exit( 1 );

  /*
   * Open rle file.
   */
  rle_names( &the_hdr, cmd_name( argv ), inname, 0 );
  infile = rle_open_f(the_hdr.cmd, inname, "r");

  /*
   * Translate Utah's rle format to our bitmap.
   */
  read_rle(infile, &bitmap);
  fclose(infile);    /* we finish with this file */

  outfile = rle_open_f(cmd_name(argv), outname, "w");
  /* An output file name ? */
  rle_names( &the_hdr, cmd_name( argv ), outname, 0 );
  VPRINTF(stderr, "Writing to file %s\n", the_hdr.file_name);
  outfile= rle_open_f(the_hdr.cmd, outname, "w");

  write_alias(outfile, &bitmap);
  fclose(outfile);            /* it is not necesary, but ... */

  exit(0);
}

static char * Malloc ( long int  size )

static

Definition at line 455 of file rletoalias.c.

{
  char *ptr;

  if ((ptr = (char *) malloc(size)) == NULL)
    error(2);

  /*
   * Usually compilers fill buffers with zeros,
   * but ...
   */
  bzero( ptr, size );
  return ptr;
}

static void read_rle ( FILE *  handle, bitmap_hdr *  image  )

static

Definition at line 156 of file rletoalias.c.

{
  register int i, j;
  rle_pixel **row;
  byte *r, *g = 0, *b = 0;
  int totalsize;
  color_map *map = 0;
  int type = 0;
  int two_lines;
  int offset_last;

  /*
   * Read the file's configuration.
   */
  the_hdr.rle_file = handle;
  rle_get_setup_ok( &the_hdr, NULL, NULL );

  /*
   * Fill our bitmap.
   */
  image->xsize = the_hdr.xmax - the_hdr.xmin + 1;
  image->ysize = the_hdr.ymax - the_hdr.ymin + 1;
  image->depth = ( the_hdr.ncolors < 3 ? the_hdr.cmaplen : 24 );
  image->colors = ( 1 << image->depth );
  totalsize= image->xsize * image->ysize;
  offset_last = totalsize - image->xsize;
  two_lines = 2 * image->xsize;
  VPRINTF(stderr, "Image size: %dx%d\n", image->xsize, image->ysize);
  VPRINTF(stderr, "Image depth: %d\n", image->depth);
  VPRINTF(stderr, "%s colormap\n", 
                  (the_hdr.ncmap ? "With" : "Without"));

  /*
   * Check the coherence and image type.
   */
  VPRINTF(stderr, "Image type ");
  switch ( the_hdr.ncolors ) {
    case  1: switch ( the_hdr.ncmap ) {
               case  0: type = GRAYSCALE;       /* 8 planes, no cmap */
                        VPRINTF(stderr, "GRAYSCALE\n");
                        break;
               case  3: type = PSEUDOCOLOR;     /* 8 planes, cmap */
                        VPRINTF(stderr, "PSEUDOCOLOR\n");
                        break;
               default: VPRINTF(stderr, "unkown\n");
                        error(6);
                        break;
             }
             break;
    case  3: switch ( the_hdr.ncmap ) {
               case  0: type = DIRECTCOLOR;     /* 24 planes, no cmap */
                        VPRINTF(stderr, "DIRECTCOLOR\n");
                        break;
               case  3: type = TRUECOLOR;       /* 24 planes, cmap */
                        VPRINTF(stderr, "TRUECOLOR\n");
                        break;
               default: VPRINTF(stderr, "unkown\n");
                        error(6);
                        break;
             }

             break;
    default: error(6);
             VPRINTF(stderr, "unkown\n");
             break;
  }

  /*
   * Allocate some memory.
   */
  if (rle_row_alloc(&the_hdr, &row) < 0)
    error(2);
  if (image->depth > 8 || type == GRAYSCALE) {
    /*
     * 24 planes => we need three components
     * GRAYSCALE use 8 planes but it's defined like 24 planes
     */
    r= image->r = (byte *) Malloc(totalsize);
    g= image->g = (byte *) Malloc(totalsize);
    b= image->b = (byte *) Malloc(totalsize);
    if ( type == TRUECOLOR) {
      image->colors = 256;      /* well, a trap to rlecmap_to_bit... */
      rlecmap_to_bitmapcmap(&the_hdr, image);
      map = (color_map *) image->cmap;  /* will be more easy use it */
    }
  }else {
    /* 8 planes => one component and cmap */
    r= image->r = (byte *) Malloc(totalsize);
    /* Convert rle cmap to bitmap cmap */
    rlecmap_to_bitmapcmap(&the_hdr, image);
    map = (color_map *) image->cmap;    /* will be more easy use it */
  }

  /*
   * Read the input image and convert it to a simple bitmap.
   * RLE writes lines in reverse order, so we point to last
   * line.
   */
  VPRINTF(stderr, "Uncompressing RLE file\n");
  r += offset_last;
  g += offset_last;
  b += offset_last;
  for (j= 0; j< image->ysize; j++) {
    rle_getrow(&the_hdr, row);
    switch ( type ) {
      case GRAYSCALE  :
      case DIRECTCOLOR: for (i= 0; i< image->xsize; i++) {
                          *r++ = row[0][i];
                          *g++ = row[1][i];
                          *b++ = row[2][i];
                        }
                        break;
      case PSEUDOCOLOR: for (i= 0; i<image->xsize; i++) {
                          *r++ = row[0][i];
                        }
                        break;
      case TRUECOLOR  : for (i= 0; i< image->xsize; i++) {
                          *r++ = map[row[0][i]][0];
                          *g++ = map[row[1][i]][1];
                          *b++ = map[row[2][i]][i];
                        }
                        break;
      default         : error(6);
                        break;
    }
    /*
     * Pointers to next byte of current line, so we substract
     * two lines.
     */
    r -= two_lines;
    g -= two_lines;
    b -= two_lines;
  }

  /*
   * TRUECOLOR has map of colors, but we'll not use it.
   */
  if ( type == TRUECOLOR )
    free(image->cmap);
}

static void rlecmap_to_bitmapcmap ( rle_hdr *  rle, bitmap_hdr *  bitmap  )

static

Definition at line 300 of file rletoalias.c.

{
  register int i;
  rle_map *rch, *gch, *bch;
  byte *ptr;

  /* Allocate memory */
  ptr= bitmap->cmap= (byte *) Malloc(bitmap->colors * 3);

  /*
   * We'll use 3 ptrs, first to R channel, second to G channel, ...
   */
  rch = rle->cmap;
  gch = &(rle->cmap[bitmap->colors]);
  bch = &(rle->cmap[2 * bitmap->colors]);
  for (i= 0; i< bitmap->colors; i++) {
    *ptr++ = (byte) (*rch++ >> 8);
    *ptr++ = (byte) (*gch++ >> 8);
    *ptr++ = (byte) (*bch++ >> 8);
  }
}

static void write_alias ( FILE *  handle, bitmap_hdr *  image  )

static

Definition at line 325 of file rletoalias.c.

{
  register int i;
  alias_hdr alias;
  byte *rbuf, *gbuf, *bbuf;

  /*
   * Alias 8 bits files are b&w ( no cmap ), so Alias
   * don't support really a 8 bits file.
   */
  if (image->depth <= 8) {
    fprintf(stderr, "Bitmap with 8 planes\n");
    error(99);
  }

  VPRINTF(stderr, "Writing Alias file\n");
  /* Fill the Alias header and write it */
  alias.yinit = 0;
  alias.xinit = 0;
  alias.xsize = image->xsize;
  alias.ysize = image->ysize;
  alias.depth = image->depth;
  Fwrite(&alias, sizeof(alias_hdr), 1, handle);

  /* Set the pointers to buffers */
  rbuf = image->r;
  gbuf = image->g;
  bbuf = image->b;

  /* Compress each line */
  for (i= 0; i< image->ysize; i++) {
    /*
     * Alias "pix" format do a compression method on
     * each raster line.
     */
    code_alias24(rbuf, gbuf, bbuf, image->xsize, handle);
    /* Move pointers to next lines */
    rbuf += image->xsize;
    gbuf += image->xsize;
    bbuf += image->xsize;
  }
}

Variable Documentation

char rcs_id[] = "$Header: /l/spencer/src/urt/cnv/RCS/rletoalias.c,v 3.0.1.1 1992/04/30 13:58:47 spencer Exp $"

static

Definition at line 29 of file rletoalias.c.

rle_hdr the_hdr

Definition at line 78 of file rletoalias.c.

int verbose = 0

Definition at line 74 of file rletoalias.c.