[imager.git] / SGI / imsgi.c

#include "imsgi.h"

#include <stdlib.h>
#include <errno.h>
#include <string.h>

/* value for imagic */
#define SGI_MAGIC 474

/* values for the storage field */
#define SGI_STORAGE_VERBATIM 0
#define SGI_STORAGE_RLE 1

/* values for the colormap field */
#define SGI_COLORMAP_NORMAL 0
#define SGI_COLORMAP_DITHERED 1
#define SGI_COLORMAP_SCREEN 2
#define SGI_COLORMAP_COLORMAP 3

/* we add that little bit to avoid rounding issues */
#define SampleFTo16(num) ((int)((num) * 65535.0 + 0.01))

/* maximum size of an SGI image */
#define SGI_DIM_LIMIT 0xFFFF

typedef struct {
  unsigned short imagic;
  unsigned char storagetype;
  unsigned char BPC;
  unsigned short dimensions;
  unsigned short xsize, ysize, zsize;
  unsigned int pixmin, pixmax;
  char name[80];
  unsigned int colormap;
} rgb_header;

static i_img *
read_rgb_8_verbatim(i_img *im, io_glue *ig, rgb_header const *hdr);
static i_img *
read_rgb_8_rle(i_img *im, io_glue *ig, rgb_header const *hdr);
static i_img *
read_rgb_16_verbatim(i_img *im, io_glue *ig, rgb_header const *hdr);
static i_img *
read_rgb_16_rle(i_img *im, io_glue *ig, rgb_header const *hdr);
static int
write_sgi_header(i_img *img, io_glue *ig, int *rle, int *bpc2);
static int
write_sgi_8_rle(i_img *img, io_glue *ig);
static int
write_sgi_8_verb(i_img *img, io_glue *ig);
static int
write_sgi_16_rle(i_img *img, io_glue *ig);
static int
write_sgi_16_verb(i_img *img, io_glue *ig);

#define Sample16ToF(num) ((num) / 65535.0)

#define _STRING(x) #x
#define STRING(x) _STRING(x)

/*
=head1 NAME

rgb.c - implements reading and writing sgi image files, uses io layer.

=head1 SYNOPSIS

   io_glue *ig = io_new_fd( fd );
   i_img *im   = i_readrgb_wiol(ig, 0); // disallow partial reads
   // or 
   io_glue *ig = io_new_fd( fd );
   return_code = i_writergb_wiol(im, ig); 

=head1 DESCRIPTION

imsgi.c implements the basic functions to read and write portable SGI
files.  It uses the iolayer and needs either a seekable source or an
entire memory mapped buffer.

=head1 FUNCTION REFERENCE

Some of these functions are internal.

=over

=cut
*/

/*
=item rgb_header_unpack(header, headbuf)

Unpacks the header structure into from buffer and stores
in the header structure.

    header - header structure
    headbuf - buffer to unpack from

=cut
*/


static
void
rgb_header_unpack(rgb_header *header, const unsigned char *headbuf) {
  header->imagic      = (headbuf[0]<<8) + headbuf[1];
  header->storagetype = headbuf[2];
  header->BPC         = headbuf[3];
  header->dimensions  = (headbuf[4]<<8) + headbuf[5];
  header->xsize       = (headbuf[6]<<8) + headbuf[7];
  header->ysize       = (headbuf[8]<<8) + headbuf[9];
  header->zsize       = (headbuf[10]<<8) + headbuf[11];
  header->pixmin      = (headbuf[12]<<24) + (headbuf[13]<<16)+(headbuf[14]<<8)+headbuf[15];
  header->pixmax      = (headbuf[16]<<24) + (headbuf[17]<<16)+(headbuf[18]<<8)+headbuf[19];
  memcpy(header->name,headbuf+24,80);
  header->name[79] = '\0';
  header->colormap    = (headbuf[104]<<24) + (headbuf[105]<<16)+(headbuf[106]<<8)+headbuf[107];
}

/* don't make this a macro */
static void
store_16(unsigned char *buf, unsigned short value) {
  buf[0] = value >> 8;
  buf[1] = value & 0xFF;
}

static void
store_32(unsigned char *buf, unsigned long value) {
  buf[0] = value >> 24;
  buf[1] = (value >> 16) & 0xFF;
  buf[2] = (value >> 8) & 0xFF;
  buf[3] = value & 0xFF;
}

/*
=item rgb_header_pack(header, headbuf)

Packs header structure into buffer for writing.

    header - header structure
    headbuf - buffer to pack into

=cut
*/

