rawtorle.c File Reference

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

Include dependency graph for rawtorle.c:

Go to the source code of this file.

Macros
#define	duff(counter, block)
#define	Nflag   (Nsflag & 2)
#define	sflag   (Nsflag & 1)

Functions
void	main (int argc, argv)

Macro Definition Documentation

#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 53 of file rawtorle.c.

#define Nflag   (Nsflag & 2)

#define sflag   (Nsflag & 1)

Function Documentation

void main	(	int	argc,
		argv
	)

Definition at line 70 of file rawtorle.c.

{ 
    int i;
    char *header_bytes = NULL, *trailer_bytes = NULL;
    char *infname = NULL, *outfname = NULL;
    FILE *infile, *outfile;
    rle_hdr hdr;
    int oflag = 0, wflag = 0, hflag = 0, nflag = 0;
    int fflag = 0, tflag = 0, Nsflag = 0, rflag = 0;
#define Nflag   (Nsflag & 2)
#define sflag   (Nsflag & 1)
    int header = 0, trailer = 0, alpha_value = 255;
    int pflag= 0, right_pad = 0, lflag = 0, left_pad = 0;
    int aflag = 0, input_alpha = 0;
    int height = 512, width = 512, nochan = 3;
    int red_pos, alpha_pos, green_pos = 0, blue_pos = 0;
    int img_size;

    /* Default color values */
    rle_pixel **outrows;
    unsigned char *inrows;
    int inrows_size;

    if ( scanargs( argc, argv, 
          "% Ns%- r%- w%-width!d h%-height!d f%-header-size!d \n\
\t\tt%-trailer-size!d n%-nchannels!d a%-alpha-value%d  \n\
\t\tp%-scanline-pad!d l%-left-scanline-pad!d o%-outfile!s \n\
\t\tinfile%s\n(\
\t-a\tAdd an alpha channel to the rle file with given value.\n\
\t-f,-t\tEach input 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-n\tNumber of channels in the input. If 2 or 4, presence of\n\
\t\talpha channel is assumed.\n\
\t-N\tinput is in non-interleaved order (e.g.\n\
\t\tcat pic.r pic.g pic.b | rawtorle)\n\
\t-r\treverse the channel order (e.g. read data as ABGR instead of\n\
\t\tthe default RGBA order)\n\
\t-s\tInput data is in scanline interleaved order.)",
          &Nsflag, &rflag, &wflag, &width, &hflag, &height,
          &fflag, &header, &tflag, &trailer, &nflag, &nochan,
          &aflag, &alpha_value,
          &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 ), outfname, 0 );

    /* Error check arguments. */
    if ( width <= 0 || height <= 0 ) {
    fprintf(stderr, "%s: Invalid width or height arg (%d,%d)\n",
        hdr.cmd, width, height);
    exit(-2);
    }

    if ( 0 > nochan || nochan > 4 ) {
    fprintf(stderr, "%s: Invalid number of channels %d\n",
        hdr.cmd, nochan);
    exit(-2);
    }
    
    /* For 2 channels we assume one is an alpha channel */
    if ( nochan == 2 || nochan == 4 )
    input_alpha = 1;
    
    /* either way, who cares */
    if ( Nflag && nochan == 1 )
    Nsflag = 0;

    if ( Nflag && (lflag || pflag))
    fprintf( stderr,
         "%s: -N with -l or -p is not supported, padding ignored.\n",
         hdr.cmd );
    
    /* Open Raw file */
    infile = rle_open_f( hdr.cmd, infname, "r" );
    outfile = rle_open_f( hdr.cmd, outfname, "w" );

    /* for -Non-interleaved case, we need nochan-1 whole channels of buffer */
    inrows_size = Nflag ? width * (height + 1) * (nochan - 1) : width * nochan;

    if ((inrows = (unsigned char *) malloc ( inrows_size )) == NULL) {
    fprintf(stderr, "%s: No memory available for inrows malloc\n",
        hdr.cmd);
    exit(-2);
    }
    /* HACK: we allocate more memory; we jack the size for the first fread */
    if ( Nflag ) 
    inrows_size = width * height * (nochan - 1) + width;
    
    img_size = width * height;

    rle_dflt_hdr.rle_file = outfile;
    rle_dflt_hdr.xmin = rle_dflt_hdr.ymin = 0;
    rle_dflt_hdr.xmax = width - 1;
    rle_dflt_hdr.ymax = height - 1;
    rle_dflt_hdr.alpha = aflag || input_alpha;
    switch ( nochan ) {
    case 4: case 3:
    rle_dflt_hdr.ncolors = 3;
    break;
    case 2: case 1:
    rle_dflt_hdr.ncolors = 1;
    break;
    }
    if ( aflag || input_alpha )
    RLE_SET_BIT( rle_dflt_hdr, RLE_ALPHA );
    else
    RLE_CLR_BIT( rle_dflt_hdr, RLE_ALPHA );
    rle_addhist( argv, (rle_hdr *)NULL, &rle_dflt_hdr );
    
    /* maybe faster to malloc and fread than to do lots of GETCs, Idunno */
    if (fflag) 
    header_bytes = (char *) malloc ( header );
    if (tflag) 
    trailer_bytes = (char *) malloc ( trailer );

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

    /* insert alpha channel */
    if ( aflag && !input_alpha )
    for (i = 0; i < width; i++)
        outrows[RLE_ALPHA][i] = alpha_value;
    
    /* 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 + input_alpha;
        green_pos = 1 + input_alpha;
        blue_pos = 0 + input_alpha;
    } else
        red_pos = 0 + input_alpha;
    }
    else {
    alpha_pos = nochan - input_alpha;
    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;
    }
    if ( sflag ) {
    red_pos *= width;
    green_pos *= width;
    blue_pos *= width;
    alpha_pos *= width;
    }
    while ( !feof( infile ))
    {
    int y = height;
    int ni_y = 0;   /* only used in -N cases */
    int first_line = 1;
    int fread_len = inrows_size;
    unsigned char *fread_pos = inrows;

    /* skip the header */
    if (fflag)
        fread( header_bytes, 1, header, infile );
    
    while (--y >= 0) {
        register rle_pixel *p, *o;
        register int stride = nochan, count;

        /* LEFT_PAD */
        for (count = 0; count < left_pad; count++)
        getc(infile);

        /* READ_SCANLINE */
        if (fread( fread_pos, 1, fread_len, infile ) != fread_len) {
        if (!first_line)
            perror( "read error" );
        exit (!first_line);
        }
        
        /* RIGHT_PAD */
        for (count = 0; count < right_pad; count++)
        getc(infile);
        
        /* 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 ( first_line ) {
            fread_len = width;
            fread_pos = inrows + (img_size * (nochan - 1));
        }
        
        if ( input_alpha ) 
            outrows[RLE_ALPHA] = (rflag ? inrows + ni_y : fread_pos);

        if ( rflag )
            outrows[RLE_RED] = fread_pos;
        else
            outrows[RLE_RED] = inrows + red_pos + ni_y;

        if (nochan > 2) {
            outrows[RLE_GREEN] = inrows + green_pos + ni_y;
            if ( rflag || input_alpha )
            outrows[RLE_BLUE] = inrows + blue_pos + ni_y;
            else
            outrows[RLE_BLUE] = fread_pos;
        }
        ni_y += width;
        } else if ( sflag ) {
        /* scanline interleaved! Like the rle_putrow format.. cake  */
        /* we only need to jack the pointers on the first scanline */
        if (first_line) {
            if ( input_alpha )
            outrows[RLE_ALPHA] = inrows + alpha_pos;
            
            outrows[RLE_RED] = inrows + red_pos;
            
            if (nochan > 2) {
            outrows[RLE_GREEN] = inrows + green_pos;
            outrows[RLE_BLUE] = inrows +  blue_pos;
            }
        }
        }
        else {
        /* ahhh...  the default.  interleaved data */
        if ( input_alpha ) {
            o = outrows[RLE_ALPHA];
            p = inrows + alpha_pos;
            count = width;
            duff(count, *o++ = *p; p += stride);
        }       
        
        o = outrows[RLE_RED];
        p = inrows + red_pos;
        count = width;
        duff( count, *o++ = *p; p += stride);
        
        if (nochan > 2) {
            o = outrows[RLE_GREEN];
            p = inrows + green_pos;
            count = width;
            duff( count, *o++ = *p; p += stride);
            
            o = outrows[RLE_BLUE];
            p = inrows + blue_pos;
            count = width;
            duff( count, *o++ = *p; p += stride);
        }
        }
        /* start the file */
        if (first_line) {
        rle_put_setup( &rle_dflt_hdr );
        first_line = 0;
        }
        rle_putrow( outrows, width, &rle_dflt_hdr );
    }
    rle_puteof( &rle_dflt_hdr );
    
    /* skip the trailer */
    if (tflag)
        fread( trailer_bytes, 1, trailer, infile );
    }
    exit(0);
}