/*
 * This software is copyrighted as noted below.  It may be freely copied,
 * modified, and redistributed, provided that the copyright notice is 
 * preserved on all copies.
 * 
 * There is no warranty or other guarantee of fitness for this software,
 * it is provided solely "as is".  Bug reports or fixes may be sent
 * to the author, who may or may not act on them as he desires.
 *
 * You may not include this software in a program or other software product
 * without supplying the source, or without informing the end-user that the 
 * source is available for no extra charge.
 *
 * If you modify this software, you should include a notice giving the
 * name of the person performing the modification, the date of modification,
 * and the reason for such modification.
 */
/* 
 * crop.c - Crop an image to the given size.
 * 
 * Author:	Rod Bogart & John W. Peterson
 * 		Computer Science Dept. 
 * 		University of Utah
 * Date:	Mon Jun 23 1986
 * Copyright (c) 1986, University of Utah
 * 
 */
#ifndef lint
static char rcs_ident[] = "$Header: /l/spencer/src/urt/tools/RCS/crop.c,v 3.0.1.2 1992/04/30 14:09:40 spencer Exp $";
#endif

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

extern void rle_box();
int pos_box_vals();

void
main(argc, argv)
int	argc;
char	*argv[];
{
    rle_pixel **scanline, **rows, **outrows;
    int xlen, i, j;
    int xmin = -1, ymin = -1, xmax = -1, ymax = -1;
    char *infilename = NULL, *out_fname = NULL;
    FILE *outfile = stdout;
    int oflag = 0, bflag = 0, bottom_row;
    rle_hdr 	in_hdr, out_hdr;
    int rle_cnt, rle_err;
    long start;

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

    if (scanargs( argc, argv,
		  "% b%- xmin%d ymin%d xmax%d ymax%d o%-outfile!s infile%s",
		  &bflag, &xmin, &ymin, &xmax, &ymax, &oflag,  &out_fname,
		  &infilename ) == 0)
    {
	exit(-1);
    }

    in_hdr.rle_file = rle_open_f( cmd_name( argv ), infilename, "r" );
    rle_names( &in_hdr, cmd_name( argv ), infilename, 0 );
    rle_names( &out_hdr, in_hdr.cmd, out_fname, 0 );
    for ( rle_cnt = 0; ; rle_cnt++ )
    {
	start = ftell( in_hdr.rle_file );
	if ( (rle_err = rle_get_setup( &in_hdr )) != RLE_SUCCESS )
	    break;

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

	if ( rle_cnt == 0 )
	    outfile = rle_open_f( cmd_name( argv ), out_fname, "w" );
	out_hdr.rle_file = outfile;

	/* If bflag, then pre-scan file to get bounding box. */
	if (bflag != 0)
	{
	    if (xmin == -1 && start >= 0)
	    {
		/* Common code with rlebox program. */
		rle_box( &in_hdr, &xmin, &xmax, &ymin, &ymax );

		/* Rewind and start over. */
		fseek( in_hdr.rle_file, start, 0 );
		rle_get_setup( &in_hdr );	/* Should work fine this time. */
	    }
	    else
	    {
		/* error message and exit: -b flag and box values or piped input */
		if (xmin != -1) 
		    fprintf( stderr,
			     "%s: You cannot specify the -b flag and box values together\n",
			     cmd_name( argv ) );
		else
		    fprintf( stderr,
			     "%s: No piped input allowed with the -b flag\n",
			     cmd_name( argv ) );
		exit(-1);
	    }
	}
	else if ( pos_box_vals( xmin, ymin, xmax, ymax ) != 0 )
	{
	    fprintf( stderr,
		     "%s: You must specify either all the box coordinates or the -b flag\n",
		     cmd_name( argv ) );
	    exit(-1);
	}
 
	xlen = xmax - xmin + 1;

	if ( (xmin > xmax) || (ymin > ymax) )
	{
	    fprintf( stderr, "%s: Illegal size: %d, %d to %d, %d\n",
		     cmd_name( argv ), xmin, ymin, xmax, ymax );
	    exit(-1);
	}

	/* should check for disjoint regions */

	out_hdr.xmin = xmin;
	out_hdr.ymin = ymin;
	out_hdr.xmax = xmax;
	out_hdr.ymax = ymax;

	rle_put_setup( &out_hdr );

	if (out_hdr.xmax > in_hdr.xmax)
	    RLE_CHECK_ALLOC( cmd_name( argv ),
			     rle_row_alloc( &out_hdr, &scanline ) == 0,
			     "image data" );
	else
	    RLE_CHECK_ALLOC( cmd_name( argv ),
			     rle_row_alloc( &in_hdr, &scanline ) == 0,
			     "image data" );

	rows = (rle_pixel **)
	    malloc((in_hdr.ncolors + in_hdr.alpha) * sizeof( rle_pixel * ));
	RLE_CHECK_ALLOC( cmd_name( argv ), rows, "input image data" );

	outrows = (rle_pixel **)
	    malloc((in_hdr.ncolors + in_hdr.alpha) * sizeof( rle_pixel * ));
	RLE_CHECK_ALLOC( cmd_name( argv ), outrows, "output image data" );

	if ( in_hdr.alpha )
	{
	    rows++;		/* So alpha is rows[-1] */
	    outrows++;
	}
 
	for( i = -in_hdr.alpha; i < in_hdr.ncolors; i++ )
	    rows[i] = scanline[i];

	for( i = -in_hdr.alpha; i < in_hdr.ncolors; i++ )
	    outrows[i] = &scanline[i][xmin];
    
	/* Fill scanline with background color in case output is
	 * larger than input.
	 */
	for ( j = -in_hdr.alpha; j < in_hdr.ncolors; j++ )
	    if ( in_hdr.bg_color && j >= 0 && in_hdr.bg_color[j] != 0 )
	    {
		int c = in_hdr.bg_color[j];
		register rle_pixel *pix;
		for ( i = out_hdr.xmin, pix = &scanline[j][i];
		      i <= out_hdr.xmax;
		      i++, pix++ )
		    *pix = c;
	    }
	    else
		bzero( (char *)&scanline[j][out_hdr.xmin],
		       out_hdr.xmax - out_hdr.xmin + 1 );

	bottom_row = in_hdr.ymin;
	if (in_hdr.ymin > out_hdr.ymin)
	{
	    /* Output blank scanlines if crop region is larger than data */
	    rle_skiprow(&out_hdr, in_hdr.ymin - out_hdr.ymin);
	    bottom_row = in_hdr.ymin;
	}
	else
	    if (in_hdr.ymin < out_hdr.ymin)
	    {
		/* Read past extra lower scanlines */
		for (i = in_hdr.ymin; i < out_hdr.ymin; i++)
		    rle_getrow(&in_hdr, rows );
		bottom_row = out_hdr.ymin;
	    }

	/* Read in image */
	for (j = bottom_row; j <= out_hdr.ymax; j++)
	{
	    rle_getrow(&in_hdr, rows );

	    rle_putrow( outrows, xlen, &out_hdr );
	}
	rle_puteof( &out_hdr );

	/* Skip extra upper scanlines. */
	while ( rle_getskip( &in_hdr ) != 32768 )
	    ;

	/* Clean up for next time around. */
	rle_row_free( (out_hdr.xmax > in_hdr.xmax) ? &out_hdr : &in_hdr,
		      scanline );
	free( rows - in_hdr.alpha );
	free( outrows - in_hdr.alpha );

	if ( bflag )
	    xmin = xmax = ymin = ymax = -1;
    }

    /* Check for an error.  EOF or EMPTY is ok if at least one image
     * has been read.  Otherwise, print an error message.
     */
    if ( rle_cnt == 0 || (rle_err != RLE_EOF && rle_err != RLE_EMPTY) )
	rle_get_error( rle_err, cmd_name( argv ), infilename );


    exit( 0 );
}

/* Return 0 if all parameters >= 0, else -1. */
int
pos_box_vals(x1, y1, x2, y2)
int x1, y1, x2, y2;
{
  if ((x1 < 0) || (y1 < 0) || (x2 < 0) || (y2 < 0))
    return -1;
  else
    return 0;
}