rle.h File Reference

#include "rle_config.h"
#include <stdio.h>

Include dependency graph for rle.h:

Go to the source code of this file.

Data Structures
struct	rle_hdr

Macros
#define	RLE_RED   0 /* Red channel traditionally here. */
#define	RLE_GREEN   1 /* Green channel traditionally here. */
#define	RLE_BLUE   2 /* Blue channel traditionally here. */
#define	RLE_ALPHA   -1 /* Alpha channel here. */
#define	RLE_SUCCESS   0
#define	RLE_NOT_RLE   -1
#define	RLE_NO_SPACE   -2
#define	RLE_EMPTY   -3
#define	RLE_EOF   -4
#define	RLE_INIT_MAGIC   0x6487ED51L
#define	RLE_CHECK_ALLOC(pgm, ptr, name)   ( !(ptr) ? rle_alloc_error( pgm, name ) : 0 )
#define	RLE_SET_BIT(glob, bit)   ((glob).bits[((bit)&0xff)/8] |= (1<<((bit)&0x7)))
#define	RLE_CLR_BIT(glob, bit)   ((glob).bits[((bit)&0xff)/8] &= ~(1<<((bit)&0x7)))
#define	RLE_BIT(glob, bit)   ((glob).bits[((bit)&0xff)/8] & (1<<((bit)&0x7)))

Typedefs
typedef unsigned char	rle_pixel
typedef unsigned short	rle_map
typedef struct rle_hdr	rle_hdr

Enumerations
enum	rle_dispatch { NO_DISPATCH = -1, RUN_DISPATCH = 0 }

Functions
int	rle_alloc_error (const char *pgm, const char *name)
int	rle_get_error (int code, const char *pgmname, const char *fname)
void	rle_debug (int on_off)
int	rle_get_setup (rle_hdr *the_hdr)
void	rle_get_setup_ok (rle_hdr *the_hdr, const char *prog_name, const char *file_name)
int	rle_getrow (rle_hdr *the_hdr, rle_pixel *scanline[])
unsigned int	rle_getskip (rle_hdr *the_hdr)
void	rle_names (rle_hdr *the_hdr, const char *pgmname, const char *fname, int img_num)
rle_hdr *	rle_hdr_cp (rle_hdr *from_hdr, rle_hdr *to_hdr)
rle_hdr *	rle_hdr_init (rle_hdr *the_hdr)
void	rle_hdr_clear (rle_hdr *the_hdr)
void	rgb_to_bw (rle_pixel *red_row, rle_pixel *green_row, rle_pixel *blue_row, rle_pixel *bw_row, int rowlen)
void	rle_puteof (rle_hdr *the_hdr)
void	rle_putrow (rle_pixel *rows[], int rowlen, rle_hdr *the_hdr)
void	rle_put_init (rle_hdr *the_hdr)
void	rle_put_setup (rle_hdr *the_hdr)
void	rle_skiprow (rle_hdr *the_hdr, int nrow)
void	rle_cp (rle_hdr *in_hdr, rle_hdr *out_hdr)
int	rle_row_alloc (rle_hdr *the_hdr, rle_pixel ***scanp)
void	rle_row_free (rle_hdr *the_hdr, rle_pixel **scanp)
rle_pixel **	buildmap (rle_hdr *the_hdr, int minmap, double orig_gamma, double new_gamma)
char *	rle_getcom (const char *name, rle_hdr *the_hdr)
const char *	rle_delcom (const char *name, rle_hdr *the_hdr)
const char *	rle_putcom (const char *value, rle_hdr *the_hdr)
void	bwdithermap (int levels, double gamma, int bwmap[], int divN[256], int modN[256], int magic[16][16])
int	ditherbw (int x, int y, int val, int divN[256], int modN[256], int magic[16][16])
int	dithergb (int x, int y, int r, int g, int b, int divN[256], int modN[256], int magic[16][16])
void	dithermap (int levels, double gamma, int rgbmap[][3], int divN[256], int modN[256], int magic[16][16])
void	make_square (double N, int divN[256], int modN[256], int magic[16][16])
void	float_to_exp (int count, float *floats, rle_pixel *pixels)
FILE *	rle_open_f (const char *prog_name, const char *f_name, const char *mode)
FILE *	rle_open_f_noexit (const char *prog_name, const char *f_name, const char *mode)
void	rle_close_f (FILE *fd)
int	colorquant (rle_pixel *red, rle_pixel *green, rle_pixel *blue, unsigned long pixels, rle_pixel *colormap[3], int colors, int bits, rle_pixel *rgbmap, int fast, int otherimages)
void	rle_addhist (char *argv[], rle_hdr *in_hdr, rle_hdr *out_hdr)
char *	cmd_name (char **argv)
int	scanargs (int argc, char **argv, const char *format,...)
void	hilbert_c2i (int n, int m, int a[], long int *r)
void	hilbert_i2c (int n, int m, long int r, int a[])
void	inv_cmap (int colors, unsigned char *colormap[3], int bits, unsigned long *dist_buf, unsigned char *rgbmap)

