rlesplice.c File Reference

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

Include dependency graph for rlesplice.c:

Go to the source code of this file.

Macros
#define	MALLOC_ERR   RLE_CHECK_ALLOC( cmd_name( argv ), 0, 0 )
#define	VERT_FLAG   0x01 /* Command line flags */
#define	HORIZ_FLAG   0x02 /* must match appearance in scanargs */
#define	FOO_FLAG   0x04
#define	Max(x, y)   (((x) > (y)) ? (x) : (y) )
#define	Min(x, y)   (((x) < (y)) ? (x) : (y) )
#define	Check(thing, printthing)

Functions
static void	bfill ()
int	compatible_hdr (rle_hdr *hdr_1, rle_hdr *hdr_2)
void	rle_row_clear (rle_hdr *the_hdr, scanline)
void	main (int argc, argv)
static void	bfill (char *s, int n, int c)

Variables
char *	progname = ((void *)0)

Macro Definition Documentation

#define Check	(		thing,
			printthing
	)

Value:

if (hdr_1->thing != hdr_2->thing) \
    { \
    fprintf( stderr, "%s: %s does not match\n", progname, printthing); \
    return 0; \
    }

#define FOO_FLAG   0x04

Definition at line 35 of file rlesplice.c.

#define HORIZ_FLAG   0x02 /* must match appearance in scanargs */

Definition at line 34 of file rlesplice.c.

#define MALLOC_ERR   RLE_CHECK_ALLOC( cmd_name( argv ), 0, 0 )

Definition at line 31 of file rlesplice.c.

#define Max	(		x,
			y
	)		(((x) > (y)) ? (x) : (y) )

Definition at line 37 of file rlesplice.c.

#define Min	(		x,
			y
	)		(((x) < (y)) ? (x) : (y) )

Definition at line 38 of file rlesplice.c.

#define VERT_FLAG   0x01 /* Command line flags */

Definition at line 33 of file rlesplice.c.

Function Documentation

static void bfill ( )

static

static void bfill ( char *  s, int  n, int  c  )

static

Definition at line 240 of file rlesplice.c.

{
#ifdef vax
    asm("   movc5   $0,*4(ap),12(ap),8(ap),*4(ap)");
#else
    while ( n-- > 0 )
    *s++ = c;
#endif
}

int compatible_hdr	(	rle_hdr *	hdr_1,
		rle_hdr *	hdr_2
	)

Definition at line 44 of file rlesplice.c.

{
#define Check(thing,printthing) \
    if (hdr_1->thing != hdr_2->thing) \
    { \
    fprintf( stderr, "%s: %s does not match\n", progname, printthing); \
    return 0; \
    }
    Check(ncolors, "Number of color channels");
    Check(alpha, "Existance of alpha channel");
    Check(ncmap, "Number of colormap channels");
    Check(cmaplen, "Colormap length");
    return 1;
#undef Check
}

void main	(	int	argc,
		argv
	)

Definition at line 81 of file rlesplice.c.

