#include "rle.h"
#include <string.h>
#include "rla_header.h"
#include "rlb_header.h"

Include dependency graph for rlatorle.c:

Macros
#define	VPRINTF if (verbose \|\| header) fprintf

#define	SHORTREAD(var, fp) {fread(var, 2, 1, fp);}

#define	LONGREAD(var, fp) {fread(var, 4, 1, fp);}

Typedefs
typedef unsigned char	U_CHAR

Functions
void	read_rla_header (int act_x_res, int act_y_res, int width, int height)

void	write_rle_header ()

void	decode (U_CHAR c_in, U_CHAR c_out, int len)

void	write_rle_data ()

int	main (int argc, char **argv)

Variables
static char	rcsid [] = "$Header: /l/spencer/src/urt/cnv/RCS/rlatorle.c,v 3.0.1.5 1992/04/30 13:58:32 spencer Exp $"

rle_hdr	hdr

union {
RLA_HEADER rla_head

RLB_HEADER rlb_head

}	head

static FILE *	fp

static int	act_x_res

static int	act_y_res

static int	width

static int	height

static int	verbose = 0

static int	header = 0

static int	do_matte = 0

static int	rlb_flag = 0

Macro Definition Documentation

#define LONGREAD	(	var,
		fp
	)	{fread(var, 4, 1, fp);}

Definition at line 65 of file rlatorle.c.

#define SHORTREAD	(	var,
		fp
	)	{fread(var, 2, 1, fp);}

Definition at line 64 of file rlatorle.c.

#define VPRINTF if (verbose || header) fprintf

Definition at line 47 of file rlatorle.c.

Typedef Documentation

typedef unsigned char U_CHAR

Definition at line 49 of file rlatorle.c.

Function Documentation

void decode	(	U_CHAR *	c_in,
		U_CHAR *	c_out,
		int	len
	)

Definition at line 200 of file rlatorle.c.

 {
    int  ct;
 
    while(len > 0) {
       ct = *c_in++;
       len--;
       if (ct < 128) {
 /*
  * Repeat pixel value ct+1 times.
  */
          while (ct-- >= 0)
             *c_out++ = *c_in;
          c_in++;
          len--;
          }
       else {
 /*
  * Copy ct unencoded values.
  */
          for (ct = 256-ct; ct-- > 0; len--)
             *c_out++ = *c_in++;
          }
       }
 }

int main	(	int	argc,
		char **	argv
	)

Definition at line 376 of file rlatorle.c.

 {
    char     *periodP, *inname = NULL, *outname = NULL;
    static char  filename[BUFSIZ];
    int      oflag = 0;
 /*
  * Get those options.
  */
    if (!scanargs(argc,argv,
        "% b%- v%- h%- m%- o%-outfile!s infile.rla%s",
        &rlb_flag,
        &verbose,
        &header,
        &do_matte,
        &oflag, &outname,
        &inname))
       exit(-1);
 /*
  * Open the file.
  */
    if (inname == NULL) {
       strcpy(filename, "stdin");
       fp = stdin;
       }
    else {
       periodP = strrchr(inname, (int)'.');
       strcpy(filename, inname);
       if (periodP) {
          if (rlb_flag) {
             if (strcmp(periodP, ".rlb")) { /* does not end in rla */
                if (!strcmp(periodP, ".rla")) {
                   fprintf(stderr, "This is an rla file -- don't use the -b flag.\n");
                   exit(1);
                   }
                strcat(filename, ".rlb");
                }
             }
          else {
             if (strcmp(periodP, ".rla")) { /* does not end in rla */
                if (!strcmp(periodP, ".rlb"))
                   rlb_flag = 1;
                else
                   strcat(filename, ".rla");
                }
             }
          }
       else              /* no ext -- add one */
          if (rlb_flag)
             strcat(filename, ".rlb");
          else
             strcat(filename, ".rla");
       if (!(fp = fopen(filename, "r"))) {
          fprintf(stderr, "Cannot open %s for reading.\n", filename);
          exit(-1);
          }
       }
 /*
  * Read the Wavefront file file header.
  */
    read_rla_header(&act_x_res, &act_y_res, &width, &height);
    if (header)
       exit(0);
 /*
  * Write the rle file header.
  */
    hdr = *rle_hdr_init( (rle_hdr *)NULL );
    hdr.rle_file = rle_open_f( cmd_name(argv), outname, "w" );
    rle_names( &hdr, cmd_name(argv), outname, 0 );
    rle_addhist(argv, (rle_hdr *)NULL, &hdr);
    write_rle_header();
 /*
  * Write the rle file data.
  */
    write_rle_data();
    fclose(fp);
 
    return 0;
 }