static
void
rgb_header_pack(const rgb_header *header, unsigned char headbuf[512]) {
  memset(headbuf, 0, 512);
  store_16(headbuf, header->imagic);
  headbuf[2] = header->storagetype;
  headbuf[3] = header->BPC;
  store_16(headbuf+4, header->dimensions);
  store_16(headbuf+6, header->xsize);
  store_16(headbuf+8, header->ysize);
  store_16(headbuf+10, header->zsize);
  store_32(headbuf+12, header->pixmin);
  store_32(headbuf+16, header->pixmax);
  memccpy(headbuf+24, header->name, '\0', 80);
  store_32(headbuf+104, header->colormap);
}

/*
=item i_readsgi_wiol(ig, partial)

Read in an image from the iolayer data source and return the image structure to it.
Returns NULL on error.

   ig     - io_glue object
   length - maximum length to read from data source, before closing it -1 
            signifies no limit.

=cut
*/

i_img *
i_readsgi_wiol(io_glue *ig, int partial) {
  i_img *img = NULL;
  int width, height, channels;
  rgb_header header;
  unsigned char headbuf[512];

  mm_log((1,"i_readsgi(ig %p, partial %d)\n", ig, partial));
  i_clear_error();

  if (i_io_read(ig, headbuf, 512) != 512) {
    i_push_error(errno, "SGI image: could not read header");
    return NULL;
  }

  rgb_header_unpack(&header, headbuf);

  if (header.imagic != SGI_MAGIC) {
    i_push_error(0, "SGI image: invalid magic number");
    return NULL;
  }

  mm_log((1,"imagic:         %d\n", header.imagic));
  mm_log((1,"storagetype:    %d\n", header.storagetype));
  mm_log((1,"BPC:            %d\n", header.BPC));
  mm_log((1,"dimensions:     %d\n", header.dimensions));
  mm_log((1,"xsize:          %d\n", header.xsize));
  mm_log((1,"ysize:          %d\n", header.ysize));
  mm_log((1,"zsize:          %d\n", header.zsize));
  mm_log((1,"min:            %d\n", header.pixmin));
  mm_log((1,"max:            %d\n", header.pixmax));
  mm_log((1,"name [skipped]\n"));
  mm_log((1,"colormap:       %d\n", header.colormap));

  if (header.colormap != SGI_COLORMAP_NORMAL) {
    i_push_errorf(0, "SGI image: invalid value for colormap (%d)", header.colormap);
    return NULL;
  }

  if (header.BPC != 1 && header.BPC != 2) {
    i_push_errorf(0, "SGI image: invalid value for BPC (%d)", header.BPC);
    return NULL;
  }

  if (header.storagetype != SGI_STORAGE_VERBATIM 
      && header.storagetype != SGI_STORAGE_RLE) {
    i_push_error(0, "SGI image: invalid storage type field");
    return NULL;
  }

  if (header.pixmin >= header.pixmax) {
    i_push_error(0, "SGI image: invalid pixmin >= pixmax");
    return NULL;
  }

  width    = header.xsize;
  height   = header.ysize;
  channels = header.zsize;

  switch (header.dimensions) {
  case 1:
    channels = 1;
    height = 1;
    break;

  case 2:
    channels = 1;
    break;

  case 3:
    /* fall through and use all of the dimensions */
    break;

  default:
    i_push_error(0, "SGI image: invalid dimension field");
    return NULL;
  }

  if (!i_int_check_image_file_limits(width, height, channels, header.BPC)) {
    mm_log((1, "i_readsgi_wiol: image size exceeds limits\n"));
    return NULL;
  }

  if (header.BPC == 1) {
    img = i_img_8_new(width, height, channels);
    if (!img)
      goto ErrorReturn;

    switch (header.storagetype) {
    case SGI_STORAGE_VERBATIM:
      img = read_rgb_8_verbatim(img, ig, &header);
      break;

    case SGI_STORAGE_RLE:
      img = read_rgb_8_rle(img, ig, &header);
      break;

    default:
      goto ErrorReturn;
    }
  }
  else {
    img = i_img_16_new(width, height, channels);
    if (!img)
      goto ErrorReturn;

    switch (header.storagetype) {
    case SGI_STORAGE_VERBATIM:
      img = read_rgb_16_verbatim(img, ig, &header);
      break;

    case SGI_STORAGE_RLE:
      img = read_rgb_16_rle(img, ig, &header);
      break;

    default:
      goto ErrorReturn;
    }
  }

  if (!img)
    goto ErrorReturn;

  if (*header.name)
    i_tags_set(&img->tags, "i_comment", header.name, -1);
  i_tags_setn(&img->tags, "sgi_pixmin", header.pixmin);
  i_tags_setn(&img->tags, "sgi_pixmax", header.pixmax);
  i_tags_setn(&img->tags, "sgi_bpc", header.BPC);
  i_tags_setn(&img->tags, "sgi_rle", header.storagetype == SGI_STORAGE_RLE);
  i_tags_set(&img->tags, "i_format", "sgi", -1);

  return img;

 ErrorReturn:
  if (img) i_img_destroy(img);
  return NULL;
}

