doxygen: prevent GPL license block from being parsed as doxygen comment.
[blender.git] / source / blender / imbuf / intern / iris.c
index fb875bf..f29f68b 100644 (file)
@@ -1,14 +1,11 @@
-/**
+/*
  *
- * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. The Blender
- * Foundation also sells licenses for use in proprietary software under
- * the Blender License.  See http://www.blender.org/BL/ for information
- * about this.
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,7 +14,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  *
  * Contributor(s): none yet.
  *
- * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  * iris.c
  *
  * $Id$
  */
 
 #include <string.h>
+
 #include "BLI_blenlib.h"
+#include "MEM_guardedalloc.h"
+
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 #include "IMB_allocimbuf.h"
-#include "IMB_iris.h"
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include "IMB_filetype.h"
 
 typedef struct {
-    unsigned short     imagic;         /* stuff saved on disk . . */
-    unsigned short     type;
-    unsigned short     dim;
-    unsigned short     xsize;
-    unsigned short     ysize;
-    unsigned short     zsize;
-    unsigned int       min;
-    unsigned int       max;
-    unsigned int       wastebytes;     
-    char               name[80];
-    unsigned int       colormap;
-
-    int                file;           /* stuff used in core only */
-    unsigned short     flags;
-    short              dorev;
-    short              x;
-    short              y;
-    short              z;
-    short              cnt;
-    unsigned short     *ptr;
-    unsigned short     *base;
-    unsigned short     *tmpbuf;
-    unsigned int       offset;
-    unsigned int       rleend;         /* for rle images */
-    unsigned int       *rowstart;      /* for rle images */
-    int                        *rowsize;       /* for rle images */
+       unsigned short  imagic;         /* stuff saved on disk . . */
+       unsigned short  type;
+       unsigned short  dim;
+       unsigned short  xsize;
+       unsigned short  ysize;
+       unsigned short  zsize;
+       unsigned int    min;
+       unsigned int    max;
+       unsigned int    wastebytes;     
+       char            name[80];
+       unsigned int    colormap;
+
+       int             file;           /* stuff used in core only */
+       unsigned short  flags;
+       short           dorev;
+       short           x;
+       short           y;
+       short           z;
+       short           cnt;
+       unsigned short  *ptr;
+       unsigned short  *base;
+       unsigned short  *tmpbuf;
+       unsigned int    offset;
+       unsigned int    rleend;         /* for rle images */
+       unsigned int    *rowstart;      /* for rle images */
+       int             *rowsize;       /* for rle images */
 } IMAGE;
 
 #define RINTLUM (79)
 #define GINTLUM (156)
 #define BINTLUM (21)
 
-#define ILUM(r,g,b)     ((int)(RINTLUM*(r)+GINTLUM*(g)+BINTLUM*(b))>>8)
+#define ILUM(r,g,b)    ((int)(RINTLUM*(r)+GINTLUM*(g)+BINTLUM*(b))>>8)
 
 #define OFFSET_R       0       /* this is byte order dependent */
 #define OFFSET_G       1
@@ -111,14 +106,12 @@ static int writetab(FILE *outf, unsigned int *tab, int len);
 static void readtab(FILE *inf, unsigned int *tab, int len);
 
 static void expandrow(unsigned char *optr, unsigned char *iptr, int z);
+static void expandrow2(float *optr, unsigned char *iptr, int z);
 static void interleaverow(unsigned char *lptr, unsigned char *cptr, int z, int n);
+static void interleaverow2(float *lptr, unsigned char *cptr, int z, int n);
 static int compressrow(unsigned char *lbuf, unsigned char *rlebuf, int z, int cnt);
 static void lumrow(unsigned char *rgbptr, unsigned char *lumptr, int n);
 
-/* not used... */
-/*  static void copybw(int *lptr, int n); */
-/*  static void setalpha(unsigned char *lptr, int n); */
-
 /*
  *     byte order independent read/write of shorts and ints.
  *
@@ -128,10 +121,10 @@ static uchar * file_data;
 static int file_offset;
 
 static unsigned short getshort(FILE *inf)
-/*  FILE *inf; */
 {
        unsigned char * buf;
-       
+       (void)inf; /* unused */
+
        buf = file_data + file_offset;
        file_offset += 2;
        
@@ -139,9 +132,9 @@ static unsigned short getshort(FILE *inf)
 }
 
 static unsigned int getlong(FILE *inf)