Variables
rle_hdr	rle_dflt_hdr

Macro Definition Documentation

#define RLE_ALPHA   -1 /* Alpha channel here. */

Definition at line 65 of file rle.h.

#define RLE_BIT	(		glob,
			bit
	)		((glob).bits[((bit)&0xff)/8] & (1<<((bit)&0x7)))

Definition at line 126 of file rle.h.

#define RLE_BLUE   2 /* Blue channel traditionally here. */

Definition at line 64 of file rle.h.

#define RLE_CHECK_ALLOC	(		pgm,
			ptr,
			name
	)		( !(ptr) ? rle_alloc_error( pgm, name ) : 0 )

Definition at line 86 of file rle.h.

#define RLE_CLR_BIT	(		glob,
			bit
	)		((glob).bits[((bit)&0xff)/8] &= ~(1<<((bit)&0x7)))

Definition at line 124 of file rle.h.

#define RLE_EMPTY   -3

Definition at line 73 of file rle.h.

#define RLE_EOF   -4

Definition at line 74 of file rle.h.

#define RLE_GREEN   1 /* Green channel traditionally here. */

Definition at line 63 of file rle.h.

#define RLE_INIT_MAGIC   0x6487ED51L

Definition at line 79 of file rle.h.

#define RLE_NO_SPACE   -2

Definition at line 72 of file rle.h.

#define RLE_NOT_RLE   -1

Definition at line 71 of file rle.h.

#define RLE_RED   0 /* Red channel traditionally here. */

Definition at line 62 of file rle.h.

#define RLE_SET_BIT	(		glob,
			bit
	)		((glob).bits[((bit)&0xff)/8] |= (1<<((bit)&0x7)))

Definition at line 122 of file rle.h.

#define RLE_SUCCESS   0

Definition at line 70 of file rle.h.

Typedef Documentation

typedef struct rle_hdr rle_hdr

typedef unsigned short rle_map

Definition at line 57 of file rle.h.

typedef unsigned char rle_pixel

Definition at line 56 of file rle.h.

Enumeration Type Documentation

enum rle_dispatch

Enumerator
NO_DISPATCH
RUN_DISPATCH

Definition at line 44 of file rle.h.

                  {
    NO_DISPATCH = -1,
    RUN_DISPATCH = 0
};

Function Documentation

rle_pixel** buildmap	(	rle_hdr *	the_hdr,
		int	minmap,
		double	orig_gamma,
		double	new_gamma
	)

Definition at line 56 of file buildmap.c.

Referenced by find_most_used().

{
    rle_pixel ** cmap, * gammap;
    double gamma;
    register int i, j;
    int maplen, cmaplen, nmap;

    if ( the_hdr->ncmap == 0 )  /* make identity map */
    {
    nmap = (minmap < the_hdr->ncolors) ? the_hdr->ncolors : minmap;
    cmap = (rle_pixel **)malloc( nmap * sizeof(rle_pixel *) );
    cmap[0] = (rle_pixel *)malloc( nmap * 256 * sizeof(rle_pixel) );
    for ( j = 1; j < nmap; j++ )
        cmap[j] = cmap[j-1] + 256;
    for ( i = 0; i < 256; i++ )
        for ( j = 0; j < nmap; j++ )
        cmap[j][i] = i;
    maplen = 256;
    }
    else            /* make map from the_hdr */
    {
    /* Map is at least 256 long */
    cmaplen = (1 << the_hdr->cmaplen);
    if ( cmaplen < 256 )
        maplen = 256;
    else
        maplen = cmaplen;

    /* Nmap is max( minmap, the_hdr->ncmap, the_hdr->ncolors ). */
    nmap = minmap;
    if ( nmap < the_hdr->ncmap )
        nmap = the_hdr->ncmap;
    if ( nmap < the_hdr->ncolors )
        nmap = the_hdr->ncolors;
    
    /* Allocate memory for the map and secondary pointers. */
    cmap = (rle_pixel **)malloc( nmap * sizeof(rle_pixel *) );
    cmap[0] = (rle_pixel *)malloc( nmap * maplen * sizeof(rle_pixel) );
    for ( i = 1; i < nmap; i++ )
        cmap[i] = cmap[0] + i * maplen;
    
    /* Fill it in. */
    for ( i = 0; i < maplen; i++ )
    {
        for ( j = 0; j < the_hdr->ncmap; j++ )
        if ( i < cmaplen )
            cmap[j][i] = the_hdr->cmap[j*cmaplen + i] >> 8;
        else
            cmap[j][i] = i;
        for ( ; j < nmap; j++ )
        cmap[j][i] = cmap[j-1][i];
    }
    }
    
    /* Gamma compensate if requested */
    if ( orig_gamma == 0 )
    {
    char *v;
    if ( (v = rle_getcom( "image_gamma", the_hdr )) != NULL )
    {
        orig_gamma = atof( v );
        /* Protect against bogus information */
        if ( orig_gamma == 0.0 )
        orig_gamma = 1.0;
        else
        orig_gamma = 1.0 / orig_gamma;
    }
    else if ( (v = rle_getcom( "display_gamma", the_hdr )) != NULL)
    {
        orig_gamma = atof( v );
        /* Protect */
        if ( orig_gamma == 0.0 )
        orig_gamma = 1.0;
    }
    else
        orig_gamma = 1.0;
    }

    /* Now, compensate for the gamma of the new display, too. */
    if ( new_gamma != 0.0 )
    gamma = orig_gamma / new_gamma;
    else
    gamma = orig_gamma;

    if ( gamma != 1.0 )
    {
    gammap = (rle_pixel *)malloc( 256 * sizeof(rle_pixel) );
    for ( i = 0; i < 256; i++ )
        gammap[i] = (int)(0.5 + 255.0 * pow( i / 255.0, gamma ));
    for ( i = 0; i < nmap; i++ )
        for ( j = 0; j < maplen; j++ )
        cmap[i][j] = gammap[cmap[i][j]];
    free( gammap );
    }

    return cmap;
}

