Orange branch: OpenEXR finally in Blender!
authorTon Roosendaal <ton@blender.org>
Mon, 9 Jan 2006 00:40:35 +0000 (00:40 +0000)
committerTon Roosendaal <ton@blender.org>
Mon, 9 Jan 2006 00:40:35 +0000 (00:40 +0000)
Credits go to Gernot Ziegler, who originally coded EXR support, and to
Austin  Benesh for bringing it further. Kent Mein provided a lot of code
for integrating float buffers in Blender imbuf and ImBuf API cleanup,
and provided Make and Scons and static linking.

At this moment; the EXR libraries are a *dependency*, so you cannot get
the Orange branch compiled without having OpenEXR installed. Get the
(precompiled or sources) stuff from www.openexr.com. Current default is
that the headers and lib resides in /user/local/

Several changes/additions/fixes were added:

- EXR code only supported 'half' format (16 bits per channel). I've added
  float writing, but for reading it I need tomorrow. :)
- Quite some clumsy copying of data happened in EXR code.
- cleaned up the api calls already a bit, preparing for more advanced
  support
- Zbuffers were saved 16 bits, now 32 bits
- automatic adding of .exr extensions went wrong

Imbuf:

- added proper imbuf->flags and imbuf->mall support for float buffers, it
  was created for *each* imbuf. :)
- found bugs for float buffers in scaling and flipping. Code there will
  need more checks still
- imbuf also needs to be verified to behave properly when no 32 bits
  rect exists (for saving for example)

TODO:

- support internal float images for textures, backbuf, AO probes, and
  display in Image window

Hope this commit won't screwup syncing with bf-blender... :/

53 files changed:
source/blender/SConscript
source/blender/blenkernel/BKE_global.h
source/blender/blenkernel/intern/Makefile
source/blender/blenkernel/intern/image.c
source/blender/blenkernel/intern/writeavi.c
source/blender/blenlib/intern/util.c
source/blender/blenpluginapi/iff.h
source/blender/blenpluginapi/intern/pluginapi.c
source/blender/imbuf/IMB_imbuf.h
source/blender/imbuf/IMB_imbuf_types.h
source/blender/imbuf/SConscript
source/blender/imbuf/intern/IMB_allocimbuf.h
source/blender/imbuf/intern/Makefile
source/blender/imbuf/intern/allocimbuf.c
source/blender/imbuf/intern/amiga.c
source/blender/imbuf/intern/anim.c
source/blender/imbuf/intern/anim5.c
source/blender/imbuf/intern/bitplanes.c
source/blender/imbuf/intern/divers.c
source/blender/imbuf/intern/filter.c
source/blender/imbuf/intern/imageprocess.c
source/blender/imbuf/intern/iris.c
source/blender/imbuf/intern/jpeg.c
source/blender/imbuf/intern/openexr/Makefile [new file with mode: 0644]
source/blender/imbuf/intern/openexr/SConscript [new file with mode: 0644]
source/blender/imbuf/intern/openexr/openexr_api.cpp [new file with mode: 0644]
source/blender/imbuf/intern/openexr/openexr_api.h [new file with mode: 0644]
source/blender/imbuf/intern/radiance_hdr.c
source/blender/imbuf/intern/readimage.c
source/blender/imbuf/intern/rectop.c
source/blender/imbuf/intern/rotate.c
source/blender/imbuf/intern/scaling.c
source/blender/imbuf/intern/targa.c
source/blender/imbuf/intern/tiff.c
source/blender/imbuf/intern/util.c
source/blender/imbuf/intern/writeimage.c
source/blender/include/butspace.h
source/blender/makesdna/DNA_scene_types.h
source/blender/render/intern/source/envmap.c
source/blender/render/intern/source/initrender.c
source/blender/src/Makefile
source/blender/src/buttons_scene.c
source/blender/src/editface.c
source/blender/src/editmesh_mods.c
source/blender/src/filesel.c
source/blender/src/imasel.c
source/blender/src/interface_icons.c
source/blender/src/screendump.c
source/blender/src/sequence.c
source/blender/src/toets.c
source/blender/src/vpaint.c
source/blender/src/writeimage.c
source/blender/src/writemovie.c

index c40b8422a33b99055c07a8f028a3f4994df3b15e..1c21399b838b4a5c5ef7a52ec9dc7c4a7c3ead35 100644 (file)
@@ -17,6 +17,9 @@ SConscript(['avi/SConscript',
             'src/SConscript',
             'yafray/SConscript'])
 
+if user_options_dict['USE_OPENEXR'] == 1:
+    SConscript (['imbuf/intern/openexr/SConscript'])
+
 if user_options_dict['USE_INTERNATIONAL'] == 1:
     SConscript (['ftfont/SConscript'])
 
index 6ecd36269939241c4ff462b911cc0c9eb31d71be..bef63bfa2617a4f996e0dffc2bc5a6ead92077b3 100644 (file)
@@ -124,7 +124,7 @@ typedef struct Global {
        struct VFont *selfont;
        struct ListBase ttfdata;
 
-       /* libtiff flag */
+       /* libtiff flag used to determine if shared library loaded for libtiff*/
        int have_libtiff;
 
        /* this variable is written to / read from FileGlobal->fileflags */
index 9207023f9a521b442b4aace158385d9fb3018eb2..1bdeda1841f5217096ef97ca8e9c0ce80dc2daac 100644 (file)
@@ -83,3 +83,7 @@ ifeq ($(WITH_FREETYPE2), true)
     CPPFLAGS += -I$(NAN_FREETYPE)/include/freetype2
 endif
 
+ifeq ($(WITH_OPENEXR), true)
+    CPPFLAGS += -DWITH_OPENEXR
+endif
+
index fa4136d63fac2aa5419b23ef475cd481419b3e24..267114952525f199ede86b5a1a8c11cd44345687 100644 (file)
@@ -341,8 +341,15 @@ void addImageExtension(char *string)
                        extension= ".bmp";
        }
        else if(G.have_libtiff && (G.scene->r.imtype==R_TIFF)) {
-               extension= ".tif";
+               if(!BLI_testextensie(string, ".tif"))
+                       extension= ".tif";
        }
+#ifdef WITH_OPENEXR
+       else if(G.scene->r.imtype==R_OPENEXR) {
+               if(!BLI_testextensie(string, ".exr"))
+                       extension= ".exr";
+       }
+#endif
        
        strcat(string, extension);
 }
@@ -449,13 +456,13 @@ static void de_interlace_ng(struct ImBuf *ibuf)   /* neogeo fields */
                tbuf2 = IMB_allocImBuf(ibuf->x, (short)(ibuf->y >> 1), (unsigned char)32, (int)IB_rect, (unsigned char)0);
                
                ibuf->x *= 2;
-               /* These rectop calls are broken!!! I added a trailing 0 arg... */
-               IMB_rectop(tbuf1, ibuf, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
-               IMB_rectop(tbuf2, ibuf, 0, 0, tbuf2->x, 0, 32767, 32767, IMB_rectcpy, 0);
+               
+               IMB_rectcpy(tbuf1, ibuf, 0, 0, 0, 0, ibuf->x, ibuf->y);
+               IMB_rectcpy(tbuf2, ibuf, 0, 0, tbuf2->x, 0, ibuf->x, ibuf->y);
                
                ibuf->x /= 2;
-               IMB_rectop(ibuf, tbuf1, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
-               IMB_rectop(ibuf, tbuf2, 0, tbuf2->y, 0, 0, 32767, 32767, IMB_rectcpy, 0);
+               IMB_rectcpy(ibuf, tbuf1, 0, 0, 0, 0, tbuf1->x, tbuf1->y);
+               IMB_rectcpy(ibuf, tbuf2, 0, tbuf2->y, 0, 0, tbuf2->x, tbuf2->y);
                
                IMB_freeImBuf(tbuf1);
                IMB_freeImBuf(tbuf2);
@@ -477,13 +484,13 @@ static void de_interlace_st(struct ImBuf *ibuf)   /* standard fields */
                tbuf2 = IMB_allocImBuf(ibuf->x, (short)(ibuf->y >> 1), (unsigned char)32, IB_rect, 0);
                
                ibuf->x *= 2;
-               /* These are brolenm as well... */
-               IMB_rectop(tbuf1, ibuf, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
-               IMB_rectop(tbuf2, ibuf, 0, 0, tbuf2->x, 0, 32767, 32767, IMB_rectcpy, 0);
+               
+               IMB_rectcpy(tbuf1, ibuf, 0, 0, 0, 0, ibuf->x, ibuf->y);
+               IMB_rectcpy(tbuf2, ibuf, 0, 0, tbuf2->x, 0, ibuf->x, ibuf->y);
                
                ibuf->x /= 2;
-               IMB_rectop(ibuf, tbuf2, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
-               IMB_rectop(ibuf, tbuf1, 0, tbuf2->y, 0, 0, 32767, 32767, IMB_rectcpy, 0);
+               IMB_rectcpy(ibuf, tbuf2, 0, 0, 0, 0, tbuf2->x, tbuf2->y);
+               IMB_rectcpy(ibuf, tbuf1, 0, tbuf2->y, 0, 0, tbuf1->x, tbuf1->y);
                
                IMB_freeImBuf(tbuf1);
                IMB_freeImBuf(tbuf2);
@@ -559,7 +566,7 @@ void ima_ibuf_is_nul(Tex *tex, Image *ima)
                                }
                                
                                IMB_applycmap(ima->ibuf);
-                               IMB_convert_rgba_to_abgr(ima->ibuf->x*ima->ibuf->y, ima->ibuf->rect);
+                               IMB_convert_rgba_to_abgr(ima->ibuf);
                                
                        }
                        
index 77c35cc46abc1744173507f91dc00f0638a57472..35f5c7b0d17f444f97b7fa248fdff69f62d2c864 100644 (file)
 
 #include <string.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include "MEM_guardedalloc.h"
 #include "BLI_blenlib.h"
 
@@ -122,7 +118,8 @@ void start_avi(void)
 
 void append_avi(int frame)
 {
-       unsigned int *rt1, *rt2, *temp;
+       unsigned int *rt1, *rt2;
+       struct ImBuf *temp;
        int y;
 
        if (avi == NULL) {
@@ -130,20 +127,20 @@ void append_avi(int frame)
                return;
        }
 
-               /* note that libavi free's the buffer... stupid interface - zr */
-       temp = MEM_mallocN(R.rectx*R.recty*4, "append_avi buf");
+       /* note that libavi free's the buffer... stupid interface - zr */
+       temp = IMB_allocImBuf(R.rectx,R.recty*4,32, IB_rect, 0);
 
-       rt1= temp;
+       rt1= temp->rect;
        rt2= R.rectot + (R.recty-1)*R.rectx;
        for (y=0; y < R.recty; y++, rt1+= R.rectx, rt2-= R.rectx) {
                memcpy (rt1, rt2, R.rectx*4);
        }
 
-       IMB_convert_rgba_to_abgr(R.rectx*R.recty, temp);
+       IMB_convert_rgba_to_abgr(temp);
        
-       AVI_write_frame (avi, (frame-sframe), AVI_FORMAT_RGB32, 
-                                                                               temp, R.rectx*R.recty*4);
+       AVI_write_frame (avi, (frame-sframe), AVI_FORMAT_RGB32, temp->rect, R.rectx*R.recty*4);
        printf ("added frame %3d (frame %3d in avi): ", frame, frame-sframe);
+       IMB_freeImBuf(temp);
 }
 
 void end_avi(void)
index 45ff6e83f1b740eca87c63070fe18f003b45a058..3e679cfc2324ec50885b01f65e1aa5c8f57d664b 100644 (file)
@@ -139,6 +139,7 @@ int BLI_stringdec(char *string, char *kop, char *staart, unsigned short *numlen)
                        else if (BLI_strncasecmp(string + len - 4, ".rgb", 4) == 0) len -= 4;
                        else if (BLI_strncasecmp(string + len - 4, ".psx", 4) == 0) len -= 4;
                        else if (BLI_strncasecmp(string + len - 4, ".ble", 4) == 0) len -= 4;
+                       else if (BLI_strncasecmp(string + len - 4, ".exr", 4) == 0) len -= 4;
                }
        }
        
index 4fa3e0214fa7fde5658f3939b963a459243a936c..456291e664bcbe02fa894eea3bc3326aa5849d7e 100644 (file)
 #define IB_zbuf                        (1 << 13)
 #define IB_rgba                        (1 << 14)
 
-#define AMI        (1 << 31)
-#define Anim   (1 << 29)
-#define TGA        (1 << 28)
-#define JPG            (1 << 27)
+#define AMI             (1 << 31)
+#define PNG             (1 << 30)
+#define Anim            (1 << 29)
+#define TGA             (1 << 28)
+#define JPG             (1 << 27)
+#define BMP             (1 << 26)
+#ifdef WITH_QUICKTIME
+#define QUICKTIME       (1 << 25)
+#endif
+#define RADHDR  (1<<24)
 
 #define RAWTGA (TGA | 1)
 
@@ -90,6 +96,7 @@
 #define IS_amiga(x)            (x->ftype & AMI)
 #define IS_ham(x)              ((x->ftype & AM_ham) == AM_ham)
 #define IS_hbrite(x)   ((x->ftype & AM_hbrite) == AM_hbrite)
+
 #define IS_lace(x)             ((x->ftype & AM_lace) == AM_lace)
 #define IS_hires(x)            ((x->ftype & AM_hires) == AM_hires)
 #define IS_hblace(x)   ((x->ftype & AM_hblace) == AM_hblace)
 
 #define IS_anim(x)             (x->ftype & Anim)
 #define IS_hamx(x)             (x->ftype == AN_hamx)
-
 #define IS_tga(x)              (x->ftype & TGA)
+#define IS_png(x)               (x->ftype & PNG)
+#define IS_bmp(x)               (x->ftype & BMP)
+#define IS_radhdr(x)           (x->ftype & RADHDR)
 #define IS_tim(x)              (x->ftype & TIM)
+#define IS_tiff(x)             (x->ftype & TIFF)
+#define IS_openexr(x)           (x->ftype & OPENEXR)
+
 
 #define IMAGIC         0732
 #define IS_iris(x)             (x->ftype == IMAGIC)
@@ -136,6 +148,7 @@ typedef struct ImBuf{
        unsigned char *encodedbuffer;
        unsigned int   encodedsize;
        unsigned int   encodedbuffersize;
+       float *rect_float;
 } ImBuf;
 
 extern struct ImBuf *allocImBuf(short,short,uchar,uint,uchar);
index aefd8d3f4585cf52b6bb58483e149f5c34768717..bb64e9caa8fa714396b2024d66154df6dcf2b9ca 100644 (file)
  * - util.h       : Useful defines, memory management.
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #ifdef WIN32
 #include "blenpluginapi\util.h"
 #else
@@ -250,20 +246,6 @@ void de_interlace(struct ImBuf *ib)
        IMB_de_interlace(ib);
 }
 
-void rectop(struct ImBuf *dbuf,
-                       struct ImBuf *sbuf,
-                       int destx,
-                       int desty,
-                       int srcx,
-                       int srcy,
-                       int width,
-                       int height,
-                       void (*operation)(unsigned int *, unsigned int*, int, int),
-                       int value)
-{
-       IMB_rectop(dbuf, sbuf, destx, desty, srcx, srcy, width, height, operation, value);
-}
-
 /* -------------------------------------------------------------------------- */
 /* stuff from plugin.h                                                        */ 
 /* -------------------------------------------------------------------------- */
@@ -354,6 +336,5 @@ int pluginapi_force_ref(void)
                (int) turbulence1 +
                (int) de_interlace +
                (int) interlace +
-               (int) gamwarp +
-               (int) rectop;
+               (int) gamwarp;
 }
index b631ac79a06f721e9b288ce287a8715c6b048972..aa69e680c355b553ecbde150dfe6edf968a3569a 100644 (file)
@@ -196,31 +196,8 @@ void IMB_freecmapImBuf(struct ImBuf * ibuf);
  *
  * @attention Defined in rectop.c
  */
-void IMB_rectop(struct ImBuf *dbuf,
-                       struct ImBuf *sbuf,
-                       int destx,
-                       int desty,
-                       int srcx,
-                       int srcy,
-                       int width,
-                       int height,
-                       void (*operation)(unsigned int *, unsigned int*, int, int),
-                       int value);
-
-/**
- *
- * @attention Defined in rectop.c
- */
-void IMB_rectoptot(struct ImBuf *dbuf,
-                          struct ImBuf *sbuf,
-                          void (*operation)(unsigned int *, unsigned int*, int, int),
-                          int value);
-
-/**
- *
- * @attention Defined in rectop.c
- */
-void IMB_rectcpy(unsigned int *drect, unsigned int *srect, int x, int dummy);
+void IMB_rectcpy(struct ImBuf *drect, struct ImBuf *srect, int destx,
+       int desty, int srcx, int srcy, int width, int height);
 
 /**
  * Return the length (in frames) of the given @a anim.
@@ -360,7 +337,7 @@ void IMB_gamwarp(struct ImBuf *ibuf, double gamma);
  *
  * @attention Defined in imageprocess.c
  */
-void IMB_convert_rgba_to_abgr(int size, unsigned int *rect);
+void IMB_convert_rgba_to_abgr(struct ImBuf *ibuf);
 
 /**
  * Change the ordering of the colour bytes pointed to by rect from
@@ -495,7 +472,7 @@ void IMB_freezbufImBuf(struct ImBuf * ibuf);
  *
  * @attention Defined in rectop.c
  */
-void IMB_rectfill(unsigned int *drect, unsigned int *srect, int x, int value);
+void IMB_rectfill(struct ImBuf *drect, float col[4]);
 
 
 #ifdef WITH_QUICKTIME
@@ -513,12 +490,6 @@ void quicktime_exit(void);
 
 #endif //WITH_QUICKTIME
 
-/* radhdr: Temporary routine to save directly from render floatbuffer.
-   Defined in radiance_hdr.c
-   Called by schrijfplaatje() in toets.c */
-short imb_savehdr_fromfloat(float *fbuf, char *name, int width, int height);
-
-
 /* intern/dynlibtiff.c */
 void libtiff_exit(void);
 
index 56a28850e71ce0986be08689bae9cf710cfe28a9..4f648031fc69978f3d1944c89772e800992204d3 100644 (file)
@@ -93,6 +93,7 @@ typedef struct ImBuf{
        unsigned char *encodedbuffer;     /**< Compressed image only used with png currently */
        unsigned int   encodedsize;       /**< Size of data written to encodedbuffer */
        unsigned int   encodedbuffersize; /**< Size of encodedbuffer */
+       float *rect_float;              /**< floating point Rect equivilant */
 } ImBuf;
 
 /* Moved from BKE_bmfont_types.h because it is a userflag bit mask. */
