rlespiff.c File Reference

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

Include dependency graph for rlespiff.c:

Go to the source code of this file.

Macros
#define	CLAMP(x)   ((x)<0 ? 0 : ((x)>255 ? 255 : (x)))

Functions
void	copy_raw ()
void	main (int argc, char **argv)
void	copy_raw (rle_hdr *the_hdr, int y, rle_op **scan, int *nraw, rle_op ***save_scan, int **save_nraw)

Macro Definition Documentation

#define CLAMP

(

x

)

((x)<0 ? 0 : ((x)>255 ? 255 : (x)))

Definition at line 20 of file rlespiff.c.

Function Documentation

void copy_raw

(

)

void copy_raw	(	rle_hdr *	the_hdr,
		int	y,
		rle_op **	scan,
		int *	nraw,
		rle_op ***	save_scan,
		int **	save_nraw
	)

Definition at line 295 of file rlespiff.c.

{
    int     totlen = 0;
    register int c;

    /* Allocate space to save counts */
    save_nraw[y] = (int *)malloc( (the_hdr->ncolors + the_hdr->alpha) *
                  sizeof(int) );
    if ( save_nraw[y] == NULL )
    goto malloc_err;
    if ( the_hdr->alpha )
    save_nraw[y]++;
    /* Count total number of raw data to save, and save counts. */
    for ( c = -the_hdr->alpha; c < the_hdr->ncolors; c++ )
    totlen += save_nraw[y][c] = nraw[c];

    /* Allocate space to save raw data */
    save_scan[y] = (rle_op **)malloc( (the_hdr->ncolors + the_hdr->alpha) *
                      sizeof(rle_op *) );
    if ( save_scan[y] == NULL )
    goto malloc_err;
/*   BUG fixed by Michel GAUDET
 *   In  case of totlen = 0 (happens if all runs in a given line)
 *   the return value of malloc is NULL
 *   and it is not an error of malloc
 *   Correction : add one unit to the size
 */
    save_scan[y][0] = (rle_op *)malloc( 1 + totlen * sizeof(rle_op) );
    if ( save_scan[y][0] == NULL )
    goto malloc_err;
    if ( the_hdr->alpha )
    save_scan[y]++;

    /* Save raw data */
    for ( c = -the_hdr->alpha; c < the_hdr->ncolors; c++ )
    {
    if ( c > -the_hdr->alpha )
        save_scan[y][c] = save_scan[y][c-1] + nraw[c-1];
    bcopy( scan[c], save_scan[y][c], nraw[c] * sizeof(rle_op) );
    }
    return;

malloc_err:
    RLE_CHECK_ALLOC( the_hdr->cmd, 0, 0 );
}

void main	(	int	argc,
		char **	argv
	)

Definition at line 60 of file rlespiff.c.