Here is the caller graph for this function:

void bwdithermap	(	int	levels,
		double	gamma,
		int	bwmap[],
		int	divN[256],
		int	modN[256],
		int	magic[16][16]
	)

char* cmd_name

(

char **

argv

)

Definition at line 31 of file cmd_name.c.

{
    register char *cp, *a;

    /* Be paranoid. */
    if ( !argv || !(a = *argv) )
    return no_name;

    /* Find end of file name. */
    for ( cp = a; *cp; cp++ )
    ;

    /* Find last / or beginning of command name. */
    for ( cp--; *cp != '/' && cp > a; cp-- )
    ;
    
    /* If it's a /, skip it. */
    if ( *cp == '/' )
    cp++;

    return cp;
}

int colorquant	(	rle_pixel *	red,
		rle_pixel *	green,
		rle_pixel *	blue,
		unsigned long	pixels,
		rle_pixel *	colormap[3],
		int	colors,
		int	bits,
		rle_pixel *	rgbmap,
		int	fast,
		int	otherimages
	)

int ditherbw	(	int	x,
		int	y,
		int	val,
		int	divN[256],
		int	modN[256],
		int	magic[16][16]
	)

int dithergb	(	int	x,
		int	y,
		int	r,
		int	g,
		int	b,
		int	divN[256],
		int	modN[256],
		int	magic[16][16]
	)

void dithermap	(	int	levels,
		double	gamma,
		int	rgbmap[][3],
		int	divN[256],
		int	modN[256],
		int	magic[16][16]
	)

void float_to_exp	(	int	count,
		float *	floats,
		rle_pixel *	pixels
	)

Definition at line 42 of file float_to_exp.c.

{
    register int i;
    int expon, max_exp = -2000;
    float * fptr = floats;
    double f_exp;

    /* Find largest exponent */
    /* Use "Block normalization":
     * ExpScan[x] is largest exponent of the three
     * color components.  Red/Grn/BluScan[1..3] are the
     * normalized color components.
     */

    for (i = 0; i < count; i++)
    {
    frexp( *fptr++, &expon );
    max_exp = (expon > max_exp) ? expon : max_exp;
    }

    /* Don't over/underflow */
    if (max_exp > 128) max_exp = 128;
    else
    if (max_exp < -127) max_exp = -127;

    f_exp = ldexp( 256.0, -max_exp );

    fptr = floats;
    for( i = 0; i < count; i++ )  /* Extra casts for broken HP compiler */
        *pixels++ = (rle_pixel) ((int)(*fptr++ * f_exp)); 

    /* Excess 127 exponent */
    *pixels = (rle_pixel) (max_exp + 127); 
}

void hilbert_c2i	(	int	n,
		int	m,
		int	a[],
		long int *	r
	)

void hilbert_i2c	(	int	n,
		int	m,
		long int	r,
		int	a[]
	)

void inv_cmap	(	int	colors,
		unsigned char *	colormap[3],
		int	bits,
		unsigned long *	dist_buf,
		unsigned char *	rgbmap
	)

void make_square	(	double	N,
		int	divN[256],
		int	modN[256],
		int	magic[16][16]
	)

void rgb_to_bw	(	rle_pixel *	red_row,
		rle_pixel *	green_row,
		rle_pixel *	blue_row,
		rle_pixel *	bw_row,
		int	rowlen
	)

Definition at line 680 of file rle_putrow.c.

{
    register int x, bw;

    for (x=0; x<rowlen; x++)
    {
    /* 68000 won't store float > 127 into byte? */
    /* HP compiler blows it */
    bw = 0.5 + .30*red_row[x] + .59*green_row[x] + .11*blue_row[x];
    bw_row[x] = bw;
    }
}