/*
=item i_writergb_wiol(img, ig)

Writes an image in targa format.  Returns 0 on error.

   img    - image to store
   ig     - io_glue object

=cut
*/

int
i_writesgi_wiol(io_glue *ig, i_img *img) {
  int rle;
  int bpc2;

  i_clear_error();

  if (img->xsize > SGI_DIM_LIMIT || img->ysize > SGI_DIM_LIMIT) {
    i_push_error(0, "image too large for SGI");
    return 0;
  }

  if (!write_sgi_header(img, ig, &rle, &bpc2))
    return 0;

  mm_log((1, "format rle %d bpc2 %d\n", rle, bpc2));

  if (bpc2) {
    if (rle)
      return write_sgi_16_rle(img, ig);
    else
      return write_sgi_16_verb(img, ig);
  }
  else {
    if (rle)
      return write_sgi_8_rle(img, ig);
    else
      return write_sgi_8_verb(img, ig);
  }
}

static i_img *
read_rgb_8_verbatim(i_img *img, io_glue *ig, rgb_header const *header) {
  i_color *linebuf;
  unsigned char *databuf;
  int c, y;
  int savemask;
  i_img_dim width = i_img_get_width(img);
  i_img_dim height = i_img_get_height(img);
  int channels = i_img_getchannels(img);
  int pixmin = header->pixmin;
  int pixmax = header->pixmax;
  int outmax = pixmax - pixmin;
  
  linebuf   = mymalloc(width * sizeof(i_color)); /* checked 31Jul07 TonyC */
  databuf   = mymalloc(width); /* checked 31Jul07 TonyC */

  savemask = i_img_getmask(img);

  for(c = 0; c < channels; c++) {
    i_img_setmask(img, 1<<c);
    for(y = 0; y < height; y++) {
      int x;
      
      if (i_io_read(ig, databuf, width) != width) {
	i_push_error(0, "SGI image: cannot read image data");
	i_img_destroy(img);
	myfree(linebuf);
	myfree(databuf);
	return NULL;
      }

      if (pixmin == 0 && pixmax == 255) {
	for(x = 0; x < img->xsize; x++)
	  linebuf[x].channel[c] = databuf[x];
      }
      else {
	for(x = 0; x < img->xsize; x++) {
	  int sample = databuf[x];
	  if (sample < pixmin)
	    sample = 0;
	  else if (sample > pixmax)
	    sample = outmax;
	  else
	    sample -= pixmin;
	    
	  linebuf[x].channel[c] = sample * 255 / outmax;
	}
      }
      
      i_plin(img, 0, width, height-1-y, linebuf);
    }
  }
  i_img_setmask(img, savemask);

  myfree(linebuf);
  myfree(databuf);
  
  return img;
}

static int
read_rle_tables(io_glue *ig, i_img *img,
		unsigned long **pstart_tab, unsigned long **plength_tab, 
		unsigned long *pmax_length) {
  i_img_dim height = i_img_get_height(img);
  int channels = i_img_getchannels(img);
  unsigned char *databuf;
  unsigned long *start_tab, *length_tab;
  unsigned long max_length = 0;
  int i;
  size_t databuf_size = (size_t)height * channels * 4;
  size_t tab_size = (size_t)height * channels * sizeof(unsigned long);

  /* assumption: that the lengths are in bytes rather than in pixels */
  if (databuf_size / height / channels != 4
      || tab_size / height / channels != sizeof(unsigned long)) {
    i_push_error(0, "SGI image: integer overflow calculating allocation size");
    return 0;
  }
  databuf    = mymalloc(height * channels * 4);  /* checked 31Jul07 TonyC */
  start_tab  = mymalloc(height*channels*sizeof(unsigned long));
  length_tab = mymalloc(height*channels*sizeof(unsigned long));
    
    /* Read offset table */
  if (i_io_read(ig, databuf, height * channels * 4) != height * channels * 4) {
    i_push_error(0, "SGI image: short read reading RLE start table");
    goto ErrorReturn;
  }

  for(i = 0; i < height * channels; i++) 
    start_tab[i] = ((unsigned long)databuf[i*4] << 24) | (databuf[i*4+1] << 16) |
      (databuf[i*4+2] << 8) | (databuf[i*4+3]);


  /* Read length table */
  if (i_io_read(ig, databuf, height*channels*4) != height*channels*4) {
    i_push_error(0, "SGI image: short read reading RLE length table");
    goto ErrorReturn;
  }

  for(i=0; i < height * channels; i++) {
    length_tab[i] = ((unsigned long)databuf[i*4] << 24) | (databuf[i*4+1] << 16) |
      (databuf[i*4+2] << 8) | (databuf[i*4+3]);
    if (length_tab[i] > max_length)
      max_length = length_tab[i];
  }

  mm_log((3, "Offset/length table:\n"));
  for(i=0; i < height * channels; i++)
    mm_log((3, "%d: %lu/%lu\n", i, start_tab[i], length_tab[i]));

  *pstart_tab = start_tab;
  *plength_tab = length_tab;
  *pmax_length = max_length;

  myfree(databuf);

  return 1;

 ErrorReturn:
  myfree(databuf);
  myfree(start_tab);
  myfree(length_tab);

  return 0;
}

