Example #1
0
static GImage *ColorWheel(int width,int height) {
    struct hslrgb col;
    GImage *wheel;
    struct _GImage *base;
    int i,j;
    double x,y, hh, hw;
    uint32 *row;

    memset(&col,0,sizeof(col));
    col.v = 1.0;

    if ( width<10 ) width = 10;
    if ( height<10 ) height = 10;
    hh = height/2.0; hw = width/2.0;

    wheel = GImageCreate(it_true,width,height);
    base = wheel->u.image;
    for ( i=0; i<height; ++i ) {
	row = (uint32 *) (base->data + i*base->bytes_per_line);
	y = (i-hh)/(hh-1);
	for ( j=0; j<width; ++j ) {
	    x = (j-hw)/(hw-1);
	    col.s = sqrt(x*x + y*y);
	    if ( col.s>1.0 ) {
		*row++ = 0xffffff;
	    } else {
		col.h = atan2(y,x)*180/3.1415926535897932;
		if ( col.h < 0 ) col.h += 360;
		gHSV2RGB(&col);
		*row++ = COLOR_CREATE( (int) rint(255*col.r), (int) rint(255*col.g), (int) rint(255*col.b));
	    }
	}
    }
return( wheel );	
}
Example #2
0
int BCExportXBM(char *filename,BDFChar *bdfc, int format) {
    struct _GImage base;
    GImage gi;
    GClut clut;
    int ret;
    int tot;
    int scale, i;
    uint8 *pt, *end;

    memset(&gi,'\0', sizeof(gi));
    memset(&base,'\0', sizeof(base));
    gi.u.image = &base;

    if ( !bdfc->byte_data ) {
	BCRegularizeBitmap(bdfc);
	/* Sigh. Bitmaps use a different defn of set than images do. make it consistant */
	tot = bdfc->bytes_per_line*(bdfc->ymax-bdfc->ymin+1);
	for ( pt = bdfc->bitmap, end = pt+tot; pt<end; *pt++ ^= 0xff );

	base.image_type = it_mono;
	base.data = bdfc->bitmap;
	base.bytes_per_line = bdfc->bytes_per_line;
	base.width = bdfc->xmax-bdfc->xmin+1;
	base.height = bdfc->ymax-bdfc->ymin+1;
	base.trans = -1;
	if ( format==0 )
	    ret = !GImageWriteXbm(&gi,filename);
#ifndef _NO_LIBPNG
	else if ( format==2 )
	    ret = GImageWritePng(&gi,filename,false);
#endif
	else
	    ret = GImageWriteBmp(&gi,filename);
	/* And back to normal */
	for ( pt = bdfc->bitmap, end = pt+tot; pt<end; *pt++ ^= 0xff );
    } else {
	BCRegularizeGreymap(bdfc);
	base.image_type = it_index;
	base.data = bdfc->bitmap;
	base.bytes_per_line = bdfc->bytes_per_line;
	base.width = bdfc->xmax-bdfc->xmin+1;
	base.height = bdfc->ymax-bdfc->ymin+1;
	base.clut = &clut;
	clut.clut_len = 1<<bdfc->depth;
	clut.is_grey = true;
	clut.trans_index = base.trans = -1;
	scale = 255/((1<<bdfc->depth)-1);
	scale = COLOR_CREATE(scale,scale,scale);
	for ( i=0; i< 1<<bdfc->depth; ++i )
	    clut.clut[(1<<bdfc->depth)-1 - i] = i*scale;
#ifndef _NO_LIBPNG
	if ( format==2 )
	    ret = GImageWritePng(&gi,filename,false);
	else
#endif
	    ret = GImageWriteBmp(&gi,filename);
    }
return( ret );
}
Example #3
0
/* jpeg routines use 24 bit pixels, xvt routines pad out to 32 */
static void transferBufferToImage(struct jpegState *js,int ypos) {
    struct jpeg_decompress_struct *cinfo = js->cinfo;
    JSAMPLE *pt, *end;
    Color *ppt;

    ppt = (Color *) (js->base->data+ypos*js->base->bytes_per_line);
    for ( pt = js->buffer, end = pt+3*cinfo->image_width; pt<end; ) {
	register int r,g,b;
	r = *(pt++); g= *(pt++); b= *(pt++);
	*(ppt++) = COLOR_CREATE(r,g,b);
    }
}
Example #4
0
GImage *
GImageReadTiff (char *filename)
{
  TIFF *tif;
  uint32_t w, h, i, j;
  uint32_t *ipt, *fpt;
  size_t npixels;
  uint32 *raster;
  GImage *ret = NULL;
  struct _GImage *base;

  tif = TIFFOpen (filename, "r");

  if (tif == NULL)
    return (ret);

  TIFFGetField (tif, TIFFTAG_IMAGEWIDTH, &w);
  TIFFGetField (tif, TIFFTAG_IMAGELENGTH, &h);
  npixels = w * h;
  raster = (uint32_t *) xmalloc (szmax (1, npixels * sizeof (uint32_t)));
  if (raster != NULL)
    {
      if (TIFFReadRGBAImage (tif, w, h, raster, 0))
        {
          ret = GImageCreate (it_true, w, h);
          if (ret != NULL)
            {
              base = ret->u.image;
              for (i = 0; i < h; ++i)
                {
                  ipt = (uint32_t *) (base->data + i * base->bytes_per_line);
                  fpt = raster + (h - 1 - i) * w;
                  for (j = 0; j < w; ++j)
                    *ipt++ =
                      COLOR_CREATE (TIFFGetR (fpt[j]), TIFFGetG (fpt[j]),
                                    TIFFGetB (fpt[j]));
                }
            }
        }
      free (raster);
    }
  TIFFClose (tif);
  return (ret);
}
Example #5
0
static GImage *Gradient(int height) {
    GImage *grad;
    struct _GImage *base;
    int i,j,c;
    uint32 *row;

    if ( height<10 ) height = 10;

    grad = GImageCreate(it_true,GRAD_WIDTH,height);
    base = grad->u.image;
    for ( i=0; i<height; ++i ) {
	row = (uint32 *) (base->data + i*base->bytes_per_line);
	c = 255*(height-1-i)/(height-1);
	for ( j=0; j<GRAD_WIDTH; ++j ) {
	    *row++ = COLOR_CREATE(c,c,c);
	}
    }
return( grad );
}
Example #6
0
GImage *
GImageReadRgb (char *filename)
{
  FILE *fp = fopen (filename, "rb");
  struct sgiheader header;
  int j, i;
  unsigned char *pt, *end;
  unsigned long *ipt, *iend;
  GImage *ret;
  struct _GImage *base;

  if (fp == NULL)
    return (NULL);
  getsgiheader (&header, fp);
  if (header.magic != SGI_MAGIC ||
      (header.format != VERBATIM && header.format != RLE) ||
      (header.bpc != 1 && header.bpc != 2) ||
      header.dim < 1 || header.dim > 3 ||
      header.pixmax > 65535 || (header.pixmax > 255 && header.bpc == 1) ||
      (header.chans != 1 && header.chans != 3 && header.chans != 4) ||
      header.pixmax < 0 || header.pixmin < 0 || header.pixmin > header.pixmax ||
      header.colormap != 0)
    {
      fclose (fp);
      return (NULL);
    }

  ret =
    GImageCreate (header.dim == 3 ? it_true : it_index, header.width,
                  header.height);
  base = ret->u.image;

  if (header.format == RLE)
    {
      unsigned long *starttab /*, *lengthtab */ ;
      unsigned char **ptrtab;
      long tablen;

      tablen = header.height * header.chans;
      starttab = (unsigned long *) xmalloc (szmax (1, tablen * sizeof (long)));
      /*lengthtab = (unsigned long *)xmalloc(szmax(1, tablen*sizeof(long))); */
      ptrtab =
        (unsigned char **)
        xmalloc (szmax (1, tablen * sizeof (unsigned char *)));
      readlongtab (fp, starttab, tablen);
      /*readlongtab(fp,lengthtab,tablen); */
      for (i = 0; i < tablen; ++i)
        find_scanline (fp, &header, i, starttab, ptrtab);
      if (header.chans == 1)
        {
          for (i = 0; i < header.height; ++i)
            memcpy (base->data + (header.height - 1 - i) * base->bytes_per_line,
                    ptrtab[i], header.width);
        }
      else
        {
          unsigned long *ipt;
          for (i = 0; i < header.height; ++i)
            {
              ipt =
                (unsigned long *) (base->data +
                                   (header.height - 1 -
                                    i) * base->bytes_per_line);
              for (j = 0; j < header.width; ++j)
                *ipt++ = COLOR_CREATE (ptrtab[i][j],
                                       ptrtab[i + header.height][j],
                                       ptrtab[i + 2 * header.height][j]);
            }
        }
      freeptrtab (ptrtab, tablen);
      free (ptrtab);
      free (starttab);          /*free(lengthtab); */
    }
  else
    {
      if (header.chans == 1 && header.bpc == 1)
        {
          for (i = 0; i < header.height; ++i)
            {
              fread (base->data +
                     (header.height - 1 - i) * base->bytes_per_line,
                     header.width, 1, fp);
              if (header.pixmax != 255)
                {
                  pt =
                    (unsigned char *) (base->data +
                                       (header.height - 1 -
                                        i) * base->bytes_per_line);
                  for (end = pt + header.width; pt < end; ++pt)
                    *pt = (*pt * 255) / header.pixmax;
                }
            }
        }
      else if (header.chans == 1)
        {
          for (i = 0; i < header.height; ++i)
            {
              pt =
                (unsigned char *) (base->data +
                                   (header.height - 1 -
                                    i) * base->bytes_per_line);
              for (end = pt + header.width; pt < end;)
                *pt++ = (getshort (fp) * 255L) / header.pixmax;
            }
        }
      else if (header.bpc == 1)
        {
          unsigned char *r, *g, *b, *a = NULL;
          unsigned char *rpt, *gpt, *bpt;
          r = (unsigned char *) xmalloc (header.width);
          g = (unsigned char *) xmalloc (header.width);
          b = (unsigned char *) xmalloc (header.width);
          if (header.chans == 4)
            a = (unsigned char *) xmalloc (header.width);
          for (i = 0; i < header.height; ++i)
            {
              fread (r, header.width, 1, fp);
              fread (g, header.width, 1, fp);
              fread (b, header.width, 1, fp);
              if (header.chans == 4)
                fread (a, header.width, 1, fp);
              ipt =
                (unsigned long *) (base->data +
                                   (header.height - 1 -
                                    i) * base->bytes_per_line);
              rpt = r;
              gpt = g;
              bpt = b;
              for (iend = ipt + header.width; ipt < iend;)
                *ipt++ = COLOR_CREATE (*rpt++ * 255L / header.pixmax,
                                       *gpt++ * 255L / header.pixmax,
                                       *bpt++ * 255L / header.pixmax);
            }
          free (r);
          free (g);
          free (b);
          free (a);
        }
      else
        {
          unsigned char *r, *g, *b, *a = NULL;
          unsigned char *rpt, *gpt, *bpt;
          r = (unsigned char *) xmalloc (header.width);
          g = (unsigned char *) xmalloc (header.width);
          b = (unsigned char *) xmalloc (header.width);
          if (header.chans == 4)
            a = (unsigned char *) xmalloc (header.width);
          for (i = 0; i < header.height; ++i)
            {
              for (j = 0; j < header.width; ++j)
                r[j] = getshort (fp) * 255L / header.pixmax;
              for (j = 0; j < header.width; ++j)
                g[j] = getshort (fp) * 255L / header.pixmax;
              for (j = 0; j < header.width; ++j)
                b[j] = getshort (fp) * 255L / header.pixmax;
              if (header.chans == 4)
                {
                  fread (a, header.width, 1, fp);
                  fread (a, header.width, 1, fp);
                }
              ipt =
                (unsigned long *) (base->data +
                                   (header.height - 1 -
                                    i) * base->bytes_per_line);
              rpt = r;
              gpt = g;
              bpt = b;
              for (iend = ipt + header.width; ipt < iend;)
                *ipt++ = COLOR_CREATE (*rpt++, *gpt++, *bpt++);
            }
          free (r);
          free (g);
          free (b);
          free (a);
        }
    }

  return (ret);
}
Example #7
0
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include <basics.h>
#include <stdlib.h>
#include "utype.h"
#include "gdraw.h"
#include "ggadgetP.h"
#include "gresource.h"
#include "gwidget.h"
#include "gkeysym.h"
#include "ustring.h"