void rle_addhist	(	char *	argv[],
		rle_hdr *	in_hdr,
		rle_hdr *	out_hdr
	)

int rle_alloc_error	(	const char *	pgm,
		const char *	name
	)

void rle_close_f

(

FILE *

fd

)

Definition at line 244 of file rle_open_f.c.

{
    if ( fd == NULL || fd == stdin || fd == stdout )
    return;
    else
    fclose( fd );
}

void rle_cp	(	rle_hdr *	in_hdr,
		rle_hdr *	out_hdr
	)

Definition at line 69 of file rle_cp.c.

{
    register FILE *infile = in_hdr->rle_file;
    register FILE *outfile = the_hdr->rle_file;
    char inst[2];
    short nc, buflen;
    char *buffer;

    /* Add in vertical skip from last scanline */
    if ( in_hdr->priv.get.vert_skip > 0 )
    {
    in_hdr->priv.get.scan_y += in_hdr->priv.get.vert_skip;
    if ( in_hdr->priv.get.vert_skip > 1 )
        rle_skiprow( the_hdr, in_hdr->priv.get.vert_skip - 1 );
    }

    if ( in_hdr->priv.get.is_eof )
    {
    rle_puteof( the_hdr );
    return;
    }

    if ( the_hdr->priv.put.nblank > 0 )
    {
    SkipBlankLines( the_hdr->priv.put.nblank );
    the_hdr->priv.put.nblank = 0;
    }

    /* Allocate memory for reading byte data. */
    buflen = in_hdr->xmax - in_hdr->xmin + 2;
    buffer = (char *)malloc( buflen );

    /* Otherwise, read and write instructions until an EOF
     * instruction is encountered.
     */
    for (;;)
    {
        inst[0] = getc( infile );
    inst[1] = getc( infile );

    /* Don't 'put' the instruction until we know what it is. */
    if ( feof(infile) )
    {
        in_hdr->priv.get.is_eof = 1;
        rle_puteof( the_hdr );
        break;      /* <--- one of the exits */
    }

    switch( OPCODE(inst) )
    {
    case RSkipLinesOp:
        putc( inst[0], outfile );
        putc( inst[1], outfile );
        if ( LONGP(inst) )
        {
        putc( getc( infile ), outfile );
        putc( getc( infile ), outfile );
        }
        break;          /* need to break for() here, too */

    case RSetColorOp:
        putc( inst[0], outfile );
        putc( inst[1], outfile );
        break;

    case RSkipPixelsOp:
        putc( inst[0], outfile );
        putc( inst[1], outfile );
        if ( LONGP(inst) )
        {
        putc( getc( infile ), outfile );
        putc( getc( infile ), outfile );
        }
        break;

    case RByteDataOp:
        putc( inst[0], outfile );
        putc( inst[1], outfile );
        if ( LONGP(inst) )
        {
            VAXSHORT( nc, infile );
        put16( nc );
        }
        else
        nc = DATUM(inst);
        nc++;
        nc = 2 * ((nc + 1) / 2);
        /* Total paranoia.  nc should never be > buflen. */
        while ( nc > buflen )
        {
        fread( buffer, nc, 1, infile );
        fwrite( buffer, nc, 1, outfile );
        nc -= buflen;
        }

        fread( buffer, nc, 1, infile );
        fwrite( buffer, nc, 1, outfile );
        break;

    case RRunDataOp:
        putc( inst[0], outfile );
        putc( inst[1], outfile );
        if ( LONGP(inst) )
        {
        putc( getc( infile ), outfile );
        putc( getc( infile ), outfile );
        }

        putc( getc( infile ), outfile );
        putc( getc( infile ), outfile );
        break;

    case REOFOp:
        in_hdr->priv.get.is_eof = 1;
        rle_puteof( the_hdr );
        break;

    default:
        fprintf( stderr,
             "%s: rle_cp: Unrecognized opcode: %d, reading %s\n",
             the_hdr->cmd, OPCODE(inst), the_hdr->file_name );
        fflush( the_hdr->rle_file );
        exit(1);
    }
    if ( OPCODE(inst) == REOFOp )
        break;          /* <--- the other loop exit */
    }

    /* Just in case the caller does something silly like calling rle_getrow. */
    in_hdr->priv.get.scan_y = in_hdr->ymax;
    in_hdr->priv.get.vert_skip = 0;

    return;
}

void rle_debug

(

int

on_off

)

Definition at line 293 of file rle_getrow.c.

{
    debug_f = on_off;

    /* Set line buffering on stderr.  Character buffering is the default, and
     * it is SLOOWWW for large amounts of output.
     */
    setlinebuf( stderr );
}

const char* rle_delcom	(	const char *	name,
		rle_hdr *	the_hdr
	)

int rle_get_error	(	int	code,
		const char *	pgmname,
		const char *	fname
	)