void read_rla_header	(	int *	act_x_res,
		int *	act_y_res,
		int *	width,
		int *	height
	)

Definition at line 76 of file rlatorle.c.

 {
 
 #ifdef CRAY2CC
    long craybuf;
 
    SHORTREAD(&head.rla_head.window.left, fp);
    SHORTREAD(&head.rla_head.window.right, fp);
    SHORTREAD(&head.rla_head.window.bottom, fp);
    SHORTREAD(&head.rla_head.window.top, fp);
    SHORTREAD(&head.rla_head.active_window.left, fp);
    SHORTREAD(&head.rla_head.active_window.right, fp);
    SHORTREAD(&head.rla_head.active_window.bottom, fp);
    SHORTREAD(&head.rla_head.active_window.top, fp);
    SHORTREAD(&head.rla_head.frame, fp);
    SHORTREAD(&head.rla_head.storage_type, fp);
    SHORTREAD(&head.rla_head.num_chan, fp);
    SHORTREAD(&head.rla_head.num_matte, fp);
    SHORTREAD(&head.rla_head.num_aux, fp);
    SHORTREAD(&head.rla_head.aux_mask, fp);
    fread(&head.rla_head.gamma, 16, 1, fp);
    fread(&head.rla_head.red_pri, 24, 1, fp);
    fread(&head.rla_head.green_pri, 24, 1, fp);
    fread(&head.rla_head.blue_pri, 24, 1, fp);
    fread(&head.rla_head.white_pt, 24, 1, fp);
    LONGREAD(&head.rla_head.job_num, fp);
    fread(&head.rla_head.name, 128, 1, fp);
    fread(&head.rla_head.desc, 128, 1, fp);
    fread(&head.rla_head.program, 64, 1, fp);
    fread(&head.rla_head.machine, 32, 1, fp);
    fread(&head.rla_head.user, 32, 1, fp);
    fread(&head.rla_head.date, 20, 1, fp);
    if (rlb_flag) {
       fread(&head.rlb_head.aspect, 24, 1, fp);
       fread(&head.rlb_head.aspect_ratio, 8, 1, fp);
       fread(&head.rlb_head.chan, 32, 1, fp);
       SHORTREAD(&head.rlb_head.field, fp);
       SHORTREAD(&head.rlb_head.filter_type, fp);
       LONGREAD(&head.rlb_head.magic_number, fp);
       LONGREAD(&head.rlb_head.lut_size, fp);
       LONGREAD(&head.rlb_head.user_space_size, fp);
       LONGREAD(&head.rlb_head.wf_space_size, fp);
       SHORTREAD(&head.rlb_head.lut_type, fp);
       SHORTREAD(&head.rlb_head.mix_type, fp);
       SHORTREAD(&head.rlb_head.encode_type, fp);
       SHORTREAD(&head.rlb_head.padding, fp);
       fread(&head.rlb_head.space, 100, 1, fp);
       }
    else {
       fread(&head.rla_head.aspect, 32, 1, fp);
       fread(&head.rla_head.chan, 32, 1, fp);
       fread(&head.rla_head.space, 128, 1, fp);
       }
 #else
    if (fread(&head, 740, 1, fp) != 1) {
       fprintf(stderr, "Error reading Wavefront file header!\n");
       exit(-2);
       }
 #endif
    *act_x_res = head.rla_head.active_window.right-
        head.rla_head.active_window.left+1;
    *act_y_res = head.rla_head.active_window.top-
        head.rla_head.active_window.bottom+1;
    *width     = head.rla_head.window.right-head.rla_head.window.left+1;
    *height    = head.rla_head.window.top-head.rla_head.window.bottom+1;
    VPRINTF(stderr, "Full image:         %dx%d\n", *width, *height);
    VPRINTF(stderr, "Active window:      %dx%d\n", *act_x_res, *act_y_res);
    VPRINTF(stderr, "Number of channels: %d\n", head.rla_head.num_chan);
    VPRINTF(stderr, "Number of mattes:   %d\n", head.rla_head.num_matte);
    VPRINTF(stderr, "Image gamma:        %s\n", head.rla_head.gamma);
    VPRINTF(stderr, "Original filename:  %s\n", head.rla_head.name);
    VPRINTF(stderr, "Description:        %s\n", head.rla_head.desc);
    VPRINTF(stderr, "Machine:            %s\n", head.rla_head.machine);
    VPRINTF(stderr, "User:               %s\n", head.rla_head.user);
    VPRINTF(stderr, "Date:               %s\n", head.rla_head.date);
    if ( rlb_flag ) {
        VPRINTF(stderr, "Aspect:             %s\n", head.rlb_head.aspect);
        VPRINTF(stderr, "Aspect ratio:       %s\n", head.rlb_head.aspect_ratio);
        }
    else {
        VPRINTF(stderr, "Aspect:             %s\n", head.rla_head.aspect);
        VPRINTF(stderr, "Aspect ratio:       %s\n", "-unused-");
        }
    VPRINTF(stderr, "Channel color space %s\n", head.rla_head.chan);
    if ( rlb_flag )
        VPRINTF(stderr, "Interlaced?         %s\n", head.rlb_head.filter_type);
    else
        VPRINTF(stderr, "Interlaced?         %s\n", "-unused-");
    if (do_matte)
       VPRINTF(stderr, "Converting matte channel only...\n");
 }