{
    char    *infname1 = NULL, *outfname = NULL;
    char    *infname2 = NULL;
    int     oflag = 0, hvflag = 0, cflag = 0;
    int     rle_cnt = 0;
    FILE    *outfile = stdout;
    int         j;
    int     new_xlen,
        new_ylen;
    int     rle_err1, rle_err2 = 0;
    rle_hdr     in_hdr1, in_hdr2, out_hdr;
    int     xmin, ymin, width1, width2, height1, height2;

    progname = cmd_name( argv );
    in_hdr1 = *rle_hdr_init( NULL );
    in_hdr2 = *rle_hdr_init( NULL );
    out_hdr = *rle_hdr_init( NULL );

    if ( scanargs( argc, argv, "% hv!- c%- o%-outfile!s infile1!s infile2!s",
          &hvflag, &cflag, &oflag, &outfname,
          &infname1, &infname2 ) == 0 )
    exit( 1 );
    
    in_hdr1.rle_file = rle_open_f( progname, infname1, "r" );
    in_hdr2.rle_file = rle_open_f( progname, infname2, "r" );
    rle_names( &in_hdr1, progname, infname1, 0 );
    rle_names( &in_hdr2, progname, infname2, 0 );
    rle_names( &out_hdr, progname, outfname, 0 );


    /* Both standard input? */
    if ( in_hdr1.rle_file == in_hdr2.rle_file )
    {
    fprintf( stderr, "Both files can't be on standard input.\n" );
    exit( -1 );
    }

    for ( rle_cnt = 0;
      (rle_err1 = rle_get_setup( &in_hdr1 )) == RLE_SUCCESS &&
      (rle_err2 = rle_get_setup( &in_hdr2 )) == RLE_SUCCESS;
      rle_cnt++ ) {
    rle_pixel     **rows1, **rows2, **rowsout;
    rle_pixel      *ptr1, *ptr2, *ptrout;
    int     start_scan1, start_scan2, pad1, pad2;
    int         chan;

    if ( rle_cnt == 0 )
        outfile = rle_open_f( progname, outfname, "w" );

    if (!compatible_hdr(&in_hdr1, &in_hdr2)) {
        fprintf(stderr, "%s: Non-compatible rle files: %s and %s\n",
            progname, infname1, infname2);
        exit(1);
    }

    (void)rle_hdr_cp( &in_hdr1, &out_hdr );
    rle_addhist( argv, &in_hdr1, &out_hdr );

    /* preserve xmin and ymin from in_hdr1 */
    xmin = in_hdr1.xmin;
    ymin = in_hdr1.ymin;
    width1 = in_hdr1.xmax - in_hdr1.xmin + 1;
    width2 = in_hdr2.xmax - in_hdr2.xmin + 1;
    height1 = in_hdr1.ymax - in_hdr1.ymin + 1;
    height2 = in_hdr2.ymax - in_hdr2.ymin + 1;

    if (hvflag == VERT_FLAG) {
        new_xlen = Max( width1, width2 );
        new_ylen = height1 + height2;
    } else {
        new_xlen = width1 + width2;
        new_ylen = Max( height1, height2 );
    }

    out_hdr.xmin = xmin;
    out_hdr.ymin = ymin;
    out_hdr.xmax = xmin + new_xlen - 1;
    out_hdr.ymax = ymin + new_ylen - 1;

    out_hdr.rle_file = outfile;
    rle_put_setup( &out_hdr );

    /* Oink. */
    if ( rle_row_alloc( &in_hdr1, &rows1 ) < 0 ||
         rle_row_alloc( &in_hdr2, &rows2 ) < 0 ||
         rle_row_alloc( &out_hdr, &rowsout ) < 0 )
        MALLOC_ERR;

    rle_row_clear( &in_hdr1, rows1 );
    rle_row_clear( &in_hdr2, rows2 );
    rle_row_clear( &out_hdr, rowsout );

    if ( hvflag == HORIZ_FLAG ) {
        int diff = height1 - height2 ;
        start_scan1 = start_scan2 = pad1 = pad2 = 0;
        if ( height1 < height2 ) 
        start_scan1 = (cflag) ? -diff/2 : new_ylen - height1;
        else if ( height2 < height1 ) 
        start_scan2 = (cflag) ? diff/2 : new_ylen - height2;
    } else {
        /* upside down remember */
        start_scan2 = pad1 = pad2 = 0;
        start_scan1 = height2;
        
        if ( width1 < width2 ) 
        pad1 = (cflag) ? (width2 - width1)/2 : 0;
        else if (width2 < width1 ) 
        pad2 = (cflag) ? (width1 - width2)/2 : 0;
    }

    for ( j = 0; j < new_ylen; j++ ) {
        if ( start_scan1 <= j && hvflag == VERT_FLAG ) {
        start_scan2 = new_ylen + 1; /* never again */
        rle_row_clear( &out_hdr, rowsout );
        }
        if ( start_scan1 <= j )
        rle_getrow(&in_hdr1, rows1 );
        if ( start_scan2 <= j )
        rle_getrow(&in_hdr2, rows2 );
        
        for (chan = RLE_ALPHA; chan < in_hdr1.ncolors; chan++)
        {
        if ((chan == RLE_ALPHA) && (!in_hdr1.alpha))
            continue;
        ptr1 = &(rows1[chan][in_hdr1.xmin]);
        ptr2 = &(rows2[chan][in_hdr2.xmin]);
        ptrout = rowsout[chan];
        
        if ( start_scan1 <= j )
            bcopy( ptr1, ptrout + pad1, width1 );
        if ( start_scan2 <= j )
            bcopy( ptr2,((char *)ptrout) + pad2 +
              ((hvflag == VERT_FLAG) ? 0 : width1), width2 );
        
        }
        rle_putrow( rowsout, new_xlen, &out_hdr );
    }
    rle_puteof( &out_hdr );
    
    rle_row_free( &in_hdr1, rows1 );
    rle_row_free( &in_hdr2, rows2 );
    rle_row_free( &out_hdr, rowsout );
    }

    if ( rle_cnt == 0 || (rle_err1 != RLE_EOF && rle_err1 != RLE_EMPTY &&
              rle_err2 != RLE_EOF && rle_err2 != RLE_EMPTY ) ) {
    if (rle_err1 != RLE_SUCCESS)
        rle_get_error( rle_err1, progname, infname1 );
    if (rle_err2 != RLE_SUCCESS)
        rle_get_error( rle_err2, progname, infname2 );
    }
    exit( 0 );
}

void rle_row_clear	(	rle_hdr *	the_hdr,
		scanline
	)

Definition at line 62 of file rlesplice.c.

{
    int nc;
    rle_pixel bg_color[255];
    
    if ( the_hdr->alpha && RLE_BIT( *the_hdr, -1 ) )
    bfill( (char *)scanline[-1], the_hdr->xmax + 1, 0 );

    /* Clear to background if specified */
    for ( nc = 0; nc < the_hdr->ncolors; nc++ ) {
    bg_color[nc] = (the_hdr->background == 2 ) ? the_hdr->bg_color[nc] : 0;
    if ( RLE_BIT( *the_hdr, nc ) )
        bfill( (char *)scanline[nc], the_hdr->xmax+1, bg_color[nc] );
    }
}

Variable Documentation

char* progname = ((void *)0)

Definition at line 41 of file rlesplice.c.