int rle_get_setup

(

rle_hdr *

the_hdr

)

Definition at line 74 of file rle_getrow.c.

Referenced by display_rle(), find_most_used(), RLE::open:, and read_rle_header().

{
    struct XtndRsetup setup;
    short magic;
    register FILE *infile = the_hdr->rle_file;
    rle_pixel * bg_color;
    register int i;
    char * comment_buf;
    
    /* Clear old stuff out of the header. */
    rle_hdr_clear( the_hdr );
    if ( the_hdr->is_init != RLE_INIT_MAGIC )
    rle_names( the_hdr, "Urt", "some file", 0 );
    the_hdr->img_num++;     /* Count images. */

    VAXSHORT( magic, infile );
    if ( feof( infile ) )
    return RLE_EMPTY;
    if ( magic != RLE_MAGIC )
    return RLE_NOT_RLE;
    fread( &setup, 1, SETUPSIZE, infile );  /* assume VAX packing */
    if ( feof( infile ) )
    return RLE_EOF;

    /* Extract information from setup */
    the_hdr->ncolors = setup.h_ncolors;
    for ( i = 0; i < the_hdr->ncolors; i++ )
    RLE_SET_BIT( *the_hdr, i );

    if ( !(setup.h_flags & H_NO_BACKGROUND) && setup.h_ncolors > 0 )
    {
    the_hdr->bg_color = (int *)malloc(
        (unsigned)(sizeof(int) * setup.h_ncolors) );
    bg_color = (rle_pixel *)malloc(
        (unsigned)(1 + (setup.h_ncolors / 2) * 2) );
    RLE_CHECK_ALLOC( the_hdr->cmd, the_hdr->bg_color && bg_color,
             "background color" );
    fread( (char *)bg_color, 1, 1 + (setup.h_ncolors / 2) * 2, infile );
    for ( i = 0; i < setup.h_ncolors; i++ )
        the_hdr->bg_color[i] = bg_color[i];
    free( bg_color );
    }
    else
    {
    (void)getc( infile );   /* skip filler byte */
    the_hdr->bg_color = NULL;
    }

    if ( setup.h_flags & H_NO_BACKGROUND )
    the_hdr->background = 0;
    else if ( setup.h_flags & H_CLEARFIRST )
    the_hdr->background = 2;
    else
    the_hdr->background = 1;
    if ( setup.h_flags & H_ALPHA )
    {
    the_hdr->alpha = 1;
    RLE_SET_BIT( *the_hdr, RLE_ALPHA );
    }
    else
    the_hdr->alpha = 0;

    the_hdr->xmin = vax_gshort( setup.hc_xpos );
    the_hdr->ymin = vax_gshort( setup.hc_ypos );
    the_hdr->xmax = the_hdr->xmin + vax_gshort( setup.hc_xlen ) - 1;
    the_hdr->ymax = the_hdr->ymin + vax_gshort( setup.hc_ylen ) - 1;

    the_hdr->ncmap = setup.h_ncmap;
    the_hdr->cmaplen = setup.h_cmaplen;
    if ( the_hdr->ncmap > 0 )
    {
    register int maplen =
             the_hdr->ncmap * (1 << the_hdr->cmaplen);
    register int i;
    register char *maptemp;

    the_hdr->cmap = (rle_map *)malloc(
        (unsigned)(sizeof(rle_map) * maplen) );
    maptemp = (char *)malloc( 2 * maplen );
    if ( the_hdr->cmap == NULL || maptemp == NULL )
    {
        fprintf( stderr,
"%s: Malloc failed for color map of size %d*%d in rle_get_setup, reading %s\n",
             the_hdr->cmd,
             the_hdr->ncmap, (1 << the_hdr->cmaplen),
             the_hdr->file_name );
        return RLE_NO_SPACE;
    }
    fread( maptemp, 2, maplen, infile );
    for ( i = 0; i < maplen; i++ )
        the_hdr->cmap[i] = vax_gshort( &maptemp[i * 2] );
    free( maptemp );
    }

    /* Check for comments */
    if ( setup.h_flags & H_COMMENT )
    {
    short comlen, evenlen;
    register char * cp;

    VAXSHORT( comlen, infile ); /* get comment length */
    evenlen = (comlen + 1) & ~1;    /* make it even */
    if ( evenlen )
    {
        comment_buf = (char *)malloc( (unsigned) evenlen );
    
        if ( comment_buf == NULL )
        {
        fprintf( stderr,
"%s: Malloc failed for comment buffer of size %d in rle_get_setup, reading %s\n",
             the_hdr->cmd, comlen, the_hdr->file_name );
        return RLE_NO_SPACE;
        }
        fread( comment_buf, 1, evenlen, infile );
        /* Count the comments */
        for ( i = 0, cp = comment_buf; cp < comment_buf + comlen; cp++ )
        if ( *cp == 0 )
            i++;
        i++;            /* extra for NULL pointer at end */
        /* Get space to put pointers to comments */
        the_hdr->comments =
        (CONST_DECL char **)malloc( (unsigned)(i * sizeof(char *)) );
        if ( the_hdr->comments == NULL )
        {
        fprintf( stderr,
 "%s: Malloc failed for %d comment pointers in rle_get_setup, reading %s\n",
             the_hdr->cmd, i, the_hdr->file_name );
        return RLE_NO_SPACE;
        }
        /* Get pointers to the comments */
        *the_hdr->comments = comment_buf;
        for ( i = 1, cp = comment_buf + 1;
          cp < comment_buf + comlen;
          cp++ )
        if ( *(cp - 1) == 0 )
            the_hdr->comments[i++] = cp;
        the_hdr->comments[i] = NULL;
    }
    else
        the_hdr->comments = NULL;
    }
    else
    the_hdr->comments = NULL;

    /* Initialize state for rle_getrow */
    the_hdr->priv.get.scan_y = the_hdr->ymin;
    the_hdr->priv.get.vert_skip = 0;
    the_hdr->priv.get.is_eof = 0;
    the_hdr->priv.get.is_seek = ftell( infile ) > 0;
    debug_f = 0;

    if ( !feof( infile ) )
    return RLE_SUCCESS; /* success! */
    else
    {
    the_hdr->priv.get.is_eof = 1;
    return RLE_EOF;
    }
}