void write_rle_data ( )

Definition at line 231 of file rlatorle.c.

References act_y_res, RLA_HEADER::active_window, WINDOW_S::bottom, do_matte, fp, hdr, WINDOW_S::left, WINDOW_S::right, rle_puteof(), rle_putrow(), rle_skiprow(), WINDOW_S::top, width, and RLA_HEADER::window.

 {
    int      *offset;
    int      x;
    int      bottom;
    int      left;
    int      scan;
 #ifdef CRAY2CC
    long     craybuf;
 #endif
    U_CHAR   *red, *green, *blue, *matte;
    U_CHAR   *buf;
    short    len;
    rle_pixel    *scanline[4];
 /*
  * Read scanline offset table.
  */
    if (!(offset = (int *)malloc(sizeof(int) * act_y_res))) {
       fprintf(stderr, "Offset malloc failed!\n");
       exit(-3);
       }
 #ifdef CRAY2CC
    for (scan=0;scan<act_y_res;scan++) {
       fread(&craybuf, 4, 1, fp); offset[scan] = craybuf >> 32;
       }
 #else
    if (fread(offset, 4, act_y_res, fp) != act_y_res) {
       fprintf(stderr, "Offset table read failed!\n");
       exit(-4);
       }
 #endif
 /*
  * Allocate some memory.
  */
    if (!(buf = (U_CHAR *)malloc(width * 2))) {
       fprintf(stderr, "Buf malloc failed!\n");
       exit(-7);
       }
    if (!(red = (U_CHAR *)malloc(width * 4))) {
       fprintf(stderr, "Red scanline malloc failed!\n");
       exit(-8);
       }
    green = &red[width];
    blue  = &green[width];
    matte = &blue[width];
    /*bzero((char *)blank, width*4);*/
    if (((scanline[0]=(rle_pixel *)malloc(width))==NULL) ||
        ((scanline[1]=(rle_pixel *)malloc(width))==NULL) ||
        ((scanline[2]=(rle_pixel *)malloc(width))==NULL) ||
        ((scanline[3]=(rle_pixel *)malloc(width))==NULL)) {
       fprintf(stderr, "Unable to malloc space for pixels\n");
       exit(-1);
       }
 /*
  * Loop through the rla files image window, write blank lines outside
  * active window.
  */
    bottom = head.rla_head.active_window.bottom;
    left   = head.rla_head.active_window.left;
    for (scan = head.rla_head.window.bottom;
     scan <= head.rla_head.window.top; scan++) {
 /*
  * Check for black regions outside active window.
  */
       if ((scan < head.rla_head.active_window.bottom) ||
           (scan > head.rla_head.active_window.top))
          rle_skiprow(&hdr, 1);
       else {
          if (fseek(fp, (long)offset[scan-bottom], 0)) {
             fprintf(stderr, "rla file incomplete!\n");
             exit(-9);
             }
 /*
  * Red scanline.
  */
          SHORTREAD(&len, fp);
          fread(buf, 1, (int)len, fp);
          decode(buf, red, (int)len);
 /*
  * Green scanline.
  */
          SHORTREAD(&len, fp);
          fread(buf, 1, (int)len, fp);
          decode(buf, green, (int)len);
 /*
  * Blue scanline.
  */
          SHORTREAD(&len, fp);
          fread(buf, 1, (int)len, fp);
          decode(buf, blue, (int)len);
 /*
  * Matte scanline.
  */
          SHORTREAD(&len, fp);
          fread(buf, 1, (int)len, fp);
          decode(buf, matte, (int)len);
 /*
  * Write out RGBM for each pixel.
  */
          for (x=head.rla_head.window.left;
           x<=head.rla_head.window.right; x++) {
             if ((x < head.rla_head.active_window.left) ||
                 (x > head.rla_head.active_window.right)) {
                scanline[0][x] = 0;
                scanline[1][x] = 0;
                scanline[2][x] = 0;
                scanline[3][x] = 0;
                }
             else
                if (do_matte) {
                   scanline[0][x] = (red[x-left] ||
                                   green[x-left] ||
                                    blue[x-left] ? 255 : 0);
                   }
                else {
                   scanline[0][x] = matte[x-left];
                   scanline[1][x] = red[x-left];
                   scanline[2][x] = green[x-left];
                   scanline[3][x] = blue[x-left];
                   }
             }
          if (do_matte)
             rle_putrow(scanline, width, &hdr);
          else
             rle_putrow(scanline + 1, width, &hdr);
          } /* end of if scan is within active y */
       } /* end of for every scanline */
    VPRINTF(stderr, "Done -- write oef to RLE data.\n");
    rle_puteof(&hdr);
 /*
  * Free up some stuff.
  */
    free(offset);
    /*free(blank);*/
    free(buf);
    free(red);
    free(scanline[0]);
    free(scanline[1]);
    free(scanline[2]);
    free(scanline[3]);
 }