static i_img *
read_rgb_8_rle(i_img *img, io_glue *ig, rgb_header const *header) {
  i_color *linebuf = NULL;
  unsigned char *databuf = NULL;
  unsigned long *start_tab, *length_tab;
  unsigned long max_length;
  i_img_dim width = i_img_get_width(img);
  i_img_dim height = i_img_get_height(img);
  int channels = i_img_getchannels(img);
  i_img_dim y;
  int c;
  int pixmin = header->pixmin;
  int pixmax = header->pixmax;
  int outmax = pixmax - pixmin;

  if (!read_rle_tables(ig, img,  
		       &start_tab, &length_tab, &max_length)) {
    i_img_destroy(img);
    return NULL;
  }

  mm_log((1, "maxlen for an rle buffer: %lu\n", max_length));

  if (max_length > (img->xsize + 1) * 2) {
    i_push_errorf(0, "SGI image: ridiculous RLE line length %lu", max_length);
    goto ErrorReturn;
  }

  linebuf = mymalloc(width*sizeof(i_color)); /* checked 31Jul07 TonyC */
  databuf = mymalloc(max_length); /* checked 31Jul07 TonyC */

  for(y = 0; y < img->ysize; y++) {
    for(c = 0; c < channels; c++) {
      int ci = height * c + y;
      int datalen = length_tab[ci];
      unsigned char *inp;
      i_color *outp;
      int data_left = datalen;
      int pixels_left = width;
      i_sample_t sample;
      
      if (i_io_seek(ig, start_tab[ci], SEEK_SET) != start_tab[ci]) {
	i_push_error(0, "SGI image: cannot seek to RLE data");
	goto ErrorReturn;
      }
      if (i_io_read(ig, databuf, datalen) != datalen) {
	i_push_error(0, "SGI image: cannot read RLE data");
	goto ErrorReturn;
      }
      
      inp = databuf;
      outp = linebuf;
      while (data_left) {
	int code = *inp++;
	int count = code & 0x7f;
	--data_left;

	if (count == 0)
	  break;
	if (code & 0x80) {
	  /* literal run */
	  /* sanity checks */
	  if (count > pixels_left) {
	    i_push_error(0, "SGI image: literal run overflows scanline");
	    goto ErrorReturn;
	  }
	  if (count > data_left) {
	    i_push_error(0, "SGI image: literal run consumes more data than available");
	    goto ErrorReturn;
	  }
	  /* copy the run */
	  pixels_left -= count;
	  data_left -= count;
	  if (pixmin == 0 && pixmax == 255) {
	    while (count-- > 0) {
	      outp->channel[c] = *inp++;
	      ++outp;
	    }
	  }
	  else {
	    while (count-- > 0) {
	      int sample = *inp++;
	      if (sample < pixmin)
		sample = 0;
	      else if (sample > pixmax)
		sample = outmax;
	      else
		sample -= pixmin;
	      outp->channel[c] = sample * 255 / outmax;
	      ++outp;
	    }
	  }
	}
	else {
	  /* RLE run */
	  if (count > pixels_left) {
	    i_push_error(0, "SGI image: RLE run overflows scanline");
	    mm_log((2, "RLE run overflows scanline (y %" i_DF " chan %d offset %lu len %lu)\n", i_DFc(y), c, start_tab[ci], length_tab[ci]));
	    goto ErrorReturn;
	  }
	  if (data_left < 1) {
	    i_push_error(0, "SGI image: RLE run has no data for pixel");
	    goto ErrorReturn;
	  }
	  sample = *inp++;
	  if (pixmin != 0 || pixmax != 255) {
	    if (sample < pixmin)
	      sample = 0;
	    else if (sample > pixmax)
	      sample = outmax;
	    else
	      sample -= pixmin;
	    sample = sample * 255 / outmax;
	  }
	  --data_left;
	  pixels_left -= count;
	  while (count-- > 0) {
	    outp->channel[c] = sample;
	    ++outp;
	  }
	}
      }
      /* must have a full scanline */
      if (pixels_left) {
	i_push_error(0, "SGI image: incomplete RLE scanline");
	goto ErrorReturn;
      }
      /* must have used all of the data */
      if (data_left) {
	i_push_errorf(0, "SGI image: unused RLE data");
	goto ErrorReturn;
      }
    }
    i_plin(img, 0, width, height-1-y, linebuf);
  }

  myfree(linebuf);
  myfree(databuf);
  myfree(start_tab);
  myfree(length_tab);

  return img;

 ErrorReturn:
  if (linebuf)
    myfree(linebuf);
  if (databuf)
    myfree(databuf);
  myfree(start_tab);
  myfree(length_tab);
  i_img_destroy(img);
  return NULL;
}