Here is the caller graph for this function:

void rle_get_setup_ok	(	rle_hdr *	the_hdr,
		const char *	prog_name,
		const char *	file_name
	)

char* rle_getcom	(	const char *	name,
		rle_hdr *	the_hdr
	)

int rle_getrow	(	rle_hdr *	the_hdr,
		rle_pixel *	scanline[]
	)

unsigned int rle_getskip

(

rle_hdr *

the_hdr

)

Definition at line 57 of file rle_getskip.c.

{
    unsigned char inst[2];
    register FILE *infile = the_hdr->rle_file;
    int nc;

    /* Add in vertical skip from last scanline */
    if ( the_hdr->priv.get.vert_skip > 0) 
    the_hdr->priv.get.scan_y += the_hdr->priv.get.vert_skip;
    the_hdr->priv.get.vert_skip = 0;

    if ( the_hdr->priv.get.is_eof )
    return 32768;       /* too big for 16 bits, signal EOF */
    
    /* Otherwise, read and interpret instructions until a skipLines
     * instruction is encountered.
     */
    for (;;)
    {
        inst[0] = getc( infile );
    inst[1] = getc( infile );
    if ( feof(infile) )
    {
        the_hdr->priv.get.is_eof = 1;
        break;      /* <--- one of the exits */
    }

    switch( OPCODE(inst) )
    {
    case RSkipLinesOp:
        if ( LONGP(inst) )
        {
        VAXSHORT( the_hdr->priv.get.vert_skip, infile );
        }
        else
        the_hdr->priv.get.vert_skip = DATUM(inst);
        break;          /* need to break for() here, too */

    case RSetColorOp:
        /* No-op here. */
        break;

    case RSkipPixelsOp:
        if ( LONGP(inst) )
        {
        (void)getc( infile );
        (void)getc( infile );
        }
        break;

    case RByteDataOp:
        if ( LONGP(inst) )
        {
            VAXSHORT( nc, infile );
        }
        else
        nc = DATUM(inst);
        nc++;
        if ( the_hdr->priv.get.is_seek )
        fseek( infile, ((nc + 1) / 2) * 2, 1 );
        else
        {
        register int ii;
        for ( ii = ((nc + 1) / 2) * 2; ii > 0; ii-- )
            (void) getc( infile );  /* discard it */
        }

        break;

    case RRunDataOp:
        if ( LONGP(inst) )
        {
        (void)getc( infile );
        (void)getc( infile );
        }
        (void)getc( infile );
        (void)getc( infile );
        break;

    case REOFOp:
        the_hdr->priv.get.is_eof = 1;
        break;

    default:
        fprintf( stderr,
             "%s: rle_getskip: Unrecognized opcode: %d, reading %s\n",
             the_hdr->cmd, OPCODE(inst), the_hdr->file_name );
        exit(1);
    }
    if ( OPCODE(inst) == REOFOp )
        break;          /* <--- the other loop exit */
    if ( OPCODE(inst) == RSkipLinesOp )
        break;
    }

    /* Return the number of the NEXT scanline. */
    the_hdr->priv.get.scan_y +=
    the_hdr->priv.get.vert_skip;
    the_hdr->priv.get.vert_skip = 0;

    if ( the_hdr->priv.get.is_eof )
    return 32768;       /* too big for 16 bits, signal EOF */
    else
    return the_hdr->priv.get.scan_y;
}

void rle_hdr_clear

(

rle_hdr *

the_hdr

)

Definition at line 222 of file rle_hdr.c.