GBox _ggadget_Default_Box = { bt_raised, bs_rect, 2, 2, 0, 0, 
    COLOR_CREATE(0xd8,0xd8,0xd8),		/* border left */ /* brightest */
    COLOR_CREATE(0xd0,0xd0,0xd0),		/* border top */
    COLOR_CREATE(0x80,0x80,0x80),		/* border right */
    COLOR_CREATE(0x66,0x66,0x66),		/* border bottom */ /* darkest */
    COLOR_DEFAULT,				/* normal background */
    COLOR_DEFAULT,				/* normal foreground */
    COLOR_CREATE(0xd8,0xd8,0xd8),		/* disabled background */
    COLOR_CREATE(0x66,0x66,0x66),		/* disabled foreground */
    COLOR_CREATE(0xff,0xff,0x00),		/* active border */
    COLOR_CREATE(0xa0,0xa0,0xa0),		/* pressed background */
    COLOR_CREATE(0x00,0x00,0x00),		/* gradient bg end */
    COLOR_CREATE(0x00,0x00,0x00),		/* border inner */
    COLOR_CREATE(0x00,0x00,0x00),		/* border outer */
};
GBox _GListMark_Box = GBOX_EMPTY; /* Don't initialize here */
FontInstance *_ggadget_default_font = NULL;
Example #8
0
int ExportImage(char *filename,SplineChar *sc, int layer, int format, int pixelsize, int bitsperpixel) {
/* 0=*.xbm, 1=*.bmp, 2=*.png, 3=*.xpm, 4=*.c(fontforge-internal) */
    struct _GImage base;
    GImage gi;
    GClut clut;
    BDFChar *bdfc;
    int ret;
    int tot, i;
    uint8 *pt, *end;
    int scale;
    void *freetypecontext;
    double emsize = sc->parent->ascent+sc->parent->descent;

    if ( autohint_before_generate && sc->changedsincelasthinted && !sc->manualhints )
	SplineCharAutoHint(sc,layer,NULL);

    memset(&gi,'\0', sizeof(gi));
    memset(&base,'\0', sizeof(base));
    memset(&clut,'\0', sizeof(clut));
    gi.u.image = &base;

    if ( bitsperpixel==1 ) {
	if ( (freetypecontext = FreeTypeFontContext(sc->parent,sc,NULL,layer))==NULL )
	    bdfc = SplineCharRasterize(sc,layer,pixelsize);
	else {
	    bdfc = SplineCharFreeTypeRasterize(freetypecontext,sc->orig_pos,pixelsize,72,1);
	    FreeTypeFreeContext(freetypecontext);
	}
	BCRegularizeBitmap(bdfc);
	/* People don't seem to like having a minimal bounding box for their */
	/*  images. */
	BCExpandBitmapToEmBox(bdfc,
		0,
		(int) rint(sc->parent->ascent*pixelsize/emsize)-pixelsize,
		(int) rint(sc->width*pixelsize/emsize),
		(int) rint(sc->parent->ascent*pixelsize/emsize));

	/* Sigh. Bitmaps use a different defn of set than images do. make it consistant */
	tot = bdfc->bytes_per_line*(bdfc->ymax-bdfc->ymin+1);
	for ( pt = bdfc->bitmap, end = pt+tot; pt<end; *pt++ ^= 0xff );

	base.image_type = it_mono;
	base.data = bdfc->bitmap;
	base.bytes_per_line = bdfc->bytes_per_line;
	base.width = bdfc->xmax-bdfc->xmin+1;
	base.height = bdfc->ymax-bdfc->ymin+1;
	base.trans = -1;
	if ( format==0 )
	    ret = !GImageWriteXbm(&gi,filename);
#ifndef _NO_LIBPNG
	else if ( format==2 )
	    ret = GImageWritePng(&gi,filename,false);
#endif
	else if ( format==3 )
	    ret = !GImageWriteXpm(&gi,filename);
	else if ( format==4 )
	    ret = !GImageWriteGImage(&gi,filename);
	else
	    ret = GImageWriteBmp(&gi,filename);
	BDFCharFree(bdfc);
    } else {
	if ( (freetypecontext = FreeTypeFontContext(sc->parent,sc,NULL,layer))==NULL )
	    bdfc = SplineCharAntiAlias(sc,pixelsize,layer,(1<<(bitsperpixel/2)));
	else {
	    bdfc = SplineCharFreeTypeRasterize(freetypecontext,sc->orig_pos,pixelsize,72,bitsperpixel);
	    FreeTypeFreeContext(freetypecontext);
	}
	BCRegularizeGreymap(bdfc);
	BCExpandBitmapToEmBox(bdfc,
		0,
		(int) rint(sc->parent->ascent*pixelsize/emsize) - pixelsize,
		(int) rint(sc->width*pixelsize/emsize),
		(int) rint(sc->parent->ascent*pixelsize/emsize));
	base.image_type = it_index;
	base.data = bdfc->bitmap;
	base.bytes_per_line = bdfc->bytes_per_line;
	base.width = bdfc->xmax-bdfc->xmin+1;
	base.height = bdfc->ymax-bdfc->ymin+1;
	base.clut = &clut;
	base.trans = -1;
	clut.clut_len = 1<<bitsperpixel;
	clut.is_grey = true;
	clut.trans_index = -1;
	scale = 255/((1<<bitsperpixel)-1);
	scale = COLOR_CREATE(scale,scale,scale);
	for ( i=0; i< 1<<bitsperpixel; ++i )
	    clut.clut[(1<<bitsperpixel)-1 - i] = i*scale;
#ifndef _NO_LIBPNG
	if ( format==2 )
	    ret = GImageWritePng(&gi,filename,false);
	else
#endif
	    ret = GImageWriteBmp(&gi,filename);
	BDFCharFree(bdfc);
    }
return( ret );
}
Example #9
0
static int fillbmpheader(FILE *file,struct bmpheader *head) {
    int i;

    memset(head,'\0',sizeof(*head));
    if ( getc(file)!='B' || getc(file)!='M' )
return 0;			/* Bad format */
    head->size = getl(file);
    head->mbz1 = getshort(file);
    head->mbz2 = getshort(file);
    head->offset = getl(file);
    head->headersize = getl(file);
    if ( head->headersize==12 ) {	/* Windows 2.0 format, also OS/2 */
	head->width = getshort(file);
	head->height = getshort(file);
	head->planes = getshort(file);
	head->bitsperpixel = getshort(file);
	head->colorsused = 0;
	head->compression = 0;
    } else {
	head->width = getl(file);
	head->height = getl(file);
	head->planes = getshort(file);
	head->bitsperpixel = getshort(file);
	head->compression = getl(file);
	head->imagesize = getl(file);
	head->ignore1 = getl(file);
	head->ignore2 = getl(file);
	head->colorsused = getl(file);
	head->colorsimportant = getl(file);
    }
    if ( head->height<0 )
	head->height = -head->height;
    else
	head->invert = true;
    if ( head->bitsperpixel!=1 && head->bitsperpixel!=4 && head->bitsperpixel!=8 &&
	    head->bitsperpixel!=16 && head->bitsperpixel!=24 && head->bitsperpixel!=32 )
return( 0 );
    if ( head->compression==3 && ( head->bitsperpixel==16 || head->bitsperpixel==32 ))
	/* Good */;
    else if ( head->compression==0 && ( head->bitsperpixel<=8 || head->bitsperpixel==24 || head->bitsperpixel==32 ))
	/* Good */;
    else if ( head->compression==1 && head->bitsperpixel==8 )
	/* Good */;
    else if ( head->compression==2 && head->bitsperpixel==4 )
	/* Good */;
    else
return( 0 );
    if ( head->colorsused==0 )
	head->colorsused = 1<<head->bitsperpixel;
    if ( head->bitsperpixel>=16 )
	head->colorsused = 0;
    if ( head->colorsused>(1<<head->bitsperpixel) )
return( 0 );
    for ( i=0; i<head->colorsused; ++i ) {
	int b = getc(file), g = getc(file), r=getc(file);
	head->clut[i] = COLOR_CREATE(r,g,b);
	if ( head->headersize!=12 )
	    getc(file);
    }
    if ( head->compression==3 || head->headersize==108 ) {
	head->red_mask = getl(file);
	head->green_mask = getl(file);
	head->blue_mask = getl(file);
	head->red_shift = bitshift(head->red_mask);
	head->green_shift = bitshift(head->green_mask);
	head->blue_shift = bitshift(head->blue_mask);
    }
    if ( head->headersize==108 ) {
	getl(file);		/* alpha_mask */
	getl(file);		/* color space type */
	getl(file);		/* redx */
	getl(file);		/* redy */
	getl(file);		/* redz */
	getl(file);		/* greenx */
	getl(file);		/* greeny */
	getl(file);		/* greenz */
	getl(file);		/* bluex */
	getl(file);		/* bluey */
	getl(file);		/* bluez */
	getl(file);		/* gammared */
	getl(file);		/* gammagreen */
	getl(file);		/* gammablue */
    }
return( 1 );
}
Example #10
0
static int fillbmpheader(FILE *fp,struct bmpheader *head) {
/* Get BMPheader info. Return 0 if read the header okay, -1 if read error */
    int i;
    long temp;

    if ( fgetc(fp)!='B' || getc(fp)!='M' ||	/* Bad format */ \
	 getlong(fp,&head->size)	|| \
	 (head->mbz1=getshort(fp))<0	|| \
	 (head->mbz2=getshort(fp))<0	|| \
	 getlong(fp,&head->offset)	|| \
	 getlong(fp,&head->headersize)	)
	return( -1 );

    if ( head->headersize==12 ) {	/* Windows 2.0 format, also OS/2 */
	if ( (head->width=getshort(fp))<0	|| \
	     (head->height=getshort(fp))<0	|| \
	     (head->planes=getshort(fp))<0	|| \
	     (head->bitsperpixel=getshort(fp))<0 )
	    return( -1 );
	//head->colorsused=0;
	//head->compression=0;
    } else {
	if ( getlong(fp,&head->width)		|| \
	     getlong(fp,&head->height)		|| \
	     (head->planes=getshort(fp))<0	|| \
	     (head->bitsperpixel=getshort(fp))<0 || \
	     getlong(fp,&head->compression)	|| \
	     getlong(fp,&head->imagesize)	|| \
	     getlong(fp,&head->ignore1)		|| \
	     getlong(fp,&head->ignore2)		|| \
	     getlong(fp,&head->colorsused)	|| \
	     getlong(fp,&head->colorsimportant) )
	    return( -1 );
    }
    if ( head->height<0 )
	head->height = -head->height;
    else
	head->invert = true;

    if ( head->bitsperpixel!=1 && head->bitsperpixel!=4 && head->bitsperpixel!=8 &&
	    head->bitsperpixel!=16 && head->bitsperpixel!=24 && head->bitsperpixel!=32 )
	return( -1 );

    if ( head->compression==3 && ( head->bitsperpixel==16 || head->bitsperpixel==32 ) )
	/* Good */;
    else if ( head->compression==0 && ( head->bitsperpixel<=8 || head->bitsperpixel==24 || head->bitsperpixel==32 ) )
	/* Good */;
    else if ( head->compression==1 && head->bitsperpixel==8 )
	/* Good */;
    else if ( head->compression==2 && head->bitsperpixel==4 )
	/* Good */;
    else
	return( -1 );

    if ( head->colorsused==0 )
	head->colorsused = 1<<head->bitsperpixel;
    if ( head->bitsperpixel>=16 )
	head->colorsused = 0;
    if ( head->colorsused>(1<<head->bitsperpixel) )
	return( -1 );

    for ( i=0; i<head->colorsused; ++i ) {
	int b,g,r;
	if ( (b=fgetc(fp))<0 || (g=fgetc(fp))<0 || (r=fgetc(fp))<0 )
	    return( -1 );
	head->clut[i]=COLOR_CREATE(r,g,b);
	if ( head->headersize!=12 && fgetc(fp)<0 )
	    return( -1 );
    }
    if ( head->compression==3 || head->headersize==108 ) {
	if ( getlong(fp,&head->red_mask)	|| \
	     getlong(fp,&head->green_mask)	|| \
	     getlong(fp,&head->blue_mask) )
	    return( -1 );
	head->red_shift = bitshift(head->red_mask);
	head->green_shift = bitshift(head->green_mask);
	head->blue_shift = bitshift(head->blue_mask);
    }

    if ( head->headersize==108 && (
	 getlong(fp,&temp) ||	/* alpha_mask */ \
	 getlong(fp,&temp) ||	/* color space type */ \
	 getlong(fp,&temp) ||	/* redx */ \
	 getlong(fp,&temp) ||	/* redy */ \
	 getlong(fp,&temp) ||	/* redz */ \
	 getlong(fp,&temp) ||	/* greenx */ \
	 getlong(fp,&temp) ||	/* greeny */ \
	 getlong(fp,&temp) ||	/* greenz */ \
	 getlong(fp,&temp) ||	/* bluex */ \
	 getlong(fp,&temp) ||	/* bluey */ \
	 getlong(fp,&temp) ||	/* bluez */ \
	 getlong(fp,&temp) ||	/* gammared */ \
	 getlong(fp,&temp) ||	/* gammagreen */ \
	 getlong(fp,&temp) )	/* gammablue */ )
	return( -1 );

    return( 0 );
}