Here is the call graph for this function:

void write_rle_header ( )

Definition at line 174 of file rlatorle.c.

References rle_hdr::alpha, WINDOW_S::bottom, RLA_HEADER::desc, do_matte, hdr, WINDOW_S::left, rle_hdr::ncolors, RLA_HEADER::num_chan, RLA_HEADER::num_matte, WINDOW_S::right, rle_put_setup(), rle_putcom(), WINDOW_S::top, RLA_HEADER::window, rle_hdr::xmax, rle_hdr::xmin, rle_hdr::ymax, and rle_hdr::ymin.

 {
    hdr.xmin    = head.rla_head.window.left;
    hdr.xmax    = head.rla_head.window.right;
    hdr.ymin    = head.rla_head.window.bottom;
    hdr.ymax    = head.rla_head.window.top;
    hdr.alpha   = (head.rla_head.num_matte && !do_matte ? 1 : 0);
    hdr.ncolors = (do_matte ? 1 : head.rla_head.num_chan);
    /*hdr.ncmap   = (map ? 3 : 0);*/
    /*hdr.cmaplen = (map ? 8 : 0);*/
    /*hdr.cmap    = (map ? color_map : NULL);*/
    rle_putcom(head.rla_head.desc, &hdr);
    /*hdr.background = 0;*/
    if (hdr.alpha)
       RLE_SET_BIT(hdr, RLE_ALPHA);
    if (!do_matte) {
       RLE_SET_BIT(hdr, RLE_RED);
       RLE_SET_BIT(hdr, RLE_GREEN);
       RLE_SET_BIT(hdr, RLE_BLUE);
       }
    rle_put_setup(&hdr);
 }