{
    /* Try to free memory.  Assume if is_init is properly set that this
     * header has been previously initialized, therefore it is safe to
     * free memory.
     */
    if ( the_hdr && the_hdr->is_init == RLE_INIT_MAGIC )
    {
    if ( the_hdr->bg_color )
        free( the_hdr->bg_color );
    the_hdr->bg_color = 0;
    if ( the_hdr->cmap )
        free( the_hdr->cmap );
    the_hdr->cmap = 0;
    /* Unfortunately, we don't know how to free the comment memory. */
    if ( the_hdr->comments )
        free( the_hdr->comments );
    the_hdr->comments = 0;
    }
}

rle_hdr* rle_hdr_cp	(	rle_hdr *	from_hdr,
		rle_hdr *	to_hdr
	)

Definition at line 119 of file rle_hdr.c.

{
    static rle_hdr dflt_hdr;
    CONST_DECL char *cmd, *file;
    int num;

    /* Save command, file name, and image number if already initialized. */
    if ( to_hdr &&  to_hdr->is_init == RLE_INIT_MAGIC )
    {
    cmd = to_hdr->cmd;
    file = to_hdr->file_name;
    num = to_hdr->img_num;
    }
    else
    {
    cmd = file = NULL;
    num = 0;
    }

    if ( !no_recurse )
    {
    no_recurse++;
    rle_hdr_init( to_hdr );
    no_recurse--;
    }

    if ( to_hdr == NULL )
    to_hdr = &dflt_hdr;

    *to_hdr = *from_hdr;

    if ( to_hdr->bg_color )
    {
    int size = to_hdr->ncolors * sizeof(int);
    to_hdr->bg_color = (int *)malloc( size );
    RLE_CHECK_ALLOC( to_hdr->cmd, to_hdr->bg_color, "background color" );
    bcopy( from_hdr->bg_color, to_hdr->bg_color, size );
    }

    if ( to_hdr->cmap )
    {
    int size = to_hdr->ncmap * (1 << to_hdr->cmaplen) * sizeof(rle_map);
    to_hdr->cmap = (rle_map *)malloc( size );
    RLE_CHECK_ALLOC( to_hdr->cmd, to_hdr->cmap, "color map" );
    bcopy( from_hdr->cmap, to_hdr->cmap, size );
    }

    /* Only copy array of pointers, as the original comment memory
     * never gets overwritten.
     */
    if ( to_hdr->comments )
    {
    int size = 0;
    CONST_DECL char **cp;
    for ( cp=to_hdr->comments; *cp; cp++ )
        size++;     /* Count the comments. */
    /* Check if there are really any comments. */
    if ( size )
    {
        size++;     /* Copy the NULL pointer, too. */
        size *= sizeof(char *);
        to_hdr->comments = (CONST_DECL char **)malloc( size );
        RLE_CHECK_ALLOC( to_hdr->cmd, to_hdr->comments, "comments" );
        bcopy( from_hdr->comments, to_hdr->comments, size );
    }
    else
        to_hdr->comments = NULL;    /* Blow off empty comment list. */
    }

    /* Restore the names to their original values. */
    to_hdr->cmd = cmd;
    to_hdr->file_name = file;

    /* Lines above mean nothing much happens if cmd and file are != NULL. */
    rle_names( to_hdr, to_hdr->cmd, to_hdr->file_name, num );

    return to_hdr;
}

rle_hdr* rle_hdr_init

(

rle_hdr *

the_hdr

)

Definition at line 267 of file rle_hdr.c.

Referenced by read_file().

{
    rle_hdr *ret_hdr;

    rle_dflt_hdr.rle_file = stdout;
    /* The rest of rle_dflt_hdr is set by the loader's data initialization */

    if ( the_hdr == &rle_dflt_hdr )
    return the_hdr;

    rle_hdr_clear( the_hdr );

    /* Only call rle_hdr_cp if not called from there. */
    if ( !no_recurse )
    {
    no_recurse++;
    ret_hdr = rle_hdr_cp( &rle_dflt_hdr, the_hdr );
    no_recurse--;
    }
    else
    ret_hdr = the_hdr;

    return ret_hdr;
}

Here is the caller graph for this function:

void rle_names	(	rle_hdr *	the_hdr,
		const char *	pgmname,
		const char *	fname,
		int	img_num
	)

FILE* rle_open_f	(	const char *	prog_name,
		const char *	f_name,
		const char *	mode
	)

FILE* rle_open_f_noexit	(	const char *	prog_name,
		const char *	f_name,
		const char *	mode
	)

void rle_put_init

(

rle_hdr *

the_hdr

)

Definition at line 415 of file rle_putrow.c.