{
    int     rle_cnt = 0;
    int     tflag = 0,
            threshold = 10;
    int     bflag = 0,
            blacklevel = 0;
    int     wflag = 0,
            whitelevel = 255;
    int     sflag = 0;
    int     nhist;
    int     verbose = 0;
    int     oflag = 0;
    char       *outfname = NULL,
           *infname = NULL;
    FILE       *outfile = stdout;
    int     rle_err;
    rle_hdr     in_hdr,
                out_hdr;
    rle_op    **scan, ***save_scan;
    register rle_op *scanp;
    int        *nraw, **save_nraw;
    int     y, ynext;
    int     c, hc, i, x;
    register int t;     /* Temp value. */
    long int    (*histo)[256];
    int     thresh;     /* Mapped threshold. */
    int     maxval, minval;
    int     *slide;
    float   *stretch;

    in_hdr = *rle_hdr_init( NULL );
    out_hdr = *rle_hdr_init( NULL );

    if ( scanargs( argc, argv,
  "% t%-threshold!d b%-blacklevel!d w%-whitelevel!d s%- v%- \
\to%-outfile!s infile%s",
           &tflag, &threshold, &bflag, &blacklevel,
           &wflag, &whitelevel,
           &sflag, &verbose, &oflag, &outfname, &infname ) == 0 )
    exit( 1 );
    
    /* Open the files */
    in_hdr.rle_file = rle_open_f( cmd_name( argv ), infname, "r" );
    rle_names( &in_hdr, cmd_name( argv ), infname, 0 );
    rle_names( &out_hdr, in_hdr.cmd, outfname, 0 );
    
    /* Loop over all images in input file */
    for ( rle_cnt = 0;
      (rle_err = rle_get_setup( &in_hdr )) == RLE_SUCCESS;
      rle_cnt++ )
    {
    if ( rle_cnt == 0 )
        outfile = rle_open_f( cmd_name( argv ), outfname, "w" );

    if ( rle_raw_alloc( &in_hdr, &scan, &nraw ) < 0 )
        RLE_CHECK_ALLOC( in_hdr.cmd, 0, "image data" );

    save_scan = (rle_op ***)calloc( in_hdr.ymax + 1,
                    sizeof( rle_op ** ) );
    save_nraw = (int **)calloc( in_hdr.ymax + 1,
                    sizeof( int * )  );
    RLE_CHECK_ALLOC( in_hdr.cmd, save_scan && save_nraw, "image data" );

    nhist = sflag ? in_hdr.ncolors : 1;
    histo = (long int (*)[256]) calloc( 256 * nhist, sizeof(long int) );
    stretch = (float *)calloc( nhist, sizeof(float) );
    slide = (int *)calloc( nhist, sizeof(int) );
    RLE_CHECK_ALLOC( in_hdr.cmd, histo && stretch && slide, 0 );

    /* Read the input and find min & max */
    while ( (y = rle_getraw( &in_hdr, scan, nraw )) != 32768 )
    {
        /* Histogram values. */
        for ( c = 0; c < in_hdr.ncolors; c++ )
        {
        if ( sflag )
            hc = c;
        else
            hc = 0;

        for ( i = 0, scanp = scan[c]; i < nraw[c]; i++, scanp++ )
            switch ( scanp->opcode )
            {
            case RByteDataOp:
            for ( x = 0; x < scanp->length; x++ )
                histo[hc][scanp->u.pixels[x]]++;
            break;
            case RRunDataOp:
            histo[hc][scanp->u.run_val] += scanp->length;
            break;
            }
        }

        /* Save scanline data for second pass. */
        copy_raw( &in_hdr, y, scan, nraw, save_scan, save_nraw );
    }

        
    /* Determine min & max */
    thresh = (((double)threshold * (in_hdr.xmax - in_hdr.xmin + 1) *
          (in_hdr.ymax - in_hdr.ymin + 1) +
          500000)) / 1000000;

    if ( !sflag )
        thresh *= in_hdr.ncolors;

    for ( hc = 0; hc < nhist; hc++ )
    {
        for ( i = 0; i < 256 && histo[hc][i] <= thresh; i++ )
        ;
        minval = i;
        for ( i = 255; i >= 0 && histo[hc][i] <= thresh; i-- )
        ;
        maxval = i;

        /* Mapping parameters */
        if ( maxval > minval )
        stretch[hc] = (float)(whitelevel - blacklevel) /
            (maxval - minval);
        else
        stretch[hc] = 1.0;
        slide[hc] = blacklevel - stretch[hc] * minval;

        if ( verbose )
        {
        fprintf( stderr, "%s image %d", 
             in_hdr.rle_file == stdin ? "Standard input" : infname,
             rle_cnt );
        if ( sflag )
            fprintf( stderr, ", channel %d", hc );
        fprintf( stderr, " min = %d, max = %d\n", minval, maxval );
        }
    }

    /* Pass 2 -- map pixels and write output file */
    (void)rle_hdr_cp( &in_hdr, &out_hdr );
    out_hdr.rle_file = outfile;
    rle_addhist( argv, &in_hdr, &out_hdr );
    rle_put_setup( &out_hdr );
    for ( y = in_hdr.ymin, ynext = -1;
          y <= in_hdr.ymax;
          y++ )
    {
        if ( save_scan[y] )
        {
        /* Map pixel values */
        for ( c = 0; c < in_hdr.ncolors; c++ )
        {
            float h_stretch;
            int h_slide;

            if ( sflag )
            {
            h_stretch = stretch[c];
            h_slide = slide[c];
            }
            else
            {
            h_stretch = stretch[0];
            h_slide = slide[0];
            }

            for ( i = 0, scanp = save_scan[y][c];
              i < save_nraw[y][c];
              i++, scanp++ )
            switch ( scanp->opcode )
            {
            case RByteDataOp:
                for ( x = 0; x < scanp->length; x++ )
                {
                t = scanp->u.pixels[x] * h_stretch + h_slide;
                scanp->u.pixels[x] = CLAMP( t );
                }
                break;
            case RRunDataOp:
                t = scanp->u.run_val * h_stretch + h_slide;
                scanp->u.run_val = CLAMP( t );
                break;
            }
        }

        if ( ynext == -1 )
        {
            ynext = in_hdr.ymin;
            if ( y - ynext > 0 )
            rle_skiprow( &out_hdr, y - ynext );
        }
        else
            if ( y - ynext > 1 )
            rle_skiprow( &out_hdr, y - ynext );
        rle_putraw( save_scan[y], save_nraw[y], &out_hdr );
        rle_freeraw( &in_hdr, save_scan[y], save_nraw[y] );
        rle_raw_free( &in_hdr, save_scan[y], save_nraw[y] );
        ynext = y;  /* Most recent "real" scanline. */
        }
    }
    rle_puteof( &out_hdr );
    rle_raw_free( &in_hdr, scan, nraw );
    free( stretch );
    free( slide );
    free( histo );
    }

    if ( rle_cnt == 0 || (rle_err != RLE_EOF && rle_err != RLE_EMPTY) )
    rle_get_error( rle_err, argv[0], infname );

    exit( 0 );
}