-/*  FILE *inf; */
 {
        unsigned char * buf;
+       (void)inf; /* unused */
        
        buf = file_data + file_offset;
        file_offset += 4;
@@ -150,8 +143,6 @@ static unsigned int getlong(FILE *inf)
 }
 
 static void putshort(FILE *outf, unsigned short val)
-/*  FILE *outf; */
-/*  unsigned short val; */
 {
        unsigned char buf[2];
 
@@ -161,8 +152,6 @@ static void putshort(FILE *outf, unsigned short val)
 }
 
 static int putlong(FILE *outf, unsigned int val)
-/*  FILE *outf; */
-/*  unsigned int val; */
 {
        unsigned char buf[4];
 
@@ -174,8 +163,6 @@ static int putlong(FILE *outf, unsigned int val)
 }
 
 static void readheader(FILE *inf, IMAGE *image)
-/*  FILE *inf; */
-/*  IMAGE *image; */
 {
        memset(image, 0, sizeof(IMAGE));
        image->imagic = getshort(inf);
@@ -187,12 +174,9 @@ static void readheader(FILE *inf, IMAGE *image)
 }
 
 static int writeheader(FILE *outf, IMAGE *image)
-/*  FILE *outf; */
-/*  IMAGE *image; */
 {
-       IMAGE t;
+       IMAGE t= {0};
 
-       memset(&t, 0, sizeof(IMAGE));
        fwrite(&t,sizeof(IMAGE),1,outf);
        fseek(outf,0,SEEK_SET);
        putshort(outf,image->imagic);
@@ -208,9 +192,6 @@ static int writeheader(FILE *outf, IMAGE *image)
 }
 
 static int writetab(FILE *outf, unsigned int *tab, int len)
-/*  FILE *outf; */
-/*  unsigned int *tab; */
-/*  int len; */
 {
        int r = 0;
 
@@ -222,9 +203,6 @@ static int writetab(FILE *outf, unsigned int *tab, int len)
 }
 
 static void readtab(FILE *inf, unsigned int *tab, int len)
-/*  FILE *inf; */
-/*  unsigned int *tab; */
-/*  int len; */
 {
        while(len) {
                *tab++ = getlong(inf);
@@ -249,6 +227,16 @@ static void test_endian_zbuf(struct ImBuf *ibuf)
        }
 }
 
+/* from misc_util: flip the bytes from x  */
+#define GS(x) (((unsigned char *)(x))[0] << 8 | ((unsigned char *)(x))[1])
+
+/* this one is only def-ed once, strangely... */
+#define GSS(x) (((uchar *)(x))[1] << 8 | ((uchar *)(x))[0])
+
+int imb_is_a_iris(unsigned char *mem)
+{
+       return ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC));
+}
 
 /*
  *     longimagedata - 
@@ -257,20 +245,24 @@ static void test_endian_zbuf(struct ImBuf *ibuf)
  *
  */
 
-struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
+struct ImBuf *imb_loadiris(unsigned char *mem, size_t size, int flags)
 {
-       unsigned int *base, *lptr;
+       unsigned int *base, *lptr = NULL;
+       float *fbase, *fptr = NULL;
        unsigned int *zbase, *zptr;
        unsigned char *rledat;
-       int *starttab, *lengthtab;
-       FILE *inf;
+       unsigned int *starttab, *lengthtab;
+       FILE *inf = NULL;
        IMAGE image;
        int x, y, z, tablen;
        int xsize, ysize, zsize;
        int bpp, rle, cur, badorder;
        ImBuf * ibuf;
-       uchar * rect;
+
+       (void)size; /* unused */
        
+       if(!imb_is_a_iris(mem)) return NULL;
+
        /*printf("new iris\n");*/
        
        file_data = mem;
@@ -284,8 +276,8 @@ struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
        
        rle = ISRLE(image.type);
        bpp = BPP(image.type);
-       if(bpp != 1 ) {
-               fprintf(stderr,"longimagedata: image must have 1 byte per pix chan\n");
+       if(bpp != 1 && bpp != 2) {
+               fprintf(stderr,"longimagedata: image must have 1 or 2 byte per pix chan\n");
                return(0);
        }
        
@@ -294,20 +286,21 @@ struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
        zsize = image.zsize;
        
        if (flags & IB_test) {
-               ibuf = IMB_allocImBuf(image.xsize, image.ysize, 8 * image.zsize, 0, 0);
+               ibuf = IMB_allocImBuf(image.xsize, image.ysize, 8 * image.zsize, 0);
                if (ibuf) ibuf->ftype = IMAGIC;
                return(ibuf);
        }
        
        if (rle) {
+               
                tablen = ysize*zsize*sizeof(int);
-               starttab = (int *)malloc(tablen);
-               lengthtab = (int *)malloc(tablen);
+               starttab = (unsigned int *)MEM_mallocN(tablen, "iris starttab");
+               lengthtab = (unsigned int *)MEM_mallocN(tablen, "iris endtab");
                file_offset = 512;
                
                readtab(inf,starttab,tablen);
                readtab(inf,lengthtab,tablen);
-
+       
                /* check data order */
                cur = 0;
                badorder = 0;
@@ -322,99 +315,209 @@ struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
                        if(badorder)
                                break;
                }
-
-               ibuf = IMB_allocImBuf(xsize, ysize, 8 * zsize, IB_rect, 0);
-               if (ibuf->depth > 32) ibuf->depth = 32;
-               base = ibuf->rect;
-               zbase = (unsigned int *)ibuf->zbuf;
-               
-               if (badorder) {
-                       for(z=0; z<zsize; z++) {
+       
+               if (bpp == 1) {
+                       
+                       ibuf = IMB_allocImBuf(xsize, ysize, 8 * zsize, IB_rect);
+                       if (ibuf->depth > 32) ibuf->depth = 32;
+                       base = ibuf->rect;
+                       zbase = (unsigned int *)ibuf->zbuf;
+                       
+                       if (badorder) {
+                               for(z=0; z<zsize; z++) {
+                                       lptr = base;
+                                       for(y=0; y<ysize; y++) {
+                                               file_offset = starttab[y+z*ysize];
+                                               
+                                               rledat = file_data + file_offset;
+                                               file_offset += lengthtab[y+z*ysize];
+                                               
+                                               expandrow((uchar *)lptr, rledat, 3-z);
+                                               lptr += xsize;
+                                       }
+                               }
+                       } else {
                                lptr = base;
+                               zptr = zbase;
                                for(y=0; y<ysize; y++) {
-                                       file_offset = starttab[y+z*ysize];
-                                       
-                                       rledat = file_data + file_offset;
-                                       file_offset += lengthtab[y+z*ysize];
-                                       
-                                       expandrow(lptr, rledat, 3-z);
+                               
+                                       for(z=0; z<zsize; z++) {
+                                               
+                                               file_offset = starttab[y+z*ysize];
+
+                                               rledat = file_data + file_offset;
+                                               file_offset += lengthtab[y+z*ysize];
+                                               
+                                               if(z<4) expandrow((uchar *)lptr, rledat, 3-z);
+                                               else if(z<8) expandrow((uchar *)zptr, rledat, 7-z);
+                                       }
                                        lptr += xsize;
+                                       zptr += xsize;
                                }
                        }
-               }
-               else {
-                       lptr = base;
-                       zptr = zbase;
-                       for(y=0; y<ysize; y++) {
                        
+
+               } else {        /* bpp == 2 */
+                       
+                       ibuf = IMB_allocImBuf(xsize, ysize, 32, (flags & IB_rect)|IB_rectfloat);
+                       
+                       fbase = ibuf->rect_float;
+                       
+                       if (badorder) {
                                for(z=0; z<zsize; z++) {
-                                       
-                                       file_offset = starttab[y+z*ysize];
+                                       fptr = fbase;
+                                       for(y=0; y<ysize; y++) {
+                                               file_offset = starttab[y+z*ysize];
+                                               
+                                               rledat = file_data + file_offset;
+                                               file_offset += lengthtab[y+z*ysize];
+                                               
+                                               expandrow2(fptr, rledat, 3-z);
+                                               fptr += xsize * 4;
+                                       }
+                               }
+                       } else {
+                               fptr = fbase;
 
-                                       rledat = file_data + file_offset;
-                                       file_offset += lengthtab[y+z*ysize];
-                                       
-                                       if(z<4) expandrow(lptr, rledat, 3-z);
-                                       else if(z<8) expandrow(zptr, rledat, 7-z);
+                               for(y=0; y<ysize; y++) {
+                               
+                                       for(z=0; z<zsize; z++) {
+                                               
+                                               file_offset = starttab[y+z*ysize];
+
+                                               rledat = file_data + file_offset;
+                                               file_offset += lengthtab[y+z*ysize];
+                                               
+                                               expandrow2(fptr, rledat, 3-z);
+                                               
+                                       }
+                                       fptr += xsize * 4;
                                }
-                               lptr += xsize;
-                               zptr += xsize;
                        }
                }
                
-               free(starttab);
-               free(lengthtab);
-       } 
-       else {
-       
-               ibuf = IMB_allocImBuf(xsize, ysize, 8 * zsize, IB_rect, 0);
-               if (ibuf->depth > 32) ibuf->depth = 32;
+               MEM_freeN(starttab);
+               MEM_freeN(lengthtab);   
 
-               base = ibuf->rect;
-               zbase = (unsigned int *)ibuf->zbuf;
-               
-               file_offset = 512;
-               rledat = file_data + file_offset;
-               
-               for(z = 0; z < zsize; z++) {
+       } else {
+               if (bpp == 1) {
                        
-                       if(z<4) lptr = base;
-                       else if(z<8) lptr= zbase;
+                       ibuf = IMB_allocImBuf(xsize, ysize, 8 * zsize, IB_rect);
+                       if (ibuf->depth > 32) ibuf->depth = 32;
+
+                       base = ibuf->rect;
+                       zbase = (unsigned int *)ibuf->zbuf;
                        
-                       for(y = 0; y < ysize; y++) {
+                       file_offset = 512;
+                       rledat = file_data + file_offset;
+                       
+                       for(z = 0; z < zsize; z++) {
+                               
+                               if(z<4) lptr = base;
+                               else if(z<8) lptr= zbase;
+                               
+                               for(y = 0; y < ysize; y++) {
 
-                               interleaverow(lptr, rledat, 3-z, xsize);
-                               rledat += xsize;
+                                       interleaverow((uchar *)lptr, rledat, 3-z, xsize);
+                                       rledat += xsize;
+                                       
+                                       lptr += xsize;
+                               }
+                       }
+                       
+               } else {        /* bpp == 2 */
+                       
+                       ibuf = IMB_allocImBuf(xsize, ysize, 32, (flags & IB_rect)|IB_rectfloat);
+
+                       fbase = ibuf->rect_float;
+
+                       file_offset = 512;
+                       rledat = file_data + file_offset;
+                       
+                       for(z = 0; z < zsize; z++) {
+                               
+                               fptr = fbase;
                                
-                               lptr += xsize;
+                               for(y = 0; y < ysize; y++) {
+
+                                       interleaverow2(fptr, rledat, 3-z, xsize);
+                                       rledat += xsize * 2;
+                                       
+                                       fptr += xsize * 4;
+                               }
                        }
+                       
                }
        }
        
-       if (image.zsize == 1){
-               rect = (uchar *) ibuf->rect;
-               for (x = ibuf->x * ibuf->y; x > 0; x--) {
-                       rect[0] = 255;
-                       rect[1] = rect[2] = rect[3];
-                       rect += 4;
+       
+       if (bpp == 1) {
+               uchar * rect;
+               
+               if (image.zsize == 1){
+                       rect = (uchar *) ibuf->rect;
+                       for (x = ibuf->x * ibuf->y; x > 0; x--) {
+                               rect[0] = 255;
+                               rect[1] = rect[2] = rect[3];
+                               rect += 4;
+                       }
+               } else if (image.zsize == 2){
+                       /* grayscale with alpha */
+                       rect = (uchar *) ibuf->rect;
+                       for (x = ibuf->x * ibuf->y; x > 0; x--) {
+                               rect[0] = rect[2];
+                               rect[1] = rect[2] = rect[3];
+                               rect += 4;
+                       }
+               } else if (image.zsize == 3){
+                       /* add alpha */
+                       rect = (uchar *) ibuf->rect;
+                       for (x = ibuf->x * ibuf->y; x > 0; x--) {
+                               rect[0] = 255;
+                               rect += 4;
+                       }
+               }
+               
+       } else {        /* bpp == 2 */
+               
+               if (image.zsize == 1){
+                       fbase = ibuf->rect_float;
+                       for (x = ibuf->x * ibuf->y; x > 0; x--) {
+                               fbase[0] = 1;
+                               fbase[1] = fbase[2] = fbase[3];
+                               fbase += 4;
+                       }
+               } else if (image.zsize == 2){
+                       /* grayscale with alpha */
+                       fbase = ibuf->rect_float;
+                       for (x = ibuf->x * ibuf->y; x > 0; x--) {
+                               fbase[0] = fbase[2];
+                               fbase[1] = fbase[2] = fbase[3];
+                               fbase += 4;
+                       }
+               } else if (image.zsize == 3){
+                       /* add alpha */
+                       fbase = ibuf->rect_float;
+                       for (x = ibuf->x * ibuf->y; x > 0; x--) {
+                               fbase[0] = 1;
+                               fbase += 4;
+                       }
                }
-       } else if (image.zsize == 3){
-               /* alpha toevoegen */
-               rect = (uchar *) ibuf->rect;
-               for (x = ibuf->x * ibuf->y; x > 0; x--) {
-                       rect[0] = 255;
-                       rect += 4;
+               
+               if (flags & IB_rect) {
+                       IMB_rect_from_float(ibuf);
                }
+               
        }
-       
+
        ibuf->ftype = IMAGIC;
-       if (flags & IB_ttob) IMB_flipy(ibuf);
+       ibuf->profile = IB_PROFILE_SRGB;
        
        test_endian_zbuf(ibuf);
        
        if (ibuf) {
                if (ibuf->rect) 
-                       IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
+                       IMB_convert_rgba_to_abgr(ibuf);
        }
 
        return(ibuf);
@@ -423,8 +526,6 @@ struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
 /* static utility functions for longimagedata */
 
 static void interleaverow(unsigned char *lptr, unsigned char *cptr, int z, int n)
-/*  unsigned char *lptr, *cptr; */
-/*  int z, n; */
 {
        lptr += z;
        while(n--) {
@@ -433,56 +534,72 @@ static void interleaverow(unsigned char *lptr, unsigned char *cptr, int z, int n
        }
 }
 
-/* not used? */
-/*static void copybw(int *lptr, int n) */
-/*  int *lptr; */
-/*  int n; */
-/*{
-       while(n>=8) {
-               lptr[0] = 0xff000000+(0x010101*(lptr[0]&0xff));
-               lptr[1] = 0xff000000+(0x010101*(lptr[1]&0xff));
-               lptr[2] = 0xff000000+(0x010101*(lptr[2]&0xff));
-               lptr[3] = 0xff000000+(0x010101*(lptr[3]&0xff));
-               lptr[4] = 0xff000000+(0x010101*(lptr[4]&0xff));
-               lptr[5] = 0xff000000+(0x010101*(lptr[5]&0xff));
-               lptr[6] = 0xff000000+(0x010101*(lptr[6]&0xff));
-               lptr[7] = 0xff000000+(0x010101*(lptr[7]&0xff));
-               lptr += 8;
-               n-=8;
-       }
-       while(n--) {
-               *lptr = 0xff000000+(0x010101*(*lptr&0xff));
-               lptr++;
-       }
-}
-*/
-
-/* not used ? */
-/*static void setalpha(unsigned char *lptr, int n)*/
-/*  unsigned char *lptr; */
-/*{
-       while(n>=8) {
-               lptr[0*4] = 0xff;
-               lptr[1*4] = 0xff;
-               lptr[2*4] = 0xff;
-               lptr[3*4] = 0xff;
-               lptr[4*4] = 0xff;
-               lptr[5*4] = 0xff;
-               lptr[6*4] = 0xff;
-               lptr[7*4] = 0xff;
-               lptr += 4*8;
-               n -= 8;
-       }
+static void interleaverow2(float *lptr, unsigned char *cptr, int z, int n)
+{
+       lptr += z;
        while(n--) {
-               *lptr = 0xff;
+               *lptr = ((cptr[0]<<8) | (cptr[1]<<0)) / (float)0xFFFF;          
+               cptr += 2;
                lptr += 4;
        }
 }
-*/
+
+static void expandrow2(float *optr, unsigned char *iptr, int z)
+{
+       unsigned short pixel, count;
+       float pixel_f;
+
+       optr += z;
+       while(1) {
+               pixel = (iptr[0]<<8) | (iptr[1]<<0);
+               iptr += 2;
+               
+               if ( !(count = (pixel & 0x7f)) )
+                       return;
+               if(pixel & 0x80) {
+                       while(count>=8) {
+                               optr[0*4] = ((iptr[0]<<8) | (iptr[1]<<0))/(float)0xFFFF;
+                               optr[1*4] = ((iptr[2]<<8) | (iptr[3]<<0))/(float)0xFFFF;
+                               optr[2*4] = ((iptr[4]<<8) | (iptr[5]<<0))/(float)0xFFFF;
+                               optr[3*4] = ((iptr[6]<<8) | (iptr[7]<<0))/(float)0xFFFF;
+                               optr[4*4] = ((iptr[8]<<8) | (iptr[9]<<0))/(float)0xFFFF;
+                               optr[5*4] = ((iptr[10]<<8) | (iptr[11]<<0))/(float)0xFFFF;
+                               optr[6*4] = ((iptr[12]<<8) | (iptr[13]<<0))/(float)0xFFFF;
+                               optr[7*4] = ((iptr[14]<<8) | (iptr[15]<<0))/(float)0xFFFF;
+                               optr += 8*4;
+                               iptr += 8*2;
+                               count -= 8;
+                       }
+                       while(count--) {
+                               *optr = ((iptr[0]<<8) | (iptr[1]<<0))/(float)0xFFFF;
+                               iptr+=2;
+                               optr+=4;
+                       }
+               } else {
+                       pixel_f = ((iptr[0]<<8) | (iptr[1]<<0))/(float)0xFFFF;
+                       iptr += 2;
+
+                       while(count>=8) {
+                               optr[0*4] = pixel_f;
+                               optr[1*4] = pixel_f;
+                               optr[2*4] = pixel_f;
+                               optr[3*4] = pixel_f;
+                               optr[4*4] = pixel_f;
+                               optr[5*4] = pixel_f;
+                               optr[6*4] = pixel_f;
+                               optr[7*4] = pixel_f;
+                               optr += 8*4;
+                               count -= 8;
+                       }
+                       while(count--) {
+                               *optr = pixel_f;
+                               optr+=4;
+                       }
+               }
+       }       
+}
 
 static void expandrow(unsigned char *optr, unsigned char *iptr, int z)
-/*  unsigned char *optr, *iptr; */
-/*  int z; */
 {
        unsigned char pixel, count;
 
@@ -544,32 +661,28 @@ static void expandrow(unsigned char *optr, unsigned char *iptr, int z)
  *  Added: zbuf write
  */
 
-static int output_iris(unsigned int *lptr, int xsize, int ysize, int zsize, int file, int *zptr)
+static int output_iris(unsigned int *lptr, int xsize, int ysize, int zsize, const char *name, int *zptr)
 {
        FILE *outf;
        IMAGE *image;
        int tablen, y, z, pos, len = 0;
-       int *starttab, *lengthtab;
+       unsigned int *starttab, *lengthtab;
        unsigned char *rlebuf;
        unsigned int *lumbuf;
        int rlebuflen, goodwrite;
 
        goodwrite = 1;
-       outf = fdopen(file, "wb");
+       outf = fopen(name, "wb");
+       if(!outf) return 0;
 
-       if(!outf) {
-               perror("fdopen");
-               fprintf(stderr,"output_iris: can't open output file\n");
-               return 0;
-       }
        tablen = ysize*zsize*sizeof(int);
 
-       image = (IMAGE *)malloc(sizeof(IMAGE));
-       starttab = (int *)malloc(tablen);
-       lengthtab = (int *)malloc(tablen);
+       image = (IMAGE *)MEM_mallocN(sizeof(IMAGE), "iris image");
+       starttab = (unsigned int *)MEM_mallocN(tablen, "iris starttab");
+       lengthtab = (unsigned int *)MEM_mallocN(tablen, "iris lengthtab");
        rlebuflen = 1.05*xsize+10;
-       rlebuf = (unsigned char *)malloc(rlebuflen);
-       lumbuf = (unsigned int *)malloc(xsize*sizeof(int));
+       rlebuf = (unsigned char *)MEM_mallocN(rlebuflen, "iris rlebuf");
+       lumbuf = (unsigned int *)MEM_mallocN(xsize*sizeof(int), "iris lumbuf");
 
        memset(image, 0, sizeof(IMAGE));
        image->imagic = IMAGIC;
@@ -591,15 +704,15 @@ static int output_iris(unsigned int *lptr, int xsize, int ysize, int zsize, int
                for (z = 0; z < zsize; z++) {
                        
                        if (zsize == 1) {
-                               lumrow(lptr,lumbuf,xsize);
-                               len = compressrow(lumbuf,rlebuf,CHANOFFSET(z),xsize);
+                               lumrow((uchar *)lptr,(uchar *)lumbuf,xsize);
+                               len = compressrow((uchar *)lumbuf,rlebuf,CHANOFFSET(z),xsize);
                        }
                        else {
                                if(z<4) {
-                                       len = compressrow(lptr, rlebuf,CHANOFFSET(z),xsize);
+                                       len = compressrow((uchar *)lptr, rlebuf,CHANOFFSET(z),xsize);
                                }
                                else if(z<8 && zptr) {
-                                       len = compressrow(zptr, rlebuf,CHANOFFSET(z-4),xsize);
+                                       len = compressrow((uchar *)zptr, rlebuf,CHANOFFSET(z-4),xsize);
                                }
                        }
                        if(len>rlebuflen) {
@@ -618,11 +731,11 @@ static int output_iris(unsigned int *lptr, int xsize, int ysize, int zsize, int
        fseek(outf,512,SEEK_SET);
        goodwrite *= writetab(outf,starttab,tablen);
        goodwrite *= writetab(outf,lengthtab,tablen);
-       free(image);
-       free(starttab);
-       free(lengthtab);
-       free(rlebuf);
-       free(lumbuf);
+       MEM_freeN(image);
+       MEM_freeN(starttab);
+       MEM_freeN(lengthtab);
+       MEM_freeN(rlebuf);
+       MEM_freeN(lumbuf);
        fclose(outf);
        if(goodwrite)
                return 1;
@@ -635,8 +748,6 @@ static int output_iris(unsigned int *lptr, int xsize, int ysize, int zsize, int
 /* static utility functions for output_iris */
 
 static void lumrow(unsigned char *rgbptr, unsigned char *lumptr, int n)
-/*  unsigned char *rgbptr, *lumptr; */
-/*  int n; */
 {
        lumptr += CHANOFFSET(0);
        while(n--) {
@@ -647,8 +758,6 @@ static void lumrow(unsigned char *rgbptr, unsigned char *lumptr, int n)
 }
 
 static int compressrow(unsigned char *lbuf, unsigned char *rlebuf, int z, int cnt)
-/*  unsigned char *lbuf, *rlebuf; */
-/*  int z, cnt; */
 {
        unsigned char *iptr, *ibufend, *sptr, *optr;
        short todo, cc;
@@ -706,7 +815,7 @@ static int compressrow(unsigned char *lbuf, unsigned char *rlebuf, int z, int cn
        return optr - (unsigned char *)rlebuf;
 }
 
-short imb_saveiris(struct ImBuf * ibuf, int file, int flags)
+int imb_saveiris(struct ImBuf * ibuf, const char *name, int flags)
 {
        short zsize;
        int ret;
@@ -714,13 +823,13 @@ short imb_saveiris(struct ImBuf * ibuf, int file, int flags)
        zsize = (ibuf->depth + 7) >> 3;
        if (flags & IB_zbuf &&  ibuf->zbuf != 0) zsize = 8;
        
-       IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
+       IMB_convert_rgba_to_abgr(ibuf);
        test_endian_zbuf(ibuf);
 
-       ret = output_iris(ibuf->rect, ibuf->x, ibuf->y, zsize, file, ibuf->zbuf);
+       ret = output_iris(ibuf->rect, ibuf->x, ibuf->y, zsize, name, ibuf->zbuf);
 
        /* restore! Quite clumsy, 2 times a switch... maybe better a malloc ? */
-       IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
+       IMB_convert_rgba_to_abgr(ibuf);
        test_endian_zbuf(ibuf);
 
        return(ret);