rletoraw.c File Reference

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

Include dependency graph for rletoraw.c:

Go to the source code of this file.

Macros
#define	duff(counter, block)
#define	WRITE_DATA()
#define	COPY_LINE()   duff(count, *o = *p++; o += stride);

Functions
void	main (int argc, argv)

Macro Definition Documentation

#define COPY_LINE

(

)

duff(count, *o = *p++; o += stride);

#define duff	(		counter,
			block
	)

Value:

{\
  while (counter >= 4) {\
     { block; } \
     { block; } \
     { block; } \
     { block; } \
     counter -= 4;\
  } \
  switch (counter & 3) { \
     case 3:    { block; } \
     case 2:    { block; } \
     case 1:    { block; } \
     case 0:    counter = 0;\
     }\
}

Definition at line 44 of file rletoraw.c.

#define WRITE_DATA

(

)

Value:

if (fwrite( outrows, 1, fwrite_len, outfile ) != fwrite_len) {\
    perror( "write error" );\
    exit(-2);\
    }\

Definition at line 61 of file rletoraw.c.

Function Documentation

void main	(	int	argc,
		argv
	)

Definition at line 69 of file rletoraw.c.

{ 
    int i, rle_err;
    char *nullbytes = NULL;
    char *infname = NULL, *outfname = NULL, *progname;
    FILE *infile, *outfile;
    rle_hdr hdr;
    int oflag = 0;
    int fflag = 0, tflag = 0, Nflag = 0, rflag = 0;
    int header = 0, trailer = 0;
    int pflag= 0, right_pad = 0, lflag = 0, left_pad = 0;
    int aflag = 0, output_alpha = 0, sflag = 0;

    int height, width, nochan;
    int red_pos, alpha_pos, green_pos = 0, blue_pos = 0;
    int img_size;

    /* Default color values */
    unsigned char *outrows;
    rle_pixel **inrows;
    int outrows_size;
    int y;
    int line_pos;
    int fwrite_len;
    unsigned char *fwrite_pos;

    progname = cmd_name( argv );

    if ( scanargs( argc, argv, 
          "% Ns%- r%- a%- f%-header-size!d t%-trailer-size!d \n\
\t\tp%-scanline-pad!d l%-left-scanline-pad!d o%-outfile!s \n\
\t\tinfile%s\n(\
\t-a\tDon't strip the alpha channel from the rle file.\n\
\t-f,-t\tEach output image is preceded (followed) by so many bytes.\n\
\t-l,-p\tScanlines are padded on left (right) end with so many bytes.\n\
\t\tAll padding is with null (0) bytes.\n\
\t-s\tOutput data in scanline interleaved order\n\
\t-N\tOutput data in non-interleaved order (eg. | split -Wid*Height -)\n\
\t-r\treverse the channel order (e.g. write data as ABGR instead of\n\
\t\tthe default RGBA order).)",
          &Nflag, &rflag, &aflag, &fflag, &header,
          &tflag, &trailer, &pflag, &right_pad, &lflag, &left_pad,
          &oflag, &outfname, &infname ) == 0)
    exit( 1 );

    /* Initialize header. */
    hdr = *rle_hdr_init( (rle_hdr *)NULL );
    rle_names( &hdr, cmd_name( argv ), infname, 0 );

    if (Nflag) {
    if (Nflag & 1) {
        Nflag = 0;
        sflag = 1;
    } else {
        Nflag = 1;
        sflag = 0;
    }
    }
           

    /* Open Raw file */
    infile = rle_open_f( progname, infname, "r" );
    outfile = rle_open_f( progname, outfname, "w" );


    rle_dflt_hdr.rle_file = infile;
    
    if ( (rle_err = rle_get_setup(&rle_dflt_hdr)) < 0) {
    rle_get_error( rle_err, progname, infname );
    exit ( rle_err );
    }

    rle_dflt_hdr.xmax -= rle_dflt_hdr.xmin;
    rle_dflt_hdr.xmin = 0;
    rle_dflt_hdr.ymax -= rle_dflt_hdr.ymin;
    rle_dflt_hdr.ymin = 0;
    
    width = rle_dflt_hdr.xmax + 1;
    height = rle_dflt_hdr.ymax + 1;
    nochan = rle_dflt_hdr.ncolors;
    
    fprintf(stderr, "width %d, height %d, channels %d\n", width, height, nochan);

    if (! aflag)
    RLE_CLR_BIT(rle_dflt_hdr, RLE_ALPHA);
    output_alpha = (aflag && RLE_BIT(rle_dflt_hdr, RLE_ALPHA)) ? 1 : 0;
    
    /* for -Non-interleaved case, we need nochan-1 whole channels of buffer */
    /* HACK: we allocate more memory; we jack the size for the first fread */
    outrows_size = width * (nochan + output_alpha);
    if ( Nflag )
    outrows_size *= height;
    if ((outrows = (unsigned char *) malloc ( outrows_size )) == NULL ) {
    fprintf(stderr, "%s: No memory available for rows malloc\n", progname);
    exit(-2);
    }
    
    img_size = width * height;

    /* Were only interested in R, G, & B */
    for (i = 3; i < rle_dflt_hdr.ncolors; i++)
    RLE_CLR_BIT(rle_dflt_hdr, i);

    if (rle_row_alloc( &rle_dflt_hdr, &inrows )) {
    fprintf(stderr, "%s: No memory available for rle_row_alloc\n", progname);
    exit(-2);
    }

    /* maybe faster to malloc and fwrite than to do lots of GETCs, Idunno */
    if (fflag || tflag) {
    nullbytes = (char *) malloc ( (header > trailer) ? header : trailer );
    if (! nullbytes)
        fprintf(stderr, "%s: No memory for nullbytes\n", progname);
    else
        for( i = (header > trailer) ? header : trailer; i > 0; )
        nullbytes[--i] = 0;
    }

    /* setup byte positions for reversed colors or otherwise */
    if ( rflag ) {
    alpha_pos = 0;
    /* alpha comes first if it's there */
    if (nochan > 2) {
        red_pos = 2 + output_alpha;
        green_pos = 1 + output_alpha;
        blue_pos = 0 + output_alpha;
    } else
        red_pos = 0 + output_alpha;
    }
    else {
    alpha_pos = nochan;
    red_pos = 0;
    if (nochan > 2) {
        green_pos = 1;
        blue_pos = 2;
    }
    }
    
    if ( Nflag ) {
    red_pos *= img_size;
    green_pos *= img_size;
    blue_pos *= img_size;
    alpha_pos *= img_size;
    } else if ( sflag ) {
    red_pos *= width;
    green_pos *= width;
    blue_pos *= width;
    alpha_pos *= width;
    }

    y = height;
    line_pos = 0;
    fwrite_len = outrows_size;
    fwrite_pos = outrows;

    /* write the header */
    if (fflag)
    fwrite( nullbytes, 1, header, outfile );
    
    while (--y >= 0) {
    register rle_pixel *p, *o;
    register int stride = nochan + output_alpha, count;
    
    rle_getrow(&rle_dflt_hdr, inrows);
    /* non-interleaved data is easier to compute than interleaved */
    if ( Nflag ) {
        /*
         * This is a wierd case...  We had to read in all of the
         * scanlines for all but one of the channels...  Then we can
         * handle things scanline by scanline...  We have to jack
         * the fread parameters for all of the remaining scanlines
         */
        
        if ( output_alpha ) 
        bcopy(inrows[RLE_ALPHA], outrows + alpha_pos + line_pos,width);
        
        bcopy(inrows[RLE_RED], outrows + red_pos + line_pos, width);
        
        if (nochan > 2) {
        bcopy(inrows[RLE_GREEN], outrows + green_pos + line_pos,width);
        bcopy(inrows[RLE_BLUE], outrows + blue_pos + line_pos,width);
        }
        line_pos += width;
    } else if (sflag) {
        /* scanline interleaved: we only need to copy the data */
        if ( output_alpha )
        bcopy (inrows[RLE_ALPHA], outrows + alpha_pos, width);
        
        bcopy (inrows[RLE_RED], outrows + red_pos, width);
        
        if (nochan > 2) {
        bcopy(inrows[RLE_GREEN], outrows + green_pos, width);
        bcopy(inrows[RLE_BLUE], outrows + blue_pos, width);
        }
    }
    else 
    {
#define COPY_LINE() duff(count, *o = *p++; o += stride);
        
        /* ahhh...  the default.  interleaved data */
        if ( output_alpha ) {
        o = outrows + alpha_pos;
        p = inrows[RLE_ALPHA];
        count = width;
        COPY_LINE();
        }       
        
        o = outrows + red_pos;
        p = inrows[RLE_RED];
        count = width;
        COPY_LINE();
        
        if (nochan > 2) {
        o = outrows + green_pos;
        p = inrows[RLE_GREEN];
        count = width;
        COPY_LINE();
        
        o = outrows + blue_pos;
        p = inrows[RLE_BLUE];
        count = width;
        COPY_LINE();
        }
    }
    
    /* LEFT_PAD */
    for (count = 0; count < left_pad; count++)
        putc('\0', outfile);
    
    /* WRITE_SCANLINE */
    if (! Nflag)
        WRITE_DATA();
    
    /* RIGHT_PAD */
    for (count = 0; count < right_pad; count++)
        putc('\0', outfile);
    
    }
    if ( Nflag )
    WRITE_DATA();
    
    /* write the trailer */
    if (tflag)
    fwrite( nullbytes, 1, trailer, outfile );
    
    exit(0);
}