Merged in the scale branch:

[imager.git] / scale.c

#include "imager.h"

/*
 * i_scale_mixing() is based on code contained in pnmscale.c, part of
 * the netpbm distribution.  No code was copied from pnmscale but
 * the algorthm was and for this I thank the netpbm crew.
 *
 * Tony
 */

/* pnmscale.c - read a portable anymap and scale it
**
** Copyright (C) 1989, 1991 by Jef Poskanzer.
**
** Permission to use, copy, modify, and distribute this software and its
** documentation for any purpose and without fee is hereby granted, provided
** that the above copyright notice appear in all copies and that both that
** copyright notice and this permission notice appear in supporting
** documentation.  This software is provided "as is" without express or
** implied warranty.
**
*/


static void
zero_row(i_fcolor *row, int width, int channels);
static void
accum_output_row(i_fcolor *accum, double fraction, i_fcolor const *in,
		 int width, int channels);
static void
horizontal_scale(i_fcolor *out, int out_width, 
		 i_fcolor const *in, int in_width,
		 int channels);

/*
=item i_scale_mixing

Returns a new image scaled to the given size.

Unlike i_scale_axis() this does a simple coverage of pixels from
source to target and doesn't resample.

Adapted from pnmscale.

=cut
*/
i_img *
i_scale_mixing(i_img *src, int x_out, int y_out) {
  i_img *result;
  i_fcolor *in_row = NULL;
  i_fcolor *xscale_row = NULL;
  i_fcolor *accum_row = NULL;
  int y;
  int in_row_bytes, out_row_bytes;
  double rowsleft, fracrowtofill;
  int rowsread;
  double y_scale;

  mm_log((1, "i_scale_mixing(src %p, x_out %d, y_out %d)\n", 
	  src, x_out, y_out));

  i_clear_error();

  if (x_out <= 0) {
    i_push_errorf(0, "output width %d invalid", x_out);
    return NULL;
  }
  if (y_out <= 0) {
    i_push_errorf(0, "output height %d invalid", y_out);
    return NULL;
  }

  in_row_bytes = sizeof(i_fcolor) * src->xsize;
  if (in_row_bytes / sizeof(i_fcolor) != src->xsize) {
    i_push_error(0, "integer overflow allocating input row buffer");
    return NULL;
  }
  out_row_bytes = sizeof(i_fcolor) * x_out;
  if (out_row_bytes / sizeof(i_fcolor) != x_out) {
    i_push_error(0, "integer overflow allocating output row buffer");
    return NULL;
  }

  if (x_out == src->xsize && y_out == src->ysize) {
    return i_copy(src);
  }

  y_scale = y_out / (double)src->ysize;

  result = i_sametype_chans(src, x_out, y_out, src->channels);
  if (!result)
    return NULL;

  in_row     = mymalloc(in_row_bytes);
  accum_row  = mymalloc(in_row_bytes);
  xscale_row = mymalloc(out_row_bytes);

  rowsread = 0;
  rowsleft = 0.0;
  for (y = 0; y < y_out; ++y) {
    if (y_out == src->ysize) {
      i_glinf(src, 0, src->xsize, y, accum_row);
    }
    else {
      fracrowtofill = 1.0;
      zero_row(accum_row, src->xsize, src->channels);
      while (fracrowtofill > 0) {
	if (rowsleft <= 0) {
	  if (rowsread < src->ysize) {
	    i_glinf(src, 0, src->xsize, rowsread, in_row);
	    ++rowsread;
	  }
	  /* else just use the last row read */

	  rowsleft = y_scale;
	}
	if (rowsleft < fracrowtofill) {
	  accum_output_row(accum_row, rowsleft, in_row, src->xsize, 
			   src->channels);
	  fracrowtofill -= rowsleft;
	  rowsleft = 0;
	}
	else {
	  accum_output_row(accum_row, fracrowtofill, in_row, src->xsize, 
			   src->channels);
	  rowsleft -= fracrowtofill;
	  fracrowtofill = 0;
	}
      }
      /* we've accumulated a vertically scaled row */
      if (x_out == src->xsize) {
	/* no need to scale */
	i_plinf(result, 0, x_out, y, accum_row);
      }
      else {
	horizontal_scale(xscale_row, x_out, accum_row, src->xsize, 
			 src->channels);
	i_plinf(result, 0, x_out, y, xscale_row);
      }
    }
  }

  myfree(in_row);
  myfree(accum_row);
  myfree(xscale_row);

  return result;
}

static void
zero_row(i_fcolor *row, int width, int channels) {
  int x;
  int ch;

  /* with IEEE floats we could just use memset() but that's not
     safe in general under ANSI C */
  for (x = 0; x < width; ++x) {
    for (ch = 0; ch < channels; ++ch)
      row[x].channel[ch] = 0.0;
  }
}

static void
accum_output_row(i_fcolor *accum, double fraction, i_fcolor const *in,
		 int width, int channels) {
  int x, ch;

  for (x = 0; x < width; ++x) {
    for (ch = 0; ch < channels; ++ch) {
      accum[x].channel[ch] += in[x].channel[ch] * fraction;
    }
  }
}

static void
horizontal_scale(i_fcolor *out, int out_width, 
		 i_fcolor const *in, int in_width,
		 int channels) {
  double frac_col_to_fill, frac_col_left;
  int in_x;
  int out_x;
  double x_scale = (double)out_width / in_width;
  int ch;
  double accum[MAXCHANNELS] = { 0 };
  
  frac_col_to_fill = 1.0;
  out_x = 0;
  for (in_x = 0; in_x < in_width; ++in_x) {
    frac_col_left = x_scale;
    while (frac_col_left >= frac_col_to_fill) {
      for (ch = 0; ch < channels; ++ch)
	accum[ch] += frac_col_to_fill * in[in_x].channel[ch];

      for (ch = 0; ch < channels; ++ch) {
	out[out_x].channel[ch] = accum[ch];
	accum[ch] = 0;
      }
      frac_col_left -= frac_col_to_fill;
      frac_col_to_fill = 1.0;
      ++out_x;
    }

    if (frac_col_left > 0) {
      for (ch = 0; ch < channels; ++ch) {
	accum[ch] += frac_col_left * in[in_x].channel[ch];
      }
      frac_col_to_fill -= frac_col_left;
    }
  }

  if (out_x < out_width-1 || out_x > out_width) {
    i_fatal(3, "Internal error: out_x %d out of range (width %d)", out_x, out_width);
  }
  
  if (out_x < out_width) {
    for (ch = 0; ch < channels; ++ch) {
      accum[ch] += frac_col_to_fill * in[in_width-1].channel[ch];
      out[out_x].channel[ch] = accum[ch];
    }
  }
}