static i_img *
read_rgb_16_verbatim(i_img *img, io_glue *ig, rgb_header const *header) {
  i_fcolor *linebuf;
  unsigned char *databuf;
  int c, y;
  int savemask;
  i_img_dim width = i_img_get_width(img);
  i_img_dim height = i_img_get_height(img);
  int channels = i_img_getchannels(img);
  int pixmin = header->pixmin;
  int pixmax = header->pixmax;
  int outmax = pixmax - pixmin;
  
  linebuf   = mymalloc(width * sizeof(i_fcolor));  /* checked 31Jul07 TonyC */
  databuf   = mymalloc(width * 2);  /* checked 31Jul07 TonyC */

  savemask = i_img_getmask(img);

  for(c = 0; c < channels; c++) {
    i_img_setmask(img, 1<<c);
    for(y = 0; y < height; y++) {
      int x;
      
      if (i_io_read(ig, databuf, width*2) != width*2) {
	i_push_error(0, "SGI image: cannot read image data");
	i_img_destroy(img);
	myfree(linebuf);
	myfree(databuf);
	return NULL;
      }

      if (pixmin == 0 && pixmax == 65535) {
	for(x = 0; x < img->xsize; x++)
	  linebuf[x].channel[c] = (databuf[x*2] * 256 + databuf[x*2+1]) / 65535.0;
      }
      else {
	for(x = 0; x < img->xsize; x++) {
	  int sample = databuf[x*2] * 256 + databuf[x*2+1];
	  if (sample < pixmin)
	    sample = 0;
	  else if (sample > pixmax)
	    sample = outmax;
	  else
	    sample -= pixmin;
	    
	  linebuf[x].channel[c] = (double)sample / outmax;
	}
      }
      
      i_plinf(img, 0, width, height-1-y, linebuf);
    }
  }
  i_img_setmask(img, savemask);

  myfree(linebuf);
  myfree(databuf);
  
  return img;
}