@@ -131,6 +132,8 @@ typedef enum {
 #define IB_zbuf                        (1 << 13)
 
 #define IB_mem                 (1 << 14)
+#define IB_rectfloat   (1 << 15)
+
 /**@}*/
 
 /** \name imbuf_formats Image file formats
@@ -141,17 +144,20 @@ typedef enum {
  *
  * The bit flag is stored in the ImBuf.ftype variable.
  */
-#define AMI            (1 << 31)
-#define PNG            (1 << 30)
+#define AMI                            (1 << 31)
+#define PNG                            (1 << 30)
 #define Anim           (1 << 29)
-#define TGA            (1 << 28)
-#define JPG            (1 << 27)
-#define BMP            (1 << 26)
+#define TGA                            (1 << 28)
+#define JPG                            (1 << 27)
+#define BMP                            (1 << 26)
+
 #ifdef WITH_QUICKTIME
-#define QUICKTIME      (1 << 25)
+#define QUICKTIME              (1 << 25)
 #endif
-#define RADHDR         (1<<24)
-#define TIF            (1<<23)
+
+#define RADHDR                 (1 << 24)
+#define TIF                            (1 << 23)
+#define OPENEXR                        (1 << 22)
 
 #define RAWTGA         (TGA | 1)
 
@@ -188,6 +194,7 @@ typedef enum {
 #define IS_hamx(x)             (x->ftype == AN_hamx)
 #define IS_tga(x)              (x->ftype & TGA)
 #define IS_png(x)              (x->ftype & PNG)
+#define IS_openexr(x)  (x->ftype & OPENEXR)
 #define IS_bmp(x)              (x->ftype & BMP)
 #define IS_tiff(x)             (x->ftype & TIF)
 #define IS_radhdr(x)   (x->ftype & RADHDR)
index c4146b6450a2f7e33c9c6662ade4b2b1afb1f691..c73c0593a863fc4fe26ccb197740d76f3927e440 100644 (file)
@@ -5,6 +5,9 @@ Import ('library_env')
 
 imbuf_env = library_env.Copy ()
 
+#if user_options_dict['USE_OPENEXR'] == 1:
+#    SConscript (['intern/openexr/SConscript'])
+
 source_files = ['intern/allocimbuf.c',
                 'intern/amiga.c',
                 'intern/anim.c',
index c01c9d60dd79aaab1354519121e3fc5e0b39ad5d..7ff44ef29f9ef0f13a09b733a81755b732faba71 100644 (file)
 struct ImBuf;
 
 short imb_addrectImBuf(struct ImBuf * ibuf);
+short imb_addrectfloatImBuf(struct ImBuf * ibuf);
 short imb_addplanesImBuf(struct ImBuf *ibuf);
 
 short imb_addencodedbufferImBuf(struct ImBuf *ibuf);
 short imb_enlargeencodedbufferImBuf(struct ImBuf *ibuf);
 
 void imb_freerectImBuf(struct ImBuf *ibuf);
+void imb_freerectfloatImBuf(struct ImBuf *ibuf);
 void imb_freeplanesImBuf(struct ImBuf *ibuf);
 
 short imb_addcmapImBuf(struct ImBuf *ibuf);
index 859f7c4cd3466bbaac1b96f9644f62bc36794561..839bb4df4c33df816aac74b49db070b18b1caa66 100644 (file)
 
 LIBNAME = imbuf
 DIR = $(OCGDIR)/blender/imbuf
+SOURCEDIR = source/blender/imbuf/intern
 
+include nan_subdirs.mk
 include nan_compile.mk
+include nan_definitions.mk
+
+ifeq ($(WITH_OPENEXR), true)
+    DIRS = openexr
+endif
+
 
 ifeq ($(OS),$(findstring $(OS), "beos darwin freebsd linux openbsd solaris windows"))
     CFLAGS += -funsigned-char
 endif
 
+ifeq ($(WITH_OPENEXR), true)
+    CFLAGS += -DWITH_OPENEXR
+endif
+
 CFLAGS += $(LEVEL_1_C_WARNINGS)
 
 CPPFLAGS += -I$(NAN_JPEG)/include
index 3178e15ffeec144899a870e83474e2f62b92770e..8344e9753a2d088a39c669f0c01dc4f8872e4245 100644 (file)
@@ -53,30 +53,48 @@ static unsigned int dfltcmap[16] = {
 
 void imb_freeplanesImBuf(struct ImBuf * ibuf)
 {
-       if (ibuf==0) return;
+       if (ibuf==NULL) return;
        if (ibuf->planes){
-               if (ibuf->mall & IB_planes) free(ibuf->planes);
+               if (ibuf->mall & IB_planes) MEM_freeN(ibuf->planes);
        }
        ibuf->planes = 0;
        ibuf->mall &= ~IB_planes;
 }
 
+void imb_freerectfloatImBuf(struct ImBuf * ibuf)
+{
+       if (ibuf==NULL) return;
+       
+       if (ibuf->rect_float) {
+               if (ibuf->mall & IB_rectfloat) {
+                       MEM_freeN(ibuf->rect_float);
+                       ibuf->rect_float=NULL;
+               }
+       }
+
+       ibuf->rect_float= NULL;
+       ibuf->mall &= ~IB_rectfloat;
+}
 
 void imb_freerectImBuf(struct ImBuf * ibuf)
 {
-       if (ibuf==0) return;
-       if (ibuf->rect){
-               if (ibuf->mall & IB_rect) free(ibuf->rect);
+       if (ibuf==NULL) return;
+       
+       if (ibuf->rect) {
+               if (ibuf->mall & IB_rect) {
+                       MEM_freeN(ibuf->rect);
+               }
        }
-       ibuf->rect=0;
+       
+       ibuf->rect= NULL;
        ibuf->mall &= ~IB_rect;
 }
 
 static void freeencodedbufferImBuf(struct ImBuf * ibuf)
 {
-       if (ibuf==0) return;
+       if (ibuf==NULL) return;
        if (ibuf->encodedbuffer){
-               if (ibuf->mall & IB_mem) free(ibuf->encodedbuffer);
+               if (ibuf->mall & IB_mem) MEM_freeN(ibuf->encodedbuffer);
        }
        ibuf->encodedbuffer = 0;
        ibuf->encodedbuffersize = 0;
@@ -86,34 +104,34 @@ static void freeencodedbufferImBuf(struct ImBuf * ibuf)
 
 void IMB_freezbufImBuf(struct ImBuf * ibuf)
 {
-       if (ibuf==0) return;
+       if (ibuf==NULL) return;
        if (ibuf->zbuf){
-               if (ibuf->mall & IB_zbuf) free(ibuf->zbuf);
+               if (ibuf->mall & IB_zbuf) MEM_freeN(ibuf->zbuf);
        }
-       ibuf->zbuf=0;
+       ibuf->zbuf= NULL;
        ibuf->mall &= ~IB_zbuf;
 }
 
 void IMB_freecmapImBuf(struct ImBuf * ibuf)
 {
-       if (ibuf == 0) return;
+       if (ibuf==NULL) return;
        if (ibuf->cmap){
-               if (ibuf->mall & IB_cmap) free(ibuf->cmap);
+               if (ibuf->mall & IB_cmap) MEM_freeN(ibuf->cmap);
        }
        ibuf->cmap = 0;
        ibuf->mall &= ~IB_cmap;
 }
 
-
 void IMB_freeImBuf(struct ImBuf * ibuf)
 {
        if (ibuf){
                imb_freeplanesImBuf(ibuf);
                imb_freerectImBuf(ibuf);
+               imb_freerectfloatImBuf(ibuf);
                IMB_freezbufImBuf(ibuf);
                IMB_freecmapImBuf(ibuf);
                freeencodedbufferImBuf(ibuf);
-               free(ibuf);
+               MEM_freeN(ibuf);
        }
 }
 
@@ -121,7 +139,8 @@ short addzbufImBuf(struct ImBuf * ibuf)
 {
        int size;
 
-       if (ibuf==0) return(FALSE);
+       if (ibuf==NULL) return(FALSE);
+       
        IMB_freezbufImBuf(ibuf);
 
        size = ibuf->x * ibuf->y * sizeof(unsigned int);
@@ -136,7 +155,7 @@ short addzbufImBuf(struct ImBuf * ibuf)
 
 short imb_addencodedbufferImBuf(struct ImBuf * ibuf)
 {
-       if (ibuf==0) return(FALSE);
+       if (ibuf==NULL) return(FALSE);
 
        freeencodedbufferImBuf(ibuf);
 
@@ -159,7 +178,7 @@ short imb_enlargeencodedbufferImBuf(struct ImBuf * ibuf)
        unsigned int newsize, encodedsize;
        void *newbuffer;
 
-       if (ibuf==0) return(FALSE);
+       if (ibuf==NULL) return(FALSE);
 
        if (ibuf->encodedbuffersize < ibuf->encodedsize) {
                printf("imb_enlargeencodedbufferImBuf: error in parameters\n");
@@ -190,15 +209,36 @@ short imb_enlargeencodedbufferImBuf(struct ImBuf * ibuf)
        return (TRUE);
 }
 
+short imb_addrectfloatImBuf(struct ImBuf * ibuf)
+{
+       int size;
+       
+       if (ibuf==NULL) return(FALSE);
+       
+       imb_freerectfloatImBuf(ibuf);
+       
+       size = ibuf->x * ibuf->y;
+       size = size * 4 * sizeof(float);
+       
+       if ( (ibuf->rect_float = MEM_mallocN(size, "imb_addrectImBuf")) ){
+               ibuf->mall |= IB_rectfloat;
+               return (TRUE);
+       }
+       
+       return (FALSE);
+}
 
+/* question; why also add zbuf? */
 short imb_addrectImBuf(struct ImBuf * ibuf)
 {
        int size;
 
-       if (ibuf==0) return(FALSE);
+       if (ibuf==NULL) return(FALSE);
        imb_freerectImBuf(ibuf);
 
-       size = ibuf->x * ibuf->y * sizeof(unsigned int);
+       size = ibuf->x * ibuf->y;
+       size = size * sizeof(unsigned int);
+
        if ( (ibuf->rect = MEM_mallocN(size, "imb_addrectImBuf")) ){
                ibuf->mall |= IB_rect;
                if (ibuf->depth > 32) return (addzbufImBuf(ibuf));
@@ -213,7 +253,7 @@ short imb_addcmapImBuf(struct ImBuf *ibuf)
 {
        int min;
        
-       if (ibuf==0) return(FALSE);
+       if (ibuf==NULL) return(FALSE);
        IMB_freecmapImBuf(ibuf);
 
        imb_checkncols(ibuf);
@@ -238,7 +278,7 @@ short imb_addplanesImBuf(struct ImBuf *ibuf)
        unsigned int **planes;
        unsigned int *point2;
 
-       if (ibuf==0) return(FALSE);
+       if (ibuf==NULL) return(FALSE);
        imb_freeplanesImBuf(ibuf);
 
        skipx = ((ibuf->x+31) >> 5);
@@ -264,7 +304,7 @@ short imb_addplanesImBuf(struct ImBuf *ibuf)
 }
 
 
-struct ImBuf *IMB_allocImBuf(short x,short y,uchar d,unsigned int flags,uchar bitmap)
+struct ImBuf *IMB_allocImBuf(short x, short y, uchar d, unsigned int flags, uchar bitmap)
 {
        struct ImBuf *ibuf;
 
@@ -272,29 +312,36 @@ struct ImBuf *IMB_allocImBuf(short x,short y,uchar d,unsigned int flags,uchar bi
        if (bitmap) flags |= IB_planes;
 
        if (ibuf){
-               ibuf->x=x;
-               ibuf->y=y;
-               ibuf->depth=d;
-               ibuf->ftype=TGA;
+               ibuf->x= x;
+               ibuf->y= y;
+               ibuf->depth= d;
+               ibuf->ftype= TGA;
 
                if (flags & IB_rect){
                        if (imb_addrectImBuf(ibuf)==FALSE){
                                IMB_freeImBuf(ibuf);
-                               return (0);
+                               return NULL;
+                       }
+               }
+               
+               if (flags & IB_rectfloat){
+                       if (imb_addrectfloatImBuf(ibuf)==FALSE){
+                               IMB_freeImBuf(ibuf);
+                               return NULL;
                        }
                }
                
                if (flags & IB_zbuf){
                        if (addzbufImBuf(ibuf)==FALSE){
                                IMB_freeImBuf(ibuf);
-                               return (0);
+                               return NULL;
                        }
                }
                
                if (flags & IB_planes){
                        if (imb_addplanesImBuf(ibuf)==FALSE){
                                IMB_freeImBuf(ibuf);
-                               return (0);
+                               return NULL;
                        }
                }
        }
@@ -307,9 +354,10 @@ struct ImBuf *IMB_dupImBuf(struct ImBuf *ibuf1)
        int flags = 0;
        int x, y;
        
-       if (ibuf1 == 0) return (0);
+       if (ibuf1 == NULL) return NULL;
 
        if (ibuf1->rect) flags |= IB_rect;
+       if (ibuf1->rect_float) flags |= IB_rectfloat;
        if (ibuf1->planes) flags |= IB_planes;
 
        x = ibuf1->x;
@@ -317,31 +365,38 @@ struct ImBuf *IMB_dupImBuf(struct ImBuf *ibuf1)
        if (ibuf1->flags & IB_fields) y *= 2;
        
        ibuf2 = IMB_allocImBuf(x, y, ibuf1->depth, flags, 0);
-       if (ibuf2 == 0) return (0);
+       if (ibuf2 == NULL) return NULL;
 
-       if (flags & IB_rect) memcpy(ibuf2->rect,ibuf1->rect,x * y * sizeof(int));
-       if (flags & IB_planes) memcpy(*(ibuf2->planes),*(ibuf1->planes),ibuf1->depth * ibuf1->skipx * y * sizeof(int));
+       if (flags & IB_rect)
+               memcpy(ibuf2->rect, ibuf1->rect, x * y * sizeof(int));
+       
+       if (flags & IB_rectfloat)
+               memcpy(ibuf2->rect_float, ibuf1->rect_float, x * y * sizeof(float));
+
+       if (flags & IB_planes) 
+               memcpy(*(ibuf2->planes),*(ibuf1->planes),ibuf1->depth * ibuf1->skipx * y * sizeof(int));
 
        if (ibuf1->encodedbuffer) {
                ibuf2->encodedbuffersize = ibuf1->encodedbuffersize;
                if (imb_addencodedbufferImBuf(ibuf2) == FALSE) {
                        IMB_freeImBuf(ibuf2);
-                       return(0);
+                       return NULL;
                }
 
                memcpy(ibuf2->encodedbuffer, ibuf1->encodedbuffer, ibuf1->encodedsize);
        }
 
-
+       /* silly trick to copy the entire contents of ibuf1 struct over to ibuf */
        tbuf = *ibuf1;
        
-       // pointers goedzetten
+       // fix pointers 
        tbuf.rect               = ibuf2->rect;
+       tbuf.rect_float = ibuf2->rect_float;
        tbuf.planes             = ibuf2->planes;
        tbuf.cmap               = ibuf2->cmap;
        tbuf.encodedbuffer = ibuf2->encodedbuffer;
        
-       // malloc flag goed zetten
+       // set malloc flag
        tbuf.mall               = ibuf2->mall;
        
        *ibuf2 = tbuf;
index 20655b3a21157abaa4f13a714f1c2d9954bd1576..d0b794c23ecd5afe447e1a27b7a2153e997c84f8 100644 (file)
@@ -531,7 +531,7 @@ struct ImBuf *imb_loadamiga(int *iffmem,int flags)
 
        if (ibuf) {
                if (ibuf->rect) 
-                       if (G.order == B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
+                       if (G.order == B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf);
        }
        
        return (ibuf);
index 284339ece4824a659cf0a95e976b7a98b856ff2b..51fadc5c06accb490fb2680be23de868f231fb6a 100644 (file)
@@ -572,7 +572,7 @@ struct ImBuf * IMB_anim_absolute(struct anim * anim, int position) {
                ibuf = movie_fetchibuf(anim, position);
                if (ibuf) {
                        anim->curposition = position;
-                       IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
+                       IMB_convert_rgba_to_abgr(ibuf);
                }
                break;
        case ANIM_AVI:
index 9f87ba09f5f1ee9def628e4f26d04fdb1342fd0d..89ddf177efe79843b3d40a15f9da6840fa726635 100644 (file)
@@ -161,7 +161,7 @@ static void planes_to_rect(struct ImBuf * ibuf, int flags) {
                if (ibuf->cmap){
                        if ((flags & IB_cmap) == 0) {
                                IMB_applycmap(ibuf);
-                               IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
+                               IMB_convert_rgba_to_abgr(ibuf);
                        }
                } else if (ibuf->depth == 18){
                        int i,col;
index 6bc2155c9492cb8cc781f7edb171403e28a1c0ff..b80e829da08092c242b2773bdfa79213a6f07834 100644 (file)
@@ -178,6 +178,8 @@ void imb_bptolong(struct ImBuf *ibuf)
 {
        int nobp,i,x;
        unsigned int *rect,offset;
+       float black[4] = {0.0,0.0,0.0,1.0};
+       float clear[4] = {0.0,0.0,0.0,0.0};
 
        /* first clear all ints */
 
@@ -187,8 +189,8 @@ void imb_bptolong(struct ImBuf *ibuf)
 
        nobp=ibuf->depth;
        if (nobp != 32){
-               if (nobp == 24) IMB_rectoptot(ibuf, 0, IMB_rectfill, 0xff000000); /* set alpha */
-               else IMB_rectoptot(ibuf, 0, IMB_rectfill, 0);
+               if (nobp == 24) IMB_rectfill(ibuf, black); /* set alpha */
+               else IMB_rectfill(ibuf, clear);
        }
 
        rect= ibuf->rect;
index 8c5791566915a1fc07251c06d3c3a443f0749a55..a56f16f71dbf3af5a651cd8a68f1658f6e7083a5 100644 (file)
@@ -95,12 +95,12 @@ void IMB_de_interlace(struct ImBuf *ibuf)
                tbuf2 = IMB_allocImBuf(ibuf->x, ibuf->y / 2, 32, IB_rect, 0);
                
                ibuf->x *= 2;   
-               IMB_rectop(tbuf1, ibuf, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
-               IMB_rectop(tbuf2, ibuf, 0, 0, tbuf2->x, 0, 32767, 32767, IMB_rectcpy, 0);
+               IMB_rectcpy(tbuf1, ibuf, 0, 0, 0, 0, ibuf->x, ibuf->y);
+               IMB_rectcpy(tbuf2, ibuf, 0, 0, tbuf2->x, 0, ibuf->x, ibuf->y);
        
                ibuf->x /= 2;
-               IMB_rectop(ibuf, tbuf1, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
-               IMB_rectop(ibuf, tbuf2, 0, tbuf2->y, 0, 0, 32767, 32767, IMB_rectcpy, 0);
+               IMB_rectcpy(ibuf, tbuf1, 0, 0, 0, 0, tbuf1->x, tbuf1->y);
+               IMB_rectcpy(ibuf, tbuf2, 0, tbuf2->y, 0, 0, tbuf2->x, tbuf2->y);
                
                IMB_freeImBuf(tbuf1);
                IMB_freeImBuf(tbuf2);
@@ -122,16 +122,12 @@ void IMB_interlace(struct ImBuf *ibuf)
                tbuf1 = IMB_allocImBuf(ibuf->x, ibuf->y / 2, 32, IB_rect, 0);
                tbuf2 = IMB_allocImBuf(ibuf->x, ibuf->y / 2, 32, IB_rect, 0);
 
-               IMB_rectop(tbuf1, ibuf, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 
-                       0);
-               IMB_rectop(tbuf2, ibuf, 0, 0, 0, tbuf2->y, 32767, 32767,
-                       IMB_rectcpy,0);
+               IMB_rectcpy(tbuf1, ibuf, 0, 0, 0, 0, ibuf->x, ibuf->y);
+               IMB_rectcpy(tbuf2, ibuf, 0, 0, 0, tbuf2->y, ibuf->x, ibuf->y);
 
                ibuf->x *= 2;
-               IMB_rectop(ibuf, tbuf1, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy,
-                       0);
-               IMB_rectop(ibuf, tbuf2, tbuf2->x, 0, 0, 0, 32767, 32767,
-                       IMB_rectcpy,0);
+               IMB_rectcpy(ibuf, tbuf1, 0, 0, 0, 0, tbuf1->x, tbuf1->y);
+               IMB_rectcpy(ibuf, tbuf2, tbuf2->x, 0, 0, 0, tbuf2->x, tbuf2->y);
                ibuf->x /= 2;
 
                IMB_freeImBuf(tbuf1);
@@ -143,11 +139,13 @@ void IMB_interlace(struct ImBuf *ibuf)
 void IMB_gamwarp(struct ImBuf *ibuf, double gamma)
 {
        uchar gam[256];
-       int i;
-       uchar *rect;
+       int i, do_float=0;
+       uchar *rect = (uchar *) ibuf->rect;
+       float *rectf = ibuf->rect_float;
 
        if (ibuf == 0) return;
        if (ibuf->rect == 0) return;
+        if (ibuf->rect != NULL) do_float = 1;
        if (gamma == 1.0) return;
 
        gamma = 1.0 / gamma;
@@ -159,5 +157,10 @@ void IMB_gamwarp(struct ImBuf *ibuf, double gamma)
                rect[0] = gam[rect[0]];
                rect[1] = gam[rect[1]];
                rect[2] = gam[rect[2]];
+               if (do_float) {
+                       rectf[0] = pow(rectf[0] / 255.0, gamma);
+                       rectf[1] = pow(rectf[1] / 255.0, gamma);
+                       rectf[2] = pow(rectf[2] / 255.0, gamma);
+               }
        }
 }
index 8aea42c700845ceda31a0976f12566a5adccf717..e51f85ab2d6c76c76b808c5de48fbef8380b9cc5 100644 (file)
@@ -65,6 +65,26 @@ static void filtrow(unsigned char *point, int x)
        }
 }
 
+static void filtrowf(float *point, int x)
+{
+        float c1,c2,c3,error;
+
+        if (x>1){
+                c1 = c2 = *point;
+                error = 2;
+                for(x--;x>0;x--){
+                        c3 = point[4];
+                        c1 += (c2 * 2) + c3 + error;
+                        *point = c1 / 4.0;
+                        point += 4;
+                        c1=c2;
+                        c2=c3;
+                }
+                *point = (c1 + (c2 * 2) + c2 + error) / 4.0;
+        }
+}
+
+
 
 static void filtcolum(unsigned char *point, int y, int skip)
 {
@@ -89,13 +109,38 @@ static void filtcolum(unsigned char *point, int y, int skip)
        }
 }
 
+static void filtcolumf(float *point, int y, int skip)
+{
+        float c1,c2,c3,error, *point2;
+
+        if (y>1){
+                c1 = c2 = *point;
+                point2 = point;
+                error = 2;
+                for(y--;y>0;y--){
+                        point2 += skip;
+                        c3 = *point2;
+                        c1 += (c2 * 2) + c3 +error;
+                        *point = c1 / 4;
+                        point=point2;
+                        c1=c2;
+                        c2=c3;
+                }
+                *point = (c1 + (c2 * 2) + c2 + error) / 4;
+        }
+}
 
 void IMB_filtery(struct ImBuf *ibuf)
 {
        unsigned char *point;
-       int x, y, skip;
+       float *pointf;
+       int x, y, skip, do_float = 0;
 
        point = (unsigned char *)ibuf->rect;
+       pointf = ibuf->rect_float;
+
+       if (ibuf->rect_float != NULL) do_float = 1;
+
        x = ibuf->x;
        y = ibuf->y;
        skip = x<<2;
@@ -109,6 +154,16 @@ void IMB_filtery(struct ImBuf *ibuf)
                point++;
                filtcolum(point,y,skip);
                point++;
+               if (do_float) {
+                       if (ibuf->depth > 24) filtcolumf(pointf,y,skip);
+                       pointf++;
+                       filtcolumf(pointf,y,skip);
+                       pointf++;
+                       filtcolumf(pointf,y,skip);
+                       pointf++;
+                       filtcolumf(pointf,y,skip);
+                       point++;
+               }
        }
 }
 
@@ -116,9 +171,14 @@ void IMB_filtery(struct ImBuf *ibuf)
 void imb_filterx(struct ImBuf *ibuf)
 {
        unsigned char *point;
-       int x, y, skip;
+       float *pointf;
+       int x, y, skip, do_float =0;
 
        point = (unsigned char *)ibuf->rect;
+       pointf = ibuf->rect_float;
+
+       if (ibuf->rect_float != NULL) do_float = 1;
+
        x = ibuf->x;
        y = ibuf->y;
        skip = (x<<2) - 3;
@@ -132,6 +192,16 @@ void imb_filterx(struct ImBuf *ibuf)
                point++;
                filtrow(point,x);
                point+=skip;
+               if (do_float) {
+                       if (ibuf->depth > 24) filtrowf(pointf,x);
+                       pointf++;
+                       filtrowf(pointf,x);
+                       pointf++;
+                       filtrowf(pointf,x);
+                       pointf++;
+                       filtrowf(pointf,x);
+                       pointf+=skip;
+               }
        }
 }
 
index dcdd0692fc462ca06939a26c2c0c190868d5a0ea..f98244c5a0f6874fd3a38675c96962d702f33d46 100644 (file)
  * $Id$
  */
 
+#include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
 /* Only this one is used liberally here, and in imbuf */
-void IMB_convert_rgba_to_abgr(int size, unsigned int *rect)
+void IMB_convert_rgba_to_abgr(struct ImBuf *ibuf)
 {
-       char *cp= (char *)rect, rt;
+       int size, do_float=0;
+       unsigned char rt, *cp = (unsigned char *)ibuf->rect;
+       float rtf, *cpf = ibuf->rect_float;
        
+       if (ibuf->rect_float)  do_float = 1;
+       size = ibuf->x * ibuf->y;
+
        while(size-- > 0) {
                rt= cp[0];
                cp[0]= cp[3];
@@ -55,5 +61,15 @@ void IMB_convert_rgba_to_abgr(int size, unsigned int *rect)
                cp[1]= cp[2];
                cp[2]= rt;
                cp+= 4;
+               if (do_float) {
+                       rtf= cpf[0];
+                       cpf[0]= cpf[3];
+                       cpf[3]= rtf;
+                       rtf= cpf[1];
+                       cpf[1]= cpf[2];
+                       cpf[2]= rtf;
+                       cpf+= 4;
+               }
        }
 }
+
index 20aa9d75fd28f6092f63f4bda8a73ada293f2421..5c0a3f94a0e91c0f72c799542c13a5b73504764c 100644 (file)
@@ -398,7 +398,7 @@ struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
        
        if (ibuf) {
                if (ibuf->rect) 
-                       IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
+                       IMB_convert_rgba_to_abgr(ibuf);
        }
 
        return(ibuf);
@@ -639,13 +639,13 @@ short imb_saveiris(struct ImBuf * ibuf, char *name, 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, 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);
index 34796bac9d5de2bb836e7d15c1f97bdcf8626bc7..afd1038a80f6a79ef0b51d40aadacbe900ed6019 100644 (file)
@@ -553,15 +553,12 @@ static int save_jstjpeg(char * name, struct ImBuf * ibuf)
        ibuf->x *= 2;
        ibuf->y /= 2;
 
-       /* extra argument assumed to be 0 (nzc) */
-       IMB_rectop(tbuf, ibuf, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
+       IMB_rectcpy(tbuf, ibuf, 0, 0, 0, 0, ibuf->x, ibuf->y);
        sprintf(fieldname, "%s.jf0", name);
 
        returnval = save_vidjpeg(fieldname, tbuf) ;
         if (returnval == 1) {
-               /* extra argument assumed to be 0 (nzc) */
-               IMB_rectop(tbuf, ibuf, 0, 0, tbuf->x, 0, 32767, 32767, 
-                       IMB_rectcpy, 0);
+               IMB_rectcpy(tbuf, ibuf, 0, 0, tbuf->x, 0, ibuf->x, ibuf->y);
                sprintf(fieldname, "%s.jf1", name);
                returnval = save_vidjpeg(fieldname, tbuf);
        }
diff --git a/source/blender/imbuf/intern/openexr/Makefile b/source/blender/imbuf/intern/openexr/Makefile
new file mode 100644 (file)
index 0000000..48abc4c
--- /dev/null
@@ -0,0 +1,51 @@
+#
+# $Id$
+#
+# ***** BEGIN GPL/BL DUAL 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.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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.
+#
+# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): Gernot Ziegler <gz@lysator.liu.se>
+#
+# ***** END GPL/BL DUAL LICENSE BLOCK *****
+#
+#
+
+LIBNAME = openexr
+DIR = $(OCGDIR)/blender/imbuf/openexr
+
+include nan_compile.mk
+
+ifeq ($(OS),$(findstring $(OS), "beos darwin freebsd linux openbsd solaris windows"))
+    CFLAGS += -funsigned-char
+endif
+
+CFLAGS += $(LEVEL_1_C_WARNINGS)
+
+CPPFLAGS += -I../../../makesdna
+CPPFLAGS += -I../../../blenkernel
+CPPFLAGS += -I../../../blenlib
+CPPFLAGS += -I../../../imbuf
+CPPFLAGS += -I../../../imbuf/intern
+CPPFLAGS += $(NAN_OPENEXR_INC)
+CPPFLAGS += -I.
diff --git a/source/blender/imbuf/intern/openexr/SConscript b/source/blender/imbuf/intern/openexr/SConscript
new file mode 100644 (file)
index 0000000..ee83466
--- /dev/null
@@ -0,0 +1,22 @@
+#!/usr/bin/python
+Import ('extra_includes')
+Import ('user_options_dict')
+Import ('library_env')
+
+openexr_env = library_env.Copy ()
+
+source_files = ['openexr_api.cpp'
+                ]
+
+include_paths = ['.',
+               '../blenkernel',
+               '../imbuf',
+               '../imbuf/intern',
+               '../blenlib',
+               '../makesdna']
+                 
+openexr_env.Append(CPPPATH = extra_includes)
+openexr_env.Append(CPPPATH = include_paths)
+openexr_env.Prepend (CPPPATH = user_options_dict['OPENEXR_INCLUDE'])
+#ftf_env.Append(CPPDEFINES = 'FTGL_STATIC_LIBRARY')
+openexr_env.Library (target='#'+user_options_dict['BUILD_DIR']+'/lib/blender_openexr', source=source_files)
diff --git a/source/blender/imbuf/intern/openexr/openexr_api.cpp b/source/blender/imbuf/intern/openexr/openexr_api.cpp
new file mode 100644 (file)
index 0000000..86beab5
--- /dev/null
@@ -0,0 +1,441 @@
+/**
+*
+ * ***** BEGIN GPLLICENSE 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. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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.
+ *
+ * Copyright by Gernot Ziegler <gz@lysator.liu.se>.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Austin Benesh, Ton Roosendaal (float, half, speedup, cleanup...).
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+
+
+#include <openexr_api.h>
+
+extern "C"
+{
+#include "IMB_imbuf_types.h"
+#include "IMB_imbuf.h"
+       
+#include "IMB_allocimbuf.h"
+#include "BKE_global.h"
+#include "DNA_scene_types.h"
+}
+
+#include <iostream>
+
+#include <OpenEXR/half.h>
+#include <OpenEXR/ImfVersion.h>
+#include <OpenEXR/ImathBox.h>
+#include <OpenEXR/ImfArray.h>
+#include <OpenEXR/ImfIO.h>
+#include <OpenEXR/ImfChannelList.h>
+#include <OpenEXR/ImfPixelType.h>
+#include <OpenEXR/ImfInputFile.h>
+#include <OpenEXR/ImfOutputFile.h>
+#include <OpenEXR/ImfCompression.h>
+#include <OpenEXR/ImfCompressionAttribute.h>
+
+using namespace Imf;
+using namespace Imath;
+
+class Mem_IStream: public IStream
+{
+public:
+       
+       Mem_IStream (unsigned char *exrbuf, int exrsize):
+    IStream("dummy"), _exrpos (0), _exrsize(exrsize)  { _exrbuf = exrbuf; }
+       
+       virtual bool    read (char c[], int n);
+       virtual Int64   tellg ();
+       virtual void    seekg (Int64 pos);
+       virtual void    clear ();
+       //virtual ~Mem_IStream() {}; // unused
+       
+private:
+               
+               Int64 _exrpos;
+       Int64 _exrsize;
+       unsigned char *_exrbuf;
+};
+
+bool Mem_IStream::read (char c[], int n)
+{
+       if (n + _exrpos <= _exrsize)
+    {
+               memcpy(c, (void *)(&_exrbuf[_exrpos]), n);
+               _exrpos += n;
+               return true;
+    }
+       else
+               return false;
+}
+
+Int64 Mem_IStream::tellg ()
+{
+       return _exrpos;
+}
+
+void Mem_IStream::seekg (Int64 pos)
+{
+       _exrpos = pos;
+}
+
+void Mem_IStream::clear () 
+{ 
+}
+
+struct _RGBAZ
+{
+       half r;
+       half g;
+       half b;
+       half a;
+       half z;
+};
+
+typedef struct _RGBAZ RGBAZ;
+
+extern "C"
+{
+       
+int imb_is_a_openexr(unsigned char *mem)
+{
+       return Imf::isImfMagic ((const char *)mem);
+}
+
+static void openexr_header_compression(Header *header, int compression)
+{
+       switch(compression)
+       {
+               case 0:
+                       header->compression() = NO_COMPRESSION;
+                       break;
+               case 1:
+                       header->compression() = PXR24_COMPRESSION;
+                       break;
+               case 2:
+                       header->compression() = ZIP_COMPRESSION;
+                       break;
+               case 3:
+                       header->compression() = PIZ_COMPRESSION;
+                       break;
+               case 4:
+                       header->compression() = RLE_COMPRESSION;
+                       break;
+               default:
+                       header->compression() = NO_COMPRESSION;
+                       break; 
+       }
+}
+
+short imb_save_openexr_half(struct ImBuf *ibuf, char *name, int flags)
+{
+       
+       int width = ibuf->x;
+       int height = ibuf->y;
+       
+       if (flags & IB_mem) 
+       {
+               printf("OpenEXR-save: Create EXR in memory CURRENTLY NOT SUPPORTED !\n");
+               imb_addencodedbufferImBuf(ibuf);
+               ibuf->encodedsize = 0;    
+               return(0);
+       } 
+       
+       int write_zbuf = (flags & IB_zbuf) && ibuf->zbuf != NULL;   // summarize
+       
+       try
+       {
+               Header header (width, height);
+               
+               openexr_header_compression(&header, G.scene->r.quality);
+               
+               header.channels().insert ("R", Channel (HALF));
+               header.channels().insert ("G", Channel (HALF));
+               header.channels().insert ("B", Channel (HALF));
+               header.channels().insert ("A", Channel (HALF));
+               if (write_zbuf)         // z we do as uint always
+                       header.channels().insert ("Z", Channel (UINT));
+               
+               FrameBuffer frameBuffer;                        
+               OutputFile *file = new OutputFile(name, header);                        
+               
+               /* we store first everything in half array */
+               RGBAZ *pixels = new RGBAZ[height * width];
+               RGBAZ *to = pixels;
+               int xstride= sizeof (RGBAZ);
+               int ystride= xstride*width;
+               
+               /* indicate used buffers */
+               frameBuffer.insert ("R", Slice (HALF,  (char *) &pixels[0].r, xstride, ystride));       
+               frameBuffer.insert ("G", Slice (HALF,  (char *) &pixels[0].g, xstride, ystride));
+               frameBuffer.insert ("B", Slice (HALF,  (char *) &pixels[0].b, xstride, ystride));
+               frameBuffer.insert ("A", Slice (HALF, (char *) &pixels[0].a, xstride, ystride));
+       
+               if (write_zbuf)
+                       frameBuffer.insert ("Z", Slice (UINT, (char *) ibuf->zbuf + 4*(height-1)*width,
+                                                                                       sizeof(int), sizeof(int) * -width));
+               if(ibuf->rect_float) {
+                       float *from;
+                       
+                       for (int i = ibuf->y-1; i >= 0; i--) 
+                       {
+                               from= ibuf->rect_float + 4*i*width;
+                               
+                               for (int j = ibuf->x; j > 0; j--) 
+                               {
+                                       to->r = from[0];
+                                       to->g = from[1];
+                                       to->b = from[2];
+                                       to->a = from[3];
+                                       to++; from += 4;
+                               }
+                       }
+               }
+               else {
+                       unsigned char *from;
+                       
+                       for (int i = ibuf->y-1; i >= 0; i--) 
+                       {
+                               from= (unsigned char *)(ibuf->rect + i*width);
+                               
+                               for (int j = ibuf->x; j > 0; j--) 
+                               {
+                                       to->r = (float)(from[0])/255.0;
+                                       to->g = (float)(from[1])/255.0;
+                                       to->b = (float)(from[2])/255.0;
+                                       to->a = (float)(from[3])/255.0;
+                                       to++; from += 4;
+                               }
+                       }
+               }
+               
+//             printf("OpenEXR-save: Writing OpenEXR file of height %d.\n", height);
+               
+               file->setFrameBuffer (frameBuffer);                               
+               file->writePixels (height);                                       
+               delete file;
+       }
+       catch (const std::exception &exc)
+       {      
+               printf("OpenEXR-save: ERROR: %s\n", exc.what());
+               if (ibuf) IMB_freeImBuf(ibuf);
+               
+               return (0);
+       }
+       
+       return (1);
+}
+
+short imb_save_openexr_float(struct ImBuf *ibuf, char *name, int flags)
+{
+       
+       int width = ibuf->x;
+       int height = ibuf->y;
+       
+       if (flags & IB_mem) 
+       {
+               printf("OpenEXR-save: Create EXR in memory CURRENTLY NOT SUPPORTED !\n");
+               imb_addencodedbufferImBuf(ibuf);
+               ibuf->encodedsize = 0;    
+               return(0);
+       } 
+       
+       if (ibuf->rect_float==NULL)
+               return(0);
+       
+       int write_zbuf = (flags & IB_zbuf) && ibuf->zbuf != NULL;   // summarize
+       
+       try
+       {
+               Header header (width, height);
+               
+               openexr_header_compression(&header, G.scene->r.quality);
+               
+               header.channels().insert ("R", Channel (FLOAT));
+               header.channels().insert ("G", Channel (FLOAT));
+               header.channels().insert ("B", Channel (FLOAT));
+               header.channels().insert ("A", Channel (FLOAT));
+               if (write_zbuf)
+                       header.channels().insert ("Z", Channel (UINT));
+               
+               FrameBuffer frameBuffer;                        
+               OutputFile *file = new OutputFile(name, header);                        
+               float *first= ibuf->rect_float + 4*(height-1)*width;
+               int xstride = sizeof(float) * 4;
+               int ystride = - xstride*width;
+
+               frameBuffer.insert ("R", Slice (FLOAT,  (char *) first, xstride, ystride));
+               frameBuffer.insert ("G", Slice (FLOAT,  (char *) (first+1), xstride, ystride));
+               frameBuffer.insert ("B", Slice (FLOAT,  (char *) (first+2), xstride, ystride));
+               frameBuffer.insert ("A", Slice (FLOAT,  (char *) (first+3), xstride, ystride));
+
+               if (write_zbuf)
+                       frameBuffer.insert ("Z", Slice (UINT, (char *) ibuf->zbuf + 4*(height-1)*width,
+                                                                                       sizeof(int), sizeof(int) * -width));
+               
+               file->setFrameBuffer (frameBuffer);                               
+               file->writePixels (height);                                       
+               delete file;
+       }
+       catch (const std::exception &exc)
+       {      
+               printf("OpenEXR-save: ERROR: %s\n", exc.what());
+               if (ibuf) IMB_freeImBuf(ibuf);
+               
+               return (0);
+       }
+       
+       return (1);
+       //      printf("OpenEXR-save: Done.\n");
+}
+
+
+
+struct ImBuf *imb_load_openexr(unsigned char *mem, int size, int flags)
+{
+       struct ImBuf *ibuf = 0;
+       InputFile *file = NULL;
+       
+//     printf("OpenEXR-load: testing input, size is %d\n", size);
+       if (imb_is_a_openexr(mem) == 0) return(NULL);
+       
+       try
+       {
+//             printf("OpenEXR-load: Creating InputFile from mem source\n");
+               Mem_IStream membuf(mem, size); 
+               file = new InputFile(membuf);
+               
+               Box2i dw = file->header().dataWindow();
+               int width  = dw.max.x - dw.min.x + 1;
+               int height = dw.max.y - dw.min.y + 1;
+               
+//             printf("OpenEXR-load: image data window %d %d %d %d\n", 
+//                        dw.min.x, dw.min.y, dw.max.x, dw.max.y);
+               
+               const ChannelList &channels = file->header().channels();
+               
+               for (ChannelList::ConstIterator i = channels.begin(); i != channels.end(); ++i)
+               {
+                       const Channel &channel = i.channel();
+//                     printf("OpenEXR-load: Found channel %s of type %d\n", i.name(), channel.type);
+                       if (channel.type != 1)
+                       {
+                               printf("OpenEXR-load: Can only process HALF input !!\n");
+                               return(NULL);
+                       }
+               }
+               
+               RGBAZ *pixels = new RGBAZ[height * width];
+               
+               FrameBuffer frameBuffer;
+               
+               frameBuffer.insert ("R",
+                                                       Slice (HALF,
+                                                                  (char *) &pixels[0].r,
+                                                                  sizeof (pixels[0]) * 1,
+                                                                  sizeof (pixels[0]) * width));
+               
+               frameBuffer.insert ("G",
+                                                       Slice (HALF,
+                                                                  (char *) &pixels[0].g,
+                                                                  sizeof (pixels[0]) * 1,
+                                                                  sizeof (pixels[0]) * width));
+               
+               frameBuffer.insert ("B",
+                                                       Slice (HALF,
+                                                                  (char *) &pixels[0].b,
+                                                                  sizeof (pixels[0]) * 1,
+                                                                  sizeof (pixels[0]) * width));
+               
+               frameBuffer.insert ("A",
+                                                       Slice (HALF,
+                                                                  (char *) &pixels[0].a,
+                                                                  sizeof (pixels[0]) * 1,
+                                                                  sizeof (pixels[0]) * width));
+               
+               // FIXME ? Would be able to read Z data or other channels here ! 
+               
+//             printf("OpenEXR-load: Reading pixel data\n");
+               file->setFrameBuffer (frameBuffer);
+               file->readPixels (dw.min.y, dw.max.y);
+               
+//             printf("OpenEXR-load: Converting to Blender float ibuf\n");
+               
+               int bytesperpixel = 4; // since OpenEXR fills in unknown channels
+               ibuf = IMB_allocImBuf(width, height, 8 * bytesperpixel, 0, 0);
+               
+               if (ibuf) 
+               {
+                       ibuf->ftype = OPENEXR;
+                       
+                       imb_addrectImBuf(ibuf);
+                       imb_addrectfloatImBuf(ibuf);
+                       
+                       if (!(flags & IB_test))
+                       {
+                               unsigned char *to = (unsigned char *) ibuf->rect;
+                               float *tof = ibuf->rect_float;
+                               RGBAZ *from = pixels;
+                               RGBAZ prescale;
+                               
+                               for (int i = ibuf->x * ibuf->y; i > 0; i--) 
+                               {
+                                       to[0] = (unsigned char)(from->r > 1.0 ? 1.0 : (float)from->r)  * 255;
+                                       to[1] = (unsigned char)(from->g > 1.0 ? 1.0 : (float)from->g)  * 255;
+                                       to[2] = (unsigned char)(from->b > 1.0 ? 1.0 : (float)from->b)  * 255;
+                                       to[3] = (unsigned char)(from->a > 1.0 ? 1.0 : (float)from->a)  * 255;
+                                       to += 4; 
+                                       
+                                       tof[0] = from->r;
+                                       tof[1] = from->g;
+                                       tof[2] = from->b;
+                                       tof[3] = from->a;
+                                       
+                                       from++;
+                               }
+                       }
+                       
+                       IMB_flipy(ibuf);
+                       
+               } 
+               else 
+                       printf("Couldn't allocate memory for OpenEXR image\n");
+               
+//             printf("OpenEXR-load: Done\n");
+               
+               return(ibuf);
+       }
+       catch (const std::exception &exc)
+       {
+               std::cerr << exc.what() << std::endl;
+               if (ibuf) IMB_freeImBuf(ibuf);
+               
+               return (0);
+       }
+       
+}
+       
+} // export "C"
diff --git a/source/blender/imbuf/intern/openexr/openexr_api.h b/source/blender/imbuf/intern/openexr/openexr_api.h
new file mode 100644 (file)
index 0000000..882b9d9
--- /dev/null
@@ -0,0 +1,63 @@
+/**
+ * $Id$ 
+ *
+ * ***** BEGIN GPL/BL DUAL 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Austin Benesh.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#ifndef _OPENEXR_API_H
+#define _OPENEXR_API_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OPENEXR_FLOATRGB 0x1
+#define OPENEXR_ZBUF 0x2
+  
+#include <stdio.h>
+  
+  /**
+ * Test presence of OpenEXR file.
+ * @param mem pointer to loaded OpenEXR bitstream
+ */
+  
+int imb_is_a_openexr(unsigned char *mem);
+       
+short imb_save_openexr_half(struct ImBuf *ibuf, char *name, int flags);
+short imb_save_openexr_float(struct ImBuf *ibuf, char *name, int flags);
+
+struct ImBuf *imb_load_openexr(unsigned char *mem, int size, int flags);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif /* __OPENEXR_API_H */
index fe18d4e3574f55a1bc9305edc6671599f67b4f3e..a90d7d651f857f5accc65bf4a97792d88ad969c8 100644 (file)
  * ***** END GPL LICENSE BLOCK *****
 */
 
-
-/*
-  -------------------------------------------------------------------------------------------------
+/* ----------------------------------------------------------------------
   Radiance High Dynamic Range image file IO
-  For description and code for reading/writing of radiance hdr files by Greg Ward, refer to:
+  For description and code for reading/writing of radiance hdr files 
+       by Greg Ward, refer to:
   http://radsite.lbl.gov/radiance/refer/Notes/picture_format.html
-  -------------------------------------------------------------------------------------------------
+----------------------------------------------------------------------
 */
 
 #ifdef WIN32
@@ -68,9 +67,7 @@ typedef float fCOLOR[3];
 #define copy_rgbe(c1, c2) (c2[RED]=c1[RED], c2[GRN]=c1[GRN], c2[BLU]=c1[BLU], c2[EXP]=c1[EXP])
 #define copy_fcol(f1, f2) (f2[RED]=f1[RED], f2[GRN]=f1[GRN], f2[BLU]=f1[BLU])
 
-/*-------------------------------------------------------------------------------------------------*/
 /* read routines */
-
 static unsigned char* oldreadcolrs(RGBE *scan, unsigned char *mem, int xmax)
 {
        int i, rshift = 0, len = xmax;
@@ -127,7 +124,6 @@ static unsigned char* freadcolrs(RGBE *scan, unsigned char* mem, int xmax)
        return mem;
 }
 
-/*-------------------------------------------------------------------------------------------------*/
 /* helper functions */
 
 /* rgbe -> float color */
@@ -161,7 +157,6 @@ static void FLOAT2RGBE(fCOLOR fcol, RGBE rgbe)
        }
 }
 
-/*-------------------------------------------------------------------------------------------------*/
 /* ImBuf read */
 
 int imb_is_a_hdr(void *buf)
@@ -174,16 +169,17 @@ int imb_is_a_hdr(void *buf)
 
 struct ImBuf *imb_loadhdr(unsigned char *mem, int size, int flags)
 {
+       struct ImBuf* ibuf;
+       RGBE* sline;
+       fCOLOR fcol;
+       float* rect_float;
        int found=0;
-       char oriY[80], oriX[80];
        int width=0, height=0;
-       RGBE* sline;
        int x, y;
-       char* ptr;
-       fCOLOR fcol;
        int ir, ig, ib;
+       unsigned char* ptr;
        unsigned char* rect;
-       struct ImBuf* ibuf;
+       char oriY[80], oriX[80];
 
        if (imb_is_a_hdr((void*)mem))
        {
@@ -198,11 +194,11 @@ struct ImBuf *imb_loadhdr(unsigned char *mem, int size, int flags)
                        sscanf((char*)&mem[x+1], "%s %d %s %d", (char*)&oriY, &height, (char*)&oriX, &width);
 
                        /* find end of this line, data right behind it */
-                       ptr = strchr((char*)&mem[x+1], '\n');
+                       ptr = (unsigned char *)strchr((char*)&mem[x+1], '\n');
                        ptr++;
 
                        if (flags & IB_test) ibuf = IMB_allocImBuf(width, height, 24, 0, 0);
-                       else ibuf = IMB_allocImBuf(width, height, 24, 1, 0);
+                       else ibuf = IMB_allocImBuf(width, height, 24, IB_rect|IB_rectfloat, 0);
 
                        if (ibuf==NULL) return NULL;
                        ibuf->ftype = RADHDR;
@@ -213,6 +209,8 @@ struct ImBuf *imb_loadhdr(unsigned char *mem, int size, int flags)
                        /* read in and decode the actual data */
                        sline = (RGBE*)MEM_mallocN(sizeof(RGBE)*width, "radhdr_read_tmpscan");
                        rect = (unsigned char*)ibuf->rect;
+                       rect_float = (float *)ibuf->rect_float;
+                       
                        for (y=0;y<height;y++) {
                                ptr = freadcolrs(sline, ptr, width);
                                if (ptr==NULL) {
@@ -223,10 +221,13 @@ struct ImBuf *imb_loadhdr(unsigned char *mem, int size, int flags)
                                for (x=0;x<width;x++) {
                                        /* convert to ldr */
                                        RGBE2FLOAT(sline[x], fcol);
-                                       /*--------------------------------------------------------------------------------------*/
-                                       /* THIS PART NEEDS TO BE ADAPTED TO WRITE TO IMBUF FLOATBUFFER ONCE THAT IS IMPLEMENTED
-                                        * temporarily now loads as regular image using simple tone mapping
-                                        * (of course this should NOT be done when loading to floatbuffer!) */
+                                       *rect_float++ = fcol[RED];
+                                       *rect_float++ = fcol[GRN];
+                                       *rect_float++ = fcol[BLU];
+                                       *rect_float++ = 255;
+
+                                       /* Also old oldstyle for the rest of blender which is not using floats yet */
+/* very weird mapping! (ton) */
                                        fcol[RED] = 1.f-exp(fcol[RED]*-1.414213562f);
                                        fcol[GRN] = 1.f-exp(fcol[GRN]*-1.414213562f);
                                        fcol[BLU] = 1.f-exp(fcol[BLU]*-1.414213562f);
@@ -237,7 +238,6 @@ struct ImBuf *imb_loadhdr(unsigned char *mem, int size, int flags)
                                        *rect++ = (unsigned char)((ig<0) ? 0 : ((ig>255) ? 255 : ig));
                                        *rect++ = (unsigned char)((ib<0) ? 0 : ((ib>255) ? 255 : ib));
                                        *rect++ = 255;
-                                       /*--------------------------------------------------------------------------------------*/
                                }
                        }
                        MEM_freeN(sline);
@@ -251,36 +251,39 @@ struct ImBuf *imb_loadhdr(unsigned char *mem, int size, int flags)
        return NULL;
 }
 
-/*-------------------------------------------------------------------------------------------------*/
 /* ImBuf write */
-
-
-static int fwritecolrs(FILE* file, int width, RGBE* rgbe_scan, unsigned char* ibufscan, float* fpscan)
+static int fwritecolrs(FILE* file, int width, unsigned char* ibufscan, float* fpscan)
 {
-       int i, j, beg, c2, cnt=0;
+       int x, i, j, beg, c2, cnt=0;
        fCOLOR fcol;
-       RGBE rgbe;
+       RGBE rgbe, *rgbe_scan;
 
        if ((ibufscan==NULL) && (fpscan==NULL)) return 0;
 
+       rgbe_scan = (RGBE*)MEM_mallocN(sizeof(RGBE)*width, "radhdr_write_tmpscan");
+
        /* convert scanline */
-       for (i=0, j=0;i<width;i++, j+=4) {
-                       if (ibufscan) {
-                               fcol[RED] = (float)ibufscan[j] / 255.f;
-                               fcol[GRN] = (float)ibufscan[j+1] / 255.f;
-                               fcol[BLU] = (float)ibufscan[j+2] /255.f;
-                       }
-                       else {
-                               fcol[RED] = fpscan[j];
-                               fcol[GRN] = fpscan[j+1];
-                               fcol[BLU] = fpscan[j+2];
-                       }
-                       FLOAT2RGBE(fcol, rgbe);
-                       copy_rgbe(rgbe, rgbe_scan[i]);
+        j= 0;
+       for (i=0;i<width;i++) {
+               if (fpscan) {
+                       fcol[RED] = fpscan[j];
+                       fcol[GRN] = fpscan[j+1];
+                       fcol[BLU] = fpscan[j+2];
+               } else {
+                       fcol[RED] = (float)ibufscan[j] / 255.f;
+                       fcol[GRN] = (float)ibufscan[j+1] / 255.f;
+                       fcol[BLU] = (float)ibufscan[j+2] /255.f;
+               }
+               FLOAT2RGBE(fcol, rgbe);
+               copy_rgbe(rgbe, rgbe_scan[i]);
+               j+=4;
        }
 
-       if ((width < MINELEN) | (width > MAXELEN))      /* OOBs, write out flat */
-               return (fwrite((char *)rgbe_scan, sizeof(RGBE), width, file) - width);
+       if ((width < MINELEN) | (width > MAXELEN)) {    /* OOBs, write out flat */
+               x=fwrite((char *)rgbe_scan, sizeof(RGBE), width, file) - width;
+               MEM_freeN(rgbe_scan);
+               return x;
+       }
        /* put magic header */
        putc(2, file);
        putc(2, file);
@@ -315,6 +318,7 @@ static int fwritecolrs(FILE* file, int width, RGBE* rgbe_scan, unsigned char* ib
                        else cnt = 0;
                }
        }
+       MEM_freeN(rgbe_scan);
        return(ferror(file) ? -1 : 0);
 }
 
@@ -336,57 +340,21 @@ static void writeHeader(FILE *file, int width, int height)
 short imb_savehdr(struct ImBuf *ibuf, char *name, int flags)
 {
        int y, width=ibuf->x, height=ibuf->y;
-       RGBE* sline;
-
        FILE* file = fopen(name, "wb");
-       if (file==NULL) return 0;
 
-       writeHeader(file, width, height);
-
-       sline = (RGBE*)MEM_mallocN(sizeof(RGBE)*width, "radhdr_write_tmpscan");
-
-       for (y=height-1;y>=0;y--) {
-               if (fwritecolrs(file, width, sline, (unsigned char*)&ibuf->rect[y*width], NULL) < 0)
-               { // error
-                       fclose(file);
-                       MEM_freeN(sline);
-                       printf("HDR write error\n");
-                       return 0;
-               }
-       }
-
-       fclose(file);
-       MEM_freeN(sline);
-       return 1;
-}
-
-/* Temporary routine to save directly from render floatbuffer.
-   Called by schrijfplaatje() in toets.c */
-short imb_savehdr_fromfloat(float *fbuf, char *name, int width, int height)
-{
-       int y;
-       RGBE* sline;
-
-       FILE* file = fopen(name, "wb");
        if (file==NULL) return 0;
 
        writeHeader(file, width, height);
 
-       sline = (RGBE*)MEM_mallocN(sizeof(RGBE)*width, "radhdr_write_tmpscan");
-
        for (y=height-1;y>=0;y--) {
-               if (fwritecolrs(file, width, sline, NULL, &fbuf[y*width*4]) < 0)
-               { // error
+               if (fwritecolrs(file, width,(unsigned char *)&ibuf->rect[y*width*4], &ibuf->rect_float[y*width*4]) < 0) {
                        fclose(file);
-                       MEM_freeN(sline);
                        printf("HDR write error\n");
                        return 0;
                }
        }
 
        fclose(file);
-       MEM_freeN(sline);
        return 1;
 }
 
-/*-------------------------------------------------------------------------------------------------*/
index 779401c3183cf410ce773df1213acd727f5aaa64..117dd54cfddde9fa2c0af0473fd9fcb332d3f4d6 100644 (file)
 #include "IMB_radiance_hdr.h"
 #include "BKE_global.h"
 
+#ifdef WITH_OPENEXR
+#include "openexr/openexr_api.h"
+#endif
+
 #ifdef WITH_QUICKTIME
 #if defined(_WIN32) || defined (__APPLE__)
 #include "quicktime_import.h"
@@ -138,6 +142,9 @@ ImBuf *IMB_ibImageFromMemory(int *mem, int size, int flags) {
                ibuf = imb_loadhdr((uchar*)mem, size, flags);
                if (ibuf) return (ibuf);
 
+               ibuf = imb_load_openexr((uchar *)mem, size, flags);
+               if (ibuf) return (ibuf);
+               
 #ifdef WITH_QUICKTIME
 #if defined(_WIN32) || defined (__APPLE__)
                if(G.have_quicktime) {
index 22f2698a8c57c1bb063d3eb02ea640a36694acd0..4ddd7ca48149d5720148ee71a9e5e8ea5a8a9fc0 100644 (file)
 
 #include "IMB_allocimbuf.h"
 
-void IMB_rectcpy(unsigned int *drect, unsigned int *srect, int x, int dummy)
+void IMB_rectcpy(struct ImBuf *dbuf, struct ImBuf *sbuf, int destx, 
+       int desty, int srcx, int srcy, int width, int height)
 {
-       memcpy(drect,srect, x * sizeof(int));
-}
-
-
-void IMB_rectfill(unsigned int *drect, unsigned int *srect, int x, int value)
-{
-       for (;x > 0; x--) *drect++ = value;
-}
-
-void IMB_rectop(struct ImBuf *dbuf,
-                       struct ImBuf *sbuf,
-                       int destx,
-                       int desty,
-                       int srcx,
-                       int srcy,
-                       int width,
-                       int height,
-                       void (*operation)(unsigned int *, unsigned int*, int, int),
-                       int value)
-{
-       unsigned int *drect,*srect;
-       int tmp;
+       unsigned int *drect, *srect;
+       float *drectf = NULL;
+       float *srectf = NULL;
+       int tmp, do_float = 0;
 
-       if (dbuf == 0) return;
-       if (operation == 0) return;
+       if (dbuf == NULL) return;
+       
+       if (sbuf->rect_float) do_float = 1;
 
        if (destx < 0){
                srcx -= destx ;
@@ -96,6 +80,7 @@ void IMB_rectop(struct ImBuf *dbuf,
        if (height > tmp) height = tmp;
 
        drect = dbuf->rect + desty * dbuf->x + destx;
+       if (do_float) drectf = dbuf->rect_float + desty * dbuf->x + destx;
        destx = dbuf->x;
 
        if (sbuf){
@@ -110,25 +95,53 @@ void IMB_rectop(struct ImBuf *dbuf,
                srect = sbuf->rect;
                srect += srcy * sbuf->x;
                srect += srcx;
+               if (do_float) {
+                       srectf = sbuf->rect_float;
+                       srectf += srcy * sbuf->x;
+                       srectf += srcx;
+               }
                srcx = sbuf->x;
        } else{
                if (width <= 0) return;
                if (height <= 0) return;
 
                srect = drect;
+               srectf = drectf;
                srcx = destx;
        }
 
        for (;height > 0; height--){
-               operation(drect,srect,width, value);
-               drect += destx;
-               srect += srcx;
+
+               memcpy(drect,srect, width * sizeof(int));
+               if (do_float) memcpy(drectf,srectf, width * sizeof(float) * 4);
        }
 }
 
-
-void IMB_rectoptot(struct ImBuf *dbuf, struct ImBuf *sbuf,
-       void (*operation)(unsigned int *, unsigned int*, int, int), int value)
+void IMB_rectfill(struct ImBuf *drect, float col[4])
 {
-       IMB_rectop(dbuf,sbuf,0,0,0,0,32767,32767,operation, value);
+       int num;
+       unsigned int *rrect = drect->rect;
+       unsigned char *spot;
+
+       num = drect->x * drect->y;
+       for (;num > 0; num--) {
+               spot = (unsigned char *)rrect;
+               spot[0] = (int)(col[0]*255);
+               spot[1] = (int)(col[1]*255);
+               spot[2] = (int)(col[2]*255);
+               spot[3] = (int)(col[3]*255);
+               *rrect++;
+       }
+       if(drect->rect_float) {
+               float *rrectf = drect->rect_float;
+               
+               num = drect->x * drect->y;
+               for (;num > 0; num--) {
+                       *rrectf++ = col[0];
+                       *rrectf++ = col[1];
+                       *rrectf++ = col[2];
+                       *rrectf++ = col[3];
+               }
+       }       
 }
+
index f8d01789cdc9feb1b357c5d490f1bef95cffb1e7..13edfbf0a33ab0c9d1659a295b0986ff66a52475 100644 (file)
 
 void IMB_flipy(struct ImBuf * ibuf)
 {
-       short x,y,backx;
-       unsigned int *top,*bottom,temp;
+       short x, y;
+       unsigned int *top, *bottom, do_float=0, *line;
+       float *topf=NULL, *bottomf=NULL, *linef=NULL;
 
-       if (ibuf == 0) return;
-       if (ibuf->rect == 0) return;
+       if (ibuf == NULL) return;
+       if (ibuf->rect == NULL) return;
+       
+       if (ibuf->rect_float) do_float =1;
 
        x = ibuf->x;
        y = ibuf->y;
-       backx = x<<1;
 
        top = ibuf->rect;
        bottom = top + ((y-1) * x);
+       line= MEM_mallocN(x*sizeof(int), "linebuf");
+       
+       if (do_float) {
+               topf= ibuf->rect_float;
+               bottomf = topf + 4*((y-1) * x);
+               linef= MEM_mallocN(4*x*sizeof(float), "linebuff");
+       }
        y >>= 1;
 
-       for(;y>0;y--){
-               for(x = ibuf->x; x > 0; x--){
-                       temp = *top;
-                       *(top++) = *bottom;
-                       *(bottom++) = temp;
+       for(;y>0;y--) {
+               
+               memcpy(line, top, x*sizeof(int));
+               memcpy(top, bottom, x*sizeof(int));
+               memcpy(bottom, line, x*sizeof(int));
+               bottom -= x;
+               top+= x;
+               
+               if(do_float) {
+                       memcpy(linef, topf, 4*x*sizeof(float));
+                       memcpy(topf, bottomf, 4*x*sizeof(float));
+                       memcpy(bottomf, linef, 4*x*sizeof(float));
+                       bottomf -= 4*x;
+                       topf+= 4*x;
                }
-               bottom -= backx;
        }
+       
+       MEM_freeN(line);
+       if(linef) MEM_freeN(linef);
 }
index 7749dadb2caf54ca3b1d409cc338ca5ff3fe8860..539ea0377b3bed0734bc9319aab12e0ab2ee6cce 100644 (file)
@@ -52,20 +52,27 @@ struct ImBuf *IMB_half_x(struct ImBuf *ibuf1)
        struct ImBuf *ibuf2;
        uchar *p1,*_p1,*dest;
        short a,r,g,b,x,y;
+       float af,rf,gf,bf, *p1f, *_p1f, *destf;
+       int do_float = 0;
 
-       if (ibuf1==0) return (0);
-       if (ibuf1->rect == 0) return (0);
+       if (ibuf1==NULL) return (0);
+       if (ibuf1->rect==NULL) return (0);
+       if (ibuf1->rect_float) do_float = 1;
        
        if (ibuf1->x <= 1) return(IMB_dupImBuf(ibuf1));
        
-       ibuf2 = IMB_allocImBuf((ibuf1->x)/2 , ibuf1->y , ibuf1->depth,1,0);
-       if (ibuf2==0) return (0);
+       ibuf2 = IMB_allocImBuf((ibuf1->x)/2, ibuf1->y, ibuf1->depth, ibuf1->flags, 0);
+       if (ibuf2==NULL) return (0);
 
        _p1 = (uchar *) ibuf1->rect;
        dest=(uchar *) ibuf2->rect;
+         
+       _p1f = ibuf1->rect_float;
+       destf= ibuf2->rect_float;
 
        for(y=ibuf2->y;y>0;y--){
                p1 = _p1;
+               p1f = _p1f;
                for(x = ibuf2->x ; x>0 ; x--){
                        a = *(p1++) ;
                        b = *(p1++) ;
@@ -79,8 +86,23 @@ struct ImBuf *IMB_half_x(struct ImBuf *ibuf1)
                        *(dest++) = b >> 1;
                        *(dest++) = g >> 1;
                        *(dest++) = r >> 1;
+                       if (do_float) {
+                               af = *(p1f++);
+                               bf = *(p1f++);
+                               gf = *(p1f++);
+                               rf = *(p1f++);
+                               af += *(p1f++);
+                               bf += *(p1f++);
+                               gf += *(p1f++);
+                               rf += *(p1f++);
+                               *(destf++) = 0.5f*af;
+                               *(destf++) = 0.5f*bf;
+                               *(destf++) = 0.5f*gf;
+                               *(destf++) = 0.5f*rf;
+                       }
                }
                _p1 += (ibuf1->x << 2);
+               if (do_float) _p1f += (ibuf1->x << 2);
        }
        return (ibuf2);
 }
@@ -89,21 +111,30 @@ struct ImBuf *IMB_half_x(struct ImBuf *ibuf1)
 struct ImBuf *IMB_double_fast_x(struct ImBuf *ibuf1)
 {
        struct ImBuf *ibuf2;
-       int *p1,*dest, i, col;
+       int *p1,*dest, i, col, do_float=0;
+       float *p1f, *destf, colf;
 
-       if (ibuf1==0) return (0);
-       if (ibuf1->rect == 0) return (0);
+       if (ibuf1==NULL) return (0);
+       if (ibuf1->rect==NULL) return (0);
+       if (ibuf1->rect_float) do_float = 1;
 
-       ibuf2 = IMB_allocImBuf(2 * ibuf1->x , ibuf1->y , ibuf1->depth,1,0);
-       if (ibuf2==0) return (0);
+       ibuf2 = IMB_allocImBuf(2 * ibuf1->x , ibuf1->y , ibuf1->depth, ibuf1->flags, 0);
+       if (ibuf2==NULL) return (0);
 
        p1 = (int *) ibuf1->rect;
        dest=(int *) ibuf2->rect;
+       p1f = ibuf1->rect_float;
+       destf = ibuf2->rect_float;
 
        for(i = ibuf1->y * ibuf1->x ; i>0 ; i--) {
                col = *p1++;
                *dest++ = col;
                *dest++ = col;
+               if (do_float) {
+                       colf = *p1f++;
+                       *destf++ = col;
+                       *destf++ = col;
+               }
        }
 
        return (ibuf2);
@@ -113,8 +144,8 @@ struct ImBuf *IMB_double_x(struct ImBuf *ibuf1)
 {
        struct ImBuf *ibuf2;
 
-       if (ibuf1==0) return (0);
-       if (ibuf1->rect == 0) return (0);
+       if (ibuf1==NULL) return (0);
+       if (ibuf1->rect==NULL) return (0);
 
        ibuf2 = IMB_double_fast_x(ibuf1);
 
@@ -128,20 +159,30 @@ struct ImBuf *IMB_half_y(struct ImBuf *ibuf1)
        struct ImBuf *ibuf2;
        uchar *p1,*p2,*_p1,*dest;
        short a,r,g,b,x,y;
+       int do_float = 0;
+       float af,rf,gf,bf,*p1f,*p2f,*_p1f,*destf;
 
-       if (ibuf1==0) return (0);
-       if (ibuf1->rect == 0) return (0);
+       p1f = NULL; p2f = NULL;
+       if (ibuf1==NULL) return (0);
+       if (ibuf1->rect==NULL) return (0);
+       if (ibuf1->rect_float) do_float = 1;
        if (ibuf1->y <= 1) return(IMB_dupImBuf(ibuf1));
 
-       ibuf2 = IMB_allocImBuf(ibuf1->x , (ibuf1->y) / 2 , ibuf1->depth,1,0);
-       if (ibuf2==0) return (0);
+       ibuf2 = IMB_allocImBuf(ibuf1->x , (ibuf1->y) / 2 , ibuf1->depth, ibuf1->flags, 0);
+       if (ibuf2==NULL) return (0);
 
        _p1 = (uchar *) ibuf1->rect;
        dest=(uchar *) ibuf2->rect;
+       _p1f = ibuf1->rect_float;
+       destf= ibuf2->rect_float;
 
        for(y=ibuf2->y ; y>0 ; y--){
                p1 = _p1;
                p2 = _p1 + (ibuf1->x << 2);
+               if (do_float) {
+                       p1f = _p1f;
+                       p2f = _p1f + (ibuf1->x << 2);
+               }
                for(x = ibuf2->x ; x>0 ; x--){
                        a = *(p1++) ;
                        b = *(p1++) ;
@@ -155,8 +196,23 @@ struct ImBuf *IMB_half_y(struct ImBuf *ibuf1)
                        *(dest++) = b >> 1;
                        *(dest++) = g >> 1;
                        *(dest++) = r >> 1;
+                       if (do_float) {
+                               af = *(p1f++) ;
+                               bf = *(p1f++) ;
+                               gf = *(p1f++) ;
+                               rf = *(p1f++);
+                               af += *(p2f++) ;
+                               bf += *(p2f++) ;
+                               gf += *(p2f++) ;
+                               rf += *(p2f++);
+                               *(destf++) = 0.5f*af;
+                               *(destf++) = 0.5f*bf;
+                               *(destf++) = 0.5f*gf;
+                               *(destf++) = 0.5f*rf;
+                       }
                }
                _p1 += (ibuf1->x << 3);
+               if (do_float) _p1f += (ibuf1->x << 3);
        }
        return (ibuf2);
 }
@@ -166,21 +222,31 @@ struct ImBuf *IMB_double_fast_y(struct ImBuf *ibuf1)
 {
        struct ImBuf *ibuf2;
        int *p1, *dest1, *dest2;
+       float *p1f, *dest1f, *dest2f;
        short x,y;
+       int do_float =0;
 
-       if (ibuf1==0) return (0);
-       if (ibuf1->rect == 0) return (0);
+       if (ibuf1==NULL) return (0);
+       if (ibuf1->rect==NULL) return (0);
+       if (ibuf1->rect_float) do_float =1;
 
-       ibuf2 = IMB_allocImBuf(ibuf1->x , 2 * ibuf1->y , ibuf1->depth,1,0);
-       if (ibuf2==0) return (0);
+       ibuf2 = IMB_allocImBuf(ibuf1->x , 2 * ibuf1->y , ibuf1->depth, ibuf1->flags, 0);
+       if (ibuf2==NULL) return (0);
 
        p1 = (int *) ibuf1->rect;
        dest1=(int *) ibuf2->rect;
+       p1f = ibuf1->rect_float;
+       dest1f= ibuf2->rect_float;
 
        for(y = ibuf1->y ; y>0 ; y--){
                dest2 = dest1 + ibuf2->x;
                for(x = ibuf2->x ; x>0 ; x--) *dest1++ = *dest2++ = *p1++;
                dest1 = dest2;
+               if (do_float) {
+                       dest2f = dest1f + ibuf2->x;
+                       for(x = ibuf2->x ; x>0 ; x--) *dest1f++ = *dest2f++ = *p1f++;
+                       dest1f = dest2f;
+               }
        }
 
        return (ibuf2);
@@ -190,8 +256,8 @@ struct ImBuf *IMB_double_y(struct ImBuf *ibuf1)
 {
        struct ImBuf *ibuf2;
 
-       if (ibuf1==0) return (0);
-       if (ibuf1->rect == 0) return (0);
+       if (ibuf1==NULL) return (0);
+       if (ibuf1->rect==NULL) return (0);
 
        ibuf2 = IMB_double_fast_y(ibuf1);
        
@@ -203,23 +269,29 @@ struct ImBuf *IMB_double_y(struct ImBuf *ibuf1)
 struct ImBuf *IMB_onehalf(struct ImBuf *ibuf1)
 {
        struct ImBuf *ibuf2;
-       uchar *p1,*p2,*dest;
+       uchar *p1, *p2, *dest;
+       float *p1f, *destf, *p2f = NULL;
        int x,y;
+       int do_float =0;
 
-       if (ibuf1 == 0) return (0);
-       if (ibuf1->rect == 0) return (0);
+       if (ibuf1==NULL) return (0);
+       if (ibuf1->rect==NULL) return (0);
+       if (ibuf1->rect_float) do_float = 1;
 
        if (ibuf1->x <= 1) return(IMB_half_y(ibuf1));
        if (ibuf1->y <= 1) return(IMB_half_x(ibuf1));
        
-       ibuf2=IMB_allocImBuf((ibuf1->x)/2,(ibuf1->y)/2,ibuf1->depth,1,0);
-       if (ibuf2==0) return (0);
+       ibuf2=IMB_allocImBuf((ibuf1->x)/2, (ibuf1->y)/2, ibuf1->depth, ibuf1->flags, 0);
+       if (ibuf2==NULL) return (0);
 
+       p1f = ibuf1->rect_float;
+       destf=ibuf2->rect_float;
        p1 = (uchar *) ibuf1->rect;
        dest=(uchar *) ibuf2->rect;
 
        for(y=ibuf2->y;y>0;y--){
                p2 = p1 + (ibuf1->x << 2);
+               if (do_float) p2f = p1f + (ibuf1->x << 2);
                for(x=ibuf2->x;x>0;x--){
                        dest[0] = (p1[0] + p2[0] + p1[4] + p2[4]) >> 2;
                        dest[1] = (p1[1] + p2[1] + p1[5] + p2[5]) >> 2;
@@ -228,10 +300,21 @@ struct ImBuf *IMB_onehalf(struct ImBuf *ibuf1)
                        p1 += 8; 
                        p2 += 8; 
                        dest += 4;
+                       if (do_float){ 
+                               destf[0] = 0.25f*(p1f[0] + p2f[0] + p1f[4] + p2f[4]);
+                               destf[1] = 0.25f*(p1f[1] + p2f[1] + p1f[5] + p2f[5]);
+                               destf[2] = 0.25f*(p1f[2] + p2f[2] + p1f[6] + p2f[6]);
+                               destf[3] = 0.25f*(p1f[3] + p2f[3] + p1f[7] + p2f[7]);
+                               p1f += 8; 
+                               p2f += 8; 
+                               destf += 4;
+                       }
                }
                p1=p2;
+               if (do_float) p1f=p2f;
                if(ibuf1->x & 1) {
                        p1+=4;
+                       if (do_float) p1f+=4;
                }
        }
        return (ibuf2);
@@ -243,34 +326,59 @@ struct ImBuf *IMB_onethird(struct ImBuf *ibuf1)
 {
        struct ImBuf *ibuf2;
        uchar *p1,*p2,*p3,*dest;
+       float *p1f, *p2f, *p3f, *destf;
+       int do_float=0;
        short a,r,g,b,x,y,i;
+       float af,rf,gf,bf;
 
-       if (ibuf1 == 0) return (0);
-       if (ibuf1->rect == 0) return (0);
+       p2f = NULL; p3f = NULL;
+       if (ibuf1==NULL) return (0);
+       if (ibuf1->rect==NULL) return (0);
+       if (ibuf1->rect_float) do_float = 1;
 
-       ibuf2=IMB_allocImBuf((ibuf1->x)/3,(ibuf1->y)/3,ibuf1->depth,1,0);
-       if (ibuf2==0) return (0);
+       ibuf2=IMB_allocImBuf((ibuf1->x)/3, (ibuf1->y)/3, ibuf1->depth, ibuf1->flags, 0);
+       if (ibuf2==NULL) return (0);
 
+       p1f = ibuf1->rect_float;
+       destf = ibuf2->rect_float;
        p1 = (uchar *) ibuf1->rect;
        dest=(uchar *) ibuf2->rect;
 
        for(y=ibuf2->y;y>0;y--){
                p2 = p1 + (ibuf1->x << 2);
                p3 = p2 + (ibuf1->x << 2);
+               if (do_float) {
+                       p2f = p1f + (ibuf1->x <<2);
+                       p3f = p2f + (ibuf1->x <<2);
+               }
                for(x=ibuf2->x;x>0;x--){
                        a=r=g=b=0;
+                       af=rf=gf=bf=0;
                        for (i=3;i>0;i--){
                                a += *(p1++) + *(p2++) + *(p3++);
                                b += *(p1++) + *(p2++) + *(p3++);
                                g += *(p1++) + *(p2++) + *(p3++);
                                r += *(p1++) + *(p2++) + *(p3++);
+                               if (do_float) {
+                                       af += *(p1f++) + *(p2f++) + *(p3f++);
+                                       bf += *(p1f++) + *(p2f++) + *(p3f++);
+                                       gf += *(p1f++) + *(p2f++) + *(p3f++);
+                                       rf += *(p1f++) + *(p2f++) + *(p3f++);
+                               }
                        }
                        *(dest++) = a/9;
                        *(dest++) = b/9;
                        *(dest++) = g/9;
                        *(dest++) = r/9;
+                       if (do_float) {
+                               *(destf++) = af/9.0f;
+                               *(destf++) = bf/9.0f;
+                               *(destf++) = gf/9.0f;
+                               *(destf++) = rf/9.0f;
+                       }
                }
                p1=p3;
+               if (do_float) p1f = p3f;
        }
        return (ibuf2);
 }
@@ -280,33 +388,55 @@ struct ImBuf *IMB_halflace(struct ImBuf *ibuf1)
 {
        struct ImBuf *ibuf2;
        uchar *p1,*p2,*dest;
+       float *p1f,*p2f,*destf;
        short a,r,g,b,x,y,i;
+       float af,rf,gf,bf;
+       int do_float = 0;
 
-       if (ibuf1 == 0) return (0);
-       if (ibuf1->rect == 0) return (0);
+       p2f = NULL;
+       if (ibuf1==NULL) return (0);
+       if (ibuf1->rect==NULL) return (0);
+       if (ibuf1->rect_float) do_float = 1;
 
-       ibuf2=IMB_allocImBuf((ibuf1->x)/4,(ibuf1->y)/2,ibuf1->depth,1,0);
-       if (ibuf2==0) return (0);
+       ibuf2=IMB_allocImBuf((ibuf1->x)/4, (ibuf1->y)/2, ibuf1->depth, ibuf1->flags, 0);
+       if (ibuf2==NULL) return (0);
 
+       p1f = ibuf1->rect_float;
+       destf= ibuf2->rect_float;
        p1 = (uchar *) ibuf1->rect;
        dest=(uchar *) ibuf2->rect;
 
        for(y= ibuf2->y / 2 ; y>0;y--){
                p2 = p1 + (ibuf1->x << 3);
+               if (do_float) p2f = p1f + (ibuf1->x << 3);
                for(x = 2 * ibuf2->x;x>0;x--){
                        a=r=g=b=0;
+                       af=rf=gf=bf=0;
                        for (i=4;i>0;i--){
                                a += *(p1++) + *(p2++);
                                b += *(p1++) + *(p2++);
                                g += *(p1++) + *(p2++);
                                r += *(p1++) + *(p2++);
+                               if (do_float) {
+                                       af += *(p1f++) + *(p2f++);
+                                       bf += *(p1f++) + *(p2f++);
+                                       gf += *(p1f++) + *(p2f++);
+                                       rf += *(p1f++) + *(p2f++);
+                               }
                        }
                        *(dest++) = a >> 3;
                        *(dest++) = b >> 3;
                        *(dest++) = g >> 3;
                        *(dest++) = r >> 3;
+                       if (do_float) {
+                               *(destf++) = 0.125f*af;
+                               *(destf++) = 0.125f*bf;
+                               *(destf++) = 0.125f*gf;
+                               *(destf++) = 0.125f*rf;
+                       }
                }
                p1 = p2;
+               if (do_float) p1f = p2f;
        }
        return (ibuf2);
 }
@@ -315,14 +445,23 @@ struct ImBuf *IMB_halflace(struct ImBuf *ibuf1)
 static struct ImBuf *scaledownx(struct ImBuf *ibuf, int newx)
 {
        uchar *rect,*_newrect,*newrect;
-       float sample, add, val, nval;
-       int x, y, i;
+       float *rectf,*_newrectf,*newrectf;
+       float sample, add, val, nval, valf, nvalf;
+       int x, y, i, do_float=0;
 
-       if (ibuf == 0) return(0);
-       if (ibuf->rect == 0) return(ibuf);
+       rectf = NULL; _newrectf= NULL; newrectf = NULL; 
+       nval = 0; nvalf = 0;
+       
+       if (ibuf==NULL) return(0);
+       if (ibuf->rect==NULL) return(ibuf);
+       if (ibuf->rect_float) {
+               do_float = 1;
+               _newrectf = MEM_mallocN(newx * ibuf->y * sizeof(float) * 4, "scaledownxf");
+               if (_newrectf==NULL) return(ibuf);
+       }
 
-       _newrect = (uchar *) malloc(newx * ibuf->y * sizeof(int));
-       if (_newrect == 0) return(ibuf);
+       _newrect = MEM_mallocN(newx * ibuf->y * sizeof(int), "scaledownx");
+       if (_newrect==NULL) return(ibuf);
 
        add = (ibuf->x - 0.001) / newx;
 
@@ -331,22 +470,39 @@ static struct ImBuf *scaledownx(struct ImBuf *ibuf, int newx)
                rect = (uchar *) ibuf->rect;
                rect += i;
                newrect = _newrect + i;
+               if (do_float) {
+                       rectf = ibuf->rect_float;
+                       rectf += i;
+                       newrectf = _newrectf + i;
+               }
 
                for (y = ibuf->y; y>0 ; y--){
-                       val = sample = 0.0;
+                       val = sample = valf = 0.0;
 
                        for (x = newx ; x>0 ; x--){
                                nval = - val * sample;
+                               if (do_float) nvalf = - valf * sample;
                                sample += add;
 
                                while (sample >= 1.0){
                                        sample -= 1.0;
                                        nval += *rect;
                                        rect += 4;
+                                       if (do_float) {
+                                               nvalf += *rectf;
+                                               rectf += 4;
+                                       }
                                }
                                val = *rect;
                                rect += 4;
                                nval += sample * val;
+                               if (do_float) {
+                                       valf = *rectf;
+                                       rectf += 4;
+                                       nvalf += sample * valf;
+                                       *newrectf = (nvalf/add) + 0.5;
+                                       newrectf += 4;
+                               }
                                sample -= 1.0;
                                *newrect = (nval/add) + 0.5;
                                newrect += 4;
@@ -357,6 +513,13 @@ static struct ImBuf *scaledownx(struct ImBuf *ibuf, int newx)
        imb_freerectImBuf(ibuf);
        ibuf->mall |= IB_rect;
        ibuf->rect = (unsigned int *) _newrect;
+       
+       if (do_float) {
+               imb_freerectfloatImBuf(ibuf);
+               ibuf->mall |= IB_rectfloat;
+               ibuf->rect_float = _newrectf;
+       }
+       
        ibuf->x = newx;
        return(ibuf);
 }
@@ -364,15 +527,25 @@ static struct ImBuf *scaledownx(struct ImBuf *ibuf, int newx)
 
 static struct ImBuf *scaledowny(struct ImBuf *ibuf, int newy)
 {
-       uchar *rect,*_newrect,*newrect;
-       float sample,add,val,nval;
-       int x,y,i,skipx;
+       uchar *rect, *_newrect, *newrect;
+       float *rectf, *_newrectf, *newrectf;
+       float sample, add, val, nval, valf, nvalf;
+       int x, y, i, skipx, do_float = 0;
 
-       if (ibuf == 0) return(0);
-       if (ibuf->rect == 0) return(ibuf);
+       rectf= NULL; _newrectf = NULL; newrectf = NULL; 
+       nval = 0; nvalf = 0;
 
-       _newrect = (uchar *) malloc(newy * ibuf->x * sizeof(int));
-       if (_newrect == 0) return(ibuf);
+       if (ibuf==NULL) return(0);
+       if (ibuf->rect==NULL) return(ibuf);
+       
+       if (ibuf->rect_float) {
+               do_float = 1;
+               _newrectf = MEM_mallocN(newy * ibuf->x * sizeof(float) * 4, "scaldownyf");
+               if (_newrectf==NULL) return(ibuf);
+       }
+
+       _newrect = MEM_mallocN(newy * ibuf->x * sizeof(int), "scaledowny");
+       if (_newrect==NULL) return(ibuf);
 
        add = (ibuf->y - 0.001) / newy;
        skipx = 4 * ibuf->x;
@@ -382,23 +555,39 @@ static struct ImBuf *scaledowny(struct ImBuf *ibuf, int newy)
                for (x = skipx - 4; x>=0 ; x-= 4){
                        rect = ((uchar *) ibuf->rect) + i + x;
                        newrect = _newrect + i + x;
+                       if (do_float) {
+                               rectf = ((float *) ibuf->rect_float) + i + x;
+                               newrectf = _newrectf + i + x;
+                       }
                        val = sample = 0.0;
 
                        for (y = newy ; y>0 ; y--){
                                nval = - val * sample;
+                               if (do_float) nvalf = - val * sample;
                                sample += add;
 
                                while (sample >= 1.0){
                                        sample -= 1.0;
                                        nval += *rect;
                                        rect += skipx;
+                                       if (do_float) {
+                                               nvalf += *rectf;
+                                               rectf += skipx;
+                                       }
                                }
                                val = *rect;
                                rect += skipx;
                                nval += sample * val;
-                               sample -= 1.0;
                                *newrect = (nval/add) + 0.5;
                                newrect += skipx;
+                               if (do_float) {
+                                       valf = *rectf;
+                                       rectf += skipx;
+                                       nvalf += sample * valf;
+                                       *newrectf = (nvalf/add) + 0.5;
+                                       newrectf += skipx;
+                               }
+                               sample -= 1.0;
                        }
                }
        }
@@ -406,6 +595,13 @@ static struct ImBuf *scaledowny(struct ImBuf *ibuf, int newy)
        imb_freerectImBuf(ibuf);
        ibuf->mall |= IB_rect;
        ibuf->rect = (unsigned int *) _newrect;
+       
+       if (do_float) {
+               imb_freerectfloatImBuf(ibuf);
+               ibuf->mall |= IB_rectfloat;
+               ibuf->rect_float = (float *) _newrectf;
+       }
+       
        ibuf->y = newy;
        return(ibuf);
 }
@@ -414,23 +610,39 @@ static struct ImBuf *scaledowny(struct ImBuf *ibuf, int newy)
 static struct ImBuf *scaleupx(struct ImBuf *ibuf, int newx)
 {
        uchar *rect,*_newrect,*newrect;
+       float *rectf,*_newrectf,*newrectf;
        float sample,add;
        float val_a,nval_a,diff_a;
        float val_b,nval_b,diff_b;
        float val_g,nval_g,diff_g;
        float val_r,nval_r,diff_r;
-       int x,y;
-
-       if (ibuf == 0) return(0);
-       if (ibuf->rect == 0) return(ibuf);
+       float val_af,nval_af,diff_af;
+       float val_bf,nval_bf,diff_bf;
+       float val_gf,nval_gf,diff_gf;
+       float val_rf,nval_rf,diff_rf;
+       int x,y, do_float = 0;
+
+       val_af = nval_af = diff_af = val_bf = nval_bf = diff_bf = 0;
+       val_gf = nval_gf = diff_gf = val_rf = nval_rf = diff_rf = 0;
+       if (ibuf==NULL) return(0);
+       if (ibuf->rect==NULL) return(ibuf);
+
+       _newrect = MEM_mallocN(newx * ibuf->y * sizeof(int), "scaleupx");
+       if (_newrect==NULL) return(ibuf);
+
+       if (ibuf->rect_float) {
+               do_float = 1;
+               _newrectf = MEM_mallocN(newx * ibuf->y * sizeof(float) * 4, "scaleupxf");
+               if (_newrectf==NULL) return(ibuf);
+       }
 
-       _newrect = (uchar *) malloc(newx * ibuf->y * sizeof(int));
-       if (_newrect == 0) return(ibuf);
 
        add = (ibuf->x - 1.001) / (newx - 1.0);
 
        rect = (uchar *) ibuf->rect;
+       rectf = (float *) ibuf->rect_float;
        newrect = _newrect;
+       newrectf = _newrectf = NULL;
 
        for (y = ibuf->y; y>0 ; y--){
 
@@ -456,9 +668,34 @@ static struct ImBuf *scaleupx(struct ImBuf *ibuf, int newx)
                val_r += 0.5;
 
                rect += 8;
+
+               if (do_float) {
+                       val_af = rectf[0] ;
+                       nval_af = rectf[4];
+                       diff_af = nval_af - val_af;
+                       val_af += 0.5;
+       
+                       val_bf = rectf[1] ;
+                       nval_bf = rectf[5];
+                       diff_bf = nval_bf - val_bf;
+                       val_bf += 0.5;
+
+                       val_gf = rectf[2] ;
+                       nval_gf = rectf[6];
+                       diff_gf = nval_gf - val_gf;
+                       val_gf += 0.5;
+
+                       val_rf = rectf[3] ;
+                       nval_rf = rectf[7];
+                       diff_rf = nval_rf - val_rf;
+                       val_rf += 0.5;
+
+                       rectf += 8;
+               }
                for (x = newx ; x>0 ; x--){
                        if (sample >= 1.0){
                                sample -= 1.0;
+
                                val_a = nval_a ;
                                nval_a = rect[0] ;
                                diff_a = nval_a - val_a ;
@@ -479,12 +716,42 @@ static struct ImBuf *scaleupx(struct ImBuf *ibuf, int newx)
                                diff_r = nval_r - val_r ;
                                val_r += 0.5;
                                rect += 4;
+
+                               if (do_float) {
+                                       val_af = nval_af ;
+                                       nval_af = rectf[0] ;
+                                       diff_af = nval_af - val_af ;
+                                       val_af += 0.5;
+       
+                                       val_bf = nval_bf ;
+                                       nval_bf = rectf[1] ;
+                                       diff_bf = nval_bf - val_bf ;
+                                       val_bf += 0.5;
+
+                                       val_gf = nval_gf ;
+                                       nval_gf = rectf[2] ;
+                                       diff_gf = nval_gf - val_gf ;
+                                       val_gf += 0.5;
+
+                                       val_rf = nval_rf ;
+                                       nval_rf = rectf[3] ;
+                                       diff_rf = nval_rf - val_rf;
+                                       val_rf += 0.5;
+                                       rectf += 4;
+                               }
                        }
                        newrect[0] = val_a + sample * diff_a;
                        newrect[1] = val_b + sample * diff_b;
                        newrect[2] = val_g + sample * diff_g;
                        newrect[3] = val_r + sample * diff_r;
                        newrect += 4;
+                       if (do_float) {
+                               newrectf[0] = val_af + sample * diff_af;
+                               newrectf[1] = val_bf + sample * diff_bf;
+                               newrectf[2] = val_gf + sample * diff_gf;
+                               newrectf[3] = val_rf + sample * diff_rf;
+                               newrectf += 4;
+                       }
                        sample += add;
                }
        }
@@ -492,6 +759,13 @@ static struct ImBuf *scaleupx(struct ImBuf *ibuf, int newx)
        imb_freerectImBuf(ibuf);
        ibuf->mall |= IB_rect;
        ibuf->rect = (unsigned int *) _newrect;
+       
+       if (do_float) {
+               imb_freerectfloatImBuf(ibuf);
+               ibuf->mall |= IB_rectfloat;
+               ibuf->rect_float = (float *) _newrectf;
+       }
+       
        ibuf->x = newx;
        return(ibuf);
 }
@@ -500,24 +774,44 @@ static struct ImBuf *scaleupx(struct ImBuf *ibuf, int newx)
 static struct ImBuf *scaleupy(struct ImBuf *ibuf, int newy)
 {
        uchar *rect,*_newrect,*newrect;
-       float sample,add,val,nval,diff;
-       int x,y,i,skipx;
+       float *rectf = NULL, *newrectf = NULL, *_newrectf = NULL;
+       float sample,add,val,nval,diff, valf=0.0f, nvalf=0.0f, difff=0.0f;
+       int x,y,i,skipx, do_float = 0;
 
-       if (ibuf == 0) return(0);
-       if (ibuf->rect == 0) return(ibuf);
+       if (ibuf==NULL) return(0);
+       if (ibuf->rect==NULL) return(ibuf);
 
-       _newrect = (uchar *)malloc(newy * ibuf->x * sizeof(int));
-       if (_newrect == 0) return(ibuf);
+       _newrect = MEM_mallocN(newy * ibuf->x * sizeof(int), "scaleupy");
+       if (_newrect==NULL) return(ibuf);
 
+       if (ibuf->rect_float) {
+               do_float = 1;
+               _newrectf = MEM_mallocN(newy * ibuf->y * sizeof(float) * 4, "scaleupyf");
+               if (_newrectf==NULL) return(ibuf);
+       }
+       
        add = (ibuf->y - 1.001) / (newy - 1.0);
        skipx = 4 * ibuf->x;
 
        /* all four components, rgba/abgr */
        for(i=3 ; i>=0 ; i--){
                for (x = skipx - 4; x >= 0 ; x -= 4){
+                       
                        rect = (uchar *) ibuf->rect;
                        rect += i + x;
                        newrect = _newrect + i + x;
+                       
+                       if (do_float) {
+                               rectf = ibuf->rect_float;
+                               rectf += i * x;
+                               newrectf = _newrectf + i + x;
+                               valf = *rectf;
+                               rectf += skipx;
+                               nvalf = *rectf;
+                               rectf += skipx;
+                               difff = nvalf - valf;
+                               valf += 0.5;
+                       }
 
                        sample = 0;
                        val = *rect ;
@@ -535,9 +829,22 @@ static struct ImBuf *scaleupy(struct ImBuf *ibuf, int newy)
                                        rect += skipx;
                                        diff = nval - val;
                                        val += 0.5;
+                                       
+                                       if (do_float) {
+                                               valf = nvalf;
+                                               nvalf = *rectf;
+                                               rectf += skipx;
+                                               difff = nvalf - valf;
+                                               valf += 0.5;
+                                       }
                                }
                                *newrect = val + sample * diff;
                                newrect += skipx;
+                               
+                               if (do_float) {
+                                       *newrectf = valf + sample * difff;
+                                       newrectf += skipx;
+                               }
                                sample += add;
                        }
                }
@@ -546,20 +853,28 @@ static struct ImBuf *scaleupy(struct ImBuf *ibuf, int newy)
        imb_freerectImBuf(ibuf);
        ibuf->mall |= IB_rect;
        ibuf->rect = (unsigned int *) _newrect;
+       
+       if(do_float) {
+               imb_freerectfloatImBuf(ibuf);
+               ibuf->mall |= IB_rectfloat;
+               ibuf->rect_float = _newrectf;
+       }
+       
        ibuf->y = newy;
        return(ibuf);
 }
 
+/* no float buf needed here! */
 static void scalefast_Z_ImBuf(ImBuf *ibuf, short newx, short newy)
 {
-       unsigned int *rect,*_newrect,*newrect;
-       int x,y;
-       int ofsx,ofsy,stepx,stepy;
+       unsigned int *rect, *_newrect, *newrect;
+       int x, y;
+       int ofsx, ofsy, stepx, stepy;
 
        if (ibuf->zbuf) {
-               _newrect = malloc(newx * newy * sizeof(int));
-               if (_newrect == 0) return;
-       
+               _newrect = MEM_mallocN(newx * newy * sizeof(int), "z rect");
+               if (_newrect==NULL) return;
+               
                stepx = (65536.0 * (ibuf->x - 1.0) / (newx - 1.0)) + 0.5;
                stepy = (65536.0 * (ibuf->y - 1.0) / (newy - 1.0)) + 0.5;
                ofsy = 32768;
@@ -585,8 +900,8 @@ static void scalefast_Z_ImBuf(ImBuf *ibuf, short newx, short newy)
 
 struct ImBuf *IMB_scaleImBuf(struct ImBuf * ibuf, short newx, short newy)
 {
-       if (ibuf == 0) return (0);
-       if (ibuf->rect == 0) return (ibuf);
+       if (ibuf==NULL) return (0);
+       if (ibuf->rect==NULL) return (ibuf);
 
        // scaleup / scaledown functions below change ibuf->x and ibuf->y
        // so we first scale the Z-buffer (if any)
@@ -604,18 +919,28 @@ struct ImBuf *IMB_scaleImBuf(struct ImBuf * ibuf, short newx, short newy)
 struct ImBuf *IMB_scalefastImBuf(struct ImBuf *ibuf, short newx, short newy)
 {
        unsigned int *rect,*_newrect,*newrect;
-       int x,y;
+       float *rectf,*_newrectf,*newrectf;
+       int x,y, do_float=0;
        int ofsx,ofsy,stepx,stepy;
 
-       if (ibuf == 0) return(0);
-       if (ibuf->rect == 0) return(ibuf);
+       rectf = NULL; _newrectf = NULL; newrectf = NULL;
 
-       if (newx == ibuf->x && newy == ibuf->y) return(ibuf);
+       if (ibuf==NULL) return(0);
+       if (ibuf->rect==NULL) return(ibuf);
+       if (ibuf->rect_float) do_float = 1;
 
-       _newrect = malloc(newx * newy * sizeof(int));
-       if (_newrect == 0) return(ibuf);
+       if (newx == ibuf->x && newy == ibuf->y) return(ibuf);
 
+       _newrect = MEM_mallocN(newx * newy * sizeof(int), "scalefastimbuf");
+       if (_newrect==NULL) return(ibuf);
        newrect = _newrect;
+
+       if (do_float) {
+               _newrectf = MEM_mallocN(newx * newy * sizeof(float) * 4, "scalefastimbuf f");
+               if (_newrectf==NULL) return(ibuf);
+               newrectf = _newrectf;
+       }
+
        stepx = (65536.0 * (ibuf->x - 1.0) / (newx - 1.0)) + 0.5;
        stepy = (65536.0 * (ibuf->y - 1.0) / (newy - 1.0)) + 0.5;
        ofsy = 32768;
@@ -623,10 +948,16 @@ struct ImBuf *IMB_scalefastImBuf(struct ImBuf *ibuf, short newx, short newy)
        for (y = newy; y > 0 ; y--){
                rect = ibuf->rect;
                rect += (ofsy >> 16) * ibuf->x;
+               if (do_float) {
+                       rectf = ibuf->rect_float;
+                       rectf += (ofsy >> 16) * ibuf->x;
+               }
                ofsy += stepy;
                ofsx = 32768;
+               
                for (x = newx ; x>0 ; x--){
                        *newrect++ = rect[ofsx >> 16];
+                       if (do_float) *newrectf++ = rectf[ofsx >> 16];
                        ofsx += stepx;
                }
        }
@@ -635,6 +966,12 @@ struct ImBuf *IMB_scalefastImBuf(struct ImBuf *ibuf, short newx, short newy)
        ibuf->mall |= IB_rect;
        ibuf->rect = _newrect;
        
+       if (do_float) {
+               imb_freerectfloatImBuf(ibuf);
+               ibuf->mall |= IB_rectfloat;
+               ibuf->rect_float = _newrectf;
+       }
+       
        scalefast_Z_ImBuf(ibuf, newx, newy);
        
        ibuf->x = newx;
@@ -646,33 +983,34 @@ struct ImBuf *IMB_scalefastImBuf(struct ImBuf *ibuf, short newx, short newy)
 static struct ImBuf *generic_fieldscale(struct ImBuf *ibuf, short newx, short newy, struct ImBuf *(*scalefunc)(ImBuf *, short, short) )
 {
        struct ImBuf *sbuf1, *sbuf2;
-/*     extern void rectcpy(); */
        
-       sbuf1 = IMB_allocImBuf(ibuf->x, ibuf->y / 2, ibuf->depth, IB_rect, 0);
-       sbuf2 = IMB_allocImBuf(ibuf->x, ibuf->y / 2, ibuf->depth, IB_rect, 0);
+       sbuf1 = IMB_allocImBuf(ibuf->x, ibuf->y / 2, ibuf->depth, ibuf->flags, 0);
+       sbuf2 = IMB_allocImBuf(ibuf->x, ibuf->y / 2, ibuf->depth, ibuf->flags, 0);
        
        ibuf->x *= 2;
+       
        /* more args needed, 0 assumed... (nzc) */
-/*     rectop(sbuf1, ibuf, 0, 0, 0, 0, 32767, 32767, rectcpy); */
-/*     rectop(sbuf2, ibuf, 0, 0, sbuf2->x, 0, 32767, 32767, rectcpy); */
-       IMB_rectop(sbuf1, ibuf, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
-       IMB_rectop(sbuf2, ibuf, 0, 0, sbuf2->x, 0, 32767, 32767, IMB_rectcpy, 0);
+       IMB_rectcpy(sbuf1, ibuf, 0, 0, 0, 0, ibuf->x, ibuf->y);
+       IMB_rectcpy(sbuf2, ibuf, 0, 0, sbuf2->x, 0, ibuf->x, ibuf->y);
        
        imb_freerectImBuf(ibuf);
+       imb_freerectfloatImBuf(ibuf);
+       
        ibuf->x = newx;
        ibuf->y = newy;
-       imb_addrectImBuf(ibuf);
        
+       imb_addrectImBuf(ibuf);
+       if(ibuf->flags & IB_rectfloat)
+               imb_addrectfloatImBuf(ibuf);
+               
        scalefunc(sbuf1, newx, newy / 2);
        scalefunc(sbuf2, newx, newy / 2);       
        
        ibuf->x *= 2;
        
        /* more args needed, 0 assumed... (nzc) */
-/*     rectop(ibuf, sbuf1, 0, 0, 0, 0, 32767, 32767, rectcpy); */
-/*     rectop(ibuf, sbuf2, sbuf2->x, 0, 0, 0, 32767, 32767, rectcpy); */
-       IMB_rectop(ibuf, sbuf1, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
-       IMB_rectop(ibuf, sbuf2, sbuf2->x, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
+       IMB_rectcpy(ibuf, sbuf1, 0, 0, 0, 0, sbuf1->x, sbuf1->y);
+       IMB_rectcpy(ibuf, sbuf2, sbuf2->x, 0, 0, 0, sbuf2->x, sbuf2->y);
        
        ibuf->x /= 2;
        
@@ -683,9 +1021,7 @@ static struct ImBuf *generic_fieldscale(struct ImBuf *ibuf, short newx, short ne
 }
 
 
-struct ImBuf *IMB_scalefastfieldImBuf(struct ImBuf *ibuf,
-                                                                         short newx,
-                                                                         short newy)
+struct ImBuf *IMB_scalefastfieldImBuf(struct ImBuf *ibuf, short newx, short newy)
 {
        return(generic_fieldscale(ibuf, newx, newy, IMB_scalefastImBuf));
 }
@@ -694,3 +1030,4 @@ struct ImBuf *IMB_scalefieldImBuf(struct ImBuf *ibuf, short newx, short newy)
 {
        return(generic_fieldscale(ibuf, newx, newy, IMB_scaleImBuf));
 }
+
index 5c0640986716801a0bf3448685ddb092a7a00af5..331c1031599634ba25583822d397da1bf024713c 100644 (file)
@@ -518,8 +518,8 @@ struct ImBuf *imb_loadtarga(unsigned char *mem, int flags)
        
        if (checktarga(&tga,mem) == 0) return(0);
 
-       if (flags & IB_test) ibuf = IMB_allocImBuf(tga.xsize,tga.ysize,tga.pixsize,0,0);
-       else ibuf = IMB_allocImBuf(tga.xsize,tga.ysize,(tga.pixsize + 0x7) & ~0x7,1,0);
+       if (flags & IB_test) ibuf = IMB_allocImBuf(tga.xsize,tga.ysize,tga.pixsize, 0, 0);
+       else ibuf = IMB_allocImBuf(tga.xsize,tga.ysize,(tga.pixsize + 0x7) & ~0x7, IB_rect, 0);
 
        if (ibuf == 0) return(0);
        ibuf->ftype = TGA;
@@ -629,7 +629,7 @@ struct ImBuf *imb_loadtarga(unsigned char *mem, int flags)
 
        if (ibuf) {
                if (ibuf->rect && (flags & IB_cmap)==0) 
-                       IMB_convert_rgba_to_abgr((ibuf->x+ibuf->skipx)*ibuf->y, ibuf->rect);
+                       IMB_convert_rgba_to_abgr(ibuf);
        }
        
        return(ibuf);
index 616531b3a771952ce260c798b8150c5ca3b5a18e..6fc5fb99f8b87e2d7268e4171aa6ae9702eccdd0 100644 (file)
@@ -399,7 +399,7 @@ struct ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags)
        /* close the client layer interface to the in-memory file */
        libtiff_TIFFClose(image);
 
-       if (G.order == B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
+       if (G.order == B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf);
 
        /* return successfully */
        return (ibuf);
index 4cdfa852df1c7fe22a5719eb9ad4e2be78fd75a3..8110a115471ba8c07bc22225cb58a37202521094 100644 (file)
 
 #include "IMB_anim.h"
 
+#ifdef WITH_OPENEXR
+#include "openexr/openexr_api.h"
+#endif
+
 #ifdef WITH_QUICKTIME
 #include "quicktime_import.h"
 #endif
@@ -97,7 +101,9 @@ static int IMB_ispic_name(char *name)
                                }
                                if (imb_is_a_png(buf)) return(PNG);
                                if (imb_is_a_targa(buf)) return(TGA);
-
+#ifdef WITH_OPENEXR
+                               if (imb_is_a_openexr((uchar *)buf)) return(OPENEXR);
+#endif
                                if (imb_is_a_tiff(buf)) return(TIF);
 
                                /* radhdr: check if hdr format */
index 340f8ace415b49431d1d2ef96f4e3fac6ce28c6f..b752dbf9dd0db9dfac410a7204bc899f67959169 100644 (file)
 #include "IMB_bmp.h"
 #include "IMB_tiff.h"
 #include "IMB_radiance_hdr.h"
+#ifdef WITH_OPENEXR
+#include "openexr/openexr_api.h"
+#endif
 
 #include "IMB_iff.h"
 #include "IMB_bitplanes.h"
 #include "IMB_divers.h"
 
-short IMB_saveiff(struct ImBuf *ibuf,char *naam,int flags)
+short IMB_saveiff(struct ImBuf *ibuf, char *name, int flags)
 {
        short ok=TRUE,delpl=FALSE;
        int file = -1;
@@ -72,28 +75,33 @@ short IMB_saveiff(struct ImBuf *ibuf,char *naam,int flags)
 
        /* Put formats that take a filename here */
        if (IS_jpg(ibuf)) {
-               return imb_savejpeg(ibuf, naam, flags);
+               return imb_savejpeg(ibuf, name, flags);
        }
        if (IS_radhdr(ibuf)) {
-               return imb_savehdr(ibuf, naam, flags);
+               return imb_savehdr(ibuf, name, flags);
        }
        if (IS_png(ibuf)) {
-               return imb_savepng(ibuf,naam,flags);
+               return imb_savepng(ibuf, name, flags);
        }
        if (IS_bmp(ibuf)) {
-               return imb_savebmp(ibuf,naam,flags);
+               return imb_savebmp(ibuf, name, flags);
        }
        if (IS_tga(ibuf)) {
-               return imb_savetarga(ibuf,naam,flags);
+               return imb_savetarga(ibuf, name, flags);
        }
        if (IS_iris(ibuf)) {
-               return imb_saveiris(ibuf,naam,flags);
+               return imb_saveiris(ibuf, name, flags);
        }
        if (G.have_libtiff && IS_tiff(ibuf)) {
-               return imb_savetiff(ibuf,naam,flags);
+               return imb_savetiff(ibuf, name, flags);
+       }
+#ifdef WITH_OPENEXR
+       if (IS_openexr(ibuf)) {
+               return imb_save_openexr_half(ibuf, name, flags);
        }
+#endif
 
-       file = open(naam, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, 0666);
+       file = open(name, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, 0666);
        if (file < 0) return (FALSE);
 
        if (flags & IB_rect){
@@ -103,7 +111,6 @@ short IMB_saveiff(struct ImBuf *ibuf,char *naam,int flags)
        }
 
        /* Put formats that take a filehandle here */
-       
        ok = imb_start_iff(ibuf,file);
        if (IS_amiga(ibuf)){
                IMB_flipy(ibuf);
index 6e6815dd41fa94fa5dba4933d55f172ef674ddc2..86f57d4455ee96ddbaf46adeb573410b5e29794d 100644 (file)
@@ -141,26 +141,26 @@ void curvemap_buttons(struct uiBlock *block, struct CurveMapping *cumap, char la
 #define B_VIEWBUTS             1100
 
 #define B_LOADBGPIC            1001
-#define B_BLENDBGPIC   1002
-#define B_BGPICBROWSE  1003
+#define B_BLENDBGPIC           1002
+#define B_BGPICBROWSE          1003
 #define B_BGPICTEX             1004
-#define B_BGPICCLEAR   1005
-#define B_BGPICTEXCLEAR        1006
+#define B_BGPICCLEAR           1005
+#define B_BGPICTEXCLEAR                1006
 
 #define B_OBJECTPANELROT       1007
-#define B_OBJECTPANELMEDIAN 1008
+#define B_OBJECTPANELMEDIAN    1008
 #define B_ARMATUREPANEL1       1009
 #define B_ARMATUREPANEL2       1010
-#define B_OBJECTPANELPARENT 1011
+#define B_OBJECTPANELPARENT    1011
 #define B_OBJECTPANEL          1012
 #define B_ARMATUREPANEL3       1013
 
 /* *********************** */
 #define B_LAMPBUTS             1200
 
-#define B_LAMPREDRAW   1101
+#define B_LAMPREDRAW           1101
 #define B_COLLAMP              1102
-#define B_TEXCLEARLAMP 1103
+#define B_TEXCLEARLAMP         1103
 #define B_SBUFF                        1104
 #define B_SHADBUF              1105
 #define B_SHADRAY              1106
@@ -289,7 +289,7 @@ void curvemap_buttons(struct uiBlock *block, struct CurveMapping *cumap, char la
 #define B_PR_PAL169            1612
 #define B_PR_D2MAC             1613
 #define B_PR_MPEG              1614
-#define B_REDRAWDISP   1615
+#define B_REDRAWDISP           1615
 #define B_SETBROWSE            1616
 #define B_CLEARSET             1617
 #define B_PR_PRESET            1618
@@ -297,32 +297,33 @@ void curvemap_buttons(struct uiBlock *block, struct CurveMapping *cumap, char la
 #define B_PR_NTSC              1620
 
 #define B_IS_FTYPE             1622
-#define B_IS_BACKBUF   1623
+#define B_IS_BACKBUF           1623
 #define B_PR_PC                        1624
 
-#define B_PR_PANO360    1627
-#define B_PR_HALFFIELDS        1628
-#define B_NEWRENDERPIPE 1629
-#define B_R_SCALE       1630
-#define B_G_SCALE       1631
-#define B_B_SCALE       1632
-#define B_USE_R_SCALE   1633
-#define B_USE_G_SCALE   1634
-#define B_USE_B_SCALE   1635
-#define B_EDGECOLSLI    1636
-#define B_GAMMASLI      1637
-
-#define B_FILETYPEMENU  1638
-#define B_SELECTCODEC   1639
+#define B_PR_PANO360           1627
+#define B_PR_HALFFIELDS                1628
+#define B_NEWRENDERPIPE        1629
+#define B_R_SCALE              1630
+#define B_G_SCALE              1631
+#define B_B_SCALE              1632
+#define B_USE_R_SCALE          1633
+#define B_USE_G_SCALE          1634
+#define B_USE_B_SCALE          1635
+#define B_EDGECOLSLI           1636
+#define B_GAMMASLI             1637
+
+#define B_FILETYPEMENU         1638
+#define B_SELECTCODEC          1639
 #define B_RTCHANGED            1640
-#define B_SWITCHRENDER 1641
+#define B_SWITCHRENDER         1641
 #define B_FBUF_REDO            1642
 
 #define B_SET_EDGE             1643
 #define B_SET_ZBLUR            1644
+#define        B_SET_OPENEXR           1645
 
 /* *********************** */
-#define B_ARMATUREBUTS 1800
+#define B_ARMATUREBUTS         1800
 #define        B_POSE                  1701
 
 /* *********************** */
@@ -342,7 +343,7 @@ void curvemap_buttons(struct uiBlock *block, struct CurveMapping *cumap, char la
 #define B_SETSOLID             2013
 #define B_AUTOTEX              2014
 #define B_DOCENTRE             2015
-#define B_DOCENTRENEW  2016
+#define B_DOCENTRENEW          2016
 #define B_DOCENTRECURSOR       2017
 
        /* 20 values! */
@@ -367,43 +368,43 @@ void curvemap_buttons(struct uiBlock *block, struct CurveMapping *cumap, char la
 #define B_SPLIT                        2056
 #define B_REMDOUB              2057
 #define B_SUBDIV               2058
-#define B_FRACSUBDIV   2059
+#define B_FRACSUBDIV           2059
 #define B_XSORT                        2060
 #define B_HASH                 2061
 #define B_DELSTICKY            2062
-#define B_DELVERTCOL   2063
-#define B_MAKE_TFACES  2064
+#define B_DELVERTCOL           2063
+#define B_MAKE_TFACES          2064
 #define B_TOSPHERE             2065
-#define B_DEL_TFACES   2066
+#define B_DEL_TFACES           2066
 #define B_NEWVGROUP            2067
 #define B_DELVGROUP            2068
-#define B_ASSIGNVGROUP 2069
-#define B_REMOVEVGROUP 2070
+#define B_ASSIGNVGROUP         2069
+#define B_REMOVEVGROUP         2070
 #define B_SELVGROUP            2071    
-#define B_DESELVGROUP  2072
-#define B_DECIM_FACES  2073
-#define B_DECIM_CANCEL 2074
-#define B_DECIM_APPLY  2075
-#define B_AUTOVGROUP   2076
-#define B_SLOWERDRAW   2077
-#define B_FASTERDRAW   2078
-#define B_VERTEXNOISE  2079
-#define B_VERTEXSMOOTH 2080
-#define B_MAKESTICKY   2082
-#define B_MAKEVERTCOL  2083
-#define B_CHROMADEPTH  2084
+#define B_DESELVGROUP          2072
+#define B_DECIM_FACES          2073
+#define B_DECIM_CANCEL         2074
+#define B_DECIM_APPLY          2075
+#define B_AUTOVGROUP           2076
+#define B_SLOWERDRAW           2077
+#define B_FASTERDRAW           2078
+#define B_VERTEXNOISE          2079
+#define B_VERTEXSMOOTH         2080
+#define B_MAKESTICKY           2082
+#define B_MAKEVERTCOL          2083
+#define B_CHROMADEPTH          2084
 #define B_DRAWEDGES            2087
-#define B_DRAWCREASES  2088
-#define B_LINKEDVGROUP 2089
+#define B_DRAWCREASES          2088
+#define B_LINKEDVGROUP         2089
 
 /* *********************** */
 #define B_CURVEBUTS            2200
 
-#define B_CONVERTPOLY  2101
-#define B_CONVERTBEZ   2102
-#define B_CONVERTBSPL  2103
-#define B_CONVERTCARD  2104
-#define B_CONVERTNURB  2105
+#define B_CONVERTPOLY          2101
+#define B_CONVERTBEZ           2102
+#define B_CONVERTBSPL          2103
+#define B_CONVERTCARD          2104
+#define B_CONVERTNURB          2105
 #define B_UNIFU                        2106
 #define B_ENDPU                        2107
 #define B_BEZU                 2108
@@ -416,12 +417,12 @@ void curvemap_buttons(struct uiBlock *block, struct CurveMapping *cumap, char la
 #define B_SETW3                        2115
 #define B_SETORDER             2116
 #define B_MAKEDISP             2117
-#define B_SUBDIVCURVE  2118
+#define B_SUBDIVCURVE          2118
 #define B_SPINNURB             2119
 #define B_CU3D                 2120
 #define B_SETRESOLU            2121
 #define B_SETW4                        2122
-#define B_SUBSURFTYPE  2123
+#define B_SUBSURFTYPE          2123
 
 /* *********************** */
 #define B_FONTBUTS             2300
@@ -430,16 +431,16 @@ void curvemap_buttons(struct uiBlock *block, struct CurveMapping *cumap, char la
 #define B_TOUPPER              2202
 #define B_SETFONT              2203
 #define B_LOADFONT             2204
-#define B_TEXTONCURVE  2205
+#define B_TEXTONCURVE          2205
 #define B_PACKFONT             2206
-#define B_LOAD3DTEXT   2207
+#define B_LOAD3DTEXT           2207
 #define B_LOREM                        2208
 #define B_FASTFONT             2209
 #define B_INSTB                        2210
 #define B_DELTB                        2211
-#define B_STYLETOSELB  2212
-#define B_STYLETOSELU  2213
-#define B_STYLETOSELI  2214
+#define B_STYLETOSELB          2212
+#define B_STYLETOSELU          2213
+#define B_STYLETOSELI          2214
 
 #define B_SETCHAR              2215
 #define B_SETUPCHAR            2216
@@ -459,106 +460,106 @@ void curvemap_buttons(struct uiBlock *block, struct CurveMapping *cumap, char la
 /* *********************** */
 #define B_MBALLBUTS            2600
 
-#define B_RECALCMBALL  2501
+#define B_RECALCMBALL          2501
 
 /* *********************** */
 #define B_LATTBUTS             2700
 
 #define B_RESIZELAT            2601
 #define B_DRAWLAT              2602
-#define B_LATTCHANGED  2603
-#define B_REGULARLAT   2604
+#define B_LATTCHANGED          2603
+#define B_REGULARLAT           2604
 
 /* *********************** */
 #define B_GAMEBUTS             2800
 
 #define B_ADD_PROP             2701
-#define B_CHANGE_PROP  2702
+#define B_CHANGE_PROP          2702
 
 #define B_ADD_SENS             2703
-#define B_CHANGE_SENS  2704
+#define B_CHANGE_SENS          2704
 #define B_DEL_SENS             2705
 
 #define B_ADD_CONT             2706
-#define B_CHANGE_CONT  2707
+#define B_CHANGE_CONT          2707
 #define B_DEL_CONT             2708
 
 #define B_ADD_ACT              2709
-#define B_CHANGE_ACT   2710
+#define B_CHANGE_ACT           2710
 #define B_DEL_ACT              2711
 
 #define B_SOUNDACT_BROWSE      2712
 
-#define B_SETSECTOR                    2713
-#define B_SETPROP                      2714
-#define B_SETACTOR                     2715
+#define B_SETSECTOR            2713
+#define B_SETPROP              2714
+#define B_SETACTOR             2715
 #define B_SETMAINACTOR         2716
-#define B_SETDYNA                      2717
+#define B_SETDYNA              2717
 
 /* *********************** */
-#define B_FPAINTBUTS   2900
+#define B_FPAINTBUTS           2900
 
 #define B_VPCOLSLI             2801
 #define B_VPGAMMA              2802
 
-#define B_COPY_TF_MODE 2804
-#define B_COPY_TF_UV   2805
-#define B_COPY_TF_COL  2806
-#define B_REDR_3D_IMA  2807
+#define B_COPY_TF_MODE         2804
+#define B_COPY_TF_UV           2805
+#define B_COPY_TF_COL          2806
+#define B_REDR_3D_IMA          2807
 #define B_SET_VCOL             2808
 
-#define B_COPY_TF_TEX  2814
-#define B_TFACE_HALO   2815
-#define B_TFACE_BILLB  2816
+#define B_COPY_TF_TEX          2814
+#define B_TFACE_HALO           2815
+#define B_TFACE_BILLB          2816
 
 #define B_SHOWTEX              2832
-#define B_ASSIGNMESH   2833
+#define B_ASSIGNMESH           2833
 
-#define B_WEIGHT0_0        2840
-#define B_WEIGHT1_4        2841
-#define B_WEIGHT1_2        2842
-#define B_WEIGHT3_4        2843
-#define B_WEIGHT1_0        2844
+#define B_WEIGHT0_0            2840
+#define B_WEIGHT1_4            2841
+#define B_WEIGHT1_2            2842
+#define B_WEIGHT3_4            2843
+#define B_WEIGHT1_0            2844
 
-#define B_OPA1_8           2845
-#define B_OPA1_4           2846
-#define B_OPA1_2           2847
-#define B_OPA3_4           2848
-#define B_OPA1_0           2849
+#define B_OPA1_8               2845
+#define B_OPA1_4               2846
+#define B_OPA1_2               2847
+#define B_OPA3_4               2848
+#define B_OPA1_0               2849
 
-#define B_CLR_WPAINT   2850
+#define B_CLR_WPAINT           2850
 
 /* *********************** */
 #define B_RADIOBUTS            3000
 
 #define B_RAD_GO               2901
 #define B_RAD_INIT             2902
-#define B_RAD_LIMITS   2903
+#define B_RAD_LIMITS           2903
 #define B_RAD_FAC              2904
-#define B_RAD_NODELIM  2905
-#define B_RAD_NODEFILT 2906
-#define B_RAD_FACEFILT 2907
+#define B_RAD_NODELIM          2905
+#define B_RAD_NODEFILT         2906
+#define B_RAD_FACEFILT         2907
 #define B_RAD_ADD              2908
-#define B_RAD_DELETE   2909
-#define B_RAD_COLLECT  2910
-#define B_RAD_SHOOTP   2911
-#define B_RAD_SHOOTE   2912
-#define B_RAD_REPLACE  2913
+#define B_RAD_DELETE           2909
+#define B_RAD_COLLECT          2910
+#define B_RAD_SHOOTP           2911
+#define B_RAD_SHOOTE           2912
+#define B_RAD_REPLACE          2913
 #define B_RAD_DRAW             2914
 #define B_RAD_FREE             2915
-#define B_RAD_ADDMESH  2916
+#define B_RAD_ADDMESH          2916
 
 /* *********************** */
-#define B_SCRIPTBUTS   3100
+#define B_SCRIPTBUTS           3100
 
-#define B_SCRIPT_ADD   3001
-#define B_SCRIPT_DEL   3002
-#define B_SCRIPT_TYPE  3003
+#define B_SCRIPT_ADD           3001
+#define B_SCRIPT_DEL           3002
+#define B_SCRIPT_TYPE          3003
 
 /* Scene script buttons */
-#define B_SSCRIPT_ADD  3004
-#define B_SSCRIPT_DEL  3005
-#define B_SSCRIPT_TYPE 3006
+#define B_SSCRIPT_ADD          3004
+#define B_SSCRIPT_DEL          3005
+#define B_SSCRIPT_TYPE         3006
 
 /* *********************** */
 #define B_SOUNDBUTS            3200
@@ -629,37 +630,32 @@ enum {
        B_UVAUTO_LSCM
 };
 
-#define B_EFFECTSBUTS  3500
+#define B_EFFECTSBUTS          3500
 
-#define B_AUTOTIMEOFS  3403
+#define B_AUTOTIMEOFS          3403
 #define B_FRAMEMAP             3404
 #define B_NEWEFFECT            3405
-#define B_PREVEFFECT   3406
-#define B_NEXTEFFECT   3407
-#define B_CHANGEEFFECT 3408
-#define B_CALCEFFECT   3409
+#define B_PREVEFFECT           3406
+#define B_NEXTEFFECT           3407
+#define B_CHANGEEFFECT         3408
+#define B_CALCEFFECT           3409
 #define B_DELEFFECT            3410
 #define B_RECALCAL             3411
-#define B_RECALC_DEFL  3412
-#define B_EFFECT_DEP   3413
+#define B_RECALC_DEFL          3412
+#define B_EFFECT_DEP           3413
 #define B_FIELD_DEP            3414
-#define B_FIELD_CHANGE 3415
-#define B_PAF_SET_VG   3416
-#define B_PAF_SET_VG1  3417
+#define B_FIELD_CHANGE         3415
+#define B_PAF_SET_VG           3416
+#define B_PAF_SET_VG1          3417
 
 #define B_MODIFIER_BUTS                3600
 
 #define B_MODIFIER_RECALC      3501
 #define B_MODIFIER_REDRAW      3502
 
-
-/* *********************** */
-
 /* *********************** */
 /*  BUTTON BUT: > 4000    */
 /*  BUTTON 4001-4032: layers */
 
-
-
 #endif
 
index 968aa6abe56b1f15c601a31b38c4ecc324ab7c7c..e2067f7dfdd53fa98b0959bb7b3d60d6c9886c07 100644 (file)
@@ -405,6 +405,7 @@ typedef struct Scene {
 #define R_BMP          20
 #define R_RADHDR       21
 #define R_TIFF         22
+#define R_OPENEXR      23
 
 /* **************** SCENE ********************* */
 #define RAD_PHASE_PATCHES      1
index c728c51038d39b50916f81b130114a19551e457d..7c962ff13280a0c0b386e255eb52111b2fa6e3a7 100644 (file)
 #include <math.h>
 #include <string.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 /* external modules: */
 #include "MEM_guardedalloc.h"
 #include "BLI_arithb.h"
@@ -168,18 +164,18 @@ static void envmap_split_ima(EnvMap *env)
                        ima->ok= 1;
                        env->cube[part]= ima;
                }
-               IMB_rectop(env->cube[0]->ibuf, env->ima->ibuf, 
-                       0, 0, 0, 0, dx, dx, IMB_rectcpy, 0);
-               IMB_rectop(env->cube[1]->ibuf, env->ima->ibuf, 
-                       0, 0, dx, 0, dx, dx, IMB_rectcpy, 0);
-               IMB_rectop(env->cube[2]->ibuf, env->ima->ibuf, 
-                       0, 0, 2*dx, 0, dx, dx, IMB_rectcpy, 0);
-               IMB_rectop(env->cube[3]->ibuf, env->ima->ibuf, 
-                       0, 0, 0, dx, dx, dx, IMB_rectcpy, 0);
-               IMB_rectop(env->cube[4]->ibuf, env->ima->ibuf, 
-                       0, 0, dx, dx, dx, dx, IMB_rectcpy, 0);
-               IMB_rectop(env->cube[5]->ibuf, env->ima->ibuf, 
-                       0, 0, 2*dx, dx, dx, dx, IMB_rectcpy, 0);
+               IMB_rectcpy(env->cube[0]->ibuf, env->ima->ibuf, 
+                       0, 0, 0, 0, dx, dx);
+               IMB_rectcpy(env->cube[1]->ibuf, env->ima->ibuf, 
+                       0, 0, dx, 0, dx, dx);
+               IMB_rectcpy(env->cube[2]->ibuf, env->ima->ibuf, 
+                       0, 0, 2*dx, 0, dx, dx);
+               IMB_rectcpy(env->cube[3]->ibuf, env->ima->ibuf, 
+                       0, 0, 0, dx, dx, dx);
+               IMB_rectcpy(env->cube[4]->ibuf, env->ima->ibuf, 
+                       0, 0, dx, dx, dx, dx);
+               IMB_rectcpy(env->cube[5]->ibuf, env->ima->ibuf, 
+                       0, 0, 2*dx, dx, dx, dx);
                env->ok= 2;
        }
 }
@@ -414,9 +410,12 @@ static void render_envmap(EnvMap *env)
        MTC_Mat4Invert(oldviewinv, R.viewmat);
 
        /* do first, envmap_renderdata copies entire R struct */
-       if(R.rectz) MEM_freeN(R.rectz); R.rectz= NULL;
-       if(R.rectot) MEM_freeN(R.rectot); R.rectot= NULL;
-       if(R.rectftot) MEM_freeN(R.rectftot); R.rectftot= NULL;
+       if(R.rectz) MEM_freeN(R.rectz);
+       if(R.rectot) MEM_freeN(R.rectot);
+       if(R.rectftot) MEM_freeN(R.rectftot);
+       R.rectftot= NULL;
+       R.rectz= NULL;
+       R.rectot= NULL;
        
        /* setup necessary globals */
        envmap_renderdata(env);
@@ -478,9 +477,12 @@ static void render_envmap(EnvMap *env)
 
        }
        
-       if(R.rectz) MEM_freeN(R.rectz); R.rectz= NULL;
-       if(R.rectot) MEM_freeN(R.rectot); R.rectot= NULL;
-       if(R.rectftot) MEM_freeN(R.rectftot); R.rectftot= NULL;
+       if(R.rectz) MEM_freeN(R.rectz);
+       if(R.rectot) MEM_freeN(R.rectot);
+       if(R.rectftot) MEM_freeN(R.rectftot);
+       R.rectz= NULL;
+       R.rectot= NULL;
+       R.rectftot= NULL;
        
        if(RE_local_test_break()) RE_free_envmapdata(env);
        else {
index ba9216fa80e5e674c6640adf1db6cc230d68b402..c0c175709e12591c15f54703ee27bcc661217242 100644 (file)
 #include <string.h>
 #include <stdio.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include "blendef.h"
 #include "MEM_guardedalloc.h"
 
@@ -897,6 +893,7 @@ static void yafrayRender(void)
        /* float rgba buf */
        if (R.rectftot) MEM_freeN(R.rectftot);
        if (R.r.mode & R_FBUF) R.rectftot= MEM_callocN(4*sizeof(float)*R.rectx*R.recty, "rectftot");
+       else R.rectftot = NULL;
 
        // switch must be done before prepareScene()
        if (!R.r.YFexportxml)
@@ -1054,6 +1051,7 @@ static void mainRenderLoop(void)  /* here the PART and FIELD loops */
                                
                                if(R.rectftot) MEM_freeN(R.rectftot);
                                if(R.r.mode & R_FBUF) R.rectftot= MEM_callocN(4*sizeof(float)*R.rectx*R.recty, "rectftot");
+                               else R.rectftot = NULL;
                                
                                if(R.r.mode & R_MBLUR) {
                                        RE_local_printrenderinfo(0.0, R.osa - blur);
index f0728897d477a05389925204f0759fbf301df410..f89f8965fd530b34028d453bb5b4c97d71d63194 100644 (file)
@@ -112,6 +112,10 @@ ifeq ($(WITH_QUICKTIME),true)
        CPPFLAGS += -DWITH_QUICKTIME
 endif
 
+ifeq ($(WITH_OPENEXR),true)
+       CPPFLAGS += -DWITH_OPENEXR
+endif
+
 ifeq ($(INTERNATIONAL), true)
     CPPFLAGS += -DINTERNATIONAL
 endif
index 7f565a9317c2461f450b423dade1f32e36b24467..5545000579339f97aa454354efe1ebaf4a53302f 100644 (file)
@@ -979,14 +979,19 @@ static char *imagetype_pup(void)
                        "HamX",           R_HAMX,
                        "Iris",           R_IRIS,
                        "Iris + Zbuffer", R_IRIZ,
-                       "Radiance HDR",   R_RADHDR,
+                       "Radiance HDR",   R_RADHDR
 #ifdef __sgi
-                       "Movie",          R_MOVIE,
+                       ,"Movie",          R_MOVIE
 #endif
-                       "Ftype",          R_FTYPE
                );
        }
 
+#ifdef WITH_OPENEXR
+       strcpy(formatstring, "|%s %%x%d");
+       sprintf(appendstring, formatstring, "OpenEXR", R_OPENEXR);
+       strcat(string, appendstring);
+#endif
+       
        if (G.have_libtiff) {
                strcpy(formatstring, "|%s %%x%d");
                sprintf(appendstring, formatstring, "TIFF", R_TIFF);
@@ -1252,7 +1257,14 @@ static void render_panel_format(void)
 #endif
                        uiDefBut(block, BUT,B_SELECTCODEC, "Set codec",  892,yofs,112,20, 0, 0, 0, 0, 0, "Set codec settings for AVI");
                }
+#ifdef WITH_OPENEXR
+       } else if (G.scene->r.imtype == R_OPENEXR ) {
+               if (G.scene->r.quality > 5) G.scene->r.quality = 0;
+               uiDefButS(block, MENU,B_SET_OPENEXR, "Codec %t|None %x0|Pxr24 (lossy) %x1|ZIP (lossless) %x2|PIZ (lossless) %x3|RLE (lossless) %x4",  892,yofs,112,20, &G.scene->r.quality, 0, 0, 0, 0, "Set codec settings for OpenEXR");
+#endif
        } else {
+               if(G.scene->r.quality < 5) G.scene->r.quality = 90;     // temp
+               
                uiDefButS(block, NUM,B_DIFF, "Quality:",           892,yofs,112,20, &G.scene->r.quality, 10.0, 100.0, 0, 0, "Quality setting for JPEG images, AVI Jpeg and SGI movies");
        }
        uiDefButS(block, NUM,B_FRAMEMAP,"Frs/sec:",   1006,yofs,113,20, &G.scene->r.frs_sec, 1.0, 120.0, 100.0, 0, "Frames per second");
index 787b6a6471a1437c7df478b92c654790451bdbdf..11179467a2fd8241680adf1524633591c598b748 100644 (file)
 #include <math.h>
 #include <string.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include "MEM_guardedalloc.h"
 
 #include "BLI_blenlib.h"
@@ -1023,7 +1019,8 @@ void face_borderselect()
        Mesh *me;
        TFace *tface;
        rcti rect;
-       unsigned int *rectm, *rt;
+       struct ImBuf *ibuf;
+       unsigned int *rt;
        int a, sx, sy, index, val;
        char *selar;
        
@@ -1046,9 +1043,10 @@ void face_borderselect()
                sy= (rect.ymax-rect.ymin+1);
                if(sx*sy<=0) return;
 
-               rt=rectm= MEM_mallocN(sizeof(int)*sx*sy, "selrect");
-               glReadPixels(rect.xmin+curarea->winrct.xmin,  rect.ymin+curarea->winrct.ymin, sx, sy, GL_RGBA, GL_UNSIGNED_BYTE,  rectm);
-               if(G.order==B_ENDIAN) IMB_convert_rgba_to_abgr(sx*sy, rectm);
+               ibuf = IMB_allocImBuf(sx,sy,32,0,0);
+               rt = ibuf->rect;
+               glReadPixels(rect.xmin+curarea->winrct.xmin,  rect.ymin+curarea->winrct.ymin, sx, sy, GL_RGBA, GL_UNSIGNED_BYTE,  ibuf->rect);
+               if(G.order==B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf);
 
                a= sx*sy;
                while(a--) {
@@ -1070,7 +1068,7 @@ void face_borderselect()
                        }
                }
                
-               MEM_freeN(rectm);
+               IMB_freeImBuf(ibuf);
                MEM_freeN(selar);
 
                BIF_undo_push("Border Select UV face");
index 8cefaf4221bad5e65e52cd007a141b16e62752be..4fc0eb7f29361720ae5f0462195e54cdcc1385d0 100644 (file)
@@ -40,10 +40,6 @@ editmesh_mods.c, UI level access, no geometry changes
 #include <string.h>
 #include <math.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include "MEM_guardedalloc.h"
 
 #include "MTC_matrixops.h"
@@ -92,6 +88,7 @@ editmesh_mods.c, UI level access, no geometry changes
 #include "BSE_edit.h"
 #include "BSE_view.h"
 
+#include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
 #include "mydevice.h"
@@ -155,11 +152,12 @@ static unsigned int sample_backbuf(int x, int y)
 }
 
 /* reads full rect, converts indices */
-static unsigned int *read_backbuf(short xmin, short ymin, short xmax, short ymax)
+struct ImBuf *read_backbuf(short xmin, short ymin, short xmax, short ymax)
 {
-       unsigned int *dr, *buf;
+       unsigned int *dr, *rd;
+       struct ImBuf *ibuf, *ibuf1;
        int a;
-       short xminc, yminc, xmaxc, ymaxc;
+       short xminc, yminc, xmaxc, ymaxc, xs, ys;
        
        /* clip */
        if(xmin<0) xminc= 0; else xminc= xmin;
@@ -170,55 +168,49 @@ static unsigned int *read_backbuf(short xmin, short ymin, short xmax, short ymax
        if(ymax>=curarea->winy) ymaxc= curarea->winy-1; else ymaxc= ymax;
        if(yminc > ymaxc) return NULL;
        
-       buf= MEM_mallocN( (xmaxc-xminc+1)*(ymaxc-yminc+1)*sizeof(int), "sample rect");
+       ibuf= IMB_allocImBuf((xmaxc-xminc+1),(ymaxc-yminc+1),32,IB_rect,0);
 
        check_backbuf(); // actually not needed for apple
        
 #ifdef __APPLE__
        glReadBuffer(GL_AUX0);
 #endif
-       glReadPixels(curarea->winrct.xmin+xminc, curarea->winrct.ymin+yminc, (xmaxc-xminc+1), (ymaxc-yminc+1), GL_RGBA, GL_UNSIGNED_BYTE, buf);
+       glReadPixels(curarea->winrct.xmin+xminc, curarea->winrct.ymin+yminc, (xmaxc-xminc+1), (ymaxc-yminc+1), GL_RGBA, GL_UNSIGNED_BYTE, ibuf->rect);
        glReadBuffer(GL_BACK);  
 
-       if(G.order==B_ENDIAN) IMB_convert_rgba_to_abgr((xmaxc-xminc+1)*(ymaxc-yminc+1), buf);
+       if(G.order==B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf);
 
        a= (xmaxc-xminc+1)*(ymaxc-yminc+1);
-       dr= buf;
+       dr= ibuf->rect;
        while(a--) {
                if(*dr) *dr= framebuffer_to_index(*dr);
                dr++;
        }
        
        /* put clipped result back, if needed */
-       if(xminc==xmin && xmaxc==xmax && yminc==ymin && ymaxc==ymax) return buf;
-       else {
-               unsigned int *buf1= MEM_callocN( (xmax-xmin+1)*(ymax-ymin+1)*sizeof(int), "sample rect2");
-               unsigned int *rd;
-               short xs, ys;
-
-               rd= buf;
-               dr= buf1;
+       if(xminc==xmin && xmaxc==xmax && yminc==ymin && ymaxc==ymax) return ibuf;
+       ibuf1= IMB_allocImBuf( (xmax-xmin+1),(ymax-ymin+1),32,IB_rect,0);
+       rd= ibuf->rect;
+       dr= ibuf1->rect;
                
-               for(ys= ymin; ys<=ymax; ys++) {
-                       for(xs= xmin; xs<=xmax; xs++, dr++) {
-                               if( xs>=xminc && xs<=xmaxc && ys>=yminc && ys<=ymaxc) {
-                                       *dr= *rd;
-                                       rd++;
-                               }
+       for(ys= ymin; ys<=ymax; ys++) {
+               for(xs= xmin; xs<=xmax; xs++, dr++) {
+                       if( xs>=xminc && xs<=xmaxc && ys>=yminc && ys<=ymaxc) {
+                               *dr= *rd;
+                               rd++;
                        }
                }
-               MEM_freeN(buf);
-               return buf1;
        }
-       
-       return buf;
+       IMB_freeImBuf(ibuf);
+       return ibuf1;
 }
 
 
 /* smart function to sample a rect spiralling outside, nice for backbuf selection */
 static unsigned int sample_backbuf_rect(short mval[2], int size, unsigned int min, unsigned int max, short *dist)
 {
-       unsigned int *buf, *bufmin, *bufmax;
+       struct ImBuf *buf;
+       unsigned int *bufmin, *bufmax, *tbuf;
        int minx, miny;
        int a, b, rc, nr, amount, dirvec[4][2];
        short distance=0;
@@ -229,8 +221,7 @@ static unsigned int sample_backbuf_rect(short mval[2], int size, unsigned int mi
        minx = mval[0]-(amount+1);
        miny = mval[1]-(amount+1);
        buf = read_backbuf(minx, miny, minx+size-1, miny+size-1);
-       if (!buf)
-               return 0;
+       if (!buf) return 0;
 
        rc= 0;
        
@@ -239,23 +230,24 @@ static unsigned int sample_backbuf_rect(short mval[2], int size, unsigned int mi
        dirvec[2][0]= -1; dirvec[2][1]= 0;
        dirvec[3][0]= 0; dirvec[3][1]= size;
        
-       bufmin= buf;
-       bufmax= buf+ size*size;
-       buf+= amount*size+ amount;
+       bufmin = buf->rect;
+       tbuf = buf->rect;
+       bufmax = buf->rect + size*size;
+       tbuf+= amount*size+ amount;
        
        for(nr=1; nr<=size; nr++) {
                
                for(a=0; a<2; a++) {
                        for(b=0; b<nr; b++, distance++) {
-                               if (*buf && *buf>=min && *buf<max) {
+                               if (*tbuf && *tbuf>=min && *tbuf<max) {
                                        *dist= (short) sqrt( (float)distance ); // XXX, this distance is wrong - zr
-                                       index = *buf - min+1; // messy yah, but indices start at 1
+                                       index = *tbuf - min+1; // messy yah, but indices start at 1
                                        goto exit;
                                }
                                
-                               buf+= (dirvec[rc][0]+dirvec[rc][1]);
+                               tbuf+= (dirvec[rc][0]+dirvec[rc][1]);
                                
-                               if(buf<bufmin || buf>=bufmax) {
+                               if(tbuf<bufmin || tbuf>=bufmax) {
                                        goto exit;
                                }
                        }
@@ -265,7 +257,7 @@ static unsigned int sample_backbuf_rect(short mval[2], int size, unsigned int mi
        }
 
 exit:
-       MEM_freeN(bufmin);
+       IMB_freeImBuf(buf);
        return index;
 }
 
@@ -322,14 +314,17 @@ static void draw_triangulated(short mcords[][2], short tot)
 /* returns if all is OK */
 int EM_init_backbuf_border(short xmin, short ymin, short xmax, short ymax)
 {
-       unsigned int *buf, *dr;
+       struct ImBuf *buf;
+       unsigned int *dr;
        int a;
        
        if(G.obedit==NULL || G.vd->drawtype<OB_SOLID || (G.vd->flag & V3D_ZBUF_SELECT)==0) return 0;
        if(em_vertoffs==0) return 0;
        
-       dr= buf= read_backbuf(xmin, ymin, xmax, ymax);
+       buf= read_backbuf(xmin, ymin, xmax, ymax);
        if(buf==NULL) return 0;
+
+       dr = buf->rect;
        
        /* build selection lookup */
        selbuf= MEM_callocN(em_vertoffs+1, "selbuf");
@@ -340,7 +335,7 @@ int EM_init_backbuf_border(short xmin, short ymin, short xmax, short ymax)
                        selbuf[*dr]= 1;
                dr++;
        }
-       MEM_freeN(buf);
+       IMB_freeImBuf(buf);
        return 1;
 }
 
@@ -366,7 +361,8 @@ void EM_free_backbuf(void)
 */
 int EM_mask_init_backbuf_border(short mcords[][2], short tot, short xmin, short ymin, short xmax, short ymax)
 {
-       unsigned int *buf, *bufmask, *dr, *drm;
+       unsigned int *dr, *drm;
+       struct ImBuf *buf, *bufmask;
        int a;
        
        /* method in use for face selecting too */
@@ -378,9 +374,11 @@ int EM_mask_init_backbuf_border(short mcords[][2], short tot, short xmin, short
 
        if(em_vertoffs==0) return 0;
        
-       dr= buf= read_backbuf(xmin, ymin, xmax, ymax);
+       buf= read_backbuf(xmin, ymin, xmax, ymax);
        if(buf==NULL) return 0;
 
+       dr = buf->rect;
+
        /* draw the mask */
 #ifdef __APPLE__
        glDrawBuffer(GL_AUX0);
@@ -403,7 +401,8 @@ int EM_mask_init_backbuf_border(short mcords[][2], short tot, short xmin, short
        glDrawBuffer(GL_BACK);
        
        /* grab mask */
-       drm= bufmask= read_backbuf(xmin, ymin, xmax, ymax);
+       bufmask= read_backbuf(xmin, ymin, xmax, ymax);
+       drm = bufmask->rect;
        if(bufmask==NULL) return 0; // only when mem alloc fails, go crash somewhere else!
        
        /* build selection lookup */
@@ -414,8 +413,8 @@ int EM_mask_init_backbuf_border(short mcords[][2], short tot, short xmin, short
                if(*dr>0 && *dr<=em_vertoffs && *drm==0) selbuf[*dr]= 1;
                dr++; drm++;
        }
-       MEM_freeN(buf);
-       MEM_freeN(bufmask);
+       IMB_freeImBuf(buf);
+       IMB_freeImBuf(bufmask);
        return 1;
        
 }
@@ -423,7 +422,8 @@ int EM_mask_init_backbuf_border(short mcords[][2], short tot, short xmin, short
 /* circle shaped sample area */
 int EM_init_backbuf_circle(short xs, short ys, short rads)
 {
-       unsigned int *buf, *dr;
+       struct ImBuf *buf;
+       unsigned int *dr;
        short xmin, ymin, xmax, ymax, xc, yc;
        int radsq;
        
@@ -437,8 +437,10 @@ int EM_init_backbuf_circle(short xs, short ys, short rads)
        
        xmin= xs-rads; xmax= xs+rads;
        ymin= ys-rads; ymax= ys+rads;
-       dr= buf= read_backbuf(xmin, ymin, xmax, ymax);
+       buf= read_backbuf(xmin, ymin, xmax, ymax);
        if(buf==NULL) return 0;
+
+       dr = buf->rect;
        
        /* build selection lookup */
        selbuf= MEM_callocN(em_vertoffs+1, "selbuf");
@@ -451,7 +453,7 @@ int EM_init_backbuf_circle(short xs, short ys, short rads)
                }
        }
 
-       MEM_freeN(buf);
+       IMB_freeImBuf(buf);
        return 1;
        
 }
index ae986cc77895e0c887f8d7a8fa3302f6f8444dbd..07d85d481607049d13efe14316af6e394394c286 100644 (file)
@@ -502,10 +502,13 @@ void test_flags_file(SpaceFile *sfile)
                                        (BLI_testextensie(file->relname, ".tif")
                                        ||      BLI_testextensie(file->relname, ".tiff"))) {
                                        file->flags |= IMAGEFILE;                       
+                       } else if (BLI_testextensie(file->relname, ".exr")) {
+                                       file->flags |= IMAGEFILE;                       
                        } else if (G.have_quicktime){
                                if(             BLI_testextensie(file->relname, ".jpg")
                                        ||      BLI_testextensie(file->relname, ".jpeg")
                                        ||      BLI_testextensie(file->relname, ".hdr")
+                                       ||      BLI_testextensie(file->relname, ".exr")
                                        ||      BLI_testextensie(file->relname, ".tga")
                                        ||      BLI_testextensie(file->relname, ".rgb")
                                        ||      BLI_testextensie(file->relname, ".bmp")
@@ -532,7 +535,8 @@ void test_flags_file(SpaceFile *sfile)
                                }
                        } else { // no quicktime
                                if(BLI_testextensie(file->relname, ".jpg")
-                                       ||      BLI_testextensie(file->relname, ".hdr")
+                                  ||   BLI_testextensie(file->relname, ".hdr")
+                                  ||   BLI_testextensie(file->relname, ".exr")
                                        ||      BLI_testextensie(file->relname, ".tga")
                                        ||      BLI_testextensie(file->relname, ".rgb")
                                        ||      BLI_testextensie(file->relname, ".bmp")
index c39fe83954e0a861db8e06068bd188eaaea82cfd..6c232ea64642119d3477b295ace333cf002a066a 100644 (file)
 #include <stdlib.h>
 #include <string.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #ifndef WIN32
 #include <unistd.h>
 #else
@@ -538,7 +534,7 @@ void get_next_image(SpaceImaSel *simasel)
                        /* the whole cmap system is wacko */
                        
                        if (G.order==B_ENDIAN)
-                               IMB_convert_rgba_to_abgr(ima->dw*ima->dh, ibuf->rect);
+                               IMB_convert_rgba_to_abgr(ibuf);
                        
                        ibuf->mincol =   0;
                        ibuf->maxcol = 256;
@@ -555,7 +551,7 @@ void get_next_image(SpaceImaSel *simasel)
                        longtochar(ima->pict_rect, ibuf->rect, size); 
 
                        IMB_applycmap(ibuf);
-                       IMB_convert_rgba_to_abgr(size, ibuf->rect);
+                       IMB_convert_rgba_to_abgr(ibuf);
                        
                        if (ima->pict) IMB_freeImBuf(ima->pict);
                        ima->pict = ibuf;
@@ -797,7 +793,7 @@ void get_pib_file(SpaceImaSel *simasel)
                                                ima->pict->cmap = simasel->cmap->cmap;
                                                ima->pict->maxcol = 256;
                                                IMB_applycmap(ima->pict);
-                                               IMB_convert_rgba_to_abgr(size, ima->pict->rect);
+                                               IMB_convert_rgba_to_abgr(ima->pict);
                                        }
                                        ima->selected   = 0;
                                        ima->selectable = 0;
index d245e0e1427fc2608b8b22084f611fcd5155ad2a..dc487ae72fe4191f8aeaf9d01a1197496ea6c06a 100644 (file)
@@ -733,8 +733,11 @@ void BIF_icon_draw(float x, float y, int icon_id)
                
                ui_rasterpos_safe(x, y, di->aspect);
                
+               if(di->w<1 || di->h<1) {
+                       printf("what the heck!\n");
+               }
                /* di->rect contains image in 'rendersize', we only scale if needed */
-               if(di->rw!=di->w && di->rh!=di->h) {
+               else if(di->rw!=di->w && di->rh!=di->h) {
                        ImBuf *ima;
                        /* first allocate imbuf for scaling and copy preview into it */
                        ima = IMB_allocImBuf(di->rw, di->rh, 32, IB_rect, 0);
index ebc5bad88c6c04459a820472af59ced768d79632..cd51f1fdb0f54067cf13c2f9480158a7140ef5da 100644 (file)
@@ -87,6 +87,9 @@ void write_screendump(char *name)
                        else if(G.scene->r.imtype==R_PNG) ibuf->ftype= PNG;
                        else if((G.have_libtiff) && 
                                (G.scene->r.imtype==R_TIFF)) ibuf->ftype= TIF;
+#ifdef WITH_OPENEXR
+                       else if(G.scene->r.imtype==R_OPENEXR) ibuf->ftype= OPENEXR;
+#endif
                        else if(G.scene->r.imtype==R_HAMX) ibuf->ftype= AN_hamx;
                        else if(ELEM5(G.scene->r.imtype, R_MOVIE, R_AVICODEC, R_AVIRAW, R_AVIJPEG, R_JPEG90)) {
                                ibuf->ftype= JPG|G.scene->r.quality;
index 17b6e4d90b076a06b01e86c738df66c30639752b..3191ec1095b7e70293ef65c882b59c7dc585fc41 100644 (file)
 #include <math.h>
 #include <stdlib.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include "MEM_guardedalloc.h"
 #include "PIL_dynlib.h"
 
@@ -1655,19 +1651,19 @@ void do_effect(int cfra, Sequence *seq, StripElem *se)
                        if(cp) strncpy(cp, seq->name+2, 22);
 
                        if (seq->plugin->version<=2) {
-                               if(se1->ibuf) IMB_convert_rgba_to_abgr(se1->ibuf->x*se1->ibuf->y, se1->ibuf->rect);
-                               if(se2->ibuf) IMB_convert_rgba_to_abgr(se2->ibuf->x*se2->ibuf->y, se2->ibuf->rect);
-                               if(se3->ibuf) IMB_convert_rgba_to_abgr(se3->ibuf->x*se3->ibuf->y, se3->ibuf->rect);
+                               if(se1->ibuf) IMB_convert_rgba_to_abgr(se1->ibuf);
+                               if(se2->ibuf) IMB_convert_rgba_to_abgr(se2->ibuf);
+                               if(se3->ibuf) IMB_convert_rgba_to_abgr(se3->ibuf);
                        }
 
                        ((SeqDoit)seq->plugin->doit)(seq->plugin->data, fac, facf, x, y,
                                                se1->ibuf, se2->ibuf, se->ibuf, se3->ibuf);
 
                        if (seq->plugin->version<=2) {
-                               if(se1->ibuf) IMB_convert_rgba_to_abgr(se1->ibuf->x*se1->ibuf->y, se1->ibuf->rect);
-                               if(se2->ibuf) IMB_convert_rgba_to_abgr(se2->ibuf->x*se2->ibuf->y, se2->ibuf->rect);
-                               if(se3->ibuf) IMB_convert_rgba_to_abgr(se3->ibuf->x*se3->ibuf->y, se3->ibuf->rect);
-                               IMB_convert_rgba_to_abgr(se->ibuf->x*se->ibuf->y, se->ibuf->rect);
+                               if(se1->ibuf) IMB_convert_rgba_to_abgr(se1->ibuf);
+                               if(se2->ibuf) IMB_convert_rgba_to_abgr(se2->ibuf);
+                               if(se3->ibuf) IMB_convert_rgba_to_abgr(se3->ibuf);
+                               IMB_convert_rgba_to_abgr(se->ibuf);
                        }
 
                        if((G.f & G_PLAYANIM)==0) waitcursor(0);
index acceccafe609f742998bf7b06ede798145c23af9..8fc3f740a0b782d75df8410960495faa5f7c1832 100644 (file)
@@ -147,13 +147,6 @@ void schrijfplaatje(char *name)
        unsigned int *temprect=0;
        char str[FILE_MAXDIR+FILE_MAXFILE];
 
-       /* radhdr: temporary call for direct float buffer save for HDR format */
-       if ((R.r.imtype==R_RADHDR) && (R.rectftot))
-       {
-               imb_savehdr_fromfloat(R.rectftot, name, R.rectx, R.recty);
-               return;
-       }
-
        /* has RGBA been set? If so: use alpha channel for color zero */
        IMB_alpha_to_col0(FALSE);
 
@@ -188,7 +181,7 @@ void schrijfplaatje(char *name)
 
        if(ibuf) {
                ibuf->rect= (unsigned int *) R.rectot;
-//             ibuf->rect_float = R.rectftot;
+               ibuf->rect_float = R.rectftot;
 
                if(R.r.planes == 8) IMB_cspace(ibuf, rgb_to_bw);
 
@@ -205,8 +198,6 @@ void schrijfplaatje(char *name)
                        }
                }
                else if(R.r.imtype==R_RADHDR) {
-                       /* radhdr: save hdr from rgba buffer, not really recommended, probably mistake, so warn user */
-                       error("Will save, but you might want to enable the floatbuffer to save a real HDRI...");
                        ibuf->ftype= RADHDR;
                }
                else if(R.r.imtype==R_PNG) {
@@ -218,6 +209,11 @@ void schrijfplaatje(char *name)
                else if((G.have_libtiff) && (R.r.imtype==R_TIFF)) {
                        ibuf->ftype= TIF;
                }
+#ifdef WITH_OPENEXR
+               else if(R.r.imtype==R_OPENEXR) {
+                       ibuf->ftype= OPENEXR;
+               }
+#endif
                else if((R.r.imtype==R_TARGA) || (R.r.imtype==R_PNG)) {
                        ibuf->ftype= TGA;
                }
@@ -500,6 +496,10 @@ int save_image_filesel_str(char *str)
                if (G.have_libtiff) {
                        strcpy(str, "Save TIFF"); return 1;
                }
+#ifdef WITH_OPENEXR
+       case R_OPENEXR:
+               strcpy(str, "Save OpenEXR"); return 1;
+#endif
        case R_TARGA:
                strcpy(str, "Save Targa"); return 1;
        case R_RAWTGA:
index ad62f6c0dc03948242d8ac2359fd84a4a8a363f0..836c98bdb222d82ec948191ec772fe8af592ebbd 100644 (file)
 #include <math.h>
 #include <string.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #ifdef WIN32
 #include <io.h>
 #else
@@ -46,6 +42,7 @@
 #include "MEM_guardedalloc.h"
 
 #include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
 
 #include "BLI_blenlib.h"
 #include "BLI_arithb.h"
@@ -599,7 +596,8 @@ static void vpaint_blend( unsigned int *col, unsigned int *colorig, unsigned int
 
 static int sample_backbuf_area(int x, int y, float size)
 {
-       unsigned int rect[129*129], *rt;
+       unsigned int *rt;
+       struct ImBuf *ibuf;
        int x1, y1, x2, y2, a, tot=0, index;
        
        if(totvpaintundo>=MAXINDEX) return 0;
@@ -617,12 +615,15 @@ static int sample_backbuf_area(int x, int y, float size)
 #ifdef __APPLE__
        glReadBuffer(GL_AUX0);
 #endif
-       glReadPixels(x1+curarea->winrct.xmin, y1+curarea->winrct.ymin, x2-x1+1, y2-y1+1, GL_RGBA, GL_UNSIGNED_BYTE,  rect);
+       ibuf = IMB_allocImBuf(size,size,32,IB_rect,0);
+       glReadPixels(x1+curarea->winrct.xmin, y1+curarea->winrct.ymin, x2-x1+1, y2-y1+1, GL_RGBA, GL_UNSIGNED_BYTE,  ibuf->rect);
        glReadBuffer(GL_BACK);  
 
-       if(G.order==B_ENDIAN) IMB_convert_rgba_to_abgr( (int)(4*size*size), rect);
+       if(G.order==B_ENDIAN)  {
+               IMB_convert_rgba_to_abgr(ibuf);
+       }
 
-       rt= rect;
+       rt= ibuf->rect;
        size= (y2-y1)*(x2-x1);
        if(size<=0) return 0;
 
@@ -642,6 +643,8 @@ static int sample_backbuf_area(int x, int y, float size)
        for(a=1; a<=totvpaintundo; a++) {
                if(indexar[a]) indexar[tot++]= a;
        }
+
+       IMB_freeImBuf(ibuf);
        
        return tot;
 }
index f386ea3ecf04cb983e613acfb5167d687c5f216b..4497ed51e8171a5c07239ea9395fc9292d7c3891 100644 (file)
@@ -63,6 +63,11 @@ int BIF_write_ibuf(ImBuf *ibuf, char *name)
        else if ((G.have_libtiff) && (G.scene->r.imtype==R_TIFF)) {
                ibuf->ftype= TIF;
        }
+#ifdef WITH_OPENEXR
+       else if (G.scene->r.imtype==R_OPENEXR) {
+               ibuf->ftype= OPENEXR;
+       }
+#endif
        else if ((G.scene->r.imtype==R_TARGA) || (G.scene->r.imtype==R_PNG)) {
                // fall back to Targa if PNG writing is not supported
                ibuf->ftype= TGA;
@@ -105,18 +110,12 @@ void BIF_save_envmap(EnvMap *env, char *str)
        dx= env->cube[0]->ibuf->x;
        ibuf= IMB_allocImBuf(3*dx, 2*dx, 24, IB_rect, 0);
        
-       IMB_rectop(ibuf, env->cube[0]->ibuf, 
-                       0, 0, 0, 0, dx, dx, IMB_rectcpy, 0);
-       IMB_rectop(ibuf, env->cube[1]->ibuf, 
-                       dx, 0, 0, 0, dx, dx, IMB_rectcpy, 0);
-       IMB_rectop(ibuf, env->cube[2]->ibuf, 
-                       2*dx, 0, 0, 0, dx, dx, IMB_rectcpy, 0);
-       IMB_rectop(ibuf, env->cube[3]->ibuf, 
-                       0, dx, 0, 0, dx, dx, IMB_rectcpy, 0);
-       IMB_rectop(ibuf, env->cube[4]->ibuf, 
-                       dx, dx, 0, 0, dx, dx, IMB_rectcpy, 0);
-       IMB_rectop(ibuf, env->cube[5]->ibuf, 
-                       2*dx, dx, 0, 0, dx, dx, IMB_rectcpy, 0);
+       IMB_rectcpy(ibuf, env->cube[0]->ibuf, 0, 0, 0, 0, dx, dx);
+       IMB_rectcpy(ibuf, env->cube[1]->ibuf, dx, 0, 0, 0, dx, dx);
+       IMB_rectcpy(ibuf, env->cube[2]->ibuf, 2*dx, 0, 0, 0, dx, dx);
+       IMB_rectcpy(ibuf, env->cube[3]->ibuf, 0, dx, 0, 0, dx, dx);
+       IMB_rectcpy(ibuf, env->cube[4]->ibuf, dx, dx, 0, 0, dx, dx);
+       IMB_rectcpy(ibuf, env->cube[5]->ibuf, 2*dx, dx, 0, 0, dx, dx);
        
        BIF_write_ibuf(ibuf, str);
        IMB_freeImBuf(ibuf);
index f27f7ffd7e33864be4aeaa6037c4af5479bafcb2..2c80200f9048b7ce20bbe894b3c0ab8187fa0c5a 100644 (file)
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #ifdef __sgi
 
 #include <unistd.h>
@@ -364,6 +360,7 @@ void append_movie(int cfra)
        char            name[FILE_MAXDIR+FILE_MAXFILE];
        const char      *string;
        int                     fd;
+       float col[4] = {0.0,0.0,0.0,0.0};
        
        set_sfra_efra();
        make_movie_name(name);
@@ -377,28 +374,28 @@ void append_movie(int cfra)
        
        if (ibuf->x != mv_outx || ibuf->y != mv_outy) {
                tbuf = IMB_allocImBuf(mv_outx, mv_outy, 32, IB_rect, 0);
-               IMB_rectoptot(tbuf, 0, IMB_rectfill, 0x00);
+               IMB_rectfill(tbuf,col);
                
                ofsx = (tbuf->x - ibuf->x) / 2;
                ofsy = (tbuf->y - ibuf->y) / 2;
                if (numfields == 2) ofsy &= ~1;
                
-               IMB_rectop(tbuf, ibuf, ofsx, ofsy, 0, 0, 32767, 32767, IMB_rectcpy, 0);
+               IMB_rectcpy(tbuf, ibuf, ofsx, ofsy, 0, 0, ibuf->x, ibuf->y);
                IMB_freeImBuf(ibuf);
                strcpy(tbuf->name, ibuf->name);
                ibuf = tbuf;
        }
-       IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
+       IMB_convert_rgba_to_abgr(ibuf);
        
        if (numfields == 2) {
                if (ntsc) {
-                       IMB_rectop(ibuf, ibuf, 0, 0, 0, 1, 32767, 32767, IMB_rectcpy, 0);
+                       IMB_rectcpy(ibuf, ibuf, 0, 0, 0, 1, ibuf->x, ibuf->y);
                        IMB_flipy(ibuf);
                        IMB_de_interlace(ibuf);
-                       if (ntsc) IMB_rectop(ibuf, ibuf, 0, 0, 0, 1, 32767, 32767, IMB_rectcpy, 0);
+                       if (ntsc) IMB_rectcpy(ibuf, ibuf, 0, 0, 0, 1, ibuf->x, ibuf->y);
                } else {
                        IMB_flipy(ibuf);
-                       IMB_rectop(ibuf, ibuf, 0, 0, 0, 1, 32767, 32767, IMB_rectcpy, 0);
+                       IMB_rectcpy(ibuf, ibuf, 0, 0, 0, 1, ibuf->x, ibuf->y);
                        IMB_de_interlace(ibuf);
                }
        }