{
    the_hdr->dispatch = RUN_DISPATCH;

    if ( the_hdr->is_init != RLE_INIT_MAGIC )
    {
    the_hdr->cmd = "Urt";
    the_hdr->file_name = "some file";
    }
    the_hdr->priv.put.nblank = 0;   /* Reinit static vars */
    /* Would like to be able to free previously allocated storage,
     * but can't count on a non-NULL value being a valid pointer.
     */
    PBRUN = NULL;
    the_hdr->priv.put.fileptr = 0;

    /* Only save alpha if alpha AND alpha channel bit are set. */
    if ( the_hdr->alpha )
    the_hdr->alpha = (RLE_BIT( *the_hdr, -1 ) != 0);
    else
    RLE_CLR_BIT( *the_hdr, -1 );
}

void rle_put_setup

(

rle_hdr *

the_hdr

)

Definition at line 453 of file rle_putrow.c.

Referenced by find_most_used(), and write_rle_header().

{
    rle_put_init( the_hdr );
    the_hdr->img_num++;     /* Count output images. */
    Setup();
}

Here is the caller graph for this function:

const char* rle_putcom	(	const char *	value,
		rle_hdr *	the_hdr
	)

void rle_puteof

(

rle_hdr *

the_hdr

)

Definition at line 474 of file rle_putrow.c.

Referenced by FormFeed(), rasterDone(), and write_rle_data().

{
    /* Don't puteof twice. */
    if ( the_hdr->dispatch == NO_DISPATCH )
    return;
    PutEof();
    fflush( the_hdr->rle_file );
    /* Free storage allocated by rle_put_init. */
    if ( PBRUN != NULL )
    {
    free( PBRUN );
    PBRUN = NULL;
    }
    /* Signal that puteof has been called. */
    the_hdr->dispatch = NO_DISPATCH;
}

Here is the caller graph for this function:

void rle_putrow	(	rle_pixel *	rows[],
		int	rowlen,
		rle_hdr *	the_hdr
	)

int rle_row_alloc	(	rle_hdr *	the_hdr,
		rle_pixel ***	scanp
	)

Definition at line 56 of file rle_row_alc.c.

Referenced by get_scanlines(), RLE::open:, write_ppm_data(), write_rlb_data(), and write_rle_data().

{
    rle_pixel ** scanbuf, * pixbuf;
    int rowlen, nchan = 0, i, ncol;

    rowlen = the_hdr->xmax + 1;
    if ( the_hdr->alpha && RLE_BIT( *the_hdr, RLE_ALPHA ) )
    nchan++;
    for ( i = 0; i < the_hdr->ncolors; i++ )
    if ( RLE_BIT( *the_hdr, i ) )
         nchan++;

    ncol = the_hdr->ncolors + the_hdr->alpha;

    if ( (scanbuf = (rle_pixel **)malloc( ncol * sizeof(rle_pixel *) )) == 0 )
    return -1;
    if ( (pixbuf = (rle_pixel *)malloc( nchan * rowlen *
                       sizeof(rle_pixel) )) == 0 )
    {
    free( scanbuf );
    return -1;
    }

    if ( the_hdr->alpha )
    scanbuf++;

    for ( i = -the_hdr->alpha; i < the_hdr->ncolors; i++ )
    if ( RLE_BIT( *the_hdr, i ) )
    {
        scanbuf[i] = pixbuf;
        pixbuf += rowlen;
    }
    else
        scanbuf[i] = 0;
    *scanp = scanbuf;

    return 0;
}

Here is the caller graph for this function:

void rle_row_free	(	rle_hdr *	the_hdr,
		rle_pixel **	scanp
	)

Definition at line 114 of file rle_row_alc.c.

Referenced by RLE::open:, write_ppm_data(), and write_rle_data().

{
    int i;

    if ( the_hdr->alpha )
    scanp--;
    for ( i = 0; i < the_hdr->ncolors + the_hdr->alpha; i++ )
    if ( scanp[i] != 0 )
    {
        free( (char *)scanp[i] );
        break;
    }
    free( (char *)scanp );
}

Here is the caller graph for this function:

void rle_skiprow	(	rle_hdr *	the_hdr,
		int	nrow
	)

Definition at line 393 of file rle_putrow.c.

Referenced by write_rle_data().

{
    the_hdr->priv.put.nblank += nrow;
}

Here is the caller graph for this function:

int scanargs	(	int	argc,
		char **	argv,
		const char *	format,
			...
	)

Definition at line 94 of file scanargs.c.

References _do_scanargs().

{
    va_list argl;
    int retval;
#ifndef USE_STDARG
    int argc;
    char ** argv;
    CONST_DECL char *format;

    va_start( argl );
    argc = va_arg( argl, int );
    argv = va_arg( argl, char ** );
    format = va_arg( argl, CONST_DECL char * );
#else
    va_start( argl, format );
#endif
    retval = _do_scanargs( argc, argv, format, argl );
    va_end( argl );
    return retval;
}

Here is the call graph for this function:

Variable Documentation

rle_hdr rle_dflt_hdr

Definition at line 66 of file rle_global.c.

Referenced by find_most_used(), and write_rlb_data().