static i_img *
read_rgb_16_rle(i_img *img, io_glue *ig, rgb_header const *header) {
  i_fcolor *linebuf = NULL;
  unsigned char *databuf = NULL;
  unsigned long *start_tab, *length_tab;
  unsigned long max_length;
  i_img_dim width = i_img_get_width(img);
  i_img_dim height = i_img_get_height(img);
  int channels = i_img_getchannels(img);
  i_img_dim y;
  int c;
  int pixmin = header->pixmin;
  int pixmax = header->pixmax;
  int outmax = pixmax - pixmin;

  if (!read_rle_tables(ig, img,  
		       &start_tab, &length_tab, &max_length)) {
    i_img_destroy(img);
    return NULL;
  }

  mm_log((1, "maxlen for an rle buffer: %lu\n", max_length));

  if (max_length > (img->xsize * 2 + 1) * 2) {
    i_push_errorf(0, "SGI image: ridiculous RLE line length %lu", max_length);
    goto ErrorReturn;
  }

  linebuf = mymalloc(width*sizeof(i_fcolor)); /* checked 31Jul07 TonyC */
  databuf = mymalloc(max_length); /* checked 31Jul07 TonyC */

  for(y = 0; y < img->ysize; y++) {
    for(c = 0; c < channels; c++) {
      int ci = height * c + y;
      int datalen = length_tab[ci];
      unsigned char *inp;
      i_fcolor *outp;
      int data_left = datalen;
      int pixels_left = width;
      int sample;
      
      if (datalen & 1) {
	i_push_error(0, "SGI image: invalid RLE length value for BPC=2");
	goto ErrorReturn;
      }
      if (i_io_seek(ig, start_tab[ci], SEEK_SET) != start_tab[ci]) {
	i_push_error(0, "SGI image: cannot seek to RLE data");
	goto ErrorReturn;
      }
      if (i_io_read(ig, databuf, datalen) != datalen) {
	i_push_error(0, "SGI image: cannot read RLE data");
	goto ErrorReturn;
      }
      
      inp = databuf;
      outp = linebuf;
      while (data_left > 0) {
	int code = inp[0] * 256 + inp[1];
	int count = code & 0x7f;
	inp += 2;
	data_left -= 2;

	if (count == 0)
	  break;
	if (code & 0x80) {
	  /* literal run */
	  /* sanity checks */
	  if (count > pixels_left) {
	    i_push_error(0, "SGI image: literal run overflows scanline");
	    goto ErrorReturn;
	  }
	  if (count > data_left) {
	    i_push_error(0, "SGI image: literal run consumes more data than available");
	    goto ErrorReturn;
	  }
	  /* copy the run */
	  pixels_left -= count;
	  data_left -= count * 2;
	  if (pixmin == 0 && pixmax == 65535) {
	    while (count-- > 0) {
	      outp->channel[c] = (inp[0] * 256 + inp[1]) / 65535.0;
	      inp += 2;
	      ++outp;
	    }
	  }
	  else {
	    while (count-- > 0) {
	      int sample = inp[0] * 256 + inp[1];
	      if (sample < pixmin)
		sample = 0;
	      else if (sample > pixmax)
		sample = outmax;
	      else
		sample -= pixmin;
	      outp->channel[c] = (double)sample / outmax;
	      ++outp;
	      inp += 2;
	    }
	  }
	}
	else {
	  double fsample;
	  /* RLE run */
	  if (count > pixels_left) {
	    i_push_error(0, "SGI image: RLE run overflows scanline");
	    goto ErrorReturn;
	  }
	  if (data_left < 2) {
	    i_push_error(0, "SGI image: RLE run has no data for pixel");
	    goto ErrorReturn;
	  }
	  sample = inp[0] * 256 + inp[1];
	  inp += 2;
	  data_left -= 2;
	  if (pixmin != 0 || pixmax != 65535) {
	    if (sample < pixmin)
	      sample = 0;
	    else if (sample > pixmax)
	      sample = outmax;
	    else
	      sample -= pixmin;
	    fsample = (double)sample / outmax;
	  }
	  else {
	    fsample = (double)sample / 65535.0;
	  }
	  pixels_left -= count;
	  while (count-- > 0) {
	    outp->channel[c] = fsample;
	    ++outp;
	  }
	}
      }
      /* must have a full scanline */
      if (pixels_left) {
	i_push_error(0, "SGI image: incomplete RLE scanline");
	goto ErrorReturn;
      }
      /* must have used all of the data */
      if (data_left) {
	i_push_errorf(0, "SGI image: unused RLE data");
	goto ErrorReturn;
      }
    }
    i_plinf(img, 0, width, height-1-y, linebuf);
  }

  myfree(linebuf);
  myfree(databuf);
  myfree(start_tab);
  myfree(length_tab);

  return img;

 ErrorReturn:
  if (linebuf)
    myfree(linebuf);
  if (databuf)
    myfree(databuf);
  myfree(start_tab);
  myfree(length_tab);
  i_img_destroy(img);
  return NULL;
}

static int
write_sgi_header(i_img *img, io_glue *ig, int *rle, int *bpc2) {
  rgb_header header;
  unsigned char headbuf[512] = { 0 };

  header.imagic = SGI_MAGIC;
  if (!i_tags_get_int(&img->tags, "sgi_rle", 0, rle))
    *rle = 0;
  header.storagetype = *rle ? SGI_STORAGE_RLE : SGI_STORAGE_VERBATIM;
  header.pixmin = 0;
  header.colormap = SGI_COLORMAP_NORMAL;
  *bpc2 = img->bits > 8;
  if (*bpc2) {
    header.BPC = 2;
    header.pixmax = 65535;
  }
  else {
    header.BPC = 1;
    header.pixmax = 255;
  }
  if (img->channels == 1) {
    header.dimensions = 2;
  }
  else {
    header.dimensions = 3;
  }
  header.xsize = img->xsize;
  header.ysize = img->ysize;
  header.zsize = img->channels;
  memset(header.name, 0, sizeof(header.name));
  i_tags_get_string(&img->tags, "i_comment",  0, 
		    header.name, sizeof(header.name));

  rgb_header_pack(&header, headbuf);

  if (i_io_write(ig, headbuf, sizeof(headbuf)) != sizeof(headbuf)) {
    i_push_error(0, "SGI image: cannot write header");
    return 0;
  }

  return 1;
}

static int
write_sgi_8_verb(i_img *img, io_glue *ig) {
  i_sample_t *linebuf;
  i_img_dim width = img->xsize;
  int c;
  i_img_dim y;

  linebuf = mymalloc(width);  /* checked 31Jul07 TonyC */
  for (c = 0; c < img->channels; ++c) {
    for (y = img->ysize - 1; y >= 0; --y) {
      i_gsamp(img, 0, width, y, linebuf, &c, 1);
      if (i_io_write(ig, linebuf, width) != width) {
	i_push_error(errno, "SGI image: error writing image data");
	myfree(linebuf);
	return 0;
      }
    }
  }
  myfree(linebuf);

  if (i_io_close(ig))
    return 0;

  return 1;
}

static int
write_sgi_8_rle(i_img *img, io_glue *ig) {
  i_sample_t *linebuf;
  unsigned char *comp_buf;
  i_img_dim width = img->xsize;
  int c;
  i_img_dim y;
  unsigned char *offsets;
  unsigned char *lengths;
  int offset_pos = 0;
  size_t offsets_size = (size_t)4 * img->ysize * img->channels * 2;
  unsigned long start_offset = 512 + offsets_size;
  unsigned long current_offset = start_offset;
  int in_left;
  unsigned char *outp;
  i_sample_t *inp;
  size_t comp_size;

  if (offsets_size / 2 / 4 / img->channels != img->ysize) {
    i_push_error(0, "SGI image: integer overflow calculating allocation size");
    return 0;
  }

  linebuf = mymalloc(width);  /* checked 31Jul07 TonyC */
  comp_buf = mymalloc((width + 1) * 2);  /* checked 31Jul07 TonyC */
  offsets = mymalloc(offsets_size);
  memset(offsets, 0, offsets_size);
  if (i_io_write(ig, offsets, offsets_size) != offsets_size) {
    i_push_error(errno, "SGI image: error writing offsets/lengths");
    goto Error;
  }
  lengths = offsets + img->ysize * img->channels * 4;
  for (c = 0; c < img->channels; ++c) {
    for (y = img->ysize - 1; y >= 0; --y) {
      i_gsamp(img, 0, width, y, linebuf, &c, 1);
      in_left = width;
      outp = comp_buf;
      inp = linebuf;
      while (in_left) {
	unsigned char *run_start = inp;

	/* first try for an RLE run */
	int run_length = 1;
	while (in_left - run_length >= 2 && inp[0] == inp[1] && run_length < 127) {
	  ++run_length;
	  ++inp;
	}
	if (in_left - run_length == 1 && inp[0] == inp[1] && run_length < 127) {
	  ++run_length;
	  ++inp;
	}
	if (run_length > 2) {
	  *outp++ = run_length;
	  *outp++ = inp[0];
	  inp++;
	  in_left -= run_length;
	}
	else {
	  inp = run_start;

	  /* scan for a literal run */
	  run_length = 1;
	  run_start = inp;
	  while (in_left - run_length > 1 && (inp[0] != inp[1] || inp[1] != inp[2]) && run_length < 127) {
	    ++run_length;
	    ++inp;
	  }
	  ++inp;
	  
	  /* fill out the run if 2 or less samples left and there's space */
	  if (in_left - run_length <= 2 
	      && in_left <= 127) {
	    run_length = in_left;
	  }
	  in_left -= run_length;
	  *outp++ = run_length | 0x80;
	  while (run_length--) {
	    *outp++ = *run_start++;
	  }
	}
      }
      *outp++ = 0;
      comp_size = outp - comp_buf;
      store_32(offsets + offset_pos, current_offset);
      store_32(lengths + offset_pos, comp_size);
      offset_pos += 4;
      current_offset += comp_size;
      if (i_io_write(ig, comp_buf, comp_size) != comp_size) {
	i_push_error(errno, "SGI image: error writing RLE data");
	goto Error;
      }
    }
  }

  /* seek back to store the offsets and lengths */
  if (i_io_seek(ig, 512, SEEK_SET) != 512) {
    i_push_error(errno, "SGI image: cannot seek to RLE table");
    goto Error;
  }

  if (i_io_write(ig, offsets, offsets_size) != offsets_size) {
    i_push_error(errno, "SGI image: cannot write final RLE table");
    goto Error;
  }

  myfree(offsets);
  myfree(comp_buf);
  myfree(linebuf);

  if (i_io_close(ig))
    return 0;

  return 1;

 Error:
  myfree(offsets);
  myfree(comp_buf);
  myfree(linebuf);
  return 0;
}

static int
write_sgi_16_verb(i_img *img, io_glue *ig) {
  i_fsample_t *linebuf;
  unsigned char *encbuf;
  unsigned char *outp;
  i_img_dim width = img->xsize;
  int c;
  i_img_dim x;
  i_img_dim y;

  linebuf = mymalloc(width * sizeof(i_fsample_t));  /* checked 31Jul07 TonyC */
  encbuf = mymalloc(width * 2);  /* checked 31Jul07 TonyC */
  for (c = 0; c < img->channels; ++c) {
    for (y = img->ysize - 1; y >= 0; --y) {
      i_gsampf(img, 0, width, y, linebuf, &c, 1);
      for (x = 0, outp = encbuf; x < width; ++x, outp+=2) {
	unsigned short samp16 = SampleFTo16(linebuf[x]);
	store_16(outp, samp16);
      }
      if (i_io_write(ig, encbuf, width * 2) != width * 2) {
	i_push_error(errno, "SGI image: error writing image data");
	myfree(linebuf);
	myfree(encbuf);
	return 0;
      }
    }
  }
  myfree(linebuf);
  myfree(encbuf);

  if (i_io_close(ig))
    return 0;

  return 1;
}

static int
write_sgi_16_rle(i_img *img, io_glue *ig) {
  i_fsample_t *sampbuf;
  unsigned short *linebuf;
  unsigned char *comp_buf;
  i_img_dim width = img->xsize;
  int c;
  i_img_dim y;
  unsigned char *offsets;
  unsigned char *lengths;
  int offset_pos = 0;
  size_t offsets_size = (size_t)4 * img->ysize * img->channels * 2;
  unsigned long start_offset = 512 + offsets_size;
  unsigned long current_offset = start_offset;
  int in_left;
  unsigned char *outp;
  unsigned short *inp;
  size_t comp_size;
  i_img_dim x;

  if (offsets_size / 4 / 2 / img->channels != img->ysize) {
    i_push_error(0, "SGI image: integer overflow calculating allocation size");
    return 0;
  }

  sampbuf = mymalloc(width * sizeof(i_fsample_t));  /* checked 31Jul07 TonyC */
  linebuf = mymalloc(width * sizeof(unsigned short));  /* checked 31Jul07 TonyC */
  comp_buf = mymalloc((width + 1) * 2 * 2);  /* checked 31Jul07 TonyC */
  offsets = mymalloc(offsets_size);
  memset(offsets, 0, offsets_size);
  if (i_io_write(ig, offsets, offsets_size) != offsets_size) {
    i_push_error(errno, "SGI image: error writing offsets/lengths");
    goto Error;
  }
  lengths = offsets + img->ysize * img->channels * 4;
  for (c = 0; c < img->channels; ++c) {
    for (y = img->ysize - 1; y >= 0; --y) {
      i_gsampf(img, 0, width, y, sampbuf, &c, 1);
      for (x = 0; x < width; ++x)
	linebuf[x] = (unsigned short)(SampleFTo16(sampbuf[x]));
      in_left = width;
      outp = comp_buf;
      inp = linebuf;
      while (in_left) {
	unsigned short *run_start = inp;

	/* first try for an RLE run */
	int run_length = 1;
	while (in_left - run_length >= 2 && inp[0] == inp[1] && run_length < 127) {
	  ++run_length;
	  ++inp;
	}
	if (in_left - run_length == 1 && inp[0] == inp[1] && run_length < 127) {
	  ++run_length;
	  ++inp;
	}
	if (run_length > 2) {
	  store_16(outp, run_length);
	  store_16(outp+2, inp[0]);
	  outp += 4;
	  inp++;
	  in_left -= run_length;
	}
	else {
	  inp = run_start;

	  /* scan for a literal run */
	  run_length = 1;
	  run_start = inp;
	  while (in_left - run_length > 1 && (inp[0] != inp[1] || inp[1] != inp[2]) && run_length < 127) {
	    ++run_length;
	    ++inp;
	  }
	  ++inp;
	  
	  /* fill out the run if 2 or less samples left and there's space */
	  if (in_left - run_length <= 2 
	      && in_left <= 127) {
	    run_length = in_left;
	  }
	  in_left -= run_length;
	  store_16(outp, run_length | 0x80);
	  outp += 2;
	  while (run_length--) {
	    store_16(outp, *run_start++);
	    outp += 2;
	  }
	}
      }
      store_16(outp, 0);
      outp += 2;
      comp_size = outp - comp_buf;
      store_32(offsets + offset_pos, current_offset);
      store_32(lengths + offset_pos, comp_size);
      offset_pos += 4;
      current_offset += comp_size;
      if (i_io_write(ig, comp_buf, comp_size) != comp_size) {
	i_push_error(errno, "SGI image: error writing RLE data");
	goto Error;
      }
    }
  }

  /* seek back to store the offsets and lengths */
  if (i_io_seek(ig, 512, SEEK_SET) != 512) {
    i_push_error(errno, "SGI image: cannot seek to RLE table");
    goto Error;
  }

  if (i_io_write(ig, offsets, offsets_size) != offsets_size) {
    i_push_error(errno, "SGI image: cannot write final RLE table");
    goto Error;
  }

  myfree(offsets);
  myfree(comp_buf);
  myfree(linebuf);
  myfree(sampbuf);

  if (i_io_close(ig))
    return 0;

  return 1;

 Error:
  myfree(offsets);
  myfree(comp_buf);
  myfree(linebuf);
  myfree(sampbuf);

  return 0;
}