Merge image related changes from the render branch. This includes the image

tile cache code in imbuf, but it is not hooked up to the render engine.


Imbuf module: some small refactoring and removing a lot of unused or old code
(about 6.5k lines).

* Added a ImFileType struct with callbacks to make adding an file format type,
  or making changes to the API easier.
* Move imbuf init/exit code into IMB_init()/IMB_exit() functions.
* Increased mipmap levels from 10 to 20, you run into this limit already with
  a 2k image.
* Removed hamx, amiga, anim5 format support.
* Removed colormap saving, only simple colormap code now for reading tga.
* Removed gen_dynlibtiff.py, editing this is almost as much work as just
  editing the code directly.
* Functions removed that were only used for sequencer plugin API:
  IMB_anim_nextpic, IMB_clever_double, IMB_antialias, IMB_gamwarp,
  IMB_scalefieldImBuf, IMB_scalefastfieldImBuf, IMB_onethird, IMB_halflace,
  IMB_dit0, IMB_dit2, IMB_cspace
* Write metadata info into OpenEXR images. Can be viewed with the command
  line utility 'exrheader'

For the image tile cache code, see this page:
http://wiki.blender.org/index.php/Dev:2.5/Source/Imaging/ImageTileCache

68 files changed, 1523 insertions, 6732 deletions

diff --git a/source/blender/imbuf/intern/IMB_amiga.h b/source/blender/imbuf/intern/IMB_amiga.h
deleted file mode 100644
index e8d908df4c3..00000000000
--- a/source/blender/imbuf/intern/IMB_amiga.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/**
- * IMB_amiga.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_amiga.h
- * \ingroup imbuf
- * \brief Function declarations for amiga.c
- */
-
-#ifndef IMB_AMIGA_H
-#define IMB_AMIGA_H
-
-struct ImBuf;
-
-struct ImBuf *imb_loadamiga(int *iffmem,int flags);
-short imb_encodebodyh(struct ImBuf *ibuf, int file);
-short imb_encodebodyv(struct ImBuf *ibuf, int file);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_anim.h b/source/blender/imbuf/intern/IMB_anim.h
index 39b8e48fb7f..c9eac2c1399 100644
--- a/source/blender/imbuf/intern/IMB_anim.h
+++ b/source/blender/imbuf/intern/IMB_anim.h
@@ -65,7 +65,6 @@
 							BLI_countlist BLI_stringdec */
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 
 #include "AVI_avi.h"
 
@@ -93,7 +92,6 @@
 #include "IMB_imbuf.h"
 
 #include "IMB_allocimbuf.h"
-#include "IMB_bitplanes.h"
 
 
 
@@ -117,7 +115,7 @@
 #define ANIM_NONE		(0)
 #define ANIM_SEQUENCE		(1 << 0)
 #define ANIM_DIR		(1 << 1)
-#define ANIM_ANIM5		(1 << 2)
+#define ANIM_DEPRECATED	(1 << 2)
 #define ANIM_TGA		(1 << 3)
 #define ANIM_MOVIE		(1 << 4)
 #define ANIM_MDEC		(1 << 5)
@@ -126,13 +124,10 @@
 #define ANIM_FFMPEG             (1 << 8)
 #define ANIM_REDCODE            (1 << 9)
 
-#define ANIM5_MMAP		0
-#define ANIM5_MALLOC		1
-#define ANIM5_SNGBUF		2
-#define ANIM5_XOR		4
-
 #define MAXNUMSTREAMS		50
 
+struct _AviMovie;
+
 struct anim {
 	int ib_flags;
 	int curtype;
@@ -145,14 +140,6 @@ struct anim {
 		/* voor sequence */
 	char first[256];
 	
-		/* anim5 */
-	struct ListBase	anim5base;
-	void		* anim5mmap;
-	int		anim5len;
-	struct Anim5Delta *anim5curdlta;
-	void		(*anim5decode)(struct ImBuf *, unsigned char *);
-	int		anim5flags;
-	
 		/* movie */
 	void *movie;
 	void *track;
diff --git a/source/blender/imbuf/intern/IMB_anim5.h b/source/blender/imbuf/intern/IMB_anim5.h
deleted file mode 100644
index 245b3b9a9be..00000000000
--- a/source/blender/imbuf/intern/IMB_anim5.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/* IMB_anim.h */
-#ifndef IMB_ANIM5_H
-#define IMB_ANIM5_H
-
-struct anim;
-
-/**
- *
- * @attention Defined in anim5.c
- */
-int nextanim5(struct anim * anim);
-int rewindanim5(struct anim * anim);
-int startanim5(struct anim * anim);
-void free_anim_anim5(struct anim * anim);
-struct ImBuf * anim5_fetchibuf(struct anim * anim);
-
-
-#endif
-
-
diff --git a/source/blender/imbuf/intern/IMB_bitplanes.h b/source/blender/imbuf/intern/IMB_bitplanes.h
deleted file mode 100644
index c8deb6f9a02..00000000000
--- a/source/blender/imbuf/intern/IMB_bitplanes.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * IMB_bitplanes.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_bitplanes.h
- * \ingroup imbuf
- * \brief Function declarations for bitplanes.c
- */
-
-#ifndef IMB_BITPLANES_H
-#define IMB_BITPLANES_H
-
-struct ImBuf;
-
-void imb_bptolong(struct ImBuf *ibuf);
-void imb_longtobp(struct ImBuf *ibuf);
-unsigned int **imb_copyplanelist(struct ImBuf *ibuf);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_bmp.h b/source/blender/imbuf/intern/IMB_bmp.h
deleted file mode 100644
index 99561eeead2..00000000000
--- a/source/blender/imbuf/intern/IMB_bmp.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * IMB_bmp.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_bmp.h
- * \ingroup imbuf
- * \brief Function declarations for bmp.c
- */
-
-#ifndef IMB_BMP_H
-#define IMB_BMP_H
-
-struct ImBuf;
-
-int imb_is_a_bmp(void *buf);
-struct ImBuf *imb_bmp_decode(unsigned char *mem, int size, int flags);
-short imb_savebmp(struct ImBuf *ibuf, char *name, int flags);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_cmap.h b/source/blender/imbuf/intern/IMB_cmap.h
deleted file mode 100644
index 5e30e66f58e..00000000000
--- a/source/blender/imbuf/intern/IMB_cmap.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * IMB_cmap.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_cmap.h
- * \ingroup imbuf
- * \brief Function declarations for cmap.c
- */
-#ifndef IMB_CMAP_H
-#define IMB_CMAP_H
-
-struct ImBuf;
-
-void imb_makecolarray(struct ImBuf *ibuf, unsigned char *mem, short nocols);
-void imb_losecmapbits(struct ImBuf *ibuf, unsigned int *coltab);
-short *imb_coldeltatab(unsigned char *coltab, short mincol, short maxcol, short cbits);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_cocoa.h b/source/blender/imbuf/intern/IMB_cocoa.h
deleted file mode 100644
index a62e7028143..00000000000
--- a/source/blender/imbuf/intern/IMB_cocoa.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * IMB_cocoa.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contributor(s): Damien Plisson 10/2009
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_cocoa.h
- * \ingroup imbuf
- * \brief Function declarations for imbuf_cocoa.m
- */
-
-#ifndef IMB_COCOA_H
-#define IMB_COCOA_H
-
-/* Foward declaration of ImBuf structure. */
-struct ImBuf;
-
-/* Declarations for imbuf_cocoa.m */
-struct ImBuf *imb_cocoaLoadImage(unsigned char *mem, int size, int flags);
-short imb_cocoaSaveImage(struct ImBuf *ibuf, char *name, int flags);
-
-#endif /* IMB_COCOA_H */
-
diff --git a/source/blender/imbuf/intern/IMB_divers.h b/source/blender/imbuf/intern/IMB_divers.h
deleted file mode 100644
index 5ab0ce25484..00000000000
--- a/source/blender/imbuf/intern/IMB_divers.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * divers.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_divers.h
- * \ingroup imbuf
- * \brief Function declarations for divers.c
- */
-
-#ifndef IMB_DIVERS_H
-#define IMB_DIVERS_H
-
-struct ImBuf;
-
-void imb_checkncols(struct ImBuf *ibuf);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_dpxcineon.h b/source/blender/imbuf/intern/IMB_dpxcineon.h
deleted file mode 100644
index 4719ecd49f3..00000000000
--- a/source/blender/imbuf/intern/IMB_dpxcineon.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * IMB_dpxcineon.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. 
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_dpxcineon.h
- * \ingroup imbuf
- */
-#ifndef _IMB_DPX_CINEON_H
-#define _IMB_DPX_CINEON_H
-
-struct ImBuf;
-
-short imb_savecineon(struct ImBuf *buf, char *myfil, int flags);
-struct ImBuf *imb_loadcineon(unsigned char *mem, int size, int flags);
-int imb_is_cineon(void *buf);
-short imb_save_dpx(struct ImBuf *buf, char *myfile, int flags);
-struct ImBuf *imb_loaddpx(unsigned char *mem, int size, int flags);
-int imb_is_dpx(void *buf);
-
-#endif /*_IMB_DPX_CINEON_H*/
diff --git a/source/blender/imbuf/intern/IMB_filetype.h b/source/blender/imbuf/intern/IMB_filetype.h
new file mode 100644
index 00000000000..f6afe20cb5c
--- /dev/null
+++ b/source/blender/imbuf/intern/IMB_filetype.h
@@ -0,0 +1,120 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Blender Foundation 2010.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef IMB_FILETYPE_H
+#define IMB_FILETYPE_H
+
+/* Generic File Type */
+
+struct ImBuf;
+
+#define IM_FTYPE_FLOAT	1
+
+typedef struct ImFileType {
+	void (*init)(void);
+	void (*exit)(void);
+
+	int (*is_a)(unsigned char *buf);
+	int (*ftype)(struct ImFileType *type, struct ImBuf *ibuf);
+	struct ImBuf *(*load)(unsigned char *mem, int size, int flags);
+	int (*save)(struct ImBuf *ibuf, char *name, int flags);
+	void (*load_tile)(struct ImBuf *ibuf, unsigned char *mem, int size, int tx, int ty, unsigned int *rect);
+
+	int flag;
+	int filetype;
+} ImFileType;
+
+extern ImFileType IMB_FILE_TYPES[];
+
+void imb_filetypes_init(void);
+void imb_filetypes_exit(void);
+
+void imb_tile_cache_init(void);
+void imb_tile_cache_exit(void);
+
+void imb_loadtile(struct ImBuf *ibuf, int tx, int ty, unsigned int *rect);
+void imb_tile_cache_tile_free(struct ImBuf *ibuf, int tx, int ty);
+
+/* Type Specific Functions */
+
+/* png */
+int imb_is_a_png(unsigned char *buf);
+struct ImBuf *imb_loadpng(unsigned char *mem, int size, int flags);
+int imb_savepng(struct ImBuf *ibuf, char *name, int flags);
+
+/* targa */
+int imb_is_a_targa(unsigned char *buf);
+struct ImBuf *imb_loadtarga(unsigned char *mem, int size, int flags);
+int imb_savetarga(struct ImBuf * ibuf, char *name, int flags);
+
+/* iris */
+int imb_is_a_iris(unsigned char *mem);
+struct ImBuf *imb_loadiris(unsigned char *mem, int size, int flags);
+int imb_saveiris(struct ImBuf * ibuf, char *name, int flags);
+
+/* jp2 */
+int imb_is_a_jp2(unsigned char *buf);
+struct ImBuf *imb_jp2_decode(unsigned char *mem, int size, int flags);
+int imb_savejp2(struct ImBuf *ibuf, char *name, int flags);
+
+/* jpeg */
+int imb_is_a_jpeg(unsigned char *mem);
+int imb_savejpeg(struct ImBuf * ibuf, char * name, int flags);
+struct ImBuf * imb_ibJpegImageFromFilename (const char * filename, int flags);
+struct ImBuf * imb_load_jpeg (unsigned char * buffer, int size, int flags);
+
+/* bmp */
+int imb_is_a_bmp(unsigned char *buf);
+struct ImBuf *imb_bmp_decode(unsigned char *mem, int size, int flags);
+int imb_savebmp(struct ImBuf *ibuf, char *name, int flags);
+
+/* cocoa */
+struct ImBuf *imb_cocoaLoadImage(unsigned char *mem, int size, int flags);
+short imb_cocoaSaveImage(struct ImBuf *ibuf, char *name, int flags);
+
+/* cineon */
+int imb_savecineon(struct ImBuf *buf, char *myfil, int flags);
+struct ImBuf *imb_loadcineon(unsigned char *mem, int size, int flags);
+int imb_is_cineon(unsigned char *buf);
+
+/* dpx */
+int imb_save_dpx(struct ImBuf *buf, char *myfile, int flags);
+struct ImBuf *imb_loaddpx(unsigned char *mem, int size, int flags);
+int imb_is_dpx(unsigned char *buf);
+
+/* hdr */
+int imb_is_a_hdr(unsigned char *buf);
+struct ImBuf *imb_loadhdr(unsigned char *mem, int size, int flags);
+int imb_savehdr(struct ImBuf * ibuf, char *name, int flags);
+
+/* tiff */
+int imb_is_a_tiff(unsigned char *buf);
+struct ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags);
+void imb_loadtiletiff(struct ImBuf *ibuf, unsigned char *mem, int size,
+	int tx, int ty, unsigned int *rect);
+int imb_savetiff(struct ImBuf *ibuf, char *name, int flags);
+void *libtiff_findsymbol(char *name);
+
+#endif	/* IMB_FILETYPE_H */
+
diff --git a/source/blender/imbuf/intern/IMB_filter.h b/source/blender/imbuf/intern/IMB_filter.h
index 4f54ea91a1f..84ad72c520a 100644
--- a/source/blender/imbuf/intern/IMB_filter.h
+++ b/source/blender/imbuf/intern/IMB_filter.h
@@ -41,5 +41,8 @@ struct ImBuf;
 
 void imb_filterx(struct ImBuf *ibuf);
 
+void IMB_premultiply_rect(unsigned int *rect, int depth, int w, int h);
+void IMB_premultiply_rect_float(float *rect_float, int depth, int w, int h);
+
 #endif
 
diff --git a/source/blender/imbuf/intern/IMB_hamx.h b/source/blender/imbuf/intern/IMB_hamx.h
deleted file mode 100644
index e39aef8355d..00000000000
--- a/source/blender/imbuf/intern/IMB_hamx.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * IMB_hamx.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_hamx.h
- * \ingroup imbuf
- * \brief Function declarations for hamx.c
- */
-
-#ifndef IMB_HAMX_H
-#define IMB_HAMX_H
-
-struct ImBuf;
-
-struct ImBuf *imb_loadanim(int *iffmem, int flags);
-short imb_enc_anim(struct ImBuf *ibuf, int file);  
-void imb_convhamx(struct ImBuf *ibuf, unsigned char *coltab, short *deltab);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_iff.h b/source/blender/imbuf/intern/IMB_iff.h
deleted file mode 100644
index 7d0a74dc00b..00000000000
--- a/source/blender/imbuf/intern/IMB_iff.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * IMB_iff.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_iff.h
- * \ingroup imbuf
- * \brief Function declarations for iff.c
- */
-
-#ifndef IMB_IFF_H
-#define IMB_IFF_H
-
-struct ImBuf;
-
-unsigned short imb_start_iff(struct ImBuf *ibuf, int file);
-unsigned short imb_update_iff(int file, int code);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_iris.h b/source/blender/imbuf/intern/IMB_iris.h
deleted file mode 100644
index 3aa157cb959..00000000000
--- a/source/blender/imbuf/intern/IMB_iris.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * IMB_iris.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_iris.h
- * \ingroup imbuf
- * \brief Function declarations for iris.c
- */
-
-#ifndef IMB_IRIS_H
-#define IMB_IRIS_H
-
-struct ImBuf;
-
-struct ImBuf *imb_loadiris(unsigned char *mem, int flags);
-short imb_saveiris(struct ImBuf * ibuf, char *name, int flags);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_jp2.h b/source/blender/imbuf/intern/IMB_jp2.h
deleted file mode 100644
index 66ff69314ae..00000000000
--- a/source/blender/imbuf/intern/IMB_jp2.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * IMB_jp2.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_jp2.h
- * \ingroup imbuf
- * \brief Function declarations for jp2.c
- */
-
-#ifndef IMB_JP2_H
-#define IMB_JP2_H
-
-#ifdef WITH_OPENJPEG
-struct ImBuf;
-
-int imb_is_a_jp2(void *buf);
-struct ImBuf *imb_jp2_decode(unsigned char *mem, int size, int flags);
-short imb_savejp2(struct ImBuf *ibuf, char *name, int flags);
-#endif /* WITH_OPENJPEG */
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_jpeg.h b/source/blender/imbuf/intern/IMB_jpeg.h
deleted file mode 100644
index 8e0ba3451ae..00000000000
--- a/source/blender/imbuf/intern/IMB_jpeg.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * IMB_jpeg.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_jpeg.h
- * \ingroup imbuf
- * \brief Function declarations for jpeg.c
- */
-
-#ifndef IMB_JPEG_H
-#define IMB_JPEG_H
-
-struct ImBuf;
-struct jpeg_compress_struct;
-
-int imb_is_a_jpeg(unsigned char *mem);
-int imb_savejpeg(struct ImBuf * ibuf, char * name, int flags);
-struct ImBuf * imb_ibJpegImageFromFilename (const char * filename, int flags);
-struct ImBuf * imb_ibJpegImageFromMemory (unsigned char * buffer, int size, int flags);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_imginfo.h b/source/blender/imbuf/intern/IMB_metadata.h
index 2884abcaf6e..751978a88da 100644
--- a/source/blender/imbuf/intern/IMB_imginfo.h
+++ b/source/blender/imbuf/intern/IMB_metadata.h
@@ -1,5 +1,5 @@
 /**
- * $Id$ 
+ * $Id: IMB_metadata.h 28607 2010-05-06 07:10:56Z campbellbarton $ 
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
@@ -30,20 +30,16 @@
 #ifndef _IMB_IMGINFO_H
 #define _IMB_IMGINFO_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 struct ImBuf;
 
-typedef struct ImgInfo {
-	struct ImgInfo *next, *prev;
+typedef struct ImMetaData {
+	struct ImMetaData *next, *prev;
 	char* key;
 	char* value;
 	int len;
-} ImgInfo;
+} ImMetaData;
 
-/** The imginfo is a list of key/value pairs (both char*) that can me 
+/** The metadata is a list of key/value pairs (both char*) that can me 
 	saved in the header of several image formats.
 	Apart from some common keys like 
 	'Software' and 'Description' (png standard) we'll use keys within the 
@@ -52,8 +48,8 @@ typedef struct ImgInfo {
 */
 
 
-/* free blender ImgInfo struct */
-void IMB_imginfo_free(struct ImBuf* img);
+/* free blender ImMetaData struct */
+void IMB_metadata_free(struct ImBuf* img);
 
 /** read the field from the image info into the field 
  *  @param img - the ImBuf that contains the image data
@@ -63,23 +59,22 @@ void IMB_imginfo_free(struct ImBuf* img);
  *  @param len - length of value buffer allocated by user.
  *  @return    - 1 (true) if ImageInfo present and value for the key found, 0 (false) otherwise
  */
-int IMB_imginfo_get_field(struct ImBuf* img, const char* key, char* value, int len);
+int IMB_metadata_get_field(struct ImBuf* img, const char* key, char* value, int len);
 
-/** set user data in the ImgInfo struct, which has to be allocated with IMB_imginfo_create
+/** set user data in the ImMetaData struct, which has to be allocated with IMB_metadata_create
  *  before calling this function.
  *  @param img - the ImBuf that contains the image data
  *  @param key - the key of the field
  *  @param value - the data to be written to the field. zero terminated string
  *  @return    - 1 (true) if ImageInfo present, 0 (false) otherwise
  */
-int IMB_imginfo_add_field(struct ImBuf* img, const char* key, const char* field);
+int IMB_metadata_add_field(struct ImBuf* img, const char* key, const char* field);
 
-/** delete the key/field par in the ImgInfo struct.
+/** delete the key/field par in the ImMetaData struct.
  * @param img - the ImBuf that contains the image data
  * @param key - the key of the field
  * @return - 1 (true) if delete the key/field, 0 (false) otherwise
  */
-int IMB_imginfo_del_field(struct ImBuf *img, const char *key);
+int IMB_metadata_del_field(struct ImBuf *img, const char *key);
 
 #endif /* _IMB_IMGINFO_H */
-
diff --git a/source/blender/imbuf/intern/IMB_png.h b/source/blender/imbuf/intern/IMB_png.h
deleted file mode 100644
index 28e3adb2722..00000000000
--- a/source/blender/imbuf/intern/IMB_png.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * IMB_png.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_png.h
- * \ingroup imbuf
- * \brief Function declarations for png.c
- */
-
-#ifndef IMB_PNG_H
-#define IMB_PNG_H
-
-struct ImBuf;
-
-int imb_is_a_png(void *buf);
-struct ImBuf *imb_loadpng(unsigned char *mem, int size, int flags);
-
-short imb_savepng(struct ImBuf *ibuf, char *name, int flags);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_radiance_hdr.h b/source/blender/imbuf/intern/IMB_radiance_hdr.h
deleted file mode 100644
index 325715906a0..00000000000
--- a/source/blender/imbuf/intern/IMB_radiance_hdr.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * IMB_radiance_hdr.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-#ifndef IMB_RADIANCE_HDR_H
-#define IMB_RADIANCE_HDR_H
-
-struct ImBuf;
-
-int imb_is_a_hdr(void *buf);
-
-struct ImBuf *imb_loadhdr(unsigned char *mem, int size, int flags);
-short imb_savehdr(struct ImBuf * ibuf, char *name, int flags);
-
-#endif
diff --git a/source/blender/imbuf/intern/IMB_targa.h b/source/blender/imbuf/intern/IMB_targa.h
deleted file mode 100644
index a81801eedac..00000000000
--- a/source/blender/imbuf/intern/IMB_targa.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * IMB_targa.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_targa.h
- * \ingroup imbuf
- * \brief Function declarations for targa.c
- */
-
-#ifndef IMB_TARGA_H
-#define IMB_TARGA_H
-
-struct ImBuf;
-
-int imb_is_a_targa(void *buf);
-
-struct ImBuf *imb_loadtarga(unsigned char *mem, int size, int flags);
-short imb_savetarga(struct ImBuf * ibuf, char *name, int flags);
-
-#endif
-
diff --git a/source/blender/imbuf/intern/IMB_tiff.h b/source/blender/imbuf/intern/IMB_tiff.h
deleted file mode 100644
index ccd993fe477..00000000000
--- a/source/blender/imbuf/intern/IMB_tiff.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * IMB_tiff.h
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contributor(s): Jonathan Merritt.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-/**
- * \file IMB_tiff.h
- * \ingroup imbuf
- * \brief Function declarations for tiff.c
- */
-
-#ifndef IMB_TIFF_H
-#define IMB_TIFF_H
-
-/* Foward declaration of ImBuf structure. */
-struct ImBuf;
-
-/* Declarations for tiff.c */
-int           imb_is_a_tiff(void *buf);
-struct ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags);
-short         imb_savetiff(struct ImBuf *ibuf, char *name, int flags);
-void*         libtiff_findsymbol(char *name);
-
-#endif /* IMB_TIFF_H */
-
diff --git a/source/blender/imbuf/intern/allocimbuf.c b/source/blender/imbuf/intern/allocimbuf.c
index 056de9ab708..606913dd590 100644
--- a/source/blender/imbuf/intern/allocimbuf.c
+++ b/source/blender/imbuf/intern/allocimbuf.c
@@ -32,54 +32,38 @@
 /* It's become a bit messy... Basically, only the IMB_ prefixed files
  * should remain. */
 
-#include "IMB_imbuf_types.h"
-
-#include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
 
-#include "IMB_divers.h"
 #include "IMB_allocimbuf.h"
-#include "IMB_imginfo.h"
-#include "MEM_CacheLimiterC-Api.h"
+#include "IMB_filetype.h"
+#include "IMB_metadata.h"
 
-static unsigned int dfltcmap[16] = {
-	0x00000000, 0xffffffff, 0x777777ff, 0xccccccff, 
-	0xcc3344ff, 0xdd8844ff, 0xccdd44ff, 0x888833ff, 
-	0x338844ff, 0x44dd44ff, 0x44ddccff, 0x3388ccff, 
-	0x8888ddff, 0x4433ccff, 0xcc33ccff, 0xcc88ddff
-};
+#include "imbuf.h"
 
-void imb_freeplanesImBuf(struct ImBuf * ibuf)
-{
-	if (ibuf==NULL) return;
-	if (ibuf->planes){
-		if (ibuf->mall & IB_planes) MEM_freeN(ibuf->planes);
-	}
-	ibuf->planes = 0;
-	ibuf->mall &= ~IB_planes;
-}
+#include "MEM_CacheLimiterC-Api.h"
 
-void imb_freemipmapImBuf(struct ImBuf * ibuf)
+void imb_freemipmapImBuf(ImBuf *ibuf)
 {
 	int a;
 	
-	for(a=0; a<IB_MIPMAP_LEVELS; a++) {
-		if(ibuf->mipmap[a]) IMB_freeImBuf(ibuf->mipmap[a]);
-		ibuf->mipmap[a]= NULL;
+	for(a=1; a<ibuf->miptot; a++) {
+		if(ibuf->mipmap[a-1])
+			IMB_freeImBuf(ibuf->mipmap[a-1]);
+		ibuf->mipmap[a-1]= NULL;
 	}
+
+	ibuf->miptot= 0;
 }
 
 /* any free rect frees mipmaps to be sure, creation is in render on first request */
-void imb_freerectfloatImBuf(struct ImBuf * ibuf)
+void imb_freerectfloatImBuf(ImBuf *ibuf)
 {
-	if (ibuf==NULL) return;
+	if(ibuf==NULL) return;
 	
-	if (ibuf->rect_float) {
-		if (ibuf->mall & IB_rectfloat) {
-			MEM_freeN(ibuf->rect_float);
-			ibuf->rect_float=NULL;
-		}
+	if(ibuf->rect_float && (ibuf->mall & IB_rectfloat)) {
+		MEM_freeN(ibuf->rect_float);
+		ibuf->rect_float=NULL;
 	}
 
 	imb_freemipmapImBuf(ibuf);
@@ -89,19 +73,15 @@ void imb_freerectfloatImBuf(struct ImBuf * ibuf)
 }
 
 /* any free rect frees mipmaps to be sure, creation is in render on first request */
-void imb_freerectImBuf(struct ImBuf * ibuf)
+void imb_freerectImBuf(ImBuf *ibuf)
 {
-	if (ibuf==NULL) return;
+	if(ibuf==NULL) return;
 	
-	if (ibuf->crect && ibuf->crect != ibuf->rect) {
+	if(ibuf->crect && ibuf->crect != ibuf->rect)
 		MEM_freeN(ibuf->crect);
-	}
 
-	if (ibuf->rect) {
-		if (ibuf->mall & IB_rect) {
-			MEM_freeN(ibuf->rect);
-		}
-	}
+	if(ibuf->rect && (ibuf->mall & IB_rect))
+		MEM_freeN(ibuf->rect);
 	
 	imb_freemipmapImBuf(ibuf);
 	
@@ -110,150 +90,166 @@ void imb_freerectImBuf(struct ImBuf * ibuf)
 	ibuf->mall &= ~IB_rect;
 }
 
-static void freeencodedbufferImBuf(struct ImBuf * ibuf)
+void imb_freetilesImBuf(ImBuf *ibuf)
 {
-	if (ibuf==NULL) return;
-	if (ibuf->encodedbuffer){
-		if (ibuf->mall & IB_mem) MEM_freeN(ibuf->encodedbuffer);
+	int tx, ty;
+
+	if(ibuf==NULL) return;
+
+	if(ibuf->tiles && (ibuf->mall & IB_tiles)) {
+		for(ty=0; ty<ibuf->ytiles; ty++) {
+			for(tx=0; tx<ibuf->xtiles; tx++) {
+				if(ibuf->tiles[ibuf->xtiles*ty + tx]) {
+					imb_tile_cache_tile_free(ibuf, tx, ty);
+					MEM_freeN(ibuf->tiles[ibuf->xtiles*ty + tx]);
+				}
+			}
+		}
+
+		MEM_freeN(ibuf->tiles);
 	}
+
+	ibuf->tiles= NULL;
+	ibuf->mall &= ~IB_tiles;
+}
+
+static void freeencodedbufferImBuf(ImBuf *ibuf)
+{
+	if(ibuf==NULL) return;
+
+	if(ibuf->encodedbuffer && (ibuf->mall & IB_mem))
+		MEM_freeN(ibuf->encodedbuffer);
+
 	ibuf->encodedbuffer = 0;
 	ibuf->encodedbuffersize = 0;
 	ibuf->encodedsize = 0;
 	ibuf->mall &= ~IB_mem;
 }
 
-void IMB_freezbufImBuf(struct ImBuf * ibuf)
+void IMB_freezbufImBuf(ImBuf *ibuf)
 {
-	if (ibuf==NULL) return;
-	if (ibuf->zbuf){
-		if (ibuf->mall & IB_zbuf) MEM_freeN(ibuf->zbuf);
-	}
+	if(ibuf==NULL) return;
+
+	if(ibuf->zbuf && (ibuf->mall & IB_zbuf))
+		MEM_freeN(ibuf->zbuf);
+
 	ibuf->zbuf= NULL;
 	ibuf->mall &= ~IB_zbuf;
 }
 
-void IMB_freezbuffloatImBuf(struct ImBuf * ibuf)
+void IMB_freezbuffloatImBuf(ImBuf *ibuf)
 {
-	if (ibuf==NULL) return;
-	if (ibuf->zbuf_float){
-		if (ibuf->mall & IB_zbuffloat) MEM_freeN(ibuf->zbuf_float);
-	}
+	if(ibuf==NULL) return;
+
+	if(ibuf->zbuf_float && (ibuf->mall & IB_zbuffloat))
+		MEM_freeN(ibuf->zbuf_float);
+
 	ibuf->zbuf_float= NULL;
 	ibuf->mall &= ~IB_zbuffloat;
 }
 
-void IMB_freecmapImBuf(struct ImBuf * ibuf)
-{
-	if (ibuf==NULL) return;
-	if (ibuf->cmap){
-		if (ibuf->mall & IB_cmap) MEM_freeN(ibuf->cmap);
-	}
-	ibuf->cmap = 0;
-	ibuf->mall &= ~IB_cmap;
-}
-
-void IMB_freeImBuf(struct ImBuf * ibuf)
+void IMB_freeImBuf(ImBuf *ibuf)
 {
-	if (ibuf){
-		if (ibuf->refcounter > 0) {
+	if(ibuf) {
+		if(ibuf->refcounter > 0) {
 			ibuf->refcounter--;
-		} else {
-			imb_freeplanesImBuf(ibuf);
+		}
+		else {
 			imb_freerectImBuf(ibuf);
 			imb_freerectfloatImBuf(ibuf);
+			imb_freetilesImBuf(ibuf);
 			IMB_freezbufImBuf(ibuf);
 			IMB_freezbuffloatImBuf(ibuf);
-			IMB_freecmapImBuf(ibuf);
 			freeencodedbufferImBuf(ibuf);
 			IMB_cache_limiter_unmanage(ibuf);
-			IMB_imginfo_free(ibuf);
+			IMB_metadata_free(ibuf);
 			MEM_freeN(ibuf);
 		}
 	}
 }
 
-void IMB_refImBuf(struct ImBuf * ibuf)
+void IMB_refImBuf(ImBuf *ibuf)
 {
 	ibuf->refcounter++;
 }
 
-short addzbufImBuf(struct ImBuf * ibuf)
+short addzbufImBuf(ImBuf *ibuf)
 {
 	int size;
 	
-	if (ibuf==NULL) return(FALSE);
+	if(ibuf==NULL) return FALSE;
 	
 	IMB_freezbufImBuf(ibuf);
 	
-	size = ibuf->x * ibuf->y * sizeof(unsigned int);
-	if ( (ibuf->zbuf = MEM_mapallocN(size, "addzbufImBuf")) ){
+	size = ibuf->x *ibuf->y *sizeof(unsigned int);
+	if((ibuf->zbuf = MEM_mapallocN(size, "addzbufImBuf"))) {
 		ibuf->mall |= IB_zbuf;
 		ibuf->flags |= IB_zbuf;
-		return (TRUE);
+		return TRUE;
 	}
 	
-	return (FALSE);
+	return FALSE;
 }
 
-short addzbuffloatImBuf(struct ImBuf * ibuf)
+short addzbuffloatImBuf(ImBuf *ibuf)
 {
 	int size;
 	
-	if (ibuf==NULL) return(FALSE);
+	if(ibuf==NULL) return FALSE;
 	
 	IMB_freezbuffloatImBuf(ibuf);
 	
-	size = ibuf->x * ibuf->y * sizeof(float);
-	if ( (ibuf->zbuf_float = MEM_mapallocN(size, "addzbuffloatImBuf")) ){
+	size = ibuf->x *ibuf->y *sizeof(float);
+	if((ibuf->zbuf_float = MEM_mapallocN(size, "addzbuffloatImBuf"))) {
 		ibuf->mall |= IB_zbuffloat;
 		ibuf->flags |= IB_zbuffloat;
-		return (TRUE);
+		return TRUE;
 	}
 	
-	return (FALSE);
+	return FALSE;
 }
 
 
-short imb_addencodedbufferImBuf(struct ImBuf * ibuf)
+short imb_addencodedbufferImBuf(ImBuf *ibuf)
 {
-	if (ibuf==NULL) return(FALSE);
+	if(ibuf==NULL) return FALSE;
 
 	freeencodedbufferImBuf(ibuf);
 
-	if (ibuf->encodedbuffersize == 0) 
+	if(ibuf->encodedbuffersize == 0) 
 		ibuf->encodedbuffersize = 10000;
 
 	ibuf->encodedsize = 0;
 
-	if ( (ibuf->encodedbuffer = MEM_mallocN(ibuf->encodedbuffersize, "addencodedbufferImBuf") )){
+	if((ibuf->encodedbuffer = MEM_mallocN(ibuf->encodedbuffersize, "addencodedbufferImBuf"))) {
 		ibuf->mall |= IB_mem;
 		ibuf->flags |= IB_mem;
-		return (TRUE);
+		return TRUE;
 	}
 
-	return (FALSE);
+	return FALSE;
 }
 
 
-short imb_enlargeencodedbufferImBuf(struct ImBuf * ibuf)
+short imb_enlargeencodedbufferImBuf(ImBuf *ibuf)
 {
 	unsigned int newsize, encodedsize;
 	void *newbuffer;
 
-	if (ibuf==NULL) return(FALSE);
+	if(ibuf==NULL) return FALSE;
 
-	if (ibuf->encodedbuffersize < ibuf->encodedsize) {
+	if(ibuf->encodedbuffersize < ibuf->encodedsize) {
 		printf("imb_enlargeencodedbufferImBuf: error in parameters\n");
-		return(FALSE);
+		return FALSE;
 	}
 
-	newsize = 2 * ibuf->encodedbuffersize;
-	if (newsize < 10000) newsize = 10000;
+	newsize = 2 *ibuf->encodedbuffersize;
+	if(newsize < 10000) newsize = 10000;
 
 	newbuffer = MEM_mallocN(newsize, "enlargeencodedbufferImBuf");
-	if (newbuffer == NULL) return(FALSE);
+	if(newbuffer == NULL) return FALSE;
 
-	if (ibuf->encodedbuffer) {
+	if(ibuf->encodedbuffer) {
 		memcpy(newbuffer, ibuf->encodedbuffer, ibuf->encodedsize);
 	} else {
 		ibuf->encodedsize = 0;
@@ -269,153 +265,98 @@ short imb_enlargeencodedbufferImBuf(struct ImBuf * ibuf)
 	ibuf->mall |= IB_mem;
 	ibuf->flags |= IB_mem;
 
-	return (TRUE);
+	return TRUE;
 }
 
-short imb_addrectfloatImBuf(struct ImBuf * ibuf)
+short imb_addrectfloatImBuf(ImBuf *ibuf)
 {
 	int size;
 	
-	if (ibuf==NULL) return(FALSE);
+	if(ibuf==NULL) return FALSE;
 	
 	imb_freerectfloatImBuf(ibuf);
 	
-	size = ibuf->x * ibuf->y;
-	size = size * 4 * sizeof(float);
+	size = ibuf->x *ibuf->y;
+	size = size *4 *sizeof(float);
 	ibuf->channels= 4;
 	
-	if ( (ibuf->rect_float = MEM_mapallocN(size, "imb_addrectfloatImBuf")) ){
+	if((ibuf->rect_float = MEM_mapallocN(size, "imb_addrectfloatImBuf"))) {
 		ibuf->mall |= IB_rectfloat;
 		ibuf->flags |= IB_rectfloat;
-		return (TRUE);
+		return TRUE;
 	}
 	
-	return (FALSE);
+	return FALSE;
 }
 
 /* question; why also add zbuf? */
-short imb_addrectImBuf(struct ImBuf * ibuf)
+short imb_addrectImBuf(ImBuf *ibuf)
 {
 	int size;
 
-	if (ibuf==NULL) return(FALSE);
+	if(ibuf==NULL) return FALSE;
 	imb_freerectImBuf(ibuf);
 
-	size = ibuf->x * ibuf->y;
-	size = size * sizeof(unsigned int);
+	size = ibuf->x*ibuf->y;
+	size = size*sizeof(unsigned int);
 
-	if ( (ibuf->rect = MEM_mapallocN(size, "imb_addrectImBuf")) ){
+	if((ibuf->rect = MEM_mapallocN(size, "imb_addrectImBuf"))) {
 		ibuf->mall |= IB_rect;
 		ibuf->flags |= IB_rect;
-		if (ibuf->depth > 32) return (addzbufImBuf(ibuf));
-		else return (TRUE);
-	}
-
-	return (FALSE);
-}
-
-
-short imb_addcmapImBuf(struct ImBuf *ibuf)
-{
-	int min;
-	
-	if (ibuf==NULL) return(FALSE);
-	IMB_freecmapImBuf(ibuf);
-
-	imb_checkncols(ibuf);
-	if (ibuf->maxcol == 0) return (TRUE);
-
-	if ( (ibuf->cmap = MEM_callocN(sizeof(unsigned int) * ibuf->maxcol, "imb_addcmapImBuf") ) ){
-		min = ibuf->maxcol * sizeof(unsigned int);
-		if (min > sizeof(dfltcmap)) min = sizeof(dfltcmap);
-		memcpy(ibuf->cmap, dfltcmap, min);
-		ibuf->mall |= IB_cmap;
-		ibuf->flags |= IB_cmap;
-		return (TRUE);
+		if(ibuf->depth > 32) return (addzbufImBuf(ibuf));
+		else return TRUE;
 	}
 
-	return (FALSE);
+	return FALSE;
 }
 
-
-short imb_addplanesImBuf(struct ImBuf *ibuf)
+short imb_addtilesImBuf(ImBuf *ibuf)
 {
-	int size;
-	short skipx,d,y;
-	unsigned int **planes;
-	unsigned int *point2;
-
-	if (ibuf==NULL) return(FALSE);
-	imb_freeplanesImBuf(ibuf);
+	if(ibuf==NULL) return FALSE;
 
-	skipx = ((ibuf->x+31) >> 5);
-	ibuf->skipx=skipx;
-	y=ibuf->y;
-	d=ibuf->depth;
-
-	planes = MEM_mallocN( (d*skipx*y)*sizeof(int) + d*sizeof(int *), "imb_addplanesImBuf");
-	
-	ibuf->planes = planes;
-	if (planes==0) return (FALSE);
+	if(!ibuf->tiles)
+		if((ibuf->tiles = MEM_callocN(sizeof(unsigned int*)*ibuf->xtiles*ibuf->ytiles, "imb_tiles")))
+			ibuf->mall |= IB_tiles;
 
-	point2 = (unsigned int *)(planes+d);
-	size = skipx*y;
-
-	for (;d>0;d--){
-		*(planes++) = point2;
-		point2 += size;
-	}
-	ibuf->mall |= IB_planes;
-	ibuf->flags |= IB_planes;
-
-	return (TRUE);
+	return (ibuf->tiles != NULL);
 }
 
-
-struct ImBuf *IMB_allocImBuf(short x, short y, uchar d, unsigned int flags, uchar bitmap)
+ImBuf *IMB_allocImBuf(short x, short y, uchar d, unsigned int flags, uchar bitmap) /* XXX bitmap argument is deprecated */
 {
-	struct ImBuf *ibuf;
+	ImBuf *ibuf;
 
-	ibuf = MEM_callocN(sizeof(struct ImBuf), "ImBuf_struct");
-	if (bitmap) flags |= IB_planes;
+	ibuf = MEM_callocN(sizeof(ImBuf), "ImBuf_struct");
 
-	if (ibuf){
+	if(ibuf) {
 		ibuf->x= x;
 		ibuf->y= y;
 		ibuf->depth= d;
 		ibuf->ftype= TGA;
 		ibuf->channels= 4;	/* float option, is set to other values when buffers get assigned */
 		
-		if (flags & IB_rect){
-			if (imb_addrectImBuf(ibuf)==FALSE){
+		if(flags & IB_rect) {
+			if(imb_addrectImBuf(ibuf)==FALSE) {
 				IMB_freeImBuf(ibuf);
 				return NULL;
 			}
 		}
 		
-		if (flags & IB_rectfloat){
-			if (imb_addrectfloatImBuf(ibuf)==FALSE){
+		if(flags & IB_rectfloat) {
+			if(imb_addrectfloatImBuf(ibuf)==FALSE) {
 				IMB_freeImBuf(ibuf);
 				return NULL;
 			}
 		}
 		
-		if (flags & IB_zbuf){
-			if (addzbufImBuf(ibuf)==FALSE){
+		if(flags & IB_zbuf) {
+			if(addzbufImBuf(ibuf)==FALSE) {
 				IMB_freeImBuf(ibuf);
 				return NULL;
 			}
 		}
 		
-		if (flags & IB_zbuffloat){
-			if (addzbuffloatImBuf(ibuf)==FALSE){
-				IMB_freeImBuf(ibuf);
-				return NULL;
-			}
-		}
-		
-		if (flags & IB_planes){
-			if (imb_addplanesImBuf(ibuf)==FALSE){
+		if(flags & IB_zbuffloat) {
+			if(addzbuffloatImBuf(ibuf)==FALSE) {
 				IMB_freeImBuf(ibuf);
 				return NULL;
 			}
@@ -425,37 +366,33 @@ struct ImBuf *IMB_allocImBuf(short x, short y, uchar d, unsigned int flags, ucha
 }
 
 /* does no zbuffers? */
-struct ImBuf *IMB_dupImBuf(struct ImBuf *ibuf1)
+ImBuf *IMB_dupImBuf(ImBuf *ibuf1)
 {
-	struct ImBuf *ibuf2, tbuf;
+	ImBuf *ibuf2, tbuf;
 	int flags = 0;
 	int a, x, y;
 	
-	if (ibuf1 == NULL) return NULL;
+	if(ibuf1 == NULL) return NULL;
 
-	if (ibuf1->rect) flags |= IB_rect;
-	if (ibuf1->rect_float) flags |= IB_rectfloat;
-	if (ibuf1->planes) flags |= IB_planes;
+	if(ibuf1->rect) flags |= IB_rect;
+	if(ibuf1->rect_float) flags |= IB_rectfloat;
 
 	x = ibuf1->x;
 	y = ibuf1->y;
-	if (ibuf1->flags & IB_fields) y *= 2;
+	if(ibuf1->flags & IB_fields) y *= 2;
 	
 	ibuf2 = IMB_allocImBuf(x, y, ibuf1->depth, flags, 0);
-	if (ibuf2 == NULL) return NULL;
+	if(ibuf2 == NULL) return NULL;
 
-	if (flags & IB_rect)
-		memcpy(ibuf2->rect, ibuf1->rect, x * 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, ibuf1->channels * x * y * sizeof(float));
+	if(flags & IB_rectfloat)
+		memcpy(ibuf2->rect_float, ibuf1->rect_float, ibuf1->channels *x *y *sizeof(float));
 
-	if (flags & IB_planes) 
-		memcpy(*(ibuf2->planes),*(ibuf1->planes),ibuf1->depth * ibuf1->skipx * y * sizeof(int));
-
-	if (ibuf1->encodedbuffer) {
+	if(ibuf1->encodedbuffer) {
 		ibuf2->encodedbuffersize = ibuf1->encodedbuffersize;
-		if (imb_addencodedbufferImBuf(ibuf2) == FALSE) {
+		if(imb_addencodedbufferImBuf(ibuf2) == FALSE) {
 			IMB_freeImBuf(ibuf2);
 			return NULL;
 		}
@@ -469,8 +406,6 @@ struct ImBuf *IMB_dupImBuf(struct ImBuf *ibuf1)
 	// fix pointers 
 	tbuf.rect		= ibuf2->rect;
 	tbuf.rect_float = ibuf2->rect_float;
-	tbuf.planes		= ibuf2->planes;
-	tbuf.cmap		= ibuf2->cmap;
 	tbuf.encodedbuffer = ibuf2->encodedbuffer;
 	tbuf.zbuf= NULL;
 	tbuf.zbuf_float= NULL;
@@ -482,42 +417,36 @@ struct ImBuf *IMB_dupImBuf(struct ImBuf *ibuf1)
 	tbuf.c_handle           = 0;
 	tbuf.refcounter         = 0;
 
-	// for now don't duplicate image info
-	tbuf.img_info = 0;
+	// for now don't duplicate metadata
+	tbuf.metadata = 0;
 
 	*ibuf2 = tbuf;
 	
-	if (ibuf1->cmap){
-		imb_addcmapImBuf(ibuf2);
-		if (ibuf2->cmap) memcpy(ibuf2->cmap,ibuf1->cmap,ibuf2->maxcol * sizeof(int));
-	}
-
 	return(ibuf2);
 }
 
 /* support for cache limiting */
 
-static void imbuf_cache_destructor(void * data)
+static void imbuf_cache_destructor(void *data)
 {
-	struct ImBuf * ibuf = (struct ImBuf*) data;
+	ImBuf *ibuf = (ImBuf*) data;
 
-	imb_freeplanesImBuf(ibuf);
 	imb_freerectImBuf(ibuf);
 	imb_freerectfloatImBuf(ibuf);
 	IMB_freezbufImBuf(ibuf);
 	IMB_freezbuffloatImBuf(ibuf);
-	IMB_freecmapImBuf(ibuf);
 	freeencodedbufferImBuf(ibuf);
 
 	ibuf->c_handle = 0;
 }
 
-static MEM_CacheLimiterC ** get_imbuf_cache_limiter()
+static MEM_CacheLimiterC **get_imbuf_cache_limiter()
 {
-	static MEM_CacheLimiterC * c = 0;
-	if (!c) {
+	static MEM_CacheLimiterC *c = 0;
+
+	if(!c)
 		c = new_MEM_CacheLimiter(imbuf_cache_destructor);
-	}
+
 	return &c;
 }
 
@@ -527,9 +456,9 @@ void IMB_free_cache_limiter()
 	*get_imbuf_cache_limiter() = 0;
 }
 
-void IMB_cache_limiter_insert(struct ImBuf * i)
+void IMB_cache_limiter_insert(ImBuf *i)
 {
-	if (!i->c_handle) {
+	if(!i->c_handle) {
 		i->c_handle = MEM_CacheLimiter_insert(
 			*get_imbuf_cache_limiter(), i);
 		MEM_CacheLimiter_ref(i->c_handle);
@@ -539,39 +468,37 @@ void IMB_cache_limiter_insert(struct ImBuf * i)
 	}
 }
 
-void IMB_cache_limiter_unmanage(struct ImBuf * i)
+void IMB_cache_limiter_unmanage(ImBuf *i)
 {
-	if (i->c_handle) {
+	if(i->c_handle) {
 		MEM_CacheLimiter_unmanage(i->c_handle);
 		i->c_handle = 0;
 	}
 }
 
-void IMB_cache_limiter_touch(struct ImBuf * i)
+void IMB_cache_limiter_touch(ImBuf *i)
 {
-	if (i->c_handle) {
+	if(i->c_handle)
 		MEM_CacheLimiter_touch(i->c_handle);
-	}
 }
 
-void IMB_cache_limiter_ref(struct ImBuf * i)
+void IMB_cache_limiter_ref(ImBuf *i)
 {
-	if (i->c_handle) {
+	if(i->c_handle)
 		MEM_CacheLimiter_ref(i->c_handle);
-	}
 }
 
-void IMB_cache_limiter_unref(struct ImBuf * i)
+void IMB_cache_limiter_unref(ImBuf *i)
 {
-	if (i->c_handle) {
+	if(i->c_handle)
 		MEM_CacheLimiter_unref(i->c_handle);
-	}
 }
 
-int IMB_cache_limiter_get_refcount(struct ImBuf * i)
+int IMB_cache_limiter_get_refcount(ImBuf *i)
 {
-	if (i->c_handle) {
+	if(i->c_handle)
 		return MEM_CacheLimiter_get_refcount(i->c_handle);
-	}
+
 	return 0;
 }
+
diff --git a/source/blender/imbuf/intern/amiga.c b/source/blender/imbuf/intern/amiga.c
deleted file mode 100644
index 4b9e1d85df3..00000000000
--- a/source/blender/imbuf/intern/amiga.c
+++ /dev/null
@@ -1,540 +0,0 @@
-/**
- * amiga.c
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-#ifdef _WIN32
-#include <io.h>
-#define open _open
-#define read _read
-#define close _close
-#define write _write
-#endif
-#include "imbuf.h"
-#include "imbuf_patch.h"
-
-#include "IMB_imbuf_types.h"
-#include "IMB_imbuf.h"
-
-#include "BKE_global.h"
-
-#include "IMB_cmap.h"
-#include "IMB_allocimbuf.h"
-#include "IMB_bitplanes.h"
-#include "IMB_amiga.h"
-
-/* actually hard coded endianness */
-#define GET_BIG_LONG(x) (((uchar *) (x))[0] << 24 | ((uchar *) (x))[1] << 16 | ((uchar *) (x))[2] << 8 | ((uchar *) (x))[3])
-#define GET_LITTLE_LONG(x) (((uchar *) (x))[3] << 24 | ((uchar *) (x))[2] << 16 | ((uchar *) (x))[1] << 8 | ((uchar *) (x))[0])
-#define SWAP_L(x) (((x << 24) & 0xff000000) | ((x << 8) & 0xff0000) | ((x >> 8) & 0xff00) | ((x >> 24) & 0xff))
-#define SWAP_S(x) (((x << 8) & 0xff00) | ((x >> 8) & 0xff))
-
-/* more endianness... should move to a separate file... */
-#if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__hppa__) || defined (__BIG_ENDIAN__)
-#define GET_ID GET_BIG_LONG
-#define LITTLE_LONG SWAP_LONG
-#else
-#define GET_ID GET_LITTLE_LONG
-#define LITTLE_LONG ENDIAN_NOP
-#endif
-
-static uchar *decodebodyscanl(uchar *body, short bytes, uchar **list, short d)
-{
-	for (;d>0;d--){
-		uchar *point;
-		short todo;
-		uchar i,j;
-
-		point = *(list++);
-		todo=bytes;
-		while (todo>0){
-			i = *body++;
-
-			if (i & 128){			/* fill */
-				if (i==128) continue;	/* nop  */
-
-				i=257-i;
-				todo-=i;
-				j = *(body++);
-				do{
-					*(point++) = j;
-					i--;
-				}while (i);
-			} else{				/* copy */
-				i++;
-				todo-=i;
-
-				do{
-					*(point++) = *(body++);
-					i--;
-				}while (i);
-			}
-		}
-		if (todo) return (0);
-	}
-	return(body);
-}
-
-
-static uchar *decodebodyh(struct ImBuf *ibuf, uchar *body)
-{
-	if (ibuf->y==1) {
-		body=decodebodyscanl(body, WIDTHB(ibuf->x), (uchar **)ibuf->planes, ibuf->depth);
-	}
-	else {
-		unsigned int **list;
-		short skipx,i,bytes,y;
-
-		list = imb_copyplanelist(ibuf);
-		if (list == 0) return (0);
-
-		y=ibuf->y;
-		bytes = WIDTHB(ibuf->x);
-		skipx = ibuf->skipx;
-
-		for (;y>0;y--){
-			body=decodebodyscanl(body, bytes, (uchar **)list, ibuf->depth);
-			if (body == 0) return (0);
-
-			for (i=ibuf->depth-1;i>=0;i--){
-				list[i] += skipx;
-			}
-		}
-		free(list);
-	}
-	return(body);
-}
-
-
-static uchar *decodebodykolum(uchar *body, short bytes, uchar **list, short d, int next)
-{
-	for (;d>0;d--){
-		uchar *point;
-		short todo;
-		uchar i,j;
-
-		point = *(list++);
-		todo=bytes;
-		while (todo>0){
-			i = *body++;
-
-			if (i & 128){			/* fill */
-				if (i==128) continue;	/* nop  */
-
-				i=257-i;
-				todo-=i;
-				j = *body++;
-				do{
-					*point = j;
-					point += next;
-					i--;
-				}while (i);
-			}
-			else{				/* copy */
-				i++;
-				todo-=i;
-
-				do{
-					*point = *body++;
-					point += next;
-					i--;
-				}while (i);
-			}
-		}
-		if (todo) return (0);
-	}
-	return(body);
-}
-
-
-static uchar *decodebodyv(struct ImBuf *ibuf, uchar *body)
-{
-	uchar **list;
-	int skipx, i, bytes, times;
-
-	list = (uchar **)imb_copyplanelist(ibuf);
-	if (list == 0) return (0);
-
-	bytes = ibuf->y;
-	times = WIDTHB(ibuf->x);
-	skipx = ibuf->skipx << 2;
-
-	for (;times>0;times--){
-		body=decodebodykolum(body,bytes,list,ibuf->depth,skipx);
-		if (body == 0) return (0);
-
-		for (i=ibuf->depth-1;i>=0;i--){
-			list[i] += 1;
-		}
-	}
-	free(list);
-	return(body);
-}
-
-static uchar *makebody(uchar **planes, short bytes, short depth, uchar *buf)
-{
-	uchar *bitplstart,*temp;
-
-	register uchar last,this,*bitpl;
-	register short todo;
-	register int copy;
-
-	bytes--;
-	for (;depth>0;depth--){
-		bitpl = *(planes++);
-		bitplstart = bitpl;
-		todo = bytes;
-		last = *bitpl++;
-		this = *bitpl++;
-		copy = last^this;
-		while (todo>0){
-
-			if (copy){
-				do{
-					last = this;
-					this = *bitpl++;
-					if (last == this){
-						if (this == bitpl[-3]){		/* three identical ones? */
-							todo -= 1;		/* set todo */
-							break;
-						}
-					}
-				}while (--todo != 0);
-
-				copy=bitpl-bitplstart;
-				copy -= 1;
-				if (todo) copy -= 2;
-
-				temp = bitpl;
-				bitpl = bitplstart;
-
-				while (copy){
-					last = copy;
-					if (copy>MAXDAT) last = MAXDAT;
-					copy -= last;
-					*buf++ = last-1;
-					do{
-						*buf++ = *bitpl++;
-					}while(--last != 0);
-				}
-				bitplstart = bitpl;
-				bitpl = temp;
-				last = this;
-
-				copy = FALSE;
-			}
-			else{
-				while (*bitpl++ == this){	/* search for first different bye */
-					if (--todo == 0) break;	/* or end of line */
-				}
-				bitpl -= 1;
-				copy = bitpl-bitplstart;
-				bitplstart = bitpl;
-				todo -= 1;
-				this = *bitpl++;
-
-				while (copy){
-					if (copy>MAXRUN){
-						*buf++ = -(MAXRUN-1);
-						*buf++ = last;
-						copy -= MAXRUN;
-					}
-					else{
-						*buf++ = -(copy-1);
-						*buf++ = last;
-						break;
-					}
-				}
-				copy=TRUE;
-			}
-		}
-	}
-	return (buf);
-}
-
-
-short imb_encodebodyh(struct ImBuf *ibuf, int file)
-{
-	uchar *buf, *endbuf, *max;
-	int size, line, ok = TRUE;
-	unsigned int **list;
-	short skipx,i,y;
-
-	line = WIDTHB(ibuf->x) * ibuf->depth;
-	line += (line >> 6) + 10;
-	size = 16 * line;
-	if (size < 16384) size = 16384;
-	
-	buf = (uchar *) malloc(size);
-	if (buf == 0) return (0);
-
-	max = buf + size - line;
-	
-	list = imb_copyplanelist(ibuf);
-	if (list == 0){
-		free(buf);
-		return (0);
-	}
-
-	y=ibuf->y;
-	skipx = ibuf->skipx;
-	endbuf = buf;
-	
-	for (y=ibuf->y;y>0;y--){
-		endbuf = makebody((uchar **)list, WIDTHB(ibuf->x), ibuf->depth, endbuf);
-		if (endbuf==0){
-			ok = -20;
-			break;
-		}
-		if (endbuf >= max || y == 1){ 
-			size = endbuf-buf;
-			if (write(file,buf,size)!=size) ok = -19;
-			endbuf = buf;
-		}
-		for (i=ibuf->depth-1;i>=0;i--){
-			list[i] += skipx;
-		}
-		if (ok != TRUE) break;
-	}
-	free(list);
-
-	free(buf);
-	return(ok);
-}
-
-
-short imb_encodebodyv(struct ImBuf *ibuf, int file)
-{
-	struct ImBuf *ibufv;
-	uchar *buf,*endbuf;
-	short x,offset;
-
-	buf = (uchar *) malloc((ibuf->y + (ibuf->y >> 6) + 10) * ibuf->depth);
-	if (buf == 0) return (0);
-
-	ibufv=IMB_allocImBuf((ibuf->y)<<3,1, ibuf->depth, 0, 1);
-	if (ibufv == 0){
-		free(buf);
-		return (0);
-	}
-
-	offset=0;
-
-	for(x = WIDTHB(ibuf->x);x>0;x--){
-		register short i;
-
-		for(i = ibuf->depth-1 ;i>=0;i--){
-			register uchar *p1,*p2;
-			register int skipx;
-			register short y;
-
-			skipx = (ibuf->skipx)*sizeof(int *);
-			p1=(uchar *)ibuf->planes[i];
-			p2=(uchar *)ibufv->planes[i];
-			p1 += offset;
-
-			for (y=ibuf->y;y>0;y--){
-				*(p2++) = *p1;
-				p1 += skipx;
-			}
-		}
-		offset += 1;
-
-		endbuf=makebody((uchar **)ibufv->planes, ibuf->y, ibuf->depth, buf);
-		if (endbuf==0) return (-20);
-		if (write(file,buf,endbuf-buf)!=endbuf-buf) return (-19);
-	}
-	free(buf);
-	IMB_freeImBuf(ibufv);
-	return (TRUE);
-}
-
-static uchar *readbody(struct ImBuf *ibuf, uchar *body)
-{
-	int skipbuf,skipbdy,depth,y,offset = 0;
-
-	skipbuf = ibuf->skipx;
-	skipbdy = WIDTHB(ibuf->x);
-
-	for (y = ibuf->y; y> 0; y--){
-		for( depth = 0; depth < ibuf->depth; depth ++){
-			memcpy(ibuf->planes[depth] + offset, body, skipbdy);
-			body += skipbdy;
-		}
-		offset += skipbuf;
-	}
-	return body;
-}
-
-struct ImBuf *imb_loadamiga(int *iffmem,int flags)
-{
-	int chunk,totlen,len,*cmap=0,cmaplen =0,*mem,ftype=0;
-	uchar *body=0;
-	struct BitMapHeader bmhd;
-	struct ImBuf *ibuf=0;
-
-	mem = iffmem;
-	bmhd.w = 0;
-
-	if (GET_ID(mem) != FORM) return (0);
-	if (GET_ID(mem+2) != ILBM) return (0);
-	totlen= (GET_BIG_LONG(mem+1) + 1) & ~1;
-	mem += 3;
-	totlen -= 4;
-
-
-	while(totlen > 0){
-		chunk = GET_ID(mem);
-		len= (GET_BIG_LONG(mem+1) + 1) & ~1;
-		mem += 2;
-
-		totlen -= len+8;
-
-		switch (chunk){
-		case BMHD:
-			memcpy(&bmhd, mem, sizeof(struct BitMapHeader));
-
-			bmhd.w = BIG_SHORT(bmhd.w);
-			bmhd.h = BIG_SHORT(bmhd.h);
-			bmhd.x = BIG_SHORT(bmhd.x);
-			bmhd.y = BIG_SHORT(bmhd.y);
-			bmhd.transparentColor = BIG_SHORT(bmhd.transparentColor);
-			bmhd.pageWidth = BIG_SHORT(bmhd.pageWidth);
-			bmhd.pageHeight = BIG_SHORT(bmhd.pageHeight);
-			
-			break;
-		case BODY:
-			body = (uchar *)mem;
-			break;
-		case CMAP:
-			cmap = mem;
-			cmaplen = len/3;
-			break;
-		case CAMG:
-			ftype = GET_BIG_LONG(mem);
-			break;
-		}
-		mem = (int *)((uchar *)mem +len);
-		if (body) break;
-	}
-	if (bmhd.w == 0) return (0);
-	if (body == 0) return (0);
-	
-	if (flags & IB_test) ibuf = IMB_allocImBuf(bmhd.w, bmhd.h, bmhd.nPlanes, 0, 0);
-	else ibuf = IMB_allocImBuf(bmhd.w, bmhd.h, bmhd.nPlanes + (bmhd.masking & 1),0,1);
-
-	if (ibuf == 0) return (0);
-
-	ibuf->ftype = (ftype | AMI);
-	ibuf->profile = IB_PROFILE_SRGB;
-	
-	if (cmap){
-		ibuf->mincol = 0;
-		ibuf->maxcol = cmaplen;
-		imb_addcmapImBuf(ibuf);
-		imb_makecolarray(ibuf, (uchar *)cmap, 0);
-	}
-
-	if (flags & IB_test){
-		if (flags & IB_freem) free(iffmem);
-		return(ibuf);
-	}
-	
-	switch (bmhd.compression){
-	case 0:
-		body= readbody(ibuf, body);
-		break;
-	case 1:
-		body= decodebodyh(ibuf,body);
-		break;
-	case 2:
-		body= decodebodyv(ibuf,body);
-		ibuf->type |= IB_subdlta;
-		break;
-	}
-
-	if (flags & IB_freem) free(iffmem);
-
-	if (body == 0){
-		free (ibuf);
-		return(0);
-	}
-	
-	/* forget stencil */
-	ibuf->depth = bmhd.nPlanes;
-	
-	if (flags & IB_rect){
-		imb_addrectImBuf(ibuf);
-		imb_bptolong(ibuf);
-		imb_freeplanesImBuf(ibuf);
-		if (ibuf->cmap){
-			if ((flags & IB_cmap) == 0) IMB_applycmap(ibuf);
-		} else if (ibuf->depth == 18){
-			int i,col;
-			unsigned int *rect;
-
-			rect = ibuf->rect;
-			for(i=ibuf->x * ibuf->y ; i>0 ; i--){
-				col = *rect;
-				col = ((col & 0x3f000) << 6) + ((col & 0xfc0) << 4) + ((col & 0x3f) << 2);
-				col += (col & 0xc0c0c0) >> 6;
-				*rect++ = col;
-			}
-			ibuf->depth = 24;
-		} else if (ibuf->depth <= 8) { /* no colormap and no 24 bits: b&w */
-			uchar *rect;
-			int size, shift;
-
-			if (ibuf->depth < 8){
-				rect = (uchar *) ibuf->rect;
-				rect += 3;
-				shift = 8 - ibuf->depth;
-				for (size = ibuf->x * ibuf->y; size > 0; size --){
-					rect[0] <<= shift;
-					rect += 4;
-				}
-			}
-			rect = (uchar *) ibuf->rect;
-			for (size = ibuf->x * ibuf->y; size > 0; size --){
-				rect[1] = rect[2] = rect[3];
-				rect += 4;
-			}
-			ibuf->depth = 8;
-		}
-	}
-
-	if ((flags & IB_ttob) == 0) IMB_flipy(ibuf);
-
-	if (ibuf) {
-		if (ibuf->rect) 
-			if (ENDIAN_ORDER == B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf);
-	}
-	
-	return (ibuf);
-}
diff --git a/source/blender/imbuf/intern/anim.c b/source/blender/imbuf/intern/anim.c
index 188f3580170..bc0f9225fbc 100644
--- a/source/blender/imbuf/intern/anim.c
+++ b/source/blender/imbuf/intern/anim.c
@@ -64,7 +64,6 @@
 #include "BKE_global.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 
 #include "AVI_avi.h"
 
@@ -78,9 +77,7 @@
 #include "IMB_imbuf.h"
 
 #include "IMB_allocimbuf.h"
-#include "IMB_bitplanes.h"
 #include "IMB_anim.h"
-#include "IMB_anim5.h"
 
 #ifdef WITH_FFMPEG
 #include <libavformat/avformat.h>
@@ -327,7 +324,6 @@ void IMB_free_anim(struct anim * anim) {
 	}
 
 	IMB_free_anim_ibuf(anim);
-	free_anim_anim5(anim);
 	free_anim_movie(anim);
 	free_anim_avi(anim);
 
@@ -341,7 +337,7 @@ void IMB_free_anim(struct anim * anim) {
 	free_anim_redcode(anim);
 #endif
 
-	free(anim);
+	MEM_freeN(anim);
 }
 
 void IMB_close_anim(struct anim * anim) {
@@ -476,7 +472,7 @@ static ImBuf * avi_fetchibuf (struct anim *anim, int position) {
 		if (anim->pgf) {
 			lpbi = AVIStreamGetFrame(anim->pgf, position + AVIStreamStart(anim->pavi[anim->firstvideo]));
 			if (lpbi) {
-				ibuf = IMB_ibImageFromMemory((int *) lpbi, 100, IB_rect);
+				ibuf = IMB_ibImageFromMemory((unsigned char *) lpbi, 100, IB_rect);
 //Oh brother...
 			}
 		}
@@ -995,7 +991,6 @@ static struct ImBuf * anim_getnew(struct anim * anim) {
 
 	if (anim == NULL) return(0);
 
-	free_anim_anim5(anim);
 	free_anim_movie(anim);
 	free_anim_avi(anim);
 #ifdef WITH_QUICKTIME
@@ -1013,10 +1008,6 @@ static struct ImBuf * anim_getnew(struct anim * anim) {
 	anim->curtype = imb_get_anim_type(anim->name);	
 
 	switch (anim->curtype) {
-	case ANIM_ANIM5:
-		if (startanim5(anim)) return (0);
-		ibuf = anim5_fetchibuf(anim);
-		break;
 	case ANIM_SEQUENCE:
 		ibuf = IMB_loadiffname(anim->name, anim->ib_flags);
 		if (ibuf) {
@@ -1094,26 +1085,13 @@ struct ImBuf * IMB_anim_absolute(struct anim * anim, int position) {
 	if (position >= anim->duration) return(0);
 
 	switch(anim->curtype) {
-	case ANIM_ANIM5:
-		if (anim->curposition > position) rewindanim5(anim);
-		while (anim->curposition < position) {
-			if (nextanim5(anim)) return (0);
-		}
-		ibuf = anim5_fetchibuf(anim);
-		ibuf->profile = IB_PROFILE_SRGB;
-		break;
 	case ANIM_SEQUENCE:
 		pic = an_stringdec(anim->first, head, tail, &digits);
 		pic += position;
 		an_stringenc(anim->name, head, tail, digits, pic);
-		ibuf = IMB_loadiffname(anim->name, LI_rect);
+		ibuf = IMB_loadiffname(anim->name, IB_rect);
 		if (ibuf) {
 			anim->curposition = position;
-			/* patch... by freeing the cmap you prevent a double apply cmap... */
-			/* probably the IB_CMAP option isn't working proper
-			 * after the abgr->rgba reconstruction
-			 */
-			IMB_freecmapImBuf(ibuf);
 		}
 		break;
 	case ANIM_MOVIE:
@@ -1153,7 +1131,6 @@ struct ImBuf * IMB_anim_absolute(struct anim * anim, int position) {
 	}
 
 	if (ibuf) {
-		if (anim->ib_flags & IB_ttob) IMB_flipy(ibuf);
 		if (filter_y) IMB_filtery(ibuf);
 		sprintf(ibuf->name, "%s.%04d", anim->name, anim->curposition + 1);
 		
@@ -1161,16 +1138,6 @@ struct ImBuf * IMB_anim_absolute(struct anim * anim, int position) {
 	return(ibuf);
 }
 
-struct ImBuf * IMB_anim_nextpic(struct anim * anim) {
-	struct ImBuf * ibuf = 0;
-
-	if (anim == 0) return(0);
-
-	ibuf = IMB_anim_absolute(anim, anim->curposition + 1);
-
-	return(ibuf);
-}
-
 /***/
 
 int IMB_anim_get_duration(struct anim *anim) {
diff --git a/source/blender/imbuf/intern/anim5.c b/source/blender/imbuf/intern/anim5.c
deleted file mode 100644
index 41c4c2c610b..00000000000
--- a/source/blender/imbuf/intern/anim5.c
+++ /dev/null
@@ -1,539 +0,0 @@
-/**
- * anim5.c
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): phase, code torn apart from anim.c
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-#include "BLI_blenlib.h" /* BLI_remlink BLI_filesize BLI_addtail
-							BLI_countlist BLI_stringdec */
-
-#include "imbuf.h"
-#include "imbuf_patch.h"
-
-#include "IMB_imbuf_types.h"
-#include "IMB_imbuf.h"
-
-#include "IMB_cmap.h"
-#include "IMB_allocimbuf.h"
-#include "IMB_bitplanes.h"
-#include "IMB_amiga.h"
-
-#include "IMB_anim.h"
-
-#include "IMB_anim5.h"
-
-#ifdef _WIN32
-#include <io.h>
-#include "BLI_winstuff.h"
-#endif
-
-typedef struct Anhd{
-	unsigned char type, mask;
-	unsigned short w, h;
-	unsigned short x, y;
-	unsigned short abs16, abs, reala6, real;
-	unsigned char interleave, pad0;
-	unsigned short bits16, bits;
-	unsigned char pad[16];
-}Anhd;
-
-typedef struct Anim5Delta {
-	struct Anim5Delta * next, * prev;
-	void * data;
-	int type;
-}Anim5Delta;
-
-
-/* om anim5's te kunnen lezen, moet een aantal gegevens bijgehouden worden:
- * Een lijst van pointers naar delta's, in geheugen of ge'mmap'ed
- * 
- * Mogelijk kan er ook een 'skiptab' aangelegd worden, om sneller
- * sprongen te kunnen maken.
- * 
- * Er moeten niet direct al plaatjes gegenereed worden, dit maakt de 
- * routines onbruikbaar om snel naar het goede plaatje te springen.
- * Een routine voert dus de delta's uit, een andere routine maakt van
- * voorgrondplaatje een ibuf;
- */
-
-
-/*
-   een aantal functie pointers moet geinporteerd worden, zodat er niet
-   nog meer library's / objects meegelinkt hoeven te worden.
-
-   Dezelfde structuur moet ook gebruikt kunnen worden voor het wegschrijven
-   van animaties. Hoe geef je dit aan ?
-   
-   Hoe snel kunnen 10 .dlta's gedecomprimeerd worden
-   (zonder omzetten naar rect).
-   
-   1 - zoek naar 1e plaatje, animatie die aan de eisen voldoet
-   2 - probeer volgende plaatje te vinden:
-		anim5 - decomprimeer
-		sequence - teller ophogen
-		directory - volgende entry
-   3 - geen succes ? ga naar 1.
-   
-   
-*/
-
-/*
-	1. Initialiseer routine met toegestane reeksen, en eerste naam
-		- series op naam (.0001)
-		- directories
-		- anim5 animaties
-		- TGA delta's
-		- iff 24bits delta's (.delta)
-	
-	2. haal volgende (vorige ?) plaatje op.
-	
-	3. vrijgeven
-*/
-
-/* selectie volgorde is:
-	1 - anim5()
-	2 - name
-	3 - dir
-*/
-
-void free_anim_anim5(struct anim * anim) {
-	ListBase * animbase;
-	Anim5Delta * delta, * next;
-
-	if (anim == NULL) return;
-
-	animbase = &anim->anim5base;
-	delta = animbase->first;
-
-	while (delta) {
-		next = delta->next;
-
-		if (delta->type == ANIM5_MALLOC) free(delta->data);
-		BLI_remlink(animbase, delta);
-		free(delta);
-
-		delta = next;
-	}
-
-	if (anim->anim5mmap && anim->anim5len) {
-		MEM_freeN(anim->anim5mmap);
-	}
-
-	anim->anim5mmap = NULL;
-	anim->anim5len = 0;
-	anim->anim5curdlta = 0;
-	anim->duration = 0;
-}
-
-static void planes_to_rect(struct ImBuf * ibuf, int flags) {
-	if (ibuf == 0) return;
-
-	/* dit komt regelrecht uit de amiga.c */
-
-	if (flags & IB_rect && ibuf->rect == 0) {
-		imb_addrectImBuf(ibuf);
-		imb_bptolong(ibuf);
-		IMB_flipy(ibuf);
-		imb_freeplanesImBuf(ibuf);
-
-		if (ibuf->cmap){
-			if ((flags & IB_cmap) == 0) {
-				IMB_applycmap(ibuf);
-				IMB_convert_rgba_to_abgr(ibuf);
-			}
-		} else if (ibuf->depth == 18){
-			int i,col;
-			unsigned int *rect;
-
-			rect = ibuf->rect;
-			for(i=ibuf->x * ibuf->y ; i>0 ; i--){
-				col = *rect;
-				col = ((col & 0x3f000) << 6) + ((col & 0xfc0) << 4)
-					+ ((col & 0x3f) << 2);
-				col += (col & 0xc0c0c0) >> 6;
-				*rect++ = col;
-			}
-			ibuf->depth = 24;
-		} else if (ibuf->depth <= 8) {
-			/* geen colormap en geen 24 bits: zwartwit */
-			uchar *rect;
-			int size, shift;
-
-			if (ibuf->depth < 8){
-				rect = (uchar *) ibuf->rect;
-				rect += 3;
-				shift = 8 - ibuf->depth;
-				for (size = ibuf->x * ibuf->y; size > 0; size --){
-					rect[0] <<= shift;
-					rect += 4;
-				}
-			}
-			rect = (uchar *) ibuf->rect;
-			for (size = ibuf->x * ibuf->y; size > 0; size --){
-				rect[1] = rect[2] = rect[3];
-				rect += 4;
-			}
-			ibuf->depth = 8;
-		}
-	}
-}
-
-
-static void anim5decode(struct ImBuf * ibuf, uchar * dlta) {
-	uchar depth;
-	int skip;
-	int *ofspoint;
-	uchar **planes;
-
-	/*	composition delta:
-		list with ofsets for delta' s by bitplane (ofspoint)
-		by column in delta (point)
-			number of operations (noops)
-				code
-					associated data
-				...
-			...
-	*/
-
-	dlta += 8;
-
-	ofspoint = (int *)dlta;
-	skip = ibuf->skipx * sizeof(int *);
-	planes = (uchar **)ibuf->planes;
-
-	for(depth=ibuf->depth ; depth>0 ; depth--){
-		if (GET_BIG_LONG(ofspoint)){
-			uchar *planestart;
-			uchar *point;
-			uchar x;
-
-			point = dlta + GET_BIG_LONG(ofspoint);
-			planestart = planes[0];
-			x = (ibuf->x + 7) >> 3;
-
-			do{
-				uchar noop;
-
-				if ( (noop = *(point++)) ){
-					uchar *plane;
-					uchar code;
-
-					plane = planestart;
-					do{
-						if ((code = *(point++))==0){
-							uchar val;
-
-							code = *(point++);
-							val = *(point++);
-							do {
-								plane[0] = val;
-								plane += skip;
-							} while(--code);
-
-						} else if (code & 128){
-
-							code &= 0x7f;
-							do{
-								plane[0] = *(point++);
-								plane += skip;
-							} while(--code);
-
-						} else plane += code * skip;
-
-					} while(--noop);
-				}
-				planestart++;
-			} while(--x);
-		}
-		ofspoint++;
-		planes++;
-	}
-}
-
-
-static void anim5xordecode(struct ImBuf * ibuf, uchar * dlta) {
-	uchar depth;
-	int skip;
-	int *ofspoint;
-	uchar **planes;
-
-	/*	samenstelling delta:
-		lijst met ofsets voor delta's per bitplane (ofspoint)
-		per kolom in delta (point)
-			aantal handelingen (noops)
-				code
-					bijbehorende data
-				...
-			...
-	*/
-
-	dlta += 8;
-
-	ofspoint = (int *)dlta;
-	skip = ibuf->skipx * sizeof(int *);
-	planes = (uchar **)ibuf->planes;
-
-	for(depth=ibuf->depth ; depth>0 ; depth--){
-
-		if (GET_BIG_LONG(ofspoint)){
-			uchar *planestart;
-			uchar *point;
-			uchar x;
-
-			point = dlta + GET_BIG_LONG(ofspoint);
-			planestart = planes[0];
-			x = (ibuf->x + 7) >> 3;
-
-			do{
-				uchar noop;
-
-				if ( (noop = *(point++)) ){
-					uchar *plane;
-					uchar code;
-
-					plane = planestart;
-					do{
-						if ((code = *(point++))==0){
-							uchar val;
-
-							code = *(point++);
-							val = *(point++);
-							do{
-								plane[0] ^= val;
-								plane += skip;
-							}while(--code);
-
-						} else if (code & 128){
-
-							code &= 0x7f;
-							do{
-								plane[0] ^= *(point++);
-								plane += skip;
-							}while(--code);
-
-						} else plane += code * skip;
-
-					}while(--noop);
-				}
-				planestart++;
-			}while(--x);
-		}
-		ofspoint++;
-		planes++;
-	}
-}
-
-
-int nextanim5(struct anim * anim) {
-	Anim5Delta * delta;
-	struct ImBuf * ibuf;
-
-	if (anim == 0) return(-1);
-
-	delta = anim->anim5curdlta;
-
-	if (delta == 0) return (-1);
-
-	if (anim->anim5flags & ANIM5_SNGBUF) {
-		ibuf = anim->ibuf1;
-		if (ibuf == 0) return (0);
-		anim->anim5decode(ibuf, delta->data);
-	} else {
-		ibuf = anim->ibuf2;
-		if (ibuf == 0) return (0);
-		anim->anim5decode(ibuf, delta->data);
-		anim->ibuf2 = anim->ibuf1;
-		anim->ibuf1 = ibuf;
-	}
-
-	anim->anim5curdlta = anim->anim5curdlta->next;
-	anim->curposition++;
-
-	return(0);
-}
-
-int rewindanim5(struct anim * anim) {
-	Anim5Delta * delta;
-	struct ImBuf * ibuf;
-
-	if (anim == 0) return (-1);
-
-	IMB_free_anim_ibuf(anim);
-
-	delta = anim->anim5base.first;
-	if (delta == 0) return (-1);
-
-	ibuf = IMB_loadiffmem(delta->data, IB_planes);
-	if (ibuf == 0) return(-1);
-
-	anim->ibuf1 = ibuf;
-	if ((anim->anim5flags & ANIM5_SNGBUF) == 0) anim->ibuf2 = IMB_dupImBuf(ibuf);
-
-	anim->anim5curdlta = delta->next;
-	anim->curposition = 0;
-
-	return(0);
-}
-
-
-int startanim5(struct anim * anim) {
-	int file, buf[20], totlen;
-	unsigned int len;
-	short * mem;
-	ListBase * animbase;
-	Anim5Delta * delta;
-	Anhd anhd;
-
-	/* Controles */
-
-	if (anim == 0) return(-1);
-
-	file = open(anim->name,O_BINARY|O_RDONLY);
-	if (file < 0) return (-1);
-
-	if (read(file, buf, 24) != 24) {
-		close(file);
-		return(-1);
-	}
-
-	if ((GET_ID(buf) != FORM) || (GET_ID(buf + 2) != ANIM)
-		|| (GET_ID(buf + 3) != FORM) || (GET_ID(buf + 5) != ILBM)){
-		printf("No anim5 file %s\n",anim->name);
-		close(file);
-		return (-1);
-	}
-
-	/* de hele file wordt in het geheugen gemapped */
-
-	totlen = BLI_filesize(file);
-	if (totlen>0 && file>=0) {
-		lseek(file, 0L, SEEK_SET);
-		
-		mem= MEM_mallocN(totlen, "mmap");
-		if (read(file, mem, totlen) != totlen) {
-			MEM_freeN(mem);
-			mem = NULL;
-		}
-	} else {
-		mem = NULL;
-	}
-	close (file);
-
-	if (!mem) return (-1);
-
-	anhd.interleave = 0;
-	anhd.bits = 0;
-	anhd.type = 5;
-
-	anim->anim5mmap = mem;
-	anim->anim5len = totlen;
-	anim->anim5flags = 0;
-	anim->duration = 0;
-
-	animbase = & anim->anim5base;
-	animbase->first = animbase->last = 0;
-
-	/* eerste plaatje inlezen */
-
-	mem = mem + 6;
-	totlen -= 12;
-
-	len = GET_BIG_LONG(mem + 2);
-	len = (len + 8 + 1) & ~1;
-	delta = NEW(Anim5Delta);
-
-	delta->data = mem;
-	delta->type = ANIM5_MMAP;
-
-	BLI_addtail(animbase, delta);
-
-	mem += (len >> 1);
-	totlen -= len;
-
-	while (totlen > 0) {
-		len = GET_BIG_LONG(mem + 2);
-		len = (len + 8 + 1) & ~1;
-
-		switch(GET_ID(mem)){
-		case FORM:
-			len = 12;
-			break;
-		case ANHD:
-			memcpy(&anhd, mem + 4, sizeof(Anhd));
-			break;
-		case DLTA:
-			delta = NEW(Anim5Delta);
-			delta->data = mem;
-			delta->type = ANIM5_MMAP;
-			BLI_addtail(animbase, delta);
-			break;
-		}
-
-		mem += (len >> 1);
-		totlen -= len;
-	}
-
-	if (anhd.interleave == 1) anim->anim5flags |= ANIM5_SNGBUF;
-	if (BIG_SHORT(anhd.bits) & 2) anim->anim5decode = anim5xordecode;
-	else anim->anim5decode = anim5decode;
-
-	/* laatste twee delta's wissen */
-
-	delta = animbase->last;
-	if (delta) {
-		BLI_remlink(animbase, delta);
-		free(delta);
-	}
-
-	if ((anim->anim5flags & ANIM5_SNGBUF) == 0) {
-		delta = animbase->last;
-		if (delta) {
-			BLI_remlink(animbase, delta);
-			free(delta);
-		}
-	}
-
-	anim->duration = BLI_countlist(animbase);
-
-	return(rewindanim5(anim));
-}
-
-
-struct ImBuf * anim5_fetchibuf(struct anim * anim) {
-	struct ImBuf * ibuf;
-
-	if (anim == 0) return (0);
-
-	ibuf = IMB_dupImBuf(anim->ibuf1);
-	planes_to_rect(ibuf, anim->ib_flags);
-
-	ibuf->profile = IB_PROFILE_SRGB;
-	
-	return(ibuf);
-}
-
diff --git a/source/blender/imbuf/intern/antialias.c b/source/blender/imbuf/intern/antialias.c
deleted file mode 100644
index e3a878d0ac4..00000000000
--- a/source/blender/imbuf/intern/antialias.c
+++ /dev/null
@@ -1,466 +0,0 @@
-/**
- * antialias.c
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-#include "imbuf.h"
-
-#include "BLI_blenlib.h"
-#include "DNA_listBase.h"
-
-#include "imbuf_patch.h"
-#include "IMB_imbuf_types.h"
-#include "IMB_imbuf.h"
-#include "IMB_allocimbuf.h"
-
-/* how it works:
-
-1 - seek for a transistion in a collumn
-2 - check the relationship with left and right, 
-
-Is pixel above transition to the left or right equal to the top color, seek down
-
-Is pixel below transition to the left or right equal to the bottom color, seek up 
-		
-*/
-
-/* there should be a funcion * to indicate if two colors are
- * equal or not.
- * For now we use a define
- */
-
-
-static unsigned int anti_mask = 0xffffffff;
-static int anti_a, anti_b, anti_g, anti_r;
-
-#define compare(x, y) ((x ^ y) & anti_mask)
-
-typedef struct Edge
-{
-	struct Edge * next, * prev;
-	short position;
-	int col1, col2;
-}Edge;
-
-static void anti_free_listarray(int count, ListBase * listarray)
-{
-	int i;
-	
-	if (listarray == 0) return;
-	
-	for (i = 0; i < count; i++) BLI_freelistN(listarray + i);
-	MEM_freeN(listarray);	
-}
-
-static ListBase * scanimage(struct ImBuf * ibuf, int dir)
-{
-	int step, pixels, lines, nextline, x, y, col1, col2;
-	unsigned int * rect;
-	ListBase * listarray, * curlist;
-	Edge * edge;
-	int count;
-	
-	switch (dir) {
-	case 'h':
-		step = 1; nextline = ibuf->x;
-		pixels = ibuf->x; lines = ibuf->y;
-		break;
-/*	case 'v':  changed so assured values for step etc.. */
-	default:
-		step = ibuf->x; nextline = 1;
-		pixels = ibuf->y; lines = ibuf->x;
-	}
-	
-	listarray = (ListBase*)MEM_callocN((lines)* sizeof(ListBase), "listarray");
-	for (y = 0; y < lines; y++){
-		rect = ibuf->rect;
-		rect += y * nextline;
-		curlist = listarray + y;
-		
-		col1 = rect[0];
-		count = 0;
-		
-		for (x = 0; x < pixels; x++) {
-			col2 = rect[0];
-			if (compare(col1, col2)) {
-				edge = NEW(Edge);
-
-				if (edge == NULL) return(0);
-
-				edge->position = x;
-				edge->col1 = col1;
-				edge->col2 = col2;
-				BLI_addtail(curlist, edge);
-				col1 = col2;
-				count++;
-				if (count > 100) {
-					printf("\n\n%s: Aborting antialias !\n", ibuf->name);
-					printf("To many transitions.\nIs this a natural image ?\n\n"), 
-					anti_free_listarray(lines, listarray);
-					return(0);
-				}
-			}
-			rect += step;
-		}
-	}
-	
-	return(listarray);
-}
-
-
-static Edge * findmatch(Edge * first, Edge * edge)
-{
-	Edge * match = 0;
-	int in = 0, out = 65535;
-	
-	if (edge->prev) in = edge->prev->position;
-	if (edge->next) out = edge->next->position;
-	
-	while (first) {
-		if (first->position < edge->position) {
-			if (first->col1 == edge->col1) {
-				if (first->position >= in) match = first;
-			} else if (first->col2 == edge->col2) {
-				if (first->next == 0) match = first;
-				else if (first->next->position >= edge->position) match = first;
-			} else if (first->col2 == edge->col1) {
-				match = 0; /* at 'sig saw' situations this one can be wrongly set */
-			}
-		} else if (first->position == edge->position) {
-			if (first->col1 == edge->col1 || first->col2 == edge->col2) match = first;
-		} else {
-			if (match) break;	/* there is one */
-			
-			if (first->col1 == edge->col1) {
-				if (first->prev == 0) match = first;
-				else if (first->prev->position <= edge->position) match = first;
-			} else if (first->col2 == edge->col2) {
-				if (first->position <= out) match = first;
-			}
-		}
-		
-		first = first->next;
-	}
-	
-	return(match);
-}
-
-
-static void filterdraw(unsigned int * ldest, unsigned int * lsrce, int zero, int half, int step)
-{
-	uchar * src, * dst;
-	int count;
-	double weight, add;
-	
-	/* we filter the pixels at ldest between in and out with pixels from lsrce
-	 * weight values go from 0 to 1
-	 */
-	
-
-	count = half - zero;
-	if (count < 0) count = -count;
-	if (count <= 1) return;
-	
-	if (zero < half) {
-		src = (uchar *) (lsrce + (step * zero));
-		dst = (uchar *) (ldest + (step * zero));
-	} else {
-		zero--;
-		src = (uchar *) (lsrce + (step * zero));
-		dst = (uchar *) (ldest + (step * zero));
-		step = -step;
-	}
-	
-	step = 4 * step;
-	
-	dst += step * (count >> 1);
-	src += step * (count >> 1);
-	
-	count = (count + 1) >> 1;
-	add = 0.5 / count;
-	weight = 0.5 * add;
-	
-	/* this of course gamma corrected */
-	
-	for(; count > 0; count --) {
-		if (anti_a) dst[0] += weight * (src[0] - dst[0]);
-		if (anti_b) dst[1] += weight * (src[1] - dst[1]);
-		if (anti_g) dst[2] += weight * (src[2] - dst[2]);
-		if (anti_r) dst[3] += weight * (src[3] - dst[3]);
-		dst += step;
-		src += step;
-		weight += add;
-	}
-}
-
-static void filterimage(struct ImBuf * ibuf, struct ImBuf * cbuf, ListBase * listarray, int dir)
-{
-	int step, pixels, lines, nextline, y, pos, drawboth;
-	unsigned int * irect, * crect;
-	Edge * left, * middle, * right, temp, * any;
-	
-	switch (dir) {
-	case 'h':
-		step = 1; nextline = ibuf->x;
-		pixels = ibuf->x; lines = ibuf->y;
-		break;
-/*	case 'v': changed so have values */
-	default:
-		step = ibuf->x; nextline = 1;
-		pixels = ibuf->y; lines = ibuf->x;
-	}
-	
-	for (y = 1; y < lines - 1; y++){
-		irect = ibuf->rect;
-		irect += y * nextline;
-		crect = cbuf->rect;
-		crect += y * nextline;
-		
-		middle = listarray[y].first;
-		while (middle) {
-			left = findmatch(listarray[y - 1].first, middle);
-			right = findmatch(listarray[y + 1].first, middle);
-			drawboth = FALSE;
-			
-			if (left == 0 || right == 0) {
-				/* edge */
-				any = left;
-				if (right) any = right;
-				if (any) {
-					/* mirroring */
-					pos = 2 * middle->position - any->position;
-
-					if (any->position < middle->position) {
-						if (pos > pixels - 1) pos = pixels - 1;
-						if (middle->next) {
-							if (pos > middle->next->position) pos = middle->next->position;
-						}
-/*						if (any->next) {
-							if (pos > any->next->position) pos = any->next->position;
-						}
-*/					} else {
-						if (pos < 0) pos = 0;
-						if (middle->prev) {
-							if (pos < middle->prev->position) pos = middle->prev->position;
-						}
-/*						if (any->prev) {
-							if (pos < any->prev->position) pos = any->prev->position;
-						}
-*/					}
-					temp.position = pos;
-					if (left) right = &temp;
-					else left = &temp;
-					drawboth = TRUE;
-				}
-			} else if (left->position == middle->position || right->position == middle->position) {
-				/* straight piece */
-				/* small corner, with one of the two at distance 2 (the other is at dist 0) ? */
-				
-				if (abs(left->position - right->position) == 2) drawboth = TRUE;
-			} else if (left->position < middle->position && right->position > middle->position){
-				/* stair 1 */
-				drawboth = TRUE;
-			} else if (left->position > middle->position && right->position < middle->position){
-				/* stair 2 */
-				drawboth = TRUE;
-			} else {
-				/* a peek */
-				drawboth = TRUE;
-			}
-			
-			if (drawboth) {
-				filterdraw(irect, crect - nextline, left->position, middle->position, step);
-				filterdraw(irect, crect + nextline, right->position, middle->position, step);
-			}
-
-			middle = middle->next;
-		}
-	}
-}
-
-
-void IMB_antialias(struct ImBuf * ibuf)
-{
-	struct ImBuf * cbuf;
-	ListBase * listarray;
-	
-	if (ibuf == 0) return;
-	cbuf = IMB_dupImBuf(ibuf);
-	if (cbuf == 0) return;
-	
-	anti_a = (anti_mask >> 24) & 0xff;
-	anti_b = (anti_mask >> 16) & 0xff;
-	anti_g = (anti_mask >>  8) & 0xff;
-	anti_r = (anti_mask >>  0) & 0xff;
-	
-	listarray = scanimage(cbuf, 'h');
-	if (listarray) {
-		filterimage(ibuf, cbuf, listarray, 'h');
-		anti_free_listarray(ibuf->y, listarray);
-		
-		listarray = scanimage(cbuf, 'v');
-		if (listarray) {
-			filterimage(ibuf, cbuf, listarray, 'v');
-			anti_free_listarray(ibuf->x, listarray);
-		}
-	}
-			
-	IMB_freeImBuf(cbuf);
-}
-
-
-/* intelligent scaling */
-
-static void _intel_scale(struct ImBuf * ibuf, ListBase * listarray, int dir)
-{
-	int step, lines, nextline, x, y, col;
-	unsigned int * irect, * trect;
-	int start, end;
-	Edge * left, * right;
-	struct ImBuf * tbuf;
-	
-	switch (dir) {
-	case 'h':
-		step = 1; nextline = ibuf->x;
-		lines = ibuf->y;
-		tbuf = IMB_double_fast_y(ibuf);
-		break;
-	case 'v':
-		step = 2 * ibuf->x; nextline = 1;
-		lines = ibuf->x;
-		tbuf = IMB_double_fast_x(ibuf);
-		break;
-	default:
-		return;
-	}
-	
-	if (tbuf == NULL) return;
-
-	imb_freerectImBuf(ibuf);
-
-	ibuf->rect = tbuf->rect;
-	ibuf->mall |= IB_rect;
-	
-	ibuf->x = tbuf->x;
-	ibuf->y = tbuf->y;
-	tbuf->rect = 0;
-	IMB_freeImBuf(tbuf);
-	
-	for (y = 0; y < lines - 2; y++){
-		irect = ibuf->rect;
-		irect += ((2 * y) + 1) * nextline;
-		
-		left = listarray[y].first;
-		while (left) {
-			right = findmatch(listarray[y + 1].first, left);
-			if (right) {
-				if (left->col2 == right->col2) {
-					if (left->next && right->next) {
-						if (left->next->position >= right->position) {
-							start = ((left->position + right->position) >> 1);
-							end = ((left->next->position + right->next->position) >> 1);
-							col = left->col2;
-							trect = irect + (start * step);
-							for (x = start; x < end; x++) {
-								*trect = col;
-								trect += step;
-							}
-						}
-					}
-				}
-
-				if (left->col1 == right->col1) {
-					if (left->prev && right->prev) {
-						if (left->prev->position <= right->position) {
-							end = ((left->position + right->position) >> 1);
-							start = ((left->prev->position + right->prev->position) >> 1);
-							col = left->col1;
-							trect = irect + (start * step);
-							for (x = start; x < end; x++) {
-								*trect = col;
-								trect += step;
-							}
-						}
-					}
-				}
-
-			}
-			left = left->next;
-		}
-	}
-}
-
-
-void IMB_clever_double(struct ImBuf * ibuf)
-{
-	ListBase * listarray, * curlist;
-	Edge * new;
-	int size;
-	int i;
-	
-	if (ibuf == 0) return;
-	
-	size = ibuf->x;
-	listarray = scanimage(ibuf, 'v');
-	if (listarray) {
-		for (i = 0; i < size; i++) {
-			curlist = listarray + i;
-			new = (Edge*)MEM_callocN(sizeof(Edge),"Edge");
-			new->col2 = ibuf->rect[i]; /* upper pixel */
-			new->col1 = new->col2 - 1;
-			BLI_addhead(curlist, new);
-			new = (Edge*)MEM_callocN(sizeof(Edge),"Edge");
-			new->position = ibuf->y - 1;
-			new->col1 = ibuf->rect[i + ((ibuf->y -1) * ibuf->x)]; /* bottom pixel */
-			new->col2 = new->col1 - 1;
-			BLI_addtail(curlist, new);
-		}
-		_intel_scale(ibuf, listarray, 'v');
-		anti_free_listarray(size, listarray);
-
-		size = ibuf->y;
-		listarray = scanimage(ibuf, 'h');
-		if (listarray) {
-			for (i = 0; i < size; i++) {
-				curlist = listarray + i;
-				new =  (Edge*)MEM_callocN(sizeof(Edge),"Edge");
-				new->col2 = ibuf->rect[i * ibuf->x]; /* left pixel */
-				new->col1 = new->col2 - 1;
-				BLI_addhead(curlist, new);
-				new =  (Edge*)MEM_callocN(sizeof(Edge),"Edge");
-				new->position = ibuf->x - 1;
-				new->col1 = ibuf->rect[((i + 1) * ibuf->x) - 1]; /* right pixel */
-				new->col2 = new->col1 - 1;
-				BLI_addtail(curlist, new);
-			}
-			_intel_scale(ibuf, listarray, 'h');
-			anti_free_listarray(size, listarray);
-		}
-	}
-}
diff --git a/source/blender/imbuf/intern/bitplanes.c b/source/blender/imbuf/intern/bitplanes.c
deleted file mode 100644
index 91fd2a0f563..00000000000
--- a/source/blender/imbuf/intern/bitplanes.c
+++ /dev/null
@@ -1,356 +0,0 @@
-/**
- * bitplanes.c
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-#include "imbuf.h"
-#include "BLI_blenlib.h"
-
-#include "imbuf_patch.h"
-
-#include "IMB_imbuf_types.h"
-#include "IMB_imbuf.h"
-#include "IMB_allocimbuf.h"
-#include "IMB_bitplanes.h"
-
-unsigned int **imb_copyplanelist(struct ImBuf *ibuf)
-{
-	int nobp,i;
-	unsigned int **listn,**listo;
-
-	nobp=ibuf->depth;
-	listn= malloc(nobp*sizeof(int *));			/* make copy of bitmap */
-	if (listn==0) return (0);
-
-	listo=ibuf->planes;
-	for (i=nobp;i>0;i--){
-		*(listn++) = *(listo++);
-	}
-	listn -= nobp;
-
-	return (listn);
-}
-
-static void bptolscanl(unsigned int *buf, int size, unsigned int **list, int nobp, int offset)
-{
-	/* 	converts bitplanes to a buffer with ints
-	by 4 dividiable amount of bitplanes,
-	the width of bitplanes is rounded at ints 	*/
-
-	list += nobp;
-
-	for (;nobp>0;)
-	{
-		int todo,i;
-		register int bp1, bp2, bp3, bp4, data;
-		register unsigned int *point;
-		int loffset;
-		/*register unsigned int bp1, bp2, bp3, bp4;*/
-
-		bp1 = bp2 = bp3 = bp4 = todo = 0;
-		point = buf;
-		loffset = offset;
-
-		if (nobp & 1){
-			list -= 1;
-			nobp -= 1;
-			for(i=size;i>0;i--)
-			{
-				if (todo==0)
-				{
-					bp1 = BIG_LONG((list[0])[loffset]);
-					loffset++;
-					todo=32;
-				}
-
-				data = *point;
-				data<<=1;
-
-				if (bp1<0) data+=1;
-				bp1<<=1;
-
-				/*		data += (bp1 >> 31);
-					bp1 <<= 1;
-				*/
-				*(point++)=data;
-				todo--;
-			}
-		} else if (nobp & 2){
-			list -= 2;
-			nobp -= 2;
-			for(i=size;i>0;i--)
-			{
-				if (todo==0)
-				{
-					bp1 = BIG_LONG((list[0])[loffset]);
-					bp2 = BIG_LONG((list[1])[loffset]);
-					loffset++;
-					todo=32;
-				}
-
-				data = *point;
-				data<<=2;
-
-				if (bp1<0) data+=1;
-				bp1<<=1;
-				if (bp2<0) data+=2;
-				bp2<<=1;
-
-				/*		data += (bp1 >> 31) + ((bp2 & 0x80000000) >> 30);
-				bp1 <<= 1; bp2 <<= 1;
-				*/
-				*(point++)=data;
-				todo--;
-			}
-		} else{
-			list -= 4;
-			nobp -= 4;
-			for(i=size;i>0;i--)
-			{
-				if (todo==0) {
-					bp1 = BIG_LONG((list[0])[loffset]);
-					bp2 = BIG_LONG((list[1])[loffset]);
-					bp3 = BIG_LONG((list[2])[loffset]);
-					bp4 = BIG_LONG((list[3])[loffset]);
-					loffset++;
-					todo=32;
-				}
-
-				data = *point;
-				data<<=4;
-
-				if (bp1<0) data+=1;
-				bp1<<=1;
-				if (bp2<0) data+=2;
-				bp2<<=1;
-				if (bp3<0) data+=4;
-				bp3<<=1;
-				if (bp4<0) data+=8;
-				bp4<<=1;
-
-				/*		data += (bp1 >> 31) \
-				+ ((bp2 & 0x80000000) >> 30) \
-				+ ((bp3 & 0x80000000) >> 29) \
-				+ ((bp4 & 0x80000000) >> 28);
-		
-				bp1 <<= 1; bp2 <<= 1;
-				bp3 <<= 1; bp4 <<= 1;
-				*/
-				
-				*(point++)=data;
-				todo--;
-			}
-		}
-	}
-}
-
-
-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 */
-
-	if (ibuf == 0) return;
-	if (ibuf->planes == 0) return;
-	if (ibuf->rect == 0) imb_addrectImBuf(ibuf);
-
-	nobp=ibuf->depth;
-	if (nobp != 32){
-		if (nobp == 24) IMB_rectfill(ibuf, black); /* set alpha */
-		else IMB_rectfill(ibuf, clear);
-	}
-
-	rect= ibuf->rect;
-	x= ibuf->x;
-	offset=0;
-
-	for (i= ibuf->y; i>0; i--){
-		bptolscanl(rect, x, ibuf->planes, nobp, offset);
-		rect += x;
-		offset += ibuf->skipx;
-	}
-}
-
-
-static void ltobpscanl(unsigned int *rect, int x, unsigned int **list, int nobp, int offset)
-{
-	/* converts a buffer with ints to bitplanes. Take care, buffer 
-		will be destroyed !*/
-
-	if (nobp != 32)
-	{
-		int *rect2;
-		int todo,j;
-
-		rect2 = (int*)rect;
-
-		todo = 32-nobp;
-		for (j = x;j>0;j--){
-			*(rect2++) <<= todo;
-		}
-	}
-
-	list += nobp;
-	for (;nobp>0;){
-		register int bp1=0, bp2=0, bp3=0, data;
-		register unsigned int *point;
-		int i,todo;
-		int bp4=0,loffset;
-
-		point = rect;
-		todo=32;
-		loffset=offset;
-
-		if (nobp & 1){
-			list -= 1;
-			nobp -= 1;
-
-			for(i=x;i>0;i--){
-				data = *point;
-
-				bp1 <<= 1;
-				if (data<0) bp1 += 1;
-				data <<= 1;
-
-				*(point++) = data;
-
-				todo--;
-				if (todo == 0){
-					(list[0])[loffset] = bp1;
-					loffset++;
-					todo=32;
-				}
-			}
-			if (todo != 32)
-			{
-				bp1 <<= todo;
-				(list[0])[loffset] = bp1;
-			}
-		} else if (nobp & 2){
-			list -= 2;
-			nobp -= 2;
-			for(i=x;i>0;i--){
-				data = *point;
-
-				bp2 <<= 1;
-				if (data<0) bp2 += 1;
-				data <<= 1;
-				bp1 <<= 1;
-				if (data<0) bp1 += 1;
-				data <<= 1;
-
-				*(point++) = data;
-
-				todo--;
-				if (todo == 0){
-					(list[0])[loffset] = bp1;
-					(list[1])[loffset] = bp2;
-					loffset++;
-					todo=32;
-				}
-			}
-			if (todo != 32){
-				bp1 <<= todo;
-				bp2 <<= todo;
-				(list[0])[loffset] = bp1;
-				(list[1])[loffset] = bp2;
-			}
-		} else{
-			list -= 4;
-			nobp -= 4;
-			for(i=x;i>0;i--){
-				data = *point;
-
-				bp4 <<= 1;
-				if (data<0) bp4 += 1;
-				data <<= 1;
-				bp3 <<= 1;
-				if (data<0) bp3 += 1;
-				data <<= 1;
-				bp2 <<= 1;
-				if (data<0) bp2 += 1;
-				data <<= 1;
-				bp1 <<= 1;
-				if (data<0) bp1 += 1;
-				data <<= 1;
-
-				*(point++) = data;
-
-				todo--;
-				if (todo == 0){
-					(list[0])[loffset] = bp1;
-					(list[1])[loffset] = bp2;
-					(list[2])[loffset] = bp3;
-					(list[3])[loffset] = bp4;
-					loffset++;
-					todo=32;
-				}
-			}
-			if (todo != 32){
-				bp1 <<= todo;
-				bp2 <<= todo;
-				bp3 <<= todo;
-				bp4 <<= todo;
-				(list[0])[loffset] = bp1;
-				(list[1])[loffset] = bp2;
-				(list[2])[loffset] = bp3;
-				(list[3])[loffset] = bp4;
-			}
-		}
-	}
-}
-
-
-void imb_longtobp(struct ImBuf *ibuf)
-{
-	/* converts a buffer with ints to bitplanes. Take care, buffer
-	will be destroyed !*/
-
-	int nobp,i,x;
-	unsigned int *rect,offset,*buf;
-	;
-
-	nobp = ibuf->depth;
-	rect=ibuf->rect;
-	x=ibuf->x;
-	offset=0;
-	if ((buf=malloc(x*sizeof(int)))==0) return;
-
-	for (i=ibuf->y;i>0;i--){
-		memcpy(buf, rect, x*sizeof(int));
-		rect +=x ;
-		ltobpscanl(buf, x, ibuf->planes, nobp, offset);
-		offset += ibuf->skipx;
-	}
-	free(buf);
-}
diff --git a/source/blender/imbuf/intern/bmp.c b/source/blender/imbuf/intern/bmp.c
index 606cce645ee..bdcf60090c3 100644
--- a/source/blender/imbuf/intern/bmp.c
+++ b/source/blender/imbuf/intern/bmp.c
@@ -30,13 +30,11 @@
 #include "BLI_blenlib.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 #include "IMB_allocimbuf.h"
-#include "IMB_cmap.h"
-#include "IMB_bmp.h"
+#include "IMB_filetype.h"
 
 /* some code copied from article on microsoft.com, copied
   here for enhanced BMP support in the future
@@ -98,7 +96,7 @@ static int checkbmp(unsigned char *mem)
 	return(ret_val);
 }
 
-int imb_is_a_bmp(void *buf) {
+int imb_is_a_bmp(unsigned char *buf) {
 	
 	return checkbmp(buf);
 }
@@ -195,7 +193,7 @@ static int putShortLSB(unsigned short us,FILE *ofile) {
 } 
 
 /* Found write info at http://users.ece.gatech.edu/~slabaugh/personal/c/bitmapUnix.c */
-short imb_savebmp(struct ImBuf *ibuf, char *name, int flags) {
+int imb_savebmp(struct ImBuf *ibuf, char *name, int flags) {
 
 	BMPINFOHEADER infoheader;
 	int bytesize, extrabytes, x, y, t, ptr;
diff --git a/source/blender/imbuf/intern/cache.c b/source/blender/imbuf/intern/cache.c
new file mode 100644
index 00000000000..d15826df2f0
--- /dev/null
+++ b/source/blender/imbuf/intern/cache.c
@@ -0,0 +1,442 @@
+/*
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "BLI_ghash.h"
+#include "BLI_listbase.h"
+#include "BLI_memarena.h"
+#include "BLI_threads.h"
+
+#include "BKE_utildefines.h"
+
+#include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
+#include "IMB_filetype.h"
+
+#include "imbuf.h"
+
+/* We use a two level cache here. A per-thread cache with limited number of
+   tiles. This can be accessed without locking and so is hoped to lead to most
+   tile access being lock-free. The global cache is shared between all threads
+   and requires slow locking to access, and contains all tiles.
+   
+   The per-thread cache should be big enough that one might hope to not fall
+   back to the global cache every pixel, but not to big to keep too many tiles
+   locked and using memory. */
+
+#define IB_THREAD_CACHE_SIZE	100
+
+typedef struct ImGlobalTile {
+	struct ImGlobalTile *next, *prev;
+
+	ImBuf *ibuf;
+	int tx, ty;
+	int refcount;
+	volatile int loading;
+} ImGlobalTile;
+
+typedef struct ImThreadTile {
+	struct ImThreadTile *next, *prev;
+
+	ImBuf *ibuf;
+	int tx, ty;
+
+	ImGlobalTile *global;
+} ImThreadTile;
+
+typedef struct ImThreadTileCache {
+	ListBase tiles;
+	ListBase unused;
+	GHash *tilehash;
+} ImThreadTileCache;
+
+typedef struct ImGlobalTileCache {
+	ListBase tiles;
+	ListBase unused;
+	GHash *tilehash;
+
+	MemArena *memarena;
+	uintptr_t totmem, maxmem;
+
+	ImThreadTileCache thread_cache[BLENDER_MAX_THREADS+1];
+	int totthread;
+
+	ThreadMutex mutex;
+} ImGlobalTileCache;
+
+static ImGlobalTileCache GLOBAL_CACHE;
+
+/***************************** Hash Functions ********************************/
+
+static unsigned int imb_global_tile_hash(void *gtile_p)
+{
+	ImGlobalTile *gtile= gtile_p;
+
+	return ((unsigned int)(intptr_t)gtile->ibuf)*769 + gtile->tx*53 + gtile->ty*97;
+}
+
+static int imb_global_tile_cmp(void *a_p, void *b_p)
+{
+	ImGlobalTile *a= a_p;
+	ImGlobalTile *b= b_p;
+
+	if(a->ibuf == b->ibuf && a->tx == b->tx && a->ty == b->ty) return 0;
+	else if(a->ibuf < b->ibuf || a->tx < b->tx || a->ty < b->ty) return -1;
+	else return 1;
+}
+
+static unsigned int imb_thread_tile_hash(void *ttile_p)
+{
+	ImThreadTile *ttile= ttile_p;
+
+	return ((unsigned int)(intptr_t)ttile->ibuf)*769 + ttile->tx*53 + ttile->ty*97;
+}
+
+static int imb_thread_tile_cmp(void *a_p, void *b_p)
+{
+	ImThreadTile *a= a_p;
+	ImThreadTile *b= b_p;
+
+	if(a->ibuf == b->ibuf && a->tx == b->tx && a->ty == b->ty) return 0;
+	else if(a->ibuf < b->ibuf || a->tx < b->tx || a->ty < b->ty) return -1;
+	else return 1;
+}
+
+/******************************** Load/Unload ********************************/
+
+static void imb_global_cache_tile_load(ImGlobalTile *gtile)
+{
+	ImBuf *ibuf= gtile->ibuf;
+	int toffs= ibuf->xtiles*gtile->ty + gtile->tx;
+	unsigned int *rect;
+
+	rect = MEM_callocN(sizeof(unsigned int)*ibuf->tilex*ibuf->tiley, "imb_tile");
+	imb_loadtile(ibuf, gtile->tx, gtile->ty, rect);
+	ibuf->tiles[toffs]= rect;
+}
+
+static void imb_global_cache_tile_unload(ImGlobalTile *gtile)
+{
+	ImBuf *ibuf= gtile->ibuf;
+	int toffs= ibuf->xtiles*gtile->ty + gtile->tx;
+
+	MEM_freeN(ibuf->tiles[toffs]);
+	ibuf->tiles[toffs]= NULL;
+
+	GLOBAL_CACHE.totmem -= sizeof(unsigned int)*ibuf->tilex*ibuf->tiley;
+}
+
+/* external free */
+void imb_tile_cache_tile_free(ImBuf *ibuf, int tx, int ty)
+{
+	ImGlobalTile *gtile, lookuptile;
+
+	BLI_mutex_lock(&GLOBAL_CACHE.mutex);
+
+	lookuptile.ibuf = ibuf;
+	lookuptile.tx = tx;
+	lookuptile.ty = ty;
+	gtile= BLI_ghash_lookup(GLOBAL_CACHE.tilehash, &lookuptile);
+
+	if(gtile) {
+		/* in case another thread is loading this */
+		while(gtile->loading)
+			;
+
+		BLI_ghash_remove(GLOBAL_CACHE.tilehash, gtile, NULL, NULL);
+		BLI_remlink(&GLOBAL_CACHE.tiles, gtile);
+		BLI_addtail(&GLOBAL_CACHE.unused, gtile);
+	}
+
+	BLI_mutex_unlock(&GLOBAL_CACHE.mutex);
+}
+
+/******************************* Init/Exit ***********************************/
+
+static void imb_thread_cache_init(ImThreadTileCache *cache)
+{
+	ImThreadTile *ttile;
+	int a;
+
+	memset(cache, 0, sizeof(ImThreadTileCache));
+
+	cache->tilehash= BLI_ghash_new(imb_thread_tile_hash, imb_thread_tile_cmp, "imb_thread_cache_init gh");
+
+	/* pre-allocate all thread local tiles in unused list */
+	for(a=0; a<IB_THREAD_CACHE_SIZE; a++) {
+		ttile= BLI_memarena_alloc(GLOBAL_CACHE.memarena, sizeof(ImThreadTile));
+		BLI_addtail(&cache->unused, ttile);
+	}
+}
+
+static void imb_thread_cache_exit(ImThreadTileCache *cache)
+{
+	BLI_ghash_free(cache->tilehash, NULL, NULL);
+}
+
+void imb_tile_cache_init(void)
+{
+	memset(&GLOBAL_CACHE, 0, sizeof(ImGlobalTileCache));
+
+	BLI_mutex_init(&GLOBAL_CACHE.mutex);
+
+	/* initialize for one thread, for places that access textures
+	   outside of rendering (displace modifier, painting, ..) */
+	IMB_tile_cache_params(0, 0);
+}
+
+void imb_tile_cache_exit(void)
+{
+	ImGlobalTile *gtile;
+	int a;
+
+	for(gtile=GLOBAL_CACHE.tiles.first; gtile; gtile=gtile->next)
+		imb_global_cache_tile_unload(gtile);
+
+	for(a=0; a<GLOBAL_CACHE.totthread; a++)
+		imb_thread_cache_exit(&GLOBAL_CACHE.thread_cache[a]);
+
+	if(GLOBAL_CACHE.memarena)
+		BLI_memarena_free(GLOBAL_CACHE.memarena);
+
+	if(GLOBAL_CACHE.tilehash)
+		BLI_ghash_free(GLOBAL_CACHE.tilehash, NULL, NULL);
+
+	BLI_mutex_end(&GLOBAL_CACHE.mutex);
+}
+
+/* presumed to be called when no threads are running */
+void IMB_tile_cache_params(int totthread, int maxmem)
+{
+	int a;
+
+	/* always one cache for non-threaded access */
+	totthread++;
+
+	/* lazy initialize cache */
+	if(GLOBAL_CACHE.totthread == totthread && GLOBAL_CACHE.maxmem == maxmem)
+		return;
+
+	imb_tile_cache_exit();
+
+	memset(&GLOBAL_CACHE, 0, sizeof(ImGlobalTileCache));
+
+	GLOBAL_CACHE.tilehash= BLI_ghash_new(imb_global_tile_hash, imb_global_tile_cmp, "tile_cache_params gh");
+
+	GLOBAL_CACHE.memarena= BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "ImTileCache arena");
+	BLI_memarena_use_calloc(GLOBAL_CACHE.memarena);
+
+	GLOBAL_CACHE.maxmem= maxmem*1024*1024;
+
+	GLOBAL_CACHE.totthread= totthread;
+	for(a=0; a<totthread; a++)
+		imb_thread_cache_init(&GLOBAL_CACHE.thread_cache[a]);
+
+	BLI_mutex_init(&GLOBAL_CACHE.mutex);
+}
+
+/***************************** Global Cache **********************************/
+
+static ImGlobalTile *imb_global_cache_get_tile(ImBuf *ibuf, int tx, int ty, ImGlobalTile *replacetile)
+{
+	ImGlobalTile *gtile, lookuptile;
+
+	BLI_mutex_lock(&GLOBAL_CACHE.mutex);
+
+	if(replacetile)
+		replacetile->refcount--;
+
+	/* find tile in global cache */
+	lookuptile.ibuf = ibuf;
+	lookuptile.tx = tx;
+	lookuptile.ty = ty;
+	gtile= BLI_ghash_lookup(GLOBAL_CACHE.tilehash, &lookuptile);
+	
+	if(gtile) {
+		/* found tile. however it may be in the process of being loaded
+		   by another thread, in that case we do stupid busy loop waiting
+		   for the other thread to load the tile */
+		gtile->refcount++;
+
+		BLI_mutex_unlock(&GLOBAL_CACHE.mutex);
+
+		while(gtile->loading)
+			;
+	}
+	else {
+		/* not found, let's load it from disk */
+
+		/* first check if we hit the memory limit */
+		if(GLOBAL_CACHE.maxmem && GLOBAL_CACHE.totmem > GLOBAL_CACHE.maxmem) {
+			/* find an existing tile to unload */
+			for(gtile=GLOBAL_CACHE.tiles.last; gtile; gtile=gtile->prev)
+				if(gtile->refcount == 0 && gtile->loading == 0)
+					break;
+		}
+
+		if(gtile) {
+			/* found a tile to unload */
+			imb_global_cache_tile_unload(gtile);
+			BLI_ghash_remove(GLOBAL_CACHE.tilehash, gtile, NULL, NULL);
+			BLI_remlink(&GLOBAL_CACHE.tiles, gtile);
+		}
+		else {
+			/* allocate a new tile or reuse unused */
+			if(GLOBAL_CACHE.unused.first) {
+				gtile= GLOBAL_CACHE.unused.first;
+				BLI_remlink(&GLOBAL_CACHE.unused, gtile);
+			}
+			else
+				gtile= BLI_memarena_alloc(GLOBAL_CACHE.memarena, sizeof(ImGlobalTile));
+		}
+
+		/* setup new tile */
+		gtile->ibuf= ibuf;
+		gtile->tx= tx;
+		gtile->ty= ty;
+		gtile->refcount= 1;
+		gtile->loading= 1;
+
+		BLI_ghash_insert(GLOBAL_CACHE.tilehash, gtile, gtile);
+		BLI_addhead(&GLOBAL_CACHE.tiles, gtile);
+
+		/* mark as being loaded and unlock to allow other threads to load too */
+		GLOBAL_CACHE.totmem += sizeof(unsigned int)*ibuf->tilex*ibuf->tiley;
+
+		BLI_mutex_unlock(&GLOBAL_CACHE.mutex);
+
+		/* load from disk */
+		imb_global_cache_tile_load(gtile);
+
+		/* mark as done loading */
+		gtile->loading= 0;
+	}
+
+	return gtile;
+}
+
+/***************************** Per-Thread Cache ******************************/
+
+static unsigned int *imb_thread_cache_get_tile(ImThreadTileCache *cache, ImBuf *ibuf, int tx, int ty)
+{
+	ImThreadTile *ttile, lookuptile;
+	ImGlobalTile *gtile, *replacetile;
+	int toffs= ibuf->xtiles*ty + tx;
+
+	/* test if it is already in our thread local cache */
+	if((ttile=cache->tiles.first)) {
+		/* check last used tile before going to hash */
+		if(ttile->ibuf == ibuf && ttile->tx == tx && ttile->ty == ty)
+			return ibuf->tiles[toffs];
+
+		/* find tile in hash */
+		lookuptile.ibuf = ibuf;
+		lookuptile.tx = tx;
+		lookuptile.ty = ty;
+
+		if((ttile=BLI_ghash_lookup(cache->tilehash, &lookuptile))) {
+			BLI_remlink(&cache->tiles, ttile);
+			BLI_addhead(&cache->tiles, ttile);
+
+			return ibuf->tiles[toffs];
+		}
+	}
+
+	/* not found, have to do slow lookup in global cache */
+	if(cache->unused.first == NULL) {
+		ttile= cache->tiles.last;
+		replacetile= ttile->global;
+		BLI_remlink(&cache->tiles, ttile);
+		BLI_ghash_remove(cache->tilehash, ttile, NULL, NULL);
+	}
+	else {
+		ttile= cache->unused.first;
+		replacetile= NULL;
+		BLI_remlink(&cache->unused, ttile);
+	}
+
+	BLI_addhead(&cache->tiles, ttile);
+	BLI_ghash_insert(cache->tilehash, ttile, ttile);
+
+	gtile= imb_global_cache_get_tile(ibuf, tx, ty, replacetile);
+
+	ttile->ibuf= gtile->ibuf;
+	ttile->tx= gtile->tx;
+	ttile->ty= gtile->ty;
+	ttile->global= gtile;
+
+	return ibuf->tiles[toffs];
+}
+
+unsigned int *IMB_gettile(ImBuf *ibuf, int tx, int ty, int thread)
+{
+	return imb_thread_cache_get_tile(&GLOBAL_CACHE.thread_cache[thread+1], ibuf, tx, ty);
+}
+
+void IMB_tiles_to_rect(ImBuf *ibuf)
+{
+	ImBuf *mipbuf;
+	ImGlobalTile *gtile;
+	unsigned int *to, *from;
+	int a, tx, ty, y, w, h;
+
+	for(a=0; a<ibuf->miptot; a++) {
+		mipbuf= IMB_getmipmap(ibuf, a);
+
+		/* don't call imb_addrectImBuf, it frees all mipmaps */
+		if(!mipbuf->rect) {
+			if((mipbuf->rect = MEM_mapallocN(ibuf->x*ibuf->y*sizeof(unsigned int), "imb_addrectImBuf"))) {
+				mipbuf->mall |= IB_rect;
+				mipbuf->flags |= IB_rect;
+			}
+			else
+				break;
+		}
+
+		for(ty=0; ty<mipbuf->ytiles; ty++) {
+			for(tx=0; tx<mipbuf->xtiles; tx++) {
+				/* acquire tile through cache, this assumes cache is initialized,
+				   which it is always now but it's a weak assumption ... */
+				gtile= imb_global_cache_get_tile(mipbuf, tx, ty, NULL);
+
+				/* setup pointers */
+				from= mipbuf->tiles[mipbuf->xtiles*ty + tx];
+				to= mipbuf->rect + mipbuf->x*ty*mipbuf->tiley + tx*mipbuf->tilex;
+
+				/* exception in tile width/height for tiles at end of image */
+				w= (tx == mipbuf->xtiles-1)? mipbuf->x - tx*mipbuf->tilex: mipbuf->tilex;
+				h= (ty == mipbuf->ytiles-1)? mipbuf->y - ty*mipbuf->tiley: mipbuf->tiley;
+
+				for(y=0; y<h; y++) {
+					memcpy(to, from, sizeof(unsigned int)*w);
+					from += mipbuf->tilex;
+					to += mipbuf->x;
+				}
+
+				/* decrease refcount for tile again */
+				BLI_mutex_lock(&GLOBAL_CACHE.mutex);
+				gtile->refcount--;
+				BLI_mutex_unlock(&GLOBAL_CACHE.mutex);
+			}
+		}
+	}
+}
+
diff --git a/source/blender/imbuf/intern/cineon/cineon_dpx.c b/source/blender/imbuf/intern/cineon/cineon_dpx.c
index 2acd4dfda75..aa1b8ca3447 100644
--- a/source/blender/imbuf/intern/cineon/cineon_dpx.c
+++ b/source/blender/imbuf/intern/cineon/cineon_dpx.c
@@ -186,7 +186,7 @@ short imb_savecineon(struct ImBuf *buf, char *myfile, int flags)
 }
 
  
-int imb_is_cineon(void *buf)
+int imb_is_cineon(unsigned char *buf)
 {
 	return cineonIsMemFileCineon(buf);
 }
@@ -203,7 +203,7 @@ short imb_save_dpx(struct ImBuf *buf, char *myfile, int flags)
 	return imb_save_dpx_cineon(buf, myfile, 0, flags);
 }
 
-int imb_is_dpx(void *buf)
+int imb_is_dpx(unsigned char *buf)
 {
 	return dpxIsMemFileCineon(buf);
 }
diff --git a/source/blender/imbuf/intern/cmap.c b/source/blender/imbuf/intern/cmap.c
deleted file mode 100644
index 49edc93b507..00000000000
--- a/source/blender/imbuf/intern/cmap.c
+++ /dev/null
@@ -1,580 +0,0 @@
-/**
- * cmap.c
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-#include <ctype.h>
-#include "BLI_blenlib.h"
-
-#include "imbuf.h"
-#include "imbuf_patch.h"
-#include "IMB_imbuf_types.h"
-#include "IMB_imbuf.h"
-
-#include "IMB_cmap.h"
-
-static short *lastcube = 0;
-static uchar *lastcoltab = 0;
-static short lastmaxcol;
-static short lastmincol;
-static short lastcbits;
-short alpha_col0 = FALSE;
-
-extern void IMB_free_cache_limiter();
-
-/*
- * there still is a bug here. If you want to convert an image to a 1 bit colormap you get
- * a black image. All conversion to less than 4 bits is too dark anyway.
- */
-
-void IMB_freeImBufdata(void)
-{
-	if (lastcube) free(lastcube);
-	lastcube= 0;
-	if (lastcoltab) free(lastcoltab);
-	lastcoltab= 0;
-	IMB_free_cache_limiter();
-}
-
-
-int IMB_alpha_to_col0(int value)
-{
-	int old;
-	
-	old = alpha_col0;
-	alpha_col0 = value;
-	return (old);
-}
-
-
-void imb_losecmapbits(struct ImBuf *ibuf, unsigned int *coltab)
-{
-	int i,bits;
-	unsigned int col, and1, and2, *rect;
-
-	if (ibuf == 0) return;
-	if (ibuf->rect == 0) return;
-	if (ibuf->cbits == 0) return;
-	if (ibuf->cbits >= 8) return;
-
-/*
-	bij cbits = 5:
-	and1 = 11100000;
-	bij cbits = 6:
-	and1 = 11000000;
-*/
-
-	bits = ibuf->cbits;
-	and1 = ((1 << (8-bits)) - 1) & 0xff;
-	and1 |= (and1 << 24) + (and1 << 16) + (and1 << 8);
-	and2 = ~and1;
-	and1 <<= bits;
-
-	rect = ibuf->rect;
-	for (i = ibuf->x * ibuf->y ; i > 0; i--) {
-		col = rect[0]; 
-		*rect++ = col - ((col & and1) >> bits);
-	}
-	
-	if (coltab){
-		for (i = 0 ; i < ibuf->maxcol ; i++) {
-			col = coltab[i];
-			coltab[i] = (col - ((col & and1) >> bits)) & and2;
-		}
-	}
-}
-
-
-static void addcmapbits(struct ImBuf *ibuf)
-{
-	int i,bits;
-	int div,mul;
-	uchar * cmap;
-	
-	if (ibuf == 0) return;
-	if (ibuf->cmap == 0) return;
-	if (ibuf->cbits == 0) return;
-	if (ibuf->cbits >= 8) return;
-
-	bits = ibuf->cbits;
-
-	/* bits = 4 -> div = 0xf0
-	 * bits = 5 -> div = 0xf8
-	 */
-	 
-	div = ((1 << bits) - 1) << (8 - bits);
-	mul = 0xffff / div;
-	
-	if (ibuf->cmap){
-		cmap = (uchar *) ibuf->cmap;
-		for (i = 0 ; i < ibuf->maxcol ; i++){
-			cmap[1] = (mul * cmap[1]) >> 8;
-			cmap[2] = (mul * cmap[2]) >> 8;
-			cmap[3] = (mul * cmap[3]) >> 8;
-			cmap += 4;
-		}
-	}
-}
-
-
-static short addplanetocube(short *cube, short *plane, int minx, int miny, int sizep, int addcx, int addcy, int sizec, int col)
-{
-	short done = FALSE;
-	int x, numx, numy, skipc, skipp, temp;
-
-	/* clip first */
-
-	numx = numy = sizep;
-
-	temp = minx + sizep - 1;
-	if (temp > sizec) numx -= temp - sizec;
-
-	temp = miny + sizep - 1;
-	if (temp > sizec) numy -= temp - sizec;
-
-	if (minx < 0){
-		plane -= minx;
-		cube -= minx * addcx;
-		numx += minx;
-	}
-
-	if (miny < 0){
-		plane -= miny * sizep;
-		cube -= miny * addcy;
-		numy += miny;
-	}
-
-	skipc = addcy - (numx * addcx);
-	skipp = sizep - numx;
-
-	for (; numy > 0 ; numy--){
-		for (x = numx ; x > 0; x--) {
-			
-			if (plane[0] < cube[1]) {
-			
-				cube[0] = col;
-				cube[1] = plane[0];
-				done = TRUE;
-			}
-			plane ++;
-			cube += addcx;
-		}
-		plane += skipp;
-		cube += skipc;
-	}
-
-	return (done);
-}
-
-
-
-short *imb_coldeltatab(unsigned char *coltab, short mincol, short maxcol, short cbits)
-{
-	short max, *quadr, *_quadr, *_cube, *cube, *_plane, done, nocol;
-	unsigned int addcb, addcg, addcr, sizep;
-	uchar *_colp, *colp, *col;
-	int i, j, k, addcube;
-	int r, g, b;
-
-	max = (1 << cbits) - 1;
-	nocol = maxcol - mincol;
-	coltab += 4 * mincol;
-	
-	/* reduce colors to the right amount of bits */
-
-	{
-		unsigned int * lctab, and;
-
-		lctab = (unsigned int *) coltab;
-		and = max << (8 - cbits);
-		and = and + (and << 8) + (and << 16) + (and << 24);
-		for (i=nocol-1 ; i >= 0 ; i--) lctab[i] = (lctab[i] & and) >> (8 - cbits);
-	}
-
-	/* is this data the same as previous ? */
-
-	if (lastcube){
-		if (mincol == lastmincol && maxcol == lastmaxcol && cbits == lastcbits){
-			if (lastcoltab){
-				if (memcmp(lastcoltab, coltab, 4 * nocol) == 0) return(lastcube);
-			}
-		}
-	}
-	if (lastcube) free(lastcube);
-	if (lastcoltab) free(lastcoltab);
-
-	lastcube = 0; 
-	lastcoltab = 0;
-	_cube = malloc(2 * (1 << (3 * cbits)) * sizeof(short));
-	_plane = malloc((2 * max + 1) * (2 * max + 1) * sizeof(short));
-	_quadr = malloc((2 * max + 1) * sizeof(short));
-	_colp = malloc(6 * nocol);
-
-	if (_cube == 0 || _plane == 0 || _quadr == 0 || _colp == 0){
-		if (_cube) free(_cube);
-		if (_plane) free(_plane);
-		if (_quadr) free(_quadr);
-		if (_colp) free(_colp);
-		return(0);
-	}
-
-	lastcoltab = malloc(4 * nocol);
-	if (lastcoltab) memcpy(lastcoltab, coltab, 4 * nocol);
-	lastcube = _cube;
-	lastmincol = mincol;
-	lastmaxcol = maxcol;
-	lastcbits = cbits;
-
-	/* cube initialise */
-
-	cube = _cube;
-	for (i = (1 << (3 * cbits)); i > 0 ; i--){
-		cube[0] = 0;
-		cube[1] = 32767;
-		cube += 2;
-	}
-
-	/* mak error look up table */
-
-	{
-		unsigned int delta;
-
-		quadr = _quadr + max + 1;
-		quadr[0] = 0;
-		delta = 3;
-		for (i = 1 ; i <= max ; i++){
-			quadr[i] = quadr[-i] = delta;
-			delta += i + 3;
-		}
-	}
-
-	/* colorplane initialise */
-
-	for (i = 6 * nocol - 1; i >= 0; i--) _colp[i] = 1;
-
-	addcr = 2;
-	addcg = (addcr << cbits);
-	addcb = (addcg << cbits);
-
-	/* fill in first round */
-
-	{
-		unsigned int ofs;
-
-		col = coltab;
-		cube = _cube;
-
-		for (i = 0 ; i < nocol ; i++){
-			ofs = (col[3] * addcr) + (col[2] * addcg) + (col[1] * addcb);
-			/* color been filled in -> then skip */
-			if (cube[ofs + 1]) cube[ofs] = i + mincol;
-			cube[ofs + 1] = 0;
-			col += 4;
-		}
-	}
-
-	for (i = 1; i <= max ; i++){
-		colp = _colp;
-		col = coltab;
-		done = FALSE;
-		sizep = 2*i +1;
-
-		/* plane initialise */
-		{
-			unsigned int delta;
-			short *plane;
-
-			plane = _plane;
-			for (j = -i ; j <= i; j++){
-				delta = quadr[i] + quadr[j];
-				for (k = -i; k <= i; k++){
-					*plane++ = delta + quadr[k];
-				}
-			}
-		}
-
-		for (j = mincol; j < maxcol; j++){
-			b = col[1] - i;
-			g = col[2] - i;
-			r = col[3] - i;
-			
-			addcube= (addcr * r) + (addcg * g) + (addcb * b);
-			/* PRINT4(d, d, d, d, addcube, r, g, b); */
-			/* if(addcube >= 2 * (1 << (3 * cbits))) { */
-			/* 	printf("maxerror: %d %d\n", addcube, 2 * (1 << (3 * cbits))); */
-				/* add_cube= 2 * (1 << (3 * cbits)) -1; */
-			/* } */
-			cube = _cube + addcube;
-
-			if (colp[0]){
-				if (b < 0) colp[0] = 0;
-				else done |= colp[0] = addplanetocube(cube, _plane, r, g, sizep, addcr, addcg, max, j);
-			}
-			if (colp[1]){
-				if (g < 0) colp[1] = 0;
-				else done |= colp[1] = addplanetocube(cube, _plane, r, b, sizep, addcr, addcb, max, j);
-			}
-			if (colp[2]){
-				if (r < 0) colp[2] = 0;
-				else done |= colp[2] = addplanetocube(cube, _plane, b, g, sizep, addcb, addcg, max, j);
-			}
-			if (colp[3]){
-				if ((b + sizep - 1) > max) colp[3] = 0;
-				else done |= colp[3] = addplanetocube(cube + (sizep -1) * addcb, _plane, r, g, sizep, addcr,
-					addcg, max, j);
-			}
-			if (colp[4]){
-				if ((g + sizep - 1) > max) colp[4] = 0;
-				else done |= colp[4] = addplanetocube(cube + (sizep -1) * addcg, _plane, r, b, sizep, addcr,
-					addcb, max, j);
-			}
-			if (colp[5]){
-				if ((r + sizep - 1) > max) colp[5] = 0;
-				else done |= colp[5] = addplanetocube(cube + (sizep -1) * addcr, _plane, b, g, sizep, addcb,
-					addcg, max, j);
-			}
-
-			colp += 6;
-			col += 4;
-		}
-		if (done == 0) break;
-	}
-
-	free(_quadr);
-	free(_plane);
-	free(_colp);
-	return(_cube);
-}
-
-
-static void convcmap(struct ImBuf* ibuf, short *deltab, short cbits)
-{
-	unsigned int *rect;
-	short x,y;
-	unsigned int col;
-	unsigned int bbits,gbits,rbits;
-	unsigned int bmask,gmask,rmask;
-
-	bbits = 24 - 3 * cbits - 1;
-	gbits = 16 - 2 * cbits - 1;
-	rbits = 8 - cbits - 1;
-
-	rmask = ((1 << cbits) - 1) << (8 - cbits);
-	gmask = rmask << 8;
-	bmask = gmask << 8;
-
-	rect =(unsigned int *)ibuf->rect;
-
-	for(y=ibuf->y;y>0;y--){
-		for(x=ibuf->x;x>0;x--){
-			col = *rect;
-			col = ((col & bmask) >> bbits) + ((col & gmask) >> gbits) + ((col & rmask) >> rbits);
-			*rect++ = deltab[col];
-		}
-	}
-}
-
-short IMB_converttocmap(struct ImBuf *ibuf)
-{
-	unsigned int *coltab;
-	short *deltab=0, cbits;
-	int i;
-	int mincol, mask = 0;
-	struct ImBuf * abuf = 0;
-	unsigned int * rect, * arect;
-	
-	cbits = 5;
-	if (ibuf->cmap == 0) return(0);
-	
-	if ((ibuf->cbits > 0) && (ibuf->cbits <8)) cbits = ibuf->cbits;
-
-	coltab = calloc(ibuf->maxcol, sizeof(unsigned int));
-	if (coltab == 0) return(0);
-	memcpy(coltab, ibuf->cmap, ibuf->maxcol * sizeof(unsigned int));
-	
-	mincol = ibuf->mincol;	
-	if (alpha_col0) {
-		if (mincol == 0) mincol = 1;
-		abuf = IMB_dupImBuf(ibuf);
-	}
-	
-	imb_losecmapbits(ibuf, coltab);
-	deltab = imb_coldeltatab((uchar *) coltab, mincol ,ibuf->maxcol, cbits);
-	
-	if (deltab == 0) {
-		free(coltab);
-		if (abuf) IMB_freeImBuf(abuf);
-		return(0);
-	}
-
-
-	IMB_dit0(ibuf,1,cbits);
-	IMB_dit0(ibuf,2,cbits);
-	IMB_dit0(ibuf,3,cbits);
-	convcmap(ibuf, deltab, cbits);
-	
-	if (abuf) {
-		/* convert alpha to color 0 */
-		rect = ibuf->rect;
-		arect = abuf->rect;
-		
-		if (alpha_col0 == 1) mask = 0xff000000; /* alpha ==  0 -> 0 */
-		if (alpha_col0 == 2) mask = 0x80000000; /* alpha < 128 -> 0 */
-		
-		for (i = ibuf->x * ibuf->y; i > 0; i--) {
-			if ((*arect++ & mask) == 0) rect[0] = 0;
-			rect++;
-		}
-		
-		IMB_freeImBuf(abuf);
-	}
-
-	free(coltab);
-	
-	return (TRUE);
-}
-
-
-void imb_makecolarray(struct ImBuf *ibuf, unsigned char *mem, short nocols)
-{
-	short i,bits = 0;
-	uchar *cmap;
-
-	/* what's the theory behind this? */
-	
-	nocols = ibuf->maxcol;
-
-	if (ibuf->cmap){
-		cmap = (uchar *) ibuf->cmap;
-		for (i = 0; i < nocols; i++){
-			cmap[3] = mem[0];
-			cmap[2] = mem[1];
-			cmap[1] = mem[2];
-			cmap[0] = 0;
-			
-			bits |= mem[0] | mem[1] | mem[2];
-			mem += 3;
-			cmap += 4;
-		}
-
-		/* patch voor AdPro II */
-		if (IS_ham(ibuf)){
-			i = ibuf->depth - 2;
-			bits = ((1 << i) - 1) << (8 - i);
-			for (i=0 ; i<nocols ; i++) ibuf->cmap[i] &= (bits << 24) + (bits << 16) + (bits << 8) + bits;
-		}
-
-		if ((bits & 0x1f) == 0){
-			ibuf->cbits = 3;
-		} else if ((bits & 0x0f) == 0){
-			ibuf->cbits = 4;
-		} else if ((bits & 0x07) == 0){
-			ibuf->cbits = 5;
-		} else if ((bits & 0x03) == 0){
-			ibuf->cbits = 6;
-		} else ibuf->cbits = 8;
-
-		addcmapbits(ibuf);
-
-		if (IS_hbrite(ibuf)){
-			for (i=31;i>=0;i--){
-				ibuf->cmap[i+32] =  (ibuf->cmap[i]  & 0xfefefefe) >> 1;
-			}
-		}
-		
-		if (IS_amiga(ibuf)){
-			cmap = (uchar * ) (ibuf->cmap + 1);
-			for (i = 1; i < nocols; i++){
-				cmap[0] = 0xff;
-				cmap += 4;
-			}
-		}
-	}
-}
-
-/* temporal... rects now are rgba, cmaps are abgr */
-#define SWITCH_INT(a)	{char s_i, *p_i; p_i= (char *)&(a); s_i= p_i[0]; p_i[0]= p_i[3]; p_i[3]= s_i; s_i= p_i[1]; p_i[1]= p_i[2]; p_i[2]= s_i; }
-
-void IMB_applycmap(struct ImBuf *ibuf)
-{
-	unsigned int *rect, *cmap;
-	int x, y, i, col, code;
-	int *mask = 0;
-	
-	if (ibuf == 0) return;
-	if (ibuf->rect == 0 || ibuf->cmap == 0) return;
-	
-	rect = ibuf->rect;
-	cmap = ibuf->cmap;
-
-	if (IS_ham(ibuf)){
-		
-		/* generate mask of max (8 + 2) bits */
-		mask = malloc(1024 * 2 * sizeof(int));
-
-		x = 1 << (ibuf->depth - 2);
-		y = 65535 / (x - 1);
-		
-		for (i = 0; i < x; i++){
-			mask[i] = 0;
-			mask[i + x]	= 0x00ffff;
-			mask[i + x + x] = 0xffff00;
-			mask[i + x + x + x] = 0xff00ff;
-
-			col = (y * i) >> 8;
-			
-			mask[i + 1024] = 0xff000000 | ibuf->cmap[i];
-			mask[i + x + 1024] = 0xff000000 | col << 16;
-			mask[i + x + x + 1024] = 0xff000000 | col;
-			mask[i + x + x + x + 1024] = 0xff000000 | col << 8;
-		}
-		
-		/* only color 0 transparant */
-		mask[0+1024] =ibuf->cmap[0];
-		
-		for (y = ibuf->y ; y>0 ; y--){
-			col = cmap[0];
-			for (x=ibuf->x ; x>0 ; x--){
-				code = *rect;
-				*rect++ = col = (col & mask[code]) | mask[code + 1024];
-			}
-		}
-		free(mask);
-	} else {
-	
-		for(i = ibuf->x * ibuf->y; i>0; i--){
-			col = *rect;
-			if (col >= 0 && col < ibuf->maxcol) *rect = cmap[col];
-			rect++;
-
-			/* *(rect++) = cmap[*rect]; */
-		}
-	}
-}
-
diff --git a/source/blender/imbuf/intern/cspace.c b/source/blender/imbuf/intern/cspace.c
deleted file mode 100644
index 46017fec5ec..00000000000
--- a/source/blender/imbuf/intern/cspace.c
+++ /dev/null
@@ -1,176 +0,0 @@
-/**
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-#include "BLI_blenlib.h"
-
-#include "imbuf.h"
-#include "imbuf_patch.h"
-#include "IMB_imbuf_types.h"
-
-void IMB_cspace(struct ImBuf *ibuf, float mat[][4]);
-
-/************************************************************************/
-/*				COLORSPACE				*/
-/************************************************************************/
-
-static void fillmattab(double val, unsigned short *mattab)
-{
-	int tot,ival;
-	int i;
-
-	val *= (1 << 22);
-	ival = val;
-	tot = 32767; /* een half */
-
-	for(i = 256; i > 0; i--){
-		*(mattab) = (tot >> 16);
-		mattab += 3;
-		tot += ival;
-	}
-}
-
-
-static void cspfill(short *buf, unsigned short *fill, int x)
-{
-	unsigned short r,g,b;
-
-	b = fill[0];
-	g = fill[1];
-	r = fill[2];
-	for (;x>0;x--){
-		buf[0] = b;
-		buf[1] = g;
-		buf[2] = r;
-		buf += 3;
-	}
-}
-
-
-static void cspadd(short *buf, unsigned short *cont, unsigned char *rect, int x)
-{
-	short i;
-	for (;x>0;x--){
-		i = *(rect);
-		rect += 4;
-		buf[0] += cont[i*3];
-		buf[1] += cont[i*3 + 1];
-		buf[2] += cont[i*3 + 2];
-		buf += 3;
-	}
-}
-
-
-static void cspret(short *buf, unsigned char *rect, int x)
-{
-	int r,g,b;
-	
-	for(; x > 0; x--){
-		b = buf[0];
-		g = buf[1];
-		r = buf[2];
-
-		if (b & 0x4000){
-			if (b<0) rect[2]=0;
-			else rect[2]=255;
-		} else rect[2] = b >> 6;
-
-		if (g & 0x4000){
-			if (g<0) rect[1]=0;
-			else rect[1]=255;
-		} else rect[1] = g >> 6;
-
-		if (r & 0x4000){
-			if (r<0) rect[0]=0;
-			else rect[0]=255;
-		} else rect[0] = r >> 6;
-
-		buf += 3;
-		rect += 4;
-	}
-}
-
-
-static void rotcspace(struct ImBuf *ibuf, unsigned short *cont_1, unsigned short *cont_2, unsigned short *cont_3, unsigned short *add)
-{
-	short x,y,*buf;
-	uchar *rect;
-
-	x=ibuf->x;
-	rect= (uchar *)ibuf->rect;
-
-	buf=(short *)malloc(x*3*sizeof(short));
-	if (buf){
-		for(y=ibuf->y;y>0;y--){
-			cspfill(buf,add,x);
-			cspadd(buf,cont_1,rect+0,x);
-			cspadd(buf,cont_2,rect+1,x);
-			cspadd(buf,cont_3,rect+2,x);
-			cspret(buf,rect,x);
-			rect += x<<2;
-		}
-		free(buf);
-	}
-}
-
-
-void IMB_cspace(struct ImBuf *ibuf, float mat[][4])
-{
-	unsigned short *cont_1,*cont_2,*cont_3,add[3];
-
-	cont_1=(unsigned short *)malloc(256*3*sizeof(short));
-	cont_2=(unsigned short *)malloc(256*3*sizeof(short));
-	cont_3=(unsigned short *)malloc(256*3*sizeof(short));
-
-	if (cont_1 && cont_2 && cont_3){
-
-		fillmattab(mat[0][0],cont_1);
-		fillmattab(mat[0][1],cont_1+1);
-		fillmattab(mat[0][2],cont_1+2);
-
-		fillmattab(mat[1][0],cont_2);
-		fillmattab(mat[1][1],cont_2+1);
-		fillmattab(mat[1][2],cont_2+2);
-
-		fillmattab(mat[2][0],cont_3);
-		fillmattab(mat[2][1],cont_3+1);
-		fillmattab(mat[2][2],cont_3+2);
-
-		add[0] = (mat[3][0] * 64.0) + .5;
-		add[1] = (mat[3][1] * 64.0) + .5;
-		add[2] = (mat[3][2] * 64.0) + .5;
-
-		rotcspace(ibuf, cont_1, cont_2, cont_3, add);
-	}
-
-	if (cont_1) free(cont_1);
-	if (cont_2) free(cont_2);
-	if (cont_3) free(cont_3);
-}
-
diff --git a/source/blender/imbuf/intern/data.c b/source/blender/imbuf/intern/data.c
deleted file mode 100644
index 3b1f3035d62..00000000000
--- a/source/blender/imbuf/intern/data.c
+++ /dev/null
@@ -1,142 +0,0 @@
-/**
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- * data.c
- *
- * $Id$
- */
-
-#include "imbuf.h"
-#include "matrix.h"
-
-/*
-static short quadbase[31] = {
-	150,133,117,102,
-	88,75,63,52,
-	42,33,25,18,
-	12,7,3,0,
-	3,7,12,18,
-	25,33,42,52,
-	63,75,88,102,
-	117,133,150,
-};
-
-short *quadr = quadbase+15;
-*/
-/*
-main()
-{
-	ushort _quadr[511], *quadr;
-	int i, delta;
-	
-	quadr = _quadr + 255;
-
-	delta = 0;
-	for (i = 0 ; i <= 255 ; i++){
-		quadr[i] = quadr[-i] = delta;
-		delta += i + 3;
-	}
-	
-	delta = 0;
-	for (i = 0; i < 511; i++){
-		printf("%6d, ", _quadr[i]);
-		delta++;
-		if (delta == 8){
-			delta = 0;
-			printf("\n");
-		}
-	}
-}
-*/
-
-static unsigned short quadbase[511] = {
- 33150,  32893,  32637,  32382,  32128,  31875,  31623,  31372, 
- 31122,  30873,  30625,  30378,  30132,  29887,  29643,  29400, 
- 29158,  28917,  28677,  28438,  28200,  27963,  27727,  27492, 
- 27258,  27025,  26793,  26562,  26332,  26103,  25875,  25648, 
- 25422,  25197,  24973,  24750,  24528,  24307,  24087,  23868, 
- 23650,  23433,  23217,  23002,  22788,  22575,  22363,  22152, 
- 21942,  21733,  21525,  21318,  21112,  20907,  20703,  20500, 
- 20298,  20097,  19897,  19698,  19500,  19303,  19107,  18912, 
- 18718,  18525,  18333,  18142,  17952,  17763,  17575,  17388, 
- 17202,  17017,  16833,  16650,  16468,  16287,  16107,  15928, 
- 15750,  15573,  15397,  15222,  15048,  14875,  14703,  14532, 
- 14362,  14193,  14025,  13858,  13692,  13527,  13363,  13200, 
- 13038,  12877,  12717,  12558,  12400,  12243,  12087,  11932, 
- 11778,  11625,  11473,  11322,  11172,  11023,  10875,  10728, 
- 10582,  10437,  10293,  10150,  10008,   9867,   9727,   9588, 
-  9450,   9313,   9177,   9042,   8908,   8775,   8643,   8512, 
-  8382,   8253,   8125,   7998,   7872,   7747,   7623,   7500, 
-  7378,   7257,   7137,   7018,   6900,   6783,   6667,   6552, 
-  6438,   6325,   6213,   6102,   5992,   5883,   5775,   5668, 
-  5562,   5457,   5353,   5250,   5148,   5047,   4947,   4848, 
-  4750,   4653,   4557,   4462,   4368,   4275,   4183,   4092, 
-  4002,   3913,   3825,   3738,   3652,   3567,   3483,   3400, 
-  3318,   3237,   3157,   3078,   3000,   2923,   2847,   2772, 
-  2698,   2625,   2553,   2482,   2412,   2343,   2275,   2208, 
-  2142,   2077,   2013,   1950,   1888,   1827,   1767,   1708, 
-  1650,   1593,   1537,   1482,   1428,   1375,   1323,   1272, 
-  1222,   1173,   1125,   1078,   1032,    987,    943,    900, 
-   858,    817,    777,    738,    700,    663,    627,    592, 
-   558,    525,    493,    462,    432,    403,    375,    348, 
-   322,    297,    273,    250,    228,    207,    187,    168, 
-   150,    133,    117,    102,     88,     75,     63,     52, 
-	42,     33,     25,     18,     12,      7,      3,      0, 
-	 3,      7,     12,     18,     25,     33,     42,     52, 
-	63,     75,     88,    102,    117,    133,    150,    168, 
-   187,    207,    228,    250,    273,    297,    322,    348, 
-   375,    403,    432,    462,    493,    525,    558,    592, 
-   627,    663,    700,    738,    777,    817,    858,    900, 
-   943,    987,   1032,   1078,   1125,   1173,   1222,   1272, 
-  1323,   1375,   1428,   1482,   1537,   1593,   1650,   1708, 
-  1767,   1827,   1888,   1950,   2013,   2077,   2142,   2208, 
-  2275,   2343,   2412,   2482,   2553,   2625,   2698,   2772, 
-  2847,   2923,   3000,   3078,   3157,   3237,   3318,   3400, 
-  3483,   3567,   3652,   3738,   3825,   3913,   4002,   4092, 
-  4183,   4275,   4368,   4462,   4557,   4653,   4750,   4848, 
-  4947,   5047,   5148,   5250,   5353,   5457,   5562,   5668, 
-  5775,   5883,   5992,   6102,   6213,   6325,   6438,   6552, 
-  6667,   6783,   6900,   7018,   7137,   7257,   7378,   7500, 
-  7623,   7747,   7872,   7998,   8125,   8253,   8382,   8512, 
-  8643,   8775,   8908,   9042,   9177,   9313,   9450,   9588, 
-  9727,   9867,  10008,  10150,  10293,  10437,  10582,  10728, 
- 10875,  11023,  11172,  11322,  11473,  11625,  11778,  11932, 
- 12087,  12243,  12400,  12558,  12717,  12877,  13038,  13200, 
- 13363,  13527,  13692,  13858,  14025,  14193,  14362,  14532, 
- 14703,  14875,  15048,  15222,  15397,  15573,  15750,  15928, 
- 16107,  16287,  16468,  16650,  16833,  17017,  17202,  17388, 
- 17575,  17763,  17952,  18142,  18333,  18525,  18718,  18912, 
- 19107,  19303,  19500,  19698,  19897,  20097,  20298,  20500, 
- 20703,  20907,  21112,  21318,  21525,  21733,  21942,  22152, 
- 22363,  22575,  22788,  23002,  23217,  23433,  23650,  23868, 
- 24087,  24307,  24528,  24750,  24973,  25197,  25422,  25648, 
- 25875,  26103,  26332,  26562,  26793,  27025,  27258,  27492, 
- 27727,  27963,  28200,  28438,  28677,  28917,  29158,  29400, 
- 29643,  29887,  30132,  30378,  30625,  30873,  31122,  31372, 
- 31623,  31875,  32128,  32382,  32637,  32893,  33150,
-};
-
-unsigned short *quadr = quadbase + 255;
diff --git a/source/blender/imbuf/intern/dds/dds_api.cpp b/source/blender/imbuf/intern/dds/dds_api.cpp
index 56880c57f1b..9a106253397 100644
--- a/source/blender/imbuf/intern/dds/dds_api.cpp
+++ b/source/blender/imbuf/intern/dds/dds_api.cpp
@@ -31,13 +31,12 @@
 extern "C" {
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 #include "IMB_allocimbuf.h"
 
 
-short imb_save_dds(struct ImBuf * ibuf, char *name, int flags)
+int imb_save_dds(struct ImBuf * ibuf, char *name, int flags)
 {
 	return(0); /* todo: finish this function */
 
@@ -78,6 +77,9 @@ struct ImBuf *imb_load_dds(unsigned char *mem, int size, int flags)
 	Color32 pixel;
 	Color32 *pixels = 0;
 
+	if(!imb_is_a_dds(mem))
+		return (0);
+
 	/* check if DDS is valid and supported */
 	if (!dds.isValid()) {
 		/* no need to print error here, just testing if it is a DDS */
diff --git a/source/blender/imbuf/intern/dds/dds_api.h b/source/blender/imbuf/intern/dds/dds_api.h
index b8a61c6fc1a..6d9fa0839dd 100644
--- a/source/blender/imbuf/intern/dds/dds_api.h
+++ b/source/blender/imbuf/intern/dds/dds_api.h
@@ -29,7 +29,7 @@
 extern "C" {
 #endif
 
-short	      imb_save_dds(struct ImBuf *ibuf, char *name, int flags);
+int  	      imb_save_dds(struct ImBuf *ibuf, char *name, int flags);
 int           imb_is_a_dds(unsigned char *mem); /* use only first 32 bytes of mem */
 struct ImBuf *imb_load_dds(unsigned char *mem, int size, int flags);
 
diff --git a/source/blender/imbuf/intern/dither.c b/source/blender/imbuf/intern/dither.c
deleted file mode 100644
index ccd7982ea07..00000000000
--- a/source/blender/imbuf/intern/dither.c
+++ /dev/null
@@ -1,130 +0,0 @@
-/**
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- * dither.c
- *
- * $Id$
- */
-
-#include "BLI_blenlib.h"
-
-#include "imbuf.h"
-#include "imbuf_patch.h"
-#include "IMB_imbuf_types.h"
-#include "IMB_imbuf.h"
-
-void IMB_dit0(struct ImBuf * ibuf, short ofs, short bits)
-{
-	int x, y, and, add, pix;
-	uchar *rect;
-
-	rect= (uchar *)ibuf->rect;
-	rect +=ofs;
-
-	bits = 8 - bits;
-	and = ~((1 << bits)-1);
-	add = 1 << (bits - 1);
-	
-	for (y = ibuf->y; y > 0; y--){
-		for (x = ibuf->x; x > 0; x--) {
-			pix = *rect + add;
-			if (pix > 255) pix = 255; 
-			*rect = pix & and;
-			rect += 4;
-		}
-	}
-}
-
-void IMB_dit2(struct ImBuf * ibuf, short ofs, short bits)
-{
-	short x,y,pix,and,add1,add2;
-	uchar *rect;
-	uchar dit[4];
-
-	rect= (uchar *)ibuf->rect;
-	rect +=ofs;
-
-	bits = 8 - bits;
-	and = ~((1<<bits)-1);
-	bits -= 2;
-
-	ofs = 0;
-	
-	switch(ofs){
-	case 3:
-		break;
-	case 2:
-		dit[0]=0;
-		dit[1]=1;
-		dit[2]=2;
-		dit[3]=3;
-		break;
-	case 1:
-		dit[0]=3;
-		dit[1]=1;
-		dit[2]=0;
-		dit[3]=2;
-		break;
-	case 0:
-		dit[0]=0;
-		dit[1]=2;
-		dit[2]=3;
-		dit[3]=1;
-		break;
-	}
-	
-	if (bits < 0){
-		dit[0] >>= -bits;
-		dit[1] >>= -bits;
-		dit[2] >>= -bits;
-		dit[3] >>= -bits;
-	} else{
-		dit[0] <<= bits;
-		dit[1] <<= bits;
-		dit[2] <<= bits;
-		dit[3] <<= bits;
-	}
-
-	for(y=ibuf->y;y>0;y--){
-		if(y & 1){
-			add1=dit[0];
-			add2=dit[1];
-		}
-		else{
-			add1=dit[2];
-			add2=dit[3];
-		}
-		for(x=ibuf->x;x>0;x--){
-			pix = *rect;
-			if (x & 1) pix += add1;
-			else pix += add2;
-
-			if (pix>255) pix=255;
-			*rect = pix & and;
-			rect += 4;
-		}
-	}
-}
diff --git a/source/blender/imbuf/intern/divers.c b/source/blender/imbuf/intern/divers.c
index 4e8d61f8675..0cc4346041f 100644
--- a/source/blender/imbuf/intern/divers.c
+++ b/source/blender/imbuf/intern/divers.c
@@ -34,55 +34,12 @@
 #include "BLI_math.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 #include "IMB_allocimbuf.h"
-#include "IMB_divers.h"
 #include "BKE_utildefines.h"
 #include "BKE_colortools.h"
 
-void imb_checkncols(struct ImBuf *ibuf)
-{
-	unsigned int i;
-
-	if (ibuf==0) return;
-	
-	if (IS_amiga(ibuf)){
-		if (IS_ham(ibuf)){
-			if (ibuf->depth == 0) ibuf->depth = 6;
-			ibuf->mincol = 0;
-			ibuf->maxcol = 1 << (ibuf->depth - 2);
-			/*printf("%d %d\n", ibuf->maxcol, ibuf->depth);*/
-			return;
-		} else if (IS_hbrite(ibuf)){
-			ibuf->mincol = 0;
-			ibuf->maxcol = 64;
-			ibuf->depth = 6;
-			return;
-		}
-	}
-
-	if (ibuf->maxcol == 0){
-		if (ibuf->depth <= 8){
-			ibuf->mincol = 0;
-			ibuf->maxcol = (1 << ibuf->depth);
-			return;
-		} else if (ibuf->depth == 0){
-			ibuf->depth = 5;
-			ibuf->mincol = 0;
-			ibuf->maxcol = 32;
-		}
-		return;
-	} else {
-		/* ibuf->maxcol defines the depth */
-		for (i=1 ; ibuf->maxcol > (1 << i); i++);
-		ibuf->depth = i;
-		return;
-	}
-}
-
-
 void IMB_de_interlace(struct ImBuf *ibuf)
 {
 	struct ImBuf * tbuf1, * tbuf2;
@@ -138,43 +95,6 @@ void IMB_interlace(struct ImBuf *ibuf)
 }
 
 
-void IMB_gamwarp(struct ImBuf *ibuf, double gamma)
-{
-	uchar gam[256];
-	int i;
-	uchar *rect;
-	float *rectf;
-
-	if (ibuf == 0) return;
-	if (gamma == 1.0) return;
-
-	rect = (uchar *) ibuf->rect;
-	rectf = ibuf->rect_float;
-
-	gamma = 1.0 / gamma;
-
-	if (rect) {
-		for (i = 255 ; i >= 0 ; i--) 
-			gam[i] = (255.0 * pow(i / 255.0 ,
-						  gamma))  + 0.5;
-
-		for (i = ibuf->x * ibuf->y ; i>0 ; i--, rect+=4){
-			rect[0] = gam[rect[0]];
-			rect[1] = gam[rect[1]];
-			rect[2] = gam[rect[2]];
-		}
-	}
-
-	if (rectf) {
-		for (i = ibuf->x * ibuf->y ; i>0 ; i--, rectf+=4){
-			rectf[0] = pow(rectf[0] / 255.0, gamma);
-			rectf[1] = pow(rectf[1] / 255.0, gamma);
-			rectf[2] = pow(rectf[2] / 255.0, gamma);
-		}
-	}
-}
-
-
 /* assume converting from linear float to sRGB byte */
 void IMB_rect_from_float(struct ImBuf *ibuf)
 {
diff --git a/source/blender/imbuf/intern/dynlibtiff.c b/source/blender/imbuf/intern/dynlibtiff.c
index 31da262ffdb..eb1b5f8e10a 100644
--- a/source/blender/imbuf/intern/dynlibtiff.c
+++ b/source/blender/imbuf/intern/dynlibtiff.c
@@ -49,7 +49,6 @@
 #include "BLI_blenlib.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf.h"
 
 #include "BKE_global.h"
@@ -172,6 +171,12 @@ void libtiff_init(void)
 	}
 	libtiff_loadlibtiff();
 	G.have_libtiff = ((libtiff != NULL) && (libtiff_load_symbols()));
+
+	if (!G.have_libtiff && (G.f & G_DEBUG)) {
+		printf("Unable to load: libtiff.\n");
+		printf("Try setting the BF_TIFF_LIB environment variable if you want this support.\n");
+		printf("Example: setenv BF_TIFF_LIB /usr/lib/libtiff.so\n");
+	}
 }
 
 void libtiff_exit(void)
@@ -230,6 +235,26 @@ int libtiff_load_symbols(void)
 	if (libtiff__TIFFmalloc == NULL) {
 		return (0);
 	}
+	/* Attempt to load TIFFSetDirectory */
+	libtiff_TIFFSetDirectory = libtiff_findsymbol("TIFFSetDirectory");
+	if (libtiff_TIFFSetDirectory == NULL) {
+		return (0);
+	}
+	/* Attempt to load TIFFNumberOfDirectories */
+	libtiff_TIFFNumberOfDirectories = libtiff_findsymbol("TIFFNumberOfDirectories");
+	if (libtiff_TIFFNumberOfDirectories == NULL) {
+		return (0);
+	}
+	/* Attempt to load TIFFIsTiled */
+	libtiff_TIFFIsTiled = libtiff_findsymbol("TIFFIsTiled");
+	if (libtiff_TIFFIsTiled == NULL) {
+		return (0);
+	}
+	/* Attempt to load TIFFReadRGBATile */
+	libtiff_TIFFReadRGBATile = libtiff_findsymbol("TIFFReadRGBATile");
+	if (libtiff_TIFFReadRGBATile == NULL) {
+		return (0);
+	}
 	return (1);
 }
 
@@ -247,3 +272,9 @@ int (*libtiff_TIFFSetField)(TIFF*, ttag_t, ...) = NULL;
 tsize_t (*libtiff_TIFFWriteEncodedStrip)(TIFF*, tstrip_t, tdata_t, tsize_t) = NULL;
 void (*libtiff__TIFFfree)(tdata_t) = NULL;
 tdata_t (*libtiff__TIFFmalloc)(tsize_t) = NULL;
+int (*libtiff_TIFFSetDirectory)(TIFF*, tdir_t) = NULL;
+tdir_t (*libtiff_TIFFNumberOfDirectories)(TIFF*) = NULL;
+int (*libtiff_TIFFIsTiled)(TIFF*) = NULL;
+int (*libtiff_TIFFReadRGBATile)(TIFF*, uint32, uint32, uint32 * ) = NULL;
+
+
diff --git a/source/blender/imbuf/intern/dynlibtiff.h b/source/blender/imbuf/intern/dynlibtiff.h
index 6c8cd184463..5fafafbcf94 100644
--- a/source/blender/imbuf/intern/dynlibtiff.h
+++ b/source/blender/imbuf/intern/dynlibtiff.h
@@ -51,5 +51,9 @@ extern int (*libtiff_TIFFSetField)(TIFF*, ttag_t, ...);
 extern tsize_t (*libtiff_TIFFWriteEncodedStrip)(TIFF*, tstrip_t, tdata_t, tsize_t);
 extern void (*libtiff__TIFFfree)(tdata_t);
 extern tdata_t (*libtiff__TIFFmalloc)(tsize_t);
+extern int (*libtiff_TIFFSetDirectory)(TIFF*, tdir_t);
+extern tdir_t (*libtiff_TIFFNumberOfDirectories)(TIFF*);
+extern int (*libtiff_TIFFIsTiled)(TIFF*);
+extern int (*libtiff_TIFFReadRGBATile)(TIFF*, uint32, uint32, uint32 * );
 #endif /* DYN_LIBTIFF_H */
 
diff --git a/source/blender/imbuf/intern/filetype.c b/source/blender/imbuf/intern/filetype.c
new file mode 100644
index 00000000000..4a491ceba22
--- /dev/null
+++ b/source/blender/imbuf/intern/filetype.c
@@ -0,0 +1,105 @@
+/*
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Blender Foundation, 2010.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
+#include "IMB_filetype.h"
+
+#ifdef WITH_OPENEXR
+#include "openexr/openexr_api.h"
+#endif
+
+#ifdef WITH_DDS
+#include "dds/dds_api.h"
+#endif
+
+#ifdef WITH_QUICKTIME
+#include "quicktime_import.h"
+#endif
+
+#include "imbuf.h"
+
+static int imb_ftype_default(ImFileType *type, ImBuf *ibuf) { return (ibuf->ftype & type->filetype); }
+#if defined(__APPLE__) && defined(IMBUF_COCOA)
+static int imb_ftype_cocoa(ImFileType *type, ImBuf *ibuf) { return (ibuf->ftype & TIF); }
+#endif
+static int imb_ftype_iris(ImFileType *type, ImBuf *ibuf) { return (ibuf->ftype == IMAGIC); }
+#ifdef WITH_QUICKTIME
+static int imb_ftype_quicktime(ImFileType *type, ImBuf *ibuf) { return 0; } // XXX
+#endif
+
+#ifdef WITH_QUICKTIME
+void quicktime_init(void);
+void quicktime_exit(void);
+#endif
+
+void libtiff_init(void);
+void libtiff_exit(void);
+
+ImFileType IMB_FILE_TYPES[]= {
+	{NULL, NULL, imb_is_a_iris, imb_ftype_iris, imb_loadiris, imb_saveiris, NULL, 0, IMAGIC},
+	{NULL, NULL, imb_is_a_jpeg, imb_ftype_default, imb_load_jpeg, imb_savejpeg, NULL, 0, JPG},
+	{NULL, NULL, imb_is_a_png, imb_ftype_default, imb_loadpng, imb_savepng, NULL, 0, PNG},
+	{NULL, NULL, imb_is_a_bmp, imb_ftype_default, imb_bmp_decode, imb_savebmp, NULL, 0, BMP},
+	{NULL, NULL, imb_is_a_targa, imb_ftype_default, imb_loadtarga, imb_savetarga, NULL, 0, TGA},
+	{NULL, NULL, imb_is_dpx, imb_ftype_default, imb_loaddpx, imb_save_dpx, NULL, IM_FTYPE_FLOAT, DPX},
+	{NULL, NULL, imb_is_cineon, imb_ftype_default, imb_loadcineon, imb_savecineon, NULL, IM_FTYPE_FLOAT, CINEON},
+#if defined(__APPLE__) && defined(IMBUF_COCOA)
+	{NULL, NULL, imb_is_a_cocoa, imb_ftype_cocoa, imb_imb_cocoaLoadImage, imb_savecocoa, NULL, 0, TIF},
+#else
+	{libtiff_init, libtiff_exit, imb_is_a_tiff, imb_ftype_default, imb_loadtiff, imb_savetiff, imb_loadtiletiff, 0, TIF},
+#endif
+	{NULL, NULL, imb_is_a_hdr, imb_ftype_default, imb_loadhdr, imb_savehdr, NULL, IM_FTYPE_FLOAT, RADHDR},
+#ifdef WITH_OPENEXR
+	{NULL, NULL, imb_is_a_openexr, imb_ftype_default, imb_load_openexr, imb_save_openexr, NULL, IM_FTYPE_FLOAT, OPENEXR},
+#endif
+#ifdef WITH_OPENJPEG
+	{NULL, NULL, imb_is_a_jp2, imb_ftype_default, imb_jp2_decode, imb_savejp2, NULL, IM_FTYPE_FLOAT, JP2},
+#endif
+#ifdef WITH_DDS
+	{NULL, NULL, imb_is_a_dds, imb_ftype_default, imb_load_dds, NULL, NULL, 0, DDS},
+#endif
+#ifdef WITH_QUICKTIME
+	{quicktime_init, quicktime_exit, imb_is_a_quicktime, imb_ftype_quicktime, imb_quicktime_decode, NULL, NULL, 0, QUICKTIME},
+#endif	
+	{NULL, NULL, NULL, NULL, NULL, NULL, 0}};
+	
+void imb_filetypes_init(void)
+{
+	ImFileType *type;
+
+	for(type=IMB_FILE_TYPES; type->is_a; type++)
+		if(type->init)
+			type->init();
+}
+
+void imb_filetypes_exit(void)
+{
+	ImFileType *type;
+
+	for(type=IMB_FILE_TYPES; type->is_a; type++)
+		if(type->exit)
+			type->exit();
+}
+
diff --git a/source/blender/imbuf/intern/filter.c b/source/blender/imbuf/intern/filter.c
index 5692686a9bc..3ee05da15c9 100644
--- a/source/blender/imbuf/intern/filter.c
+++ b/source/blender/imbuf/intern/filter.c
@@ -29,14 +29,13 @@
  * $Id$
  */
 
-#include "BLI_blenlib.h"
+#include "BKE_utildefines.h"
 
-#include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 #include "IMB_filter.h"
 
+#include "imbuf.h"
 
 /************************************************************************/
 /*				FILTERS					*/
@@ -375,17 +374,97 @@ void IMB_makemipmap(ImBuf *ibuf, int use_filter)
 {
 	ImBuf *hbuf = ibuf;
 	int curmap = 0;
-	while (curmap < IB_MIPMAP_LEVELS) {
-		if (use_filter) {
+
+	ibuf->miptot= 1;
+
+	while(curmap < IB_MIPMAP_LEVELS) {
+		if(use_filter) {
 			ImBuf *nbuf= IMB_allocImBuf(hbuf->x, hbuf->y, 32, IB_rect, 0);
 			IMB_filterN(nbuf, hbuf);
 			ibuf->mipmap[curmap] = IMB_onehalf(nbuf);
 			IMB_freeImBuf(nbuf);
 		}
-		else ibuf->mipmap[curmap] = IMB_onehalf(hbuf);
-		hbuf = ibuf->mipmap[curmap];
-		if (hbuf->x == 1 && hbuf->y == 1) break;
+		else
+			ibuf->mipmap[curmap] = IMB_onehalf(hbuf);
+
+		ibuf->miptot= curmap+2;
+		hbuf= ibuf->mipmap[curmap];
+		hbuf->miplevel= curmap+1;
+
+		if(!hbuf || (hbuf->x == 1 && hbuf->y == 1))
+			break;
+
 		curmap++;
 	}
 }
 
+ImBuf *IMB_getmipmap(ImBuf *ibuf, int level)
+{
+	CLAMP(level, 0, ibuf->miptot-1);
+	return (level == 0)? ibuf: ibuf->mipmap[level-1];
+}
+
+void IMB_premultiply_rect(unsigned int *rect, int depth, int w, int h)
+{
+	char *cp;
+	int x, y, val;
+
+	if(depth == 24) {	/* put alpha at 255 */
+		cp= (char *)(rect);
+
+		for(y=0; y<h; y++)
+			for(x=0; x<w; x++, cp+=4)
+				cp[3]= 255;
+	}
+	else {
+		cp= (char *)(rect);
+
+		for(y=0; y<h; y++) {
+			for(x=0; x<w; x++, cp+=4) {
+				val= cp[3];
+				cp[0]= (cp[0]*val)>>8;
+				cp[1]= (cp[1]*val)>>8;
+				cp[2]= (cp[2]*val)>>8;
+			}
+		}
+	}
+}
+
+void IMB_premultiply_rect_float(float *rect_float, int depth, int w, int h)
+{
+	float val, *cp;
+	int x, y;
+
+	if(depth==24) {	/* put alpha at 1.0 */
+		cp= rect_float;
+
+		for(y=0; y<h; y++)
+			for(x=0; x<w; x++, cp+=4)
+				cp[3]= 1.0;
+	}
+	else {
+		cp= rect_float;
+		for(y=0; y<h; y++) {
+			for(x=0; x<w; x++, cp+=4) {
+				val= cp[3];
+				cp[0]= cp[0]*val;
+				cp[1]= cp[1]*val;
+				cp[2]= cp[2]*val;
+			}
+		}
+	}
+
+}
+
+void IMB_premultiply_alpha(ImBuf *ibuf)
+{
+	if(ibuf==NULL)
+		return;
+
+	if(ibuf->rect)
+		IMB_premultiply_rect(ibuf->rect, ibuf->depth, ibuf->x, ibuf->y);
+
+	if(ibuf->rect_float)
+		IMB_premultiply_rect_float(ibuf->rect_float, ibuf->depth, ibuf->x, ibuf->y);
+}
+
diff --git a/source/blender/imbuf/intern/gen_dynlibtiff.py b/source/blender/imbuf/intern/gen_dynlibtiff.py
deleted file mode 100755
index fd69a353bfd..00000000000
--- a/source/blender/imbuf/intern/gen_dynlibtiff.py
+++ /dev/null
@@ -1,303 +0,0 @@
-#!/usr/bin/env python
-
-# ***** BEGIN GPL LICENSE BLOCK *****
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# Contributor(s): Jonathan Merritt.
-#
-# ***** END GPL LICENSE BLOCK *****
-
-#
-# This script generates a C source file and a header file that implement
-# dynamic loading functionality for libtiff.
-# If you need to make more functions from libtiff available, then simply add
-# them to the tiff_functions[] list below.
-#
-
-
-FILENAME   = 'dynlibtiff'
-C_FILENAME = '%s.c' % FILENAME
-H_FILENAME = '%s.h' % FILENAME
-
-
-COMMENT = \
-"""/**
- * Dynamically loaded libtiff support.
- *
- * This file is automatically generated by the gen_dynlibtiff.py script.
- * 
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contributor(s): Jonathan Merritt.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
- 
-/**
- * To use the dynamic libtiff support, you must initialize the library using:
- *	libtiff_init()
- * This attempts to load libtiff dynamically at runtime.  G.have_libtiff will
- * be set to indicate whether or not libtiff is available.  If libtiff is
- * not available, Blender can proceed with no ill effects, provided that
- * it does not attempt to use any of the libtiff_ functions.  When you're
- * finished, close the library with:
- *	libtiff_exit()
- * These functions are both declared in IMB_imbuf.h
- *
- * The functions provided by dyn_libtiff.h are the same as those in the
- * normal static / shared libtiff, except that they are prefixed by the 
- * string "libtiff_" to indicate that they belong to a dynamically-loaded 
- * version.
- */
-"""
-
-
-C_EXTRA = \
-"""
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "BLI_blenlib.h"
-
-#include "imbuf.h"
-#include "imbuf_patch.h"
-#include "IMB_imbuf.h"
-
-#include "BKE_global.h"
-#include "PIL_dynlib.h"
-
-/*********************
- * LOCAL DEFINITIONS *
- *********************/
-PILdynlib *libtiff = NULL;
-void  libtiff_loadlibtiff(void);
-void* libtiff_findsymbol(char*);
-int   libtiff_load_symbols(void);
-
-
-/**************************
- * LIBRARY INITIALIZATION *
- **************************/
-
-void libtiff_loadlibtiff(void)
-{
-	char *filename;
-	libtiff = NULL;
-
-	filename = getenv("BF_TIFF_LIB");
-	if (filename) libtiff = PIL_dynlib_open(filename);
-	if (libtiff != NULL)  return;
-
-	/* Try to find libtiff in a couple of standard places */
-#ifdef __APPLE__
-	/* OSX has version specific library */
-	//standard install location
-	libtiff = PIL_dynlib_open("/usr/local/lib/libtiff.dylib");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("/usr/local/lib/libtiff.3.dylib");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("/usr/local/lib/libtiff.4.dylib");
-	if (libtiff != NULL)  return;
-	//inside the blender app package contents/resources
-	libtiff = PIL_dynlib_open("@executable_path/../resources/libtiff.dylib");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("@executable_path/../resources/libtiff.3.dylib");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("@executable_path/../resources/libtiff.4.dylib");
-	if (libtiff != NULL)  return;
-	//inside the blender app package contents/frameworks
-	libtiff = PIL_dynlib_open("@executable_path/../frameworks/libtiff.dylib");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("@executable_path/../frameworks/libtiff.3.dylib");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("@executable_path/../frameworks/libtiff.4.dylib");
-	if (libtiff != NULL)  return;
-	//along side the blender app package
-	libtiff = PIL_dynlib_open("@executable_path/../../../libtiff.dylib");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("@executable_path/../../../libtiff.3.dylib");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("@executable_path/../../../libtiff.4.dylib");
-	if (libtiff != NULL)  return;
-	//inside the blender app package contents/MacOS
-	libtiff = PIL_dynlib_open("@executable_path/libtiff.dylib");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("@executable_path/libtiff.3.dylib");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("@executable_path/libtiff.4.dylib");
-	if (libtiff != NULL)  return;
-#else
-	libtiff = PIL_dynlib_open("libtiff.so");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("libtiff.so.3");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("libtiff.so.4");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("libtiff.dll");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("/usr/lib/libtiff.so");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("/usr/lib/libtiff.so.3");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("/usr/lib/libtiff.so.4");
-	if (libtiff != NULL)  return;
-#ifdef __x86_64__
-	libtiff = PIL_dynlib_open("/usr/lib64/libtiff.so");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("/usr/lib64/libtiff.so.3");
-	if (libtiff != NULL)  return;
-	libtiff = PIL_dynlib_open("/usr/lib64/libtiff.so.4");
-	if (libtiff != NULL)  return;
-#endif
-	libtiff = PIL_dynlib_open("/usr/local/lib/libtiff.so");
-	if (libtiff != NULL)  return;
-	/* For solaris */
-	libtiff = PIL_dynlib_open("/usr/openwin/lib/libtiff.so");
-#endif
-
-}
-
-void *libtiff_findsymbol(char *name)
-{
-	void *symbol = NULL;
-	assert(libtiff != NULL);
-	symbol = PIL_dynlib_find_symbol(libtiff, name);
-	if (symbol == NULL) {
-		char *err = PIL_dynlib_get_error_as_string(libtiff);
-
-		if (err) printf("libtiff_findsymbol: error %s\\n",err);
-		else printf("libtiff_findsymbol: error Unknown.\\n");
-
-		libtiff = NULL;
-		G.have_libtiff = (0);
-		return NULL;
-	}
-	return symbol;
-}
-
-void libtiff_init(void)
-{
-	if (libtiff != NULL) {
-		printf("libtiff_init: Attempted to load libtiff twice!\\n");
-		return;
-	}
-	libtiff_loadlibtiff();
-	G.have_libtiff = ((libtiff != NULL) && (libtiff_load_symbols()));
-}
-
-void libtiff_exit(void)
-{
-	if (libtiff != NULL) {
-		PIL_dynlib_close(libtiff);
-		libtiff = NULL;
-	}
-}
-
-
-"""
-
-
-class CFun:
-	def __init__(self, name, retType, args):
-		self.name    = name
-		self.retType = retType
-		self.args    = args
-	def getDynamicName(self):
-		return ('libtiff_%s' % self.name)
-	def getDynamicDecl(self):
-		argstr = (('%s, '*len(self.args)) % tuple(self.args))[:-2]
-		return ('%s (*%s)(%s)' % (self.retType, 
-			self.getDynamicName(), argstr))
-	def getLoadSymbol(self):
-		dname = self.getDynamicName()
-		return (
-		"""\t/* Attempt to load %s */
-	%s = libtiff_findsymbol("%s");
-	if (%s == NULL) {
-		return (0);
-	}\n""" % (self.name, dname, self.name, dname))
-
-
-# If you need more functions, add them to the list below, based upon entries
-# in either tiffio.h or tiff.h.
-tiff_functions = [
-	CFun('TIFFClientOpen', 'TIFF*', ['const char*', 'const char*',
-		'thandle_t', 'TIFFReadWriteProc', 'TIFFReadWriteProc',
-		'TIFFSeekProc', 'TIFFCloseProc', 'TIFFSizeProc',
-		'TIFFMapFileProc', 'TIFFUnmapFileProc']),
-	CFun('TIFFClose', 'void', ['TIFF*']),
-	CFun('TIFFGetField', 'int', ['TIFF*', 'ttag_t', '...']),
-	CFun('TIFFOpen', 'TIFF*', ['const char*', 'const char*']),
-	CFun('TIFFReadRGBAImage', 'int', ['TIFF*', 'uint32', 'uint32',
-		'uint32*', 'int']),
-	CFun('TIFFSetField', 'int', ['TIFF*', 'ttag_t', '...']),
-	CFun('TIFFWriteEncodedStrip', 'tsize_t', ['TIFF*', 'tstrip_t',
-		'tdata_t', 'tsize_t']),
-	CFun('_TIFFfree', 'void', ['tdata_t']),
-	CFun('_TIFFmalloc', 'tdata_t', ['tsize_t']),
-]
-
-
-def outputDynCFile(outfile, header_file_name):
-	outfile.write(COMMENT)
-	outfile.write('#include "%s"\n' % header_file_name)
-	outfile.write(C_EXTRA)
-	outfile.write('int libtiff_load_symbols(void)\n')
-	outfile.write('{\n')
-	for function in tiff_functions:
-		outfile.write(function.getLoadSymbol())
-	outfile.write('\treturn (1);\n')
-	outfile.write('}\n')
-	outfile.write("""
-	
-/*******************
- * SYMBOL POINTERS *
- *******************/\n\n""")
-	for function in tiff_functions:
-		outfile.write('%s = NULL;\n' % function.getDynamicDecl())
-
-
-def outputDynHFile(outfile):
-	outfile.write(COMMENT)
-	outfile.write('#ifndef DYN_LIBTIFF_H\n')
-	outfile.write('#include "tiffio.h"\n')
-	for function in tiff_functions:
-		outfile.write('extern %s;\n' % function.getDynamicDecl())
-	outfile.write('#endif /* DYN_LIBTIFF_H */\n\n')
-
-
-if __name__ == '__main__':
-	outfile = file(C_FILENAME, 'w')
-	outputDynCFile(outfile, H_FILENAME)
-	outfile.close()
-	outfile = file(H_FILENAME, 'w')
-	outputDynHFile(outfile)
-	outfile.close()
diff --git a/source/blender/imbuf/intern/ham.c b/source/blender/imbuf/intern/ham.c
deleted file mode 100644
index 27f6d9c691a..00000000000
--- a/source/blender/imbuf/intern/ham.c
+++ /dev/null
@@ -1,276 +0,0 @@
-/**
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- * ham.c
- *
- * $Id$
- */
-
-#include "BLI_blenlib.h"
-
-#include "imbuf.h"
-#include "imbuf_patch.h"
-#include "IMB_imbuf_types.h"
-#include "IMB_imbuf.h"
-#include "IMB_cmap.h"
-#include "IMB_hamx.h"
-#include "IMB_ham.h"
-
-extern short alpha_col0;
-
-#define HAMB	0x0100
-#define HAMG	0x0400
-#define HAMR	0x0200
-#define HAMC	0x1000
-#define HAMFREE	0x2000
-
-static void addhamdither(short x, unsigned char *dit,
-				  short dmax, unsigned char *rgb,
-				  unsigned short *ham,
-				  short type, short round, short shift)
-{
-	short dx = 0;
-	short c1, c2;
-
-	for (;x>0;x--){
-		if (ham[0] & (HAMFREE | type)){
-			c2 = c1 = *rgb;
-			
-			/* wrap dither */
-			while (dx >= dmax) dx -= dmax;
-			
-			c1 += dit[dx];
-			if (c1 > 255) c1 = 255;
-			c2 += round;
-			if (c2 > 255) c2 = 255;
-			
-			if (c1 != c2){
-				c1 >>= shift; c2 >>= shift;
-				if (ham[1] & HAMFREE){
-					ham[0] = type + c1;
-					ham[1] = type + c2;
-				} else if (ham[1] & type){
-					ham[0] = type + c1;
-				} else if ((ham[2] & (type | HAMFREE)) == type){
-					ham[0] = type + c1;
-				} else if ((ham[1] & HAMC) | (ham[2] & HAMC)){
-					ham[0] = type + c1;
-				}
-			}
-		}
-		rgb += 4;
-		ham ++;
-		dx ++;
-	}
-}
-
-static void convhamscanl(short x, short y,
-				  unsigned char *rgbbase,
-				  unsigned char *coltab,
-				  short *deltab,
-				  short bits)
-{
-	int a, r, g, b, lr, lg, lb, dr, dg, db, col, fout, type, x2;
-	int round, shift;
-	uchar *rgb, dit[2];
-	unsigned short *ham, *hambase;
-
-	/* Concept:
-		first we check the entire image, where color transitions are coded: FGRB XXXX XXXX
-		F			- free color value, can be changed by anyone
-		G/R/B		- green/red/blue ham transition, only to be changed by this color
-		XXXX XXXX	- N bits value.
-	
-		0000 XXXX XXXX is palette color.
-	
-		after that first the green dither is added, then the red dither, and finally blue dither
-	*/
-
-	if ((hambase = (unsigned short *) malloc((x+4) * sizeof(unsigned short)))==0) return;
-
-	lb = coltab[1];
-	lg = coltab[2];
-	lr = coltab[3];
-	type = col = 0;
-
-	ham = hambase;
-	rgb = rgbbase;
-	
-	shift = 8 - bits;
-	round = 1 << (shift - 1);
-	
-	/* to prevent 'noise' at the end of the line */
-	for (x2 = 3; x2 >= 0; x2 --) hambase[x + x2] = HAMFREE;
-	
-	for (x2 = x ;x2 > 0; x2--){
-		r = rgb[0] + round;
-		g = rgb[1] + round;
-		b = rgb[2] + round;
-		a = rgb[3];
-		
-		if (a < 128 && alpha_col0) {
-			a = 1;
-		} else a = 0;
-		
-		if (b > 255) b = 255;
-		if (g > 255) {
-			g = 255;
-		}
-		if (r > 255) r = 255;
-
-		r >>= shift;
-		g >>= shift;
-		b >>= shift;
-
-		if ((b-lb) | (g-lg) | (r-lr) | a){
-			if (a) {
-				col = 0;
-				type = HAMC;
-			} else {
-				col = ((b << (2 * bits)) + (g << bits) + r) << 1;
-				fout = deltab[col + 1];
-				col = deltab[col];
-				type = HAMC;
-				
-				dr = quadr[lr-r];
-				dg = quadr[lg-g];
-				db = quadr[lb-b];
-	
-				if ((dr+dg) <= fout){
-					fout = dr+dg;
-					col = b;
-					type = HAMB;
-				}
-				if ((dg+db) <= fout){
-					fout = dg+db;
-					col = r;
-					type = HAMR;
-				}
-				if ((dr+db) <= fout){
-					fout = dr+db;
-					col = g;
-					type = HAMG;
-				}
-			}
-			
-			switch(type){
-			case HAMG:
-				lg = g;
-				break;
-			case HAMR:
-				lr = r;
-				break;
-			case HAMB:
-				lb = b;
-				break;
-			default:
-				lb = coltab[col*4 + 1];
-				lg = coltab[col*4 + 2];
-				lr = coltab[col*4 + 3];
-			}
-			*ham = type + col;
-		} else *ham = HAMG + HAMFREE + g;
-
-		rgb += 4;
-		ham ++;
-	}
-
-
-	if (y & 1){
-		dit[0] = 0 << (shift - 2);
-		dit[1] = 3 << (shift - 2);
-	} else {
-		dit[0] = 2 << (shift - 2);
-		dit[1] = 1 << (shift - 2);
-	}
-
-	addhamdither(x,dit,2,rgbbase+2,hambase,HAMG, round, shift);
-
-	if ((y & 1)==0){
-		dit[0] = 3 << (shift - 2);
-		dit[1] = 0 << (shift - 2);
-	} else {
-		dit[0] = 1 << (shift - 2);
-		dit[1] = 2 << (shift - 2);
-	}
-	
-	addhamdither(x,dit,2,rgbbase+3,hambase,HAMR, round, shift);
-	addhamdither(x,dit,2,rgbbase+1,hambase,HAMB, round, shift);
-
-
-	ham = hambase;
-	rgb = rgbbase;
-	rgb += 3;
-
-	for (x2=x;x2>0;x2--){
-		type = *(ham++);
-		if (type & HAMG) type |= HAMR | HAMB;
-
-		*rgb = (type & 0xff) | ((type & (HAMR | HAMB)) >> shift);
-		rgb += 4;
-	}
-
-	free (hambase);
-}
-
-
-short imb_converttoham(struct ImBuf *ibuf)
-{
-	unsigned int coltab[256],*rect;
-	short x,y,* deltab;
-	int mincol;
-	
-	memcpy(coltab,ibuf->cmap,4 * ibuf->maxcol);
-
-	mincol = ibuf->mincol;	
-	if (alpha_col0 && mincol == 0) mincol = 1;
-
-	if (ibuf->ftype == AN_hamx) {
-		deltab = imb_coldeltatab((uchar *) coltab, 0, ibuf->maxcol, 4);
-	} else {
-		ibuf->cbits = ibuf->depth - 2;
-		imb_losecmapbits(ibuf, coltab);
-		deltab = imb_coldeltatab((uchar *) coltab, mincol, ibuf->maxcol, ibuf->cbits);
-	}
-	
-	rect = ibuf->rect;
-	x=ibuf->x;
-	y=ibuf->y;
-
-	if (ibuf->ftype == AN_hamx){
-		IMB_dit2(ibuf, 2, 4);
-		IMB_dit2(ibuf, 1, 4);
-		IMB_dit2(ibuf, 0, 4);
-		imb_convhamx(ibuf, (uchar *)coltab, deltab);
-	} else {
-		for(;y > 0; y--){
-			convhamscanl(x, y, (uchar *)rect, (uchar *)coltab, deltab, ibuf->cbits);
-			rect += x;
-		}
-	}
-
-	return (TRUE);
-}
diff --git a/source/blender/imbuf/intern/hamx.c b/source/blender/imbuf/intern/hamx.c
deleted file mode 100644
index 57672f54999..00000000000
--- a/source/blender/imbuf/intern/hamx.c
+++ /dev/null
@@ -1,581 +0,0 @@
-/**
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- * hamx.c
- *
- * $Id$
- */
-
-#include "BLI_blenlib.h"
-
-#include "imbuf.h"
-#include "imbuf_patch.h"
-#include "IMB_imbuf_types.h"
-#include "IMB_imbuf.h"
-
-#include "IMB_allocimbuf.h"
-#include "IMB_filter.h"
-#include "IMB_ham.h"
-#include "IMB_hamx.h"
-
-#ifdef WIN32
-#include <io.h>
-#include "BLI_winstuff.h"
-#endif
-
-/* actually hard coded endianness */
-#define GET_BIG_LONG(x) (((uchar *) (x))[0] << 24 | ((uchar *) (x))[1] << 16 | ((uchar *) (x))[2] << 8 | ((uchar *) (x))[3])
-#define GET_LITTLE_LONG(x) (((uchar *) (x))[3] << 24 | ((uchar *) (x))[2] << 16 | ((uchar *) (x))[1] << 8 | ((uchar *) (x))[0])
-#define SWAP_L(x) (((x << 24) & 0xff000000) | ((x << 8) & 0xff0000) | ((x >> 8) & 0xff00) | ((x >> 24) & 0xff))
-#define SWAP_S(x) (((x << 8) & 0xff00) | ((x >> 8) & 0xff))
-
-/* more endianness... should move to a separate file... */
-#if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__hppa__) || defined (__BIG_ENDIAN__)
-#define GET_ID GET_BIG_LONG
-#define LITTLE_LONG SWAP_LONG
-#else
-#define GET_ID GET_LITTLE_LONG
-#define LITTLE_LONG ENDIAN_NOP
-#endif
-
-#ifndef ABS
-#define ABS(x)	((x) < 0 ? -(x) : (x))
-#endif
-
-static uchar hamx_array_char[] = {
-	0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF,
-	0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF, 0x00,0x00,0xFF,0xFF,
-	0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF,
-	0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF, 0x00,0xFF,0x00,0xFF,
-	0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00,
-	0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00, 0x00,0xFF,0xFF,0x00,
-	
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-	
-	0x00,0x00,0x00,0x00, 0x00,0x10,0x00,0x00, 0x00,0x20,0x00,0x00, 0x00,0x30,0x00,0x00, 0x00,0x40,0x00,0x00, 0x00,0x50,0x00,0x00, 0x00,0x60,0x00,0x00, 0x00,0x70,0x00,0x00,
-	0x00,0x80,0x00,0x00, 0x00,0x90,0x00,0x00, 0x00,0xA0,0x00,0x00, 0x00,0xB0,0x00,0x00, 0x00,0xC0,0x00,0x00, 0x00,0xD0,0x00,0x00, 0x00,0xE0,0x00,0x00, 0x00,0xF0,0x00,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x10,0x00, 0x00,0x00,0x20,0x00, 0x00,0x00,0x30,0x00, 0x00,0x00,0x40,0x00, 0x00,0x00,0x50,0x00, 0x00,0x00,0x60,0x00, 0x00,0x00,0x70,0x00,
-	0x00,0x00,0x80,0x00, 0x00,0x00,0x90,0x00, 0x00,0x00,0xA0,0x00, 0x00,0x00,0xB0,0x00, 0x00,0x00,0xC0,0x00, 0x00,0x00,0xD0,0x00, 0x00,0x00,0xE0,0x00, 0x00,0x00,0xF0,0x00,
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x10, 0x00,0x00,0x00,0x20, 0x00,0x00,0x00,0x30, 0x00,0x00,0x00,0x40, 0x00,0x00,0x00,0x50, 0x00,0x00,0x00,0x60, 0x00,0x00,0x00,0x70,
-	0x00,0x00,0x00,0x80, 0x00,0x00,0x00,0x90, 0x00,0x00,0x00,0xA0, 0x00,0x00,0x00,0xB0, 0x00,0x00,0x00,0xC0, 0x00,0x00,0x00,0xD0, 0x00,0x00,0x00,0xE0, 0x00,0x00,0x00,0xF0,
-	
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x30, 0x00,0x00,0x00,0x60, 0x00,0x00,0x00,0x90, 0x00,0x00,0x00,0xC0, 0x00,0x00,0x00,0xF0,
-	0x00,0x00,0x20,0x00, 0x00,0x00,0x20,0x30, 0x00,0x00,0x20,0x60, 0x00,0x00,0x20,0x90, 0x00,0x00,0x20,0xC0, 0x00,0x00,0x20,0xF0,
-	0x00,0x00,0x40,0x00, 0x00,0x00,0x40,0x30, 0x00,0x00,0x40,0x60, 0x00,0x00,0x40,0x90, 0x00,0x00,0x40,0xC0, 0x00,0x00,0x40,0xF0,
-	0x00,0x00,0x60,0x00, 0x00,0x00,0x60,0x30, 0x00,0x00,0x60,0x60, 0x00,0x00,0x60,0x90, 0x00,0x00,0x60,0xC0, 0x00,0x00,0x60,0xF0,
-	0x00,0x00,0x90,0x00, 0x00,0x00,0x90,0x30, 0x00,0x00,0x90,0x60, 0x00,0x00,0x90,0x90, 0x00,0x00,0x90,0xC0, 0x00,0x00,0x90,0xF0,
-	0x00,0x00,0xB0,0x00, 0x00,0x00,0xB0,0x30, 0x00,0x00,0xB0,0x60, 0x00,0x00,0xB0,0x90, 0x00,0x00,0xB0,0xC0, 0x00,0x00,0xB0,0xF0,
-	0x00,0x00,0xD0,0x00, 0x00,0x00,0xD0,0x30, 0x00,0x00,0xD0,0x60, 0x00,0x00,0xD0,0x90, 0x00,0x00,0xD0,0xC0, 0x00,0x00,0xD0,0xF0,
-	0x00,0x00,0xF0,0x00, 0x00,0x00,0xF0,0x30, 0x00,0x00,0xF0,0x60, 0x00,0x00,0xF0,0x90, 0x00,0x00,0xF0,0xC0, 0x00,0x00,0xF0,0xF0,
-	0x00,0x50,0x00,0x00, 0x00,0x50,0x00,0x30, 0x00,0x50,0x00,0x60, 0x00,0x50,0x00,0x90, 0x00,0x50,0x00,0xC0, 0x00,0x50,0x00,0xF0,
-	0x00,0x50,0x20,0x00, 0x00,0x50,0x20,0x30, 0x00,0x50,0x20,0x60, 0x00,0x50,0x20,0x90, 0x00,0x50,0x20,0xC0, 0x00,0x50,0x20,0xF0,
-	0x00,0x50,0x40,0x00, 0x00,0x50,0x40,0x30, 0x00,0x50,0x40,0x60, 0x00,0x50,0x40,0x90, 0x00,0x50,0x40,0xC0, 0x00,0x50,0x40,0xF0,
-	0x00,0x50,0x60,0x00, 0x00,0x50,0x60,0x30, 0x00,0x50,0x60,0x60, 0x00,0x50,0x60,0x90, 0x00,0x50,0x60,0xC0, 0x00,0x50,0x60,0xF0,
-	0x00,0x50,0x90,0x00, 0x00,0x50,0x90,0x30, 0x00,0x50,0x90,0x60, 0x00,0x50,0x90,0x90, 0x00,0x50,0x90,0xC0, 0x00,0x50,0x90,0xF0,
-	0x00,0x50,0xB0,0x00, 0x00,0x50,0xB0,0x30, 0x00,0x50,0xB0,0x60, 0x00,0x50,0xB0,0x90, 0x00,0x50,0xB0,0xC0, 0x00,0x50,0xB0,0xF0,
-	0x00,0x50,0xD0,0x00, 0x00,0x50,0xD0,0x30, 0x00,0x50,0xD0,0x60, 0x00,0x50,0xD0,0x90, 0x00,0x50,0xD0,0xC0, 0x00,0x50,0xD0,0xF0,
-	0x00,0x50,0xF0,0x00, 0x00,0x50,0xF0,0x30, 0x00,0x50,0xF0,0x60, 0x00,0x50,0xF0,0x90, 0x00,0x50,0xF0,0xC0, 0x00,0x50,0xF0,0xF0,
-	0x00,0xA0,0x00,0x00, 0x00,0xA0,0x00,0x30, 0x00,0xA0,0x00,0x60, 0x00,0xA0,0x00,0x90, 0x00,0xA0,0x00,0xC0, 0x00,0xA0,0x00,0xF0,
-	0x00,0xA0,0x20,0x00, 0x00,0xA0,0x20,0x30, 0x00,0xA0,0x20,0x60, 0x00,0xA0,0x20,0x90, 0x00,0xA0,0x20,0xC0, 0x00,0xA0,0x20,0xF0,
-	0x00,0xA0,0x40,0x00, 0x00,0xA0,0x40,0x30, 0x00,0xA0,0x40,0x60, 0x00,0xA0,0x40,0x90, 0x00,0xA0,0x40,0xC0, 0x00,0xA0,0x40,0xF0,
-	0x00,0xA0,0x60,0x00, 0x00,0xA0,0x60,0x30, 0x00,0xA0,0x60,0x60, 0x00,0xA0,0x60,0x90, 0x00,0xA0,0x60,0xC0, 0x00,0xA0,0x60,0xF0,
-	0x00,0xA0,0x90,0x00, 0x00,0xA0,0x90,0x30, 0x00,0xA0,0x90,0x60, 0x00,0xA0,0x90,0x90, 0x00,0xA0,0x90,0xC0, 0x00,0xA0,0x90,0xF0,
-	0x00,0xA0,0xB0,0x00, 0x00,0xA0,0xB0,0x30, 0x00,0xA0,0xB0,0x60, 0x00,0xA0,0xB0,0x90, 0x00,0xA0,0xB0,0xC0, 0x00,0xA0,0xB0,0xF0,
-	0x00,0xA0,0xD0,0x00, 0x00,0xA0,0xD0,0x30, 0x00,0xA0,0xD0,0x60, 0x00,0xA0,0xD0,0x90, 0x00,0xA0,0xD0,0xC0, 0x00,0xA0,0xD0,0xF0,
-	0x00,0xA0,0xF0,0x00, 0x00,0xA0,0xF0,0x30, 0x00,0xA0,0xF0,0x60, 0x00,0xA0,0xF0,0x90, 0x00,0xA0,0xF0,0xC0, 0x00,0xA0,0xF0,0xF0,
-	0x00,0xF0,0x00,0x00, 0x00,0xF0,0x00,0x30, 0x00,0xF0,0x00,0x60, 0x00,0xF0,0x00,0x90, 0x00,0xF0,0x00,0xC0, 0x00,0xF0,0x00,0xF0,
-	0x00,0xF0,0x20,0x00, 0x00,0xF0,0x20,0x30, 0x00,0xF0,0x20,0x60, 0x00,0xF0,0x20,0x90, 0x00,0xF0,0x20,0xC0, 0x00,0xF0,0x20,0xF0,
-	0x00,0xF0,0x40,0x00, 0x00,0xF0,0x40,0x30, 0x00,0xF0,0x40,0x60, 0x00,0xF0,0x40,0x90, 0x00,0xF0,0x40,0xC0, 0x00,0xF0,0x40,0xF0,
-	0x00,0xF0,0x60,0x00, 0x00,0xF0,0x60,0x30, 0x00,0xF0,0x60,0x60, 0x00,0xF0,0x60,0x90, 0x00,0xF0,0x60,0xC0, 0x00,0xF0,0x60,0xF0,
-	0x00,0xF0,0x90,0x00, 0x00,0xF0,0x90,0x30, 0x00,0xF0,0x90,0x60, 0x00,0xF0,0x90,0x90, 0x00,0xF0,0x90,0xC0, 0x00,0xF0,0x90,0xF0,
-	0x00,0xF0,0xB0,0x00, 0x00,0xF0,0xB0,0x30, 0x00,0xF0,0xB0,0x60, 0x00,0xF0,0xB0,0x90, 0x00,0xF0,0xB0,0xC0, 0x00,0xF0,0xB0,0xF0,
-	0x00,0xF0,0xD0,0x00, 0x00,0xF0,0xD0,0x30, 0x00,0xF0,0xD0,0x60, 0x00,0xF0,0xD0,0x90, 0x00,0xF0,0xD0,0xC0, 0x00,0xF0,0xD0,0xF0,
-	0x00,0xF0,0xF0,0x00, 0x00,0xF0,0xF0,0x30, 0x00,0xF0,0xF0,0x60, 0x00,0xF0,0xF0,0x90, 0x00,0xF0,0xF0,0xC0, 0x00,0xF0,0xF0,0xF0,
-	
-	0x00,0x10,0x10,0x10, 0x00,0x20,0x20,0x20, 0x00,0x30,0x30,0x30, 0x00,0x40,0x40,0x40,
-	0x00,0x50,0x50,0x50, 0x00,0x60,0x60,0x60, 0x00,0x70,0x70,0x70, 0x00,0x80,0x80,0x80,
-	0x00,0x90,0x90,0x90, 0x00,0xA0,0xA0,0xA0, 0x00,0xB0,0xB0,0xB0, 0x00,0xC0,0xC0,0xC0,
-	0x00,0xD0,0xD0,0xD0, 0x00,0xE0,0xE0,0xE0
-};
-
-static int * hamx_array = (int *) (hamx_array_char);
-
-static uchar cmap_hamx[] = {
-	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x30, 0x00,0x00,0x00,0x60, 0x00,0x00,0x00,0x90, 0x00,0x00,0x00,0xC0, 0x00,0x00,0x00,0xF0,
-	0x00,0x00,0x20,0x00, 0x00,0x00,0x20,0x30, 0x00,0x00,0x20,0x60, 0x00,0x00,0x20,0x90, 0x00,0x00,0x20,0xC0, 0x00,0x00,0x20,0xF0,
-	0x00,0x00,0x40,0x00, 0x00,0x00,0x40,0x30, 0x00,0x00,0x40,0x60, 0x00,0x00,0x40,0x90, 0x00,0x00,0x40,0xC0, 0x00,0x00,0x40,0xF0,
-	0x00,0x00,0x60,0x00, 0x00,0x00,0x60,0x30, 0x00,0x00,0x60,0x60, 0x00,0x00,0x60,0x90, 0x00,0x00,0x60,0xC0, 0x00,0x00,0x60,0xF0,
-	0x00,0x00,0x90,0x00, 0x00,0x00,0x90,0x30, 0x00,0x00,0x90,0x60, 0x00,0x00,0x90,0x90, 0x00,0x00,0x90,0xC0, 0x00,0x00,0x90,0xF0,
-	0x00,0x00,0xB0,0x00, 0x00,0x00,0xB0,0x30, 0x00,0x00,0xB0,0x60, 0x00,0x00,0xB0,0x90, 0x00,0x00,0xB0,0xC0, 0x00,0x00,0xB0,0xF0,
-	0x00,0x00,0xD0,0x00, 0x00,0x00,0xD0,0x30, 0x00,0x00,0xD0,0x60, 0x00,0x00,0xD0,0x90, 0x00,0x00,0xD0,0xC0, 0x00,0x00,0xD0,0xF0,
-	0x00,0x00,0xF0,0x00, 0x00,0x00,0xF0,0x30, 0x00,0x00,0xF0,0x60, 0x00,0x00,0xF0,0x90, 0x00,0x00,0xF0,0xC0, 0x00,0x00,0xF0,0xF0,
-	0x00,0x50,0x00,0x00, 0x00,0x50,0x00,0x30, 0x00,0x50,0x00,0x60, 0x00,0x50,0x00,0x90, 0x00,0x50,0x00,0xC0, 0x00,0x50,0x00,0xF0,
-	0x00,0x50,0x20,0x00, 0x00,0x50,0x20,0x30, 0x00,0x50,0x20,0x60, 0x00,0x50,0x20,0x90, 0x00,0x50,0x20,0xC0, 0x00,0x50,0x20,0xF0,
-	0x00,0x50,0x40,0x00, 0x00,0x50,0x40,0x30, 0x00,0x50,0x40,0x60, 0x00,0x50,0x40,0x90, 0x00,0x50,0x40,0xC0, 0x00,0x50,0x40,0xF0,
-	0x00,0x50,0x60,0x00, 0x00,0x50,0x60,0x30, 0x00,0x50,0x60,0x60, 0x00,0x50,0x60,0x90, 0x00,0x50,0x60,0xC0, 0x00,0x50,0x60,0xF0,
-	0x00,0x50,0x90,0x00, 0x00,0x50,0x90,0x30, 0x00,0x50,0x90,0x60, 0x00,0x50,0x90,0x90, 0x00,0x50,0x90,0xC0, 0x00,0x50,0x90,0xF0,
-	0x00,0x50,0xB0,0x00, 0x00,0x50,0xB0,0x30, 0x00,0x50,0xB0,0x60, 0x00,0x50,0xB0,0x90, 0x00,0x50,0xB0,0xC0, 0x00,0x50,0xB0,0xF0,
-	0x00,0x50,0xD0,0x00, 0x00,0x50,0xD0,0x30, 0x00,0x50,0xD0,0x60, 0x00,0x50,0xD0,0x90, 0x00,0x50,0xD0,0xC0, 0x00,0x50,0xD0,0xF0,
-	0x00,0x50,0xF0,0x00, 0x00,0x50,0xF0,0x30, 0x00,0x50,0xF0,0x60, 0x00,0x50,0xF0,0x90, 0x00,0x50,0xF0,0xC0, 0x00,0x50,0xF0,0xF0,
-	0x00,0xA0,0x00,0x00, 0x00,0xA0,0x00,0x30, 0x00,0xA0,0x00,0x60, 0x00,0xA0,0x00,0x90, 0x00,0xA0,0x00,0xC0, 0x00,0xA0,0x00,0xF0,
-	0x00,0xA0,0x20,0x00, 0x00,0xA0,0x20,0x30, 0x00,0xA0,0x20,0x60, 0x00,0xA0,0x20,0x90, 0x00,0xA0,0x20,0xC0, 0x00,0xA0,0x20,0xF0,
-	0x00,0xA0,0x40,0x00, 0x00,0xA0,0x40,0x30, 0x00,0xA0,0x40,0x60, 0x00,0xA0,0x40,0x90, 0x00,0xA0,0x40,0xC0, 0x00,0xA0,0x40,0xF0,
-	0x00,0xA0,0x60,0x00, 0x00,0xA0,0x60,0x30, 0x00,0xA0,0x60,0x60, 0x00,0xA0,0x60,0x90, 0x00,0xA0,0x60,0xC0, 0x00,0xA0,0x60,0xF0,
-	0x00,0xA0,0x90,0x00, 0x00,0xA0,0x90,0x30, 0x00,0xA0,0x90,0x60, 0x00,0xA0,0x90,0x90, 0x00,0xA0,0x90,0xC0, 0x00,0xA0,0x90,0xF0,
-	0x00,0xA0,0xB0,0x00, 0x00,0xA0,0xB0,0x30, 0x00,0xA0,0xB0,0x60, 0x00,0xA0,0xB0,0x90, 0x00,0xA0,0xB0,0xC0, 0x00,0xA0,0xB0,0xF0,
-	0x00,0xA0,0xD0,0x00, 0x00,0xA0,0xD0,0x30, 0x00,0xA0,0xD0,0x60, 0x00,0xA0,0xD0,0x90, 0x00,0xA0,0xD0,0xC0, 0x00,0xA0,0xD0,0xF0,
-	0x00,0xA0,0xF0,0x00, 0x00,0xA0,0xF0,0x30, 0x00,0xA0,0xF0,0x60, 0x00,0xA0,0xF0,0x90, 0x00,0xA0,0xF0,0xC0, 0x00,0xA0,0xF0,0xF0,
-	0x00,0xF0,0x00,0x00, 0x00,0xF0,0x00,0x30, 0x00,0xF0,0x00,0x60, 0x00,0xF0,0x00,0x90, 0x00,0xF0,0x00,0xC0, 0x00,0xF0,0x00,0xF0,
-	0x00,0xF0,0x20,0x00, 0x00,0xF0,0x20,0x30, 0x00,0xF0,0x20,0x60, 0x00,0xF0,0x20,0x90, 0x00,0xF0,0x20,0xC0, 0x00,0xF0,0x20,0xF0,
-	0x00,0xF0,0x40,0x00, 0x00,0xF0,0x40,0x30, 0x00,0xF0,0x40,0x60, 0x00,0xF0,0x40,0x90, 0x00,0xF0,0x40,0xC0, 0x00,0xF0,0x40,0xF0,
-	0x00,0xF0,0x60,0x00, 0x00,0xF0,0x60,0x30, 0x00,0xF0,0x60,0x60, 0x00,0xF0,0x60,0x90, 0x00,0xF0,0x60,0xC0, 0x00,0xF0,0x60,0xF0,
-	0x00,0xF0,0x90,0x00, 0x00,0xF0,0x90,0x30, 0x00,0xF0,0x90,0x60, 0x00,0xF0,0x90,0x90, 0x00,0xF0,0x90,0xC0, 0x00,0xF0,0x90,0xF0,
-	0x00,0xF0,0xB0,0x00, 0x00,0xF0,0xB0,0x30, 0x00,0xF0,0xB0,0x60, 0x00,0xF0,0xB0,0x90, 0x00,0xF0,0xB0,0xC0, 0x00,0xF0,0xB0,0xF0,
-	0x00,0xF0,0xD0,0x00, 0x00,0xF0,0xD0,0x30, 0x00,0xF0,0xD0,0x60, 0x00,0xF0,0xD0,0x90, 0x00,0xF0,0xD0,0xC0, 0x00,0xF0,0xD0,0xF0,
-	0x00,0xF0,0xF0,0x00, 0x00,0xF0,0xF0,0x30, 0x00,0xF0,0xF0,0x60, 0x00,0xF0,0xF0,0x90, 0x00,0xF0,0xF0,0xC0, 0x00,0xF0,0xF0,0xF0,
-	0x00,0x10,0x10,0x10, 0x00,0x20,0x20,0x20, 0x00,0x30,0x30,0x30, 0x00,0x40,0x40,0x40, 0x00,0x50,0x50,0x50, 0x00,0x60,0x60,0x60,
-	0x00,0x70,0x70,0x70, 0x00,0x80,0x80,0x80, 0x00,0x90,0x90,0x90, 0x00,0xA0,0xA0,0xA0, 0x00,0xB0,0xB0,0xB0, 0x00,0xC0,0xC0,0xC0,
-	0x00,0xD0,0xD0,0xD0, 0x00,0xE0,0xE0,0xE0
-};
-
-
-float adat_gamma = 1.0;
-float adat_distort = 1.0;
-
-/*
- * 
- * New version:
- * 
- * 32 brighntesses	Y			 15 with direct access (black and white are specials)
- * 16 colors		H ue		
- * 7 intensities	S aturation
- * 
- * Total 3584 'different' colors. First 512 colors free.
- * 
- * 
- */
-
-void imb_convhamx(struct ImBuf *ibuf, unsigned char *coltab, short *deltab)
-{
-	short r,g,b,lr,lg,lb,dr,dg,db,col,fout,type,step;
-	int i;
-	uchar *rect;
-
-	/*
-		b 	= 0000 xxxx
-		g	= 0001 xxxx
-		r	= 0010 xxxx
-		cmap  >=  48
-	*/
-
-	for (step = 0 ; step < 2 ; step ++){
-		rect =  (uchar *) ibuf->rect;
-		rect += 4*step;
-		i = ((ibuf->x * ibuf->y) + 2 - step - 1) / 2;
-
-		lb = coltab[1];
-		lg = coltab[2];
-		lr = coltab[3];
-		type = col = 0;
-
-		for ( ;i>0;i--){
-			b = rect[2] >> 4;
-			g = rect[1] >> 4;
-			r = rect[0] >> 4;
-
-			if ((b-lb) | (g-lg) | (r-lr)){
-				col = ((b<<8) + (g<<4) + r) << 1;
-				fout = deltab[col + 1];
-				col = deltab[col];
-				type = 0;
-				dr = quadr[lr-r] ;
-				dg = quadr[lg-g] ;
-				db = quadr[lb-b];
-
-				if ((dr+dg)<=fout) {
-					fout = dr+dg ;
-					type = 1;
-				}
-				if ((dg+db)<=fout) {
-					fout = dg+db;
-					type = 2;
-				}
-				if ((dr+db)<=fout) {
-					fout = dr+db;
-					type = 4;
-				}
-
-				switch(type){
-				case 1:
-					lb = b ;
-					col = b;
-					break;
-				case 4:
-					lg = g ;
-					col = g+16;
-					break;
-				case 2:
-					lr = r ;
-					col = r + 32;
-					break;
-				default:
-					/*printf("%04x %5d %5d  ", (b<<8) + (g<<4) + r, col, fout);*/
-					
-					lb = coltab[col*4 + 1];
-					lg = coltab[col*4 + 2];
-					lr = coltab[col*4 + 3];
-					/*printf("%01x%01x%01x %01x%01x%01x\n", b, g, r, lb, lg, lr);*/
-					col += 48;
-				}
-			}
-			rect[3] = col;
-			rect += 8;
-		}
-	}
-}
-
-static short dec_hamx(struct ImBuf * ibuf, unsigned char *body, int cmap[])
-{
-	int todo,i;
-	int j,step,col;
-	unsigned int *rect;
-
-	for (step = 0 ; step < 2 ; step ++){
-		rect = ibuf->rect;
-		rect += step;
-		todo = (ibuf->x * ibuf->y + 2 - step - 1) / 2;
-		col = cmap[0];
-		while (todo>0){
-			i = *body++;
-
-			if (i & 128){			/* fill */
-
-				i = 257-i;
-				todo -= i;
-				j = *(body++);
-
-				col = ((col & hamx_array[j]) | hamx_array[j + 256]);
-
-				do{
-					*rect = col;
-					rect += 2;
-				}while (--i);
-			} else{				/* copy */
-				i++;
-				todo-=i;
-
-				do{
-					j = *(body++);
-					*rect = col = ((col & hamx_array[j]) | hamx_array[j + 256]);
-					rect += 2;
-				}while (--i);
-			}
-		}
-		if (todo) return (0);
-	}
-	return(1);
-}
-
-
-struct ImBuf *imb_loadanim(int *iffmem, int flags)
-{
-	int chunk, totlen, len, *mem, cmaplen = 0;
-	unsigned int *cmap = NULL;
-	uchar *body = 0;
-	struct Adat adat;
-	struct ImBuf *ibuf=0;
-	static int is_flipped = FALSE;
-	
-	mem=iffmem;
-	if (GET_ID(mem) != FORM) return (0);
-	if (GET_ID(mem + 2) != ANIM) return (0);
-	totlen= (GET_BIG_LONG(mem + 1) + 1) & ~1;
-	mem += 3;
-	totlen -= 4;
-	adat.w = 0;
-	adat.xorig = 0;
-	adat.yorig = 0;
-	adat.gamma = adat_gamma;
-	adat.distort = adat_distort;
-	
-	while(totlen > 0){
-		chunk = GET_ID(mem);
-		len = (GET_BIG_LONG(mem + 1) + 1) & ~1;
-		mem += 2;
-
-		totlen -= len+8;
-		switch (chunk){
-		case ADAT:
-			if (len > sizeof(struct Adat)){
-				memcpy(&adat,mem,sizeof(struct Adat));
-			} else{
-				memcpy(&adat,mem,len);
-			}
-			adat.w = BIG_SHORT(adat.w);
-			adat.h = BIG_SHORT(adat.h);
-			adat.type = BIG_SHORT(adat.type);
-			adat.xorig = BIG_SHORT(adat.xorig);
-			adat.yorig = BIG_SHORT(adat.yorig);
-			break;
-		case CMAP:
-			cmap = (unsigned int *) mem;
-			cmaplen = len;
-			break;
-		case BODY:
-			body = (uchar *) mem;
-			break;
-		}
-		mem = (int *)((uchar *)mem +len);
-	}
-
-	if (body == 0) return (0);
-	if (adat.w == 0) return (0);
-
-	adat_gamma = adat.gamma;
-	adat_distort = adat.distort;
-
-	if (flags & IB_test) ibuf=IMB_allocImBuf(adat.w, adat.h, 24, 0, 0);
-	else ibuf=IMB_allocImBuf(adat.w, adat.h, 24, IB_rect, 0);
-	if (ibuf==0) return (0);
-
-	ibuf->ftype = (Anim | adat.type);
-	ibuf->profile = IB_PROFILE_SRGB;
-	ibuf->xorig = adat.xorig;
-	ibuf->yorig = adat.yorig;
-	ibuf->flags = flags;
-	
-	if (cmaplen){
-		ibuf->cmap = malloc(cmaplen);
-		memcpy(ibuf->cmap, cmap, cmaplen);
-		ibuf->maxcol = cmaplen >> 2;
-	}
-
-	if (flags & IB_test){
-		if (flags & IB_freem) free(iffmem);
-		return(ibuf);
-	}
-
-	switch (adat.type){
-	case HAMX:
-		if (flags & IB_rect){
-			if (!is_flipped) {
-				int i;
-				unsigned int * t;
-				t = (unsigned int *) hamx_array_char;
-				for (i = 0; i < sizeof(hamx_array_char) / sizeof(int) ; i++) {
-					t[i] = SWAP_LONG(t[i]);
-				}
-				
-				t = (unsigned int *) cmap_hamx;
-			
-				for (i = 0; i < sizeof(cmap_hamx) / sizeof(int) ; i++) {
-					t[i] = SWAP_LONG(t[i]);
-				}
-				
-				is_flipped= TRUE;
-			}
-
-			if (dec_hamx(ibuf,body,(int*) cmap_hamx) == 0){
-				IMB_freeImBuf(ibuf);
-				ibuf = 0;
-			}
-			if (flags & IB_ttob) IMB_flipy(ibuf);
-		}
-		break;
-	default:
-		IMB_freeImBuf(ibuf);
-		ibuf = 0;
-	}
-	
-	if (flags & IB_freem) free(iffmem);
-
-	return (ibuf);
-}
-
-
-static unsigned char *makebody_anim(int bytes,
-							 unsigned char *buf,
-							 unsigned char *rect)
-{
-	register uchar last,this;
-	register int copy;
-	register uchar *rectstart,*temp;
-
-	bytes--;
-	rectstart = rect;
-	last = *rect++;
-	this = *rect++;
-	copy = last^this;
-	while (bytes>0){
-		if (copy){
-			do{
-				last = this;
-				this = *rect++;
-				if (last == this){
-					if (this == rect[-3]){		/* three the same? */
-						bytes --;					/* init bytes */
-						break;
-					}
-				}
-			}while (--bytes != 0);
-
-			copy = rect-rectstart;
-			copy --;
-			if (bytes) copy -= 2;
-
-			temp = rect;
-			rect = rectstart;
-
-			while (copy){
-				last = copy;
-				if (copy>MAXDAT) last = MAXDAT;
-				copy -= last;
-				*buf++ = last-1;
-				do{
-					*buf++ = *rect++;
-				}while(--last != 0);
-			}
-			rectstart = rect;
-			rect = temp;
-			last = this;
-
-			copy = FALSE;
-		} else {
-			while (*rect++ == this){		/* seek first different byte */
-				if (--bytes == 0) break;	/* or end of line */
-			}
-			rect --;
-			copy = rect-rectstart;
-			rectstart = rect;
-			bytes --;
-			this = *rect++;
-
-			while (copy){
-				if (copy>MAXRUN){
-					*buf++ = -(MAXRUN-1);
-					*buf++ = last;
-					copy -= MAXRUN;
-				} else {
-					*buf++ = -(copy-1);
-					*buf++ = last;
-					break;
-				}
-			}
-			copy=TRUE;
-		}
-	}
-	return (buf);
-}
-
-
-short imb_enc_anim(struct ImBuf *ibuf, int file)
-{
-	int step, size, i, skip, steps = 0;
-	uchar *buf1, *crect, *_buf1, *_buf2, *bufend;
-	short ok = TRUE;
-
-	if (ibuf == 0) return (0);
-	if (file < 0 ) return (0);
-	if (ibuf->rect == 0) return(0);
-
-	/* add dither */
-
-	switch(ibuf->ftype){
-	case AN_hamx:
-		ibuf->cmap = (unsigned int *) cmap_hamx;
-		ibuf->mincol = 0;
-		ibuf->maxcol = sizeof(cmap_hamx) / 4;
-		imb_converttoham(ibuf);
-		steps = 2;
-		break;
-	}
-	if (steps == 0) return 0;
-
-	size = ((ibuf->x + 1)* (ibuf->y + 1)) / steps + 1024;
-	if ((_buf1  = malloc(size)) == 0) return(0);
-	if ((_buf2  = malloc(size)) == 0){
-		free(_buf1);
-		return(0);
-	}
-
-	skip = 4 * steps;
-	for (step = 0 ; step < steps ; step ++){
-		crect = (uchar *) ibuf->rect;
-		crect += 4 * step;
-		size = (ibuf->x * ibuf->y + steps - step - 1) / steps;
-		buf1 = _buf1;
-		if ((ibuf->ftype == AN_hamx) || (ibuf->ftype == AN_yuvx)){
-			crect += 3;
-			for (i = size ; i>0 ; i--){
-				*(buf1 ++) = *crect;
-				crect += skip;
-			}
-		} else{
-			for (i = size ; i>0 ; i--){
-				*(buf1 ++) = crect[1] + (crect[2] >> 2) + (crect[3] >> 5);
-				crect += skip;
-			}
-		}
-		bufend = makebody_anim(size,_buf2,_buf1);
-		if (bufend == 0){
-			ok = FALSE;
-			break;
-		}
-		size = bufend - _buf2;
-		if (write(file, _buf2, size) != size){
-			ok = FALSE;
-			break;
-		}
-	}
-	free(_buf1);
-	free(_buf2);
-	return (ok);
-}
diff --git a/source/blender/imbuf/intern/iff.c b/source/blender/imbuf/intern/iff.c
deleted file mode 100644
index 7297d7d6dd1..00000000000
--- a/source/blender/imbuf/intern/iff.c
+++ /dev/null
@@ -1,224 +0,0 @@
-/**
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- * iff.c
- *
- * $Id$
- */
-
-#include "BLI_blenlib.h"
-#include "imbuf.h"
-#include "imbuf_patch.h"
-#include "IMB_imbuf_types.h"
-#include "IMB_iff.h"
-#ifdef WIN32
-#include <io.h>
-#include "BLI_winstuff.h"
-#endif
-
-unsigned short imb_start_iff(struct ImBuf *ibuf, int file)
-{
-	unsigned int *point, size, *buf;
-	
-	if ((point=buf=(unsigned int *)malloc(32768))==0) return FALSE;
-
-	*point++ = FORM;				/* FORMxxxxILBM in buffer */
-	*point++ = 0;
-
-	if (IS_amiga(ibuf)){
-		struct BitMapHeader *bmhd;
-
-		*point++ = ILBM;
-		*point++ = CAMG;
-		*point++ = 4;
-		*point++ = (ibuf->ftype & 0xffff);
-
-		*point++=BMHD;
-		*point++=sizeof(struct BitMapHeader);
-
-		bmhd=(struct BitMapHeader *)point;		/* bmhd points to location where bmhd will be */
-		point=(unsigned int *)((char *)point+sizeof(struct BitMapHeader));	/* advance pointer already */
-
-		bmhd->w=ibuf->x;
-		bmhd->h=ibuf->y;
-		bmhd->pageWidth=ibuf->x;
-		bmhd->pageHeight=ibuf->y;
-		bmhd->x=0;
-		bmhd->y=0;
-		bmhd->nPlanes=ibuf->depth;
-		bmhd->masking=0;
-		if (ibuf->flags & IB_vert){
-			bmhd->compression=2;
-		}
-		else{
-			bmhd->compression=1;
-		}
-		bmhd->pad1=0;
-		bmhd->transparentColor=0;
-		bmhd->xAspect=1;
-		bmhd->yAspect=1;
-	} else if (IS_anim(ibuf)){
-		struct Adat *adat;
-		extern float adat_gamma;
-		extern float adat_distort;
-		
-		*point++ = ANIM;
-		*point++ = ADAT;
-		*point++ = BIG_LONG(sizeof(struct Adat));
-
-		adat = (struct Adat *)point;
-		point = (unsigned int *)((char *)point+sizeof(struct Adat));	/* advance pointer already */
-
-		adat->w = BIG_SHORT(ibuf->x);
-		adat->h = BIG_SHORT(ibuf->y);
-
-		adat->type = BIG_SHORT(ibuf->ftype);
-		adat->xorig = BIG_SHORT(ibuf->xorig);
-		adat->yorig = BIG_SHORT(ibuf->yorig);
-		adat->pad = 0;
-		adat->gamma = adat_gamma;
-		adat->distort = adat_distort;
-	}
-
-	size=((uchar *)point-(uchar *)buf);
-	if (write(file,buf,size)!=size){
-		free(buf);
-		return (FALSE);
-	}
-
-	if (ibuf->cmap){
-		if (IS_anim(ibuf)){
-			size = ibuf->maxcol * sizeof(int);
-			buf[0] = CMAP;
-			buf[1] = BIG_LONG(size);
-			if (write(file,buf,8) != 8){
-				free(buf);
-				return (FALSE);
-			}
-			if (write(file,ibuf->cmap,size) != size){
-				free(buf);
-				return (FALSE);
-			}
-		} else{
-			uchar *cpoint,*cols;
-			unsigned int i,bits;
-
-			point = buf;
-			if (IS_amiga(ibuf)){
-				*(point++) = CMAP;
-				*(point++) = BIG_LONG(3*ibuf->maxcol);
-			}
-
-			cpoint = (uchar *) point;
-			cols = (uchar *)ibuf->cmap;
-			if ((ibuf->cbits > 0) && (ibuf->cbits < 8)){
-				bits = ~((1 << (8-ibuf->cbits)) - 1);
-			} else bits = -1;
-
-			if (IS_ham(ibuf)) bits = -1;
-			
-			for (i=0 ; i<ibuf->maxcol ; i++){
-				*(cpoint++) = cols[0] & bits;
-				*(cpoint++) = cols[1] & bits;
-				*(cpoint++) = cols[2] & bits;
-				cols += 4;
-			}
-			if (ibuf->maxcol & 1) *(cpoint++)=0;
-
-			size=(cpoint-(uchar *)buf);
-			if (write(file,buf,size)!=size){
-				free(buf);
-				return (FALSE);
-			}
-		}
-	}
-
-	if (IS_amiga(ibuf)) buf[0] = BODY;
-	if (IS_anim(ibuf)) buf[0] = BODY;
-	buf[1]=0;
-
-	if (write(file,buf,8)!=8){
-		free(buf);
-		return(FALSE);
-	}
-
-	free(buf);
-	return (TRUE);
-}
-
-
-unsigned short imb_update_iff(int file, int code)
-{
-	int	buf[2], filelen, skip;
-	uchar nop;
-
-	if (file<=0) return (FALSE);
-
-	filelen = BLI_filesize(file)-8;			/* calc filelength  */
-
-	lseek(file,0L,2);		/* seek end */
-
-	if (filelen & 1){						/* make length 'even' */
-		switch(code){
-		case BODY:
-			nop = IFFNOP;
-			break;
-		}
-		if (write(file,&nop,1)!=1) return (FALSE);
-		filelen++;
-	}
-	lseek(file,4L,0);
-
-	buf[0] = BIG_LONG(filelen);
-	
-	if (write(file, buf, 4) != 4) return (FALSE);
-	if (code == 0) return (TRUE);
-
-	filelen-=4;
-	if(lseek(file,4L,1) == -1) return (FALSE);
-
-	while (filelen>0){		/* seek BODY */
-		if(read(file, buf, 8) != 8) return (FALSE);
-		filelen -= 8;
-		if (buf[0] == code) break;
-		
-		skip = (BIG_LONG(buf[1]) + 1) & ~1;
-		filelen -= skip;
-		if(lseek(file, skip, 1) == -1) return (FALSE);
-	}
-	if (filelen <= 0) {
-		printf("update_iff: couldn't find chunk\n");
-		return (FALSE);
-	}
-
-	lseek(file, -4L, 1);
-	
-	buf[0] = BIG_LONG(filelen);
-	
-	if (write(file, buf, 4)!=4) return (FALSE);
-
-	return (TRUE);
-}
diff --git a/source/blender/imbuf/intern/imageprocess.c b/source/blender/imbuf/intern/imageprocess.c
index e52cab0bdd3..4450394e9e6 100644
--- a/source/blender/imbuf/intern/imageprocess.c
+++ b/source/blender/imbuf/intern/imageprocess.c
@@ -37,6 +37,8 @@
  * $Id$
  */
 
+#include <stdlib.h>
+
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 #include "math.h"
diff --git a/source/blender/imbuf/intern/imbuf.h b/source/blender/imbuf/intern/imbuf.h
index aba4784d7d7..047795355b3 100644
--- a/source/blender/imbuf/intern/imbuf.h
+++ b/source/blender/imbuf/intern/imbuf.h
@@ -51,6 +51,8 @@
 #include <sys/mman.h>
 #endif
 
+#include "MEM_guardedalloc.h"
+
 #if !defined(WIN32)
 #define O_BINARY 0
 #endif
@@ -72,97 +74,10 @@
 #define BIG_LONG SWAP_LONG
 #endif
 
-#define malloc(x) MEM_mallocN(x, __FILE__)
-#define free(x) MEM_freeN(x)
-#define calloc(x,y) MEM_callocN((x)*(y), __FILE__)
-#define freelist(x) BLI_freelistN(x)
-
-#ifdef SHLIB
-void *(*ib_calloc)();
-#define calloc(x,y) ib_calloc((x),(y))
-void *(*ib_malloc)();
-#define malloc(x) ib_malloc(x)
-void (*ib_free)();
-#define free(x) ib_free(x)
-void (*ib_memcpy)();
-#define memcpy(x,y,z) ib_memcpy((x),(y),(z))
-int (*ib_abs)();
-#define abs(x) ib_abs(x)
-void (*ib_fprin_tf)();
-#define fprintf ib_fprin_tf
-int (*ib_sprin_tf)();
-#define sprintf ib_sprin_tf
-void (*ib_prin_tf)();
-#define printf ib_prin_tf
-int (*ib_lseek)();
-#define lseek(x,y,z) ib_lseek((x),(y),(z))
-void *(*ib_mmap)();
-#define mmap(u,v,w,x,y,z) ib_mmap((u),(v),(w),(x),(y),(z))
-int (*ib_munmap)();
-#define munmap(x,y) ib_munmap((x),(y))
-int (*ib_open)();
-#define open(x,y) ib_open((x),(y))
-void (*ib_close)();
-#define close(x) ib_close(x)
-int (*ib_write)();
-#define write(x,y,z) ib_write((x),(y),(z))
-int (*ib_read)();
-#define read(x,y,z) ib_read((x),(y),(z))
-int (*ib_fchmod)();
-#define fchmod(x,y) ib_fchmod((x),(y))
-int (*ib_remove)();
-#define remove(x) ib_remove(x)
-size_t (*ib_strlen)();
-#define strlen(x) ib_strlen(x)
-int (*ib_isdigit)();
-#define isdigit(x) ib_isdigit(x)
-char *(*ib_strcpy)();
-#define strcpy(x,y) ib_strcpy((x),(y))
-int (*ib_atoi)();
-#define atoi(x) ib_atoi(x)
-char *(*ib_strcat)();
-#define strcat(x,y) ib_strcat((x),(y))
-int (*ib_stat)();
-/* #define stat(x,y) ib_stat((x),(y)) */
-FILE *ib_iob;
-#define _iob ib_iob
-
-#else
-
-#define ib_stat stat
-
-#endif /* SHLIB */
-
-
-#define WIDTHB(x) (((x+15)>>4)<<1)
-
-extern unsigned short *quadr;
-extern float dyuvrgb[4][4];
-extern float rgbdyuv[4][4];
-
-
-typedef struct Adat
-{
-	unsigned short w, h;
-	unsigned short type;
-	unsigned short xorig, yorig;
-	unsigned short pad;
-	float gamma;
-	float distort;
-}Adat;
+typedef unsigned char uchar;
 
-struct BitMapHeader
-{
-	unsigned short	w, h;		/* in pixels */
-	unsigned short	x, y;
-	char	nPlanes;
-	char	masking;
-	char	compression;
-	char	pad1;
-	unsigned short	transparentColor;
-	char	xAspect, yAspect;
-	short	pageWidth, pageHeight;
-};
+#define TRUE 1
+#define FALSE 0
 
 #endif	/* IMBUF_H */
 
diff --git a/source/blender/imbuf/intern/imbuf_cocoa.m b/source/blender/imbuf/intern/imbuf_cocoa.m
index 44ce8e061ce..02c90c5bd09 100644
--- a/source/blender/imbuf/intern/imbuf_cocoa.m
+++ b/source/blender/imbuf/intern/imbuf_cocoa.m
@@ -34,7 +34,6 @@
 #import <Cocoa/Cocoa.h>
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 
 #include "IMB_cocoa.h"
 
@@ -185,6 +184,9 @@ struct ImBuf *imb_cocoaLoadImage(unsigned char *mem, int size, int flags)
 
 	if (ENDIAN_ORDER == B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf);
 
+	ibuf->ftype = TIF;
+	ibuf->profile = IB_PROFILE_SRGB;
+
 	/* return successfully */
 	return (ibuf);
 }
diff --git a/source/blender/imbuf/intern/imbuf_patch.h b/source/blender/imbuf/intern/imbuf_patch.h
deleted file mode 100644
index 2c8d9efbfbd..00000000000
--- a/source/blender/imbuf/intern/imbuf_patch.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/**
- * imbuf_patch.h
- *
- * These are some definitions to make imbuf more independent from the
- * rest of the blender code. Most of these are dirty and should not
- * really exist.
- *
- * $Id$ *
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-#ifndef IMBUF_PATCH_H
-#define IMBUF_PATCH_H
-
-/* most of imbuf uses this aloc, and it will disappear soon
- * (hopefully) (25-10-2001 nzc) */
-#include "MEM_guardedalloc.h"
-
-struct ImBuf;
-
-/* originally, these were defines ... */
-typedef unsigned char  uchar;
-
-/* should not be used at all */
-#define TRUE 1
-#define FALSE 0
-
-/* Endianness: flip the byte order. It's strange that this is needed..
- * After all, there is an internal endian.{c,h}... */
-#if defined(__sgi) || defined (__sparc) || defined(__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__hppa__) || defined (__BIG_ENDIAN__)
-#define MAKE_ID(a,b,c,d) ( (int)(a)<<24 | (int)(b)<<16 | (c)<<8 | (d) )
-#else
-#define MAKE_ID(a,b,c,d) ( (int)(d)<<24 | (int)(c)<<16 | (b)<<8 | (a) )
-#endif
-
-/* These defines loop back to the internal Blender memory management
- * system, implemented in blenlib. */
-#define NEW(x) (x*)MEM_mallocN(sizeof(x),# x) 
-#define mallocstruct(x,y) (x*)malloc((y)* sizeof(x))
-#define callocstruct(x,y) (x*)calloc((y), sizeof(x))
-
-/* These vars are used thoughout the image buffer for conversions. */
-extern float rgbyuv[4][4];
-extern float yuvrgb[4][4];
-extern float rgbbeta[4][4];
-
-/* This one helps debugging. */
-extern int IB_verbose;
-
-/* These ID's are used for checking memory blocks. See blenlib for
- * more details. This set is only used in the imbuf internally. */
-
-#define CAT  MAKE_ID('C','A','T',' ')
-#define FORM MAKE_ID('F','O','R','M')
-#define ILBM MAKE_ID('I','L','B','M')
-#define BMHD MAKE_ID('B','M','H','D')
-#define CMAP MAKE_ID('C','M','A','P')
-#define CAMG MAKE_ID('C','A','M','G')
-#define BODY MAKE_ID('B','O','D','Y')
-
-#define ANIM MAKE_ID('A','N','I','M')
-#define ADAT MAKE_ID('A','D','A','T')
-#define CODE MAKE_ID('C','O','D','E')
-#define ANHD MAKE_ID('A','N','H','D')
-#define DLTA MAKE_ID('D','L','T','A')
-#define BLCK MAKE_ID('B','L','C','K')
-
-#define MAXRUN 126
-#define MAXDAT 126
-#define IFFNOP 128
-
-#define camg ftype
-
-#define LI_rect		IB_rect
-#define LI_planes	IB_planes
-#define LI_kcmap	IB_cmap
-#define LI_cmap		IB_cmap
-#define LI_freem	IB_freem
-#define LI_test		IB_test
-
-#define SI_rect		IB_rect
-#define SI_planes	IB_planes
-#define SI_kcmap	IB_cmap
-#define SI_cmap		IB_cmap
-#define SI_vert		IB_vert
-
-#endif
-
diff --git a/source/blender/imbuf/intern/iris.c b/source/blender/imbuf/intern/iris.c
index 01232786070..dc9c7a1dc3b 100644
--- a/source/blender/imbuf/intern/iris.c
+++ b/source/blender/imbuf/intern/iris.c
@@ -32,11 +32,10 @@
 #include <string.h>
 #include "BLI_blenlib.h"
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 #include "IMB_allocimbuf.h"
-#include "IMB_iris.h"
+#include "IMB_filetype.h"
 
 typedef struct {
 	unsigned short	imagic;		/* stuff saved on disk . . */
@@ -224,6 +223,16 @@ static void test_endian_zbuf(struct ImBuf *ibuf)
 	}
 }
 
+/* from misc_util: flip the bytes from x  */
+#define GS(x) (((unsigned char *)(x))[0] << 8 | ((unsigned char *)(x))[1])
+
+/* this one is only def-ed once, strangely... */
+#define GSS(x) (((uchar *)(x))[1] << 8 | ((uchar *)(x))[0])
+
+int imb_is_a_iris(unsigned char *mem)
+{
+	return ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC));
+}
 
 /*
  *	longimagedata - 
@@ -232,7 +241,7 @@ static void test_endian_zbuf(struct ImBuf *ibuf)
  *
  */
 
-struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
+struct ImBuf *imb_loadiris(unsigned char *mem, int size, int flags)
 {
 	unsigned int *base, *lptr = NULL;
 	float *fbase, *fptr = NULL;
@@ -245,7 +254,9 @@ struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
 	int xsize, ysize, zsize;
 	int bpp, rle, cur, badorder;
 	ImBuf * ibuf;
-	
+
+	if(!imb_is_a_iris(mem)) return NULL;
+
 	/*printf("new iris\n");*/
 	
 	file_data = mem;
@@ -277,8 +288,8 @@ struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
 	if (rle) {
 		
 		tablen = ysize*zsize*sizeof(int);
-		starttab = (unsigned int *)malloc(tablen);
-		lengthtab = (unsigned int *)malloc(tablen);
+		starttab = (unsigned int *)MEM_mallocN(tablen, "iris starttab");
+		lengthtab = (unsigned int *)MEM_mallocN(tablen, "iris endtab");
 		file_offset = 512;
 		
 		readtab(inf,starttab,tablen);
@@ -379,8 +390,8 @@ struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
 			}
 		}
 		
-		free(starttab);
-		free(lengthtab);	
+		MEM_freeN(starttab);
+		MEM_freeN(lengthtab);	
 
 	} else {
 		if (bpp == 1) {
@@ -495,7 +506,6 @@ struct ImBuf *imb_loadiris(unsigned char *mem, int flags)
 
 	ibuf->ftype = IMAGIC;
 	ibuf->profile = IB_PROFILE_SRGB;
-	if (flags & IB_ttob) IMB_flipy(ibuf);
 	
 	test_endian_zbuf(ibuf);
 	
@@ -661,12 +671,12 @@ static int output_iris(unsigned int *lptr, int xsize, int ysize, int zsize, char
 
 	tablen = ysize*zsize*sizeof(int);
 
-	image = (IMAGE *)malloc(sizeof(IMAGE));
-	starttab = (unsigned int *)malloc(tablen);
-	lengthtab = (unsigned int *)malloc(tablen);
+	image = (IMAGE *)MEM_mallocN(sizeof(IMAGE), "iris image");
+	starttab = (unsigned int *)MEM_mallocN(tablen, "iris starttab");
+	lengthtab = (unsigned int *)MEM_mallocN(tablen, "iris lengthtab");
 	rlebuflen = 1.05*xsize+10;
-	rlebuf = (unsigned char *)malloc(rlebuflen);
-	lumbuf = (unsigned int *)malloc(xsize*sizeof(int));
+	rlebuf = (unsigned char *)MEM_mallocN(rlebuflen, "iris rlebuf");
+	lumbuf = (unsigned int *)MEM_mallocN(xsize*sizeof(int), "iris lumbuf");
 
 	memset(image, 0, sizeof(IMAGE));
 	image->imagic = IMAGIC;
@@ -715,11 +725,11 @@ static int output_iris(unsigned int *lptr, int xsize, int ysize, int zsize, char
 	fseek(outf,512,SEEK_SET);
 	goodwrite *= writetab(outf,starttab,tablen);
 	goodwrite *= writetab(outf,lengthtab,tablen);
-	free(image);
-	free(starttab);
-	free(lengthtab);
-	free(rlebuf);
-	free(lumbuf);
+	MEM_freeN(image);
+	MEM_freeN(starttab);
+	MEM_freeN(lengthtab);
+	MEM_freeN(rlebuf);
+	MEM_freeN(lumbuf);
 	fclose(outf);
 	if(goodwrite)
 		return 1;
@@ -799,7 +809,7 @@ static int compressrow(unsigned char *lbuf, unsigned char *rlebuf, int z, int cn
 	return optr - (unsigned char *)rlebuf;
 }
 
-short imb_saveiris(struct ImBuf * ibuf, char *name, int flags)
+int imb_saveiris(struct ImBuf * ibuf, char *name, int flags)
 {
 	short zsize;
 	int ret;
diff --git a/source/blender/imbuf/intern/jp2.c b/source/blender/imbuf/intern/jp2.c
index d45b023fe0a..9d045aff3bf 100644
--- a/source/blender/imbuf/intern/jp2.c
+++ b/source/blender/imbuf/intern/jp2.c
@@ -26,12 +26,11 @@
 #include "BLI_blenlib.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 #include "IMB_allocimbuf.h"
-#include "IMB_jp2.h"
+#include "IMB_filetype.h"
 
 #include "openjpeg.h"
 
@@ -58,7 +57,7 @@ static int checkj2p(unsigned char *mem) /* J2K_CFMT */
 	return memcmp(JP2_HEAD, mem, 12) ? 0 : 1;
 }
 
-int imb_is_a_jp2(void *buf)
+int imb_is_a_jp2(unsigned char *buf)
 {	
 	return checkj2p(buf);
 }
@@ -642,7 +641,7 @@ static opj_image_t* ibuftoimage(ImBuf *ibuf, opj_cparameters_t *parameters) {
 
 
 /* Found write info at http://users.ece.gatech.edu/~slabaugh/personal/c/bitmapUnix.c */
-short imb_savejp2(struct ImBuf *ibuf, char *name, int flags) {
+int imb_savejp2(struct ImBuf *ibuf, char *name, int flags) {
 	
 	int quality = ibuf->ftype & 0xff;
 	
diff --git a/source/blender/imbuf/intern/jpeg.c b/source/blender/imbuf/intern/jpeg.c
index 127145c967d..3803aa9a8b2 100644
--- a/source/blender/imbuf/intern/jpeg.c
+++ b/source/blender/imbuf/intern/jpeg.c
@@ -34,17 +34,24 @@
 #include <stdio.h>
 #include <setjmp.h>
 
+#include "MEM_guardedalloc.h"
+
 #include "BLI_blenlib.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
-#include "IMB_imginfo.h"
-#include "IMB_jpeg.h"
+#include "IMB_metadata.h"
+#include "IMB_filetype.h"
 #include "jpeglib.h" 
 #include "jerror.h"
 
+#define IS_jpg(x)		(x->ftype & JPG)
+#define IS_stdjpg(x)	((x->ftype & JPG_MSK) == JPG_STD)
+#define IS_vidjpg(x)	((x->ftype & JPG_MSK) == JPG_VID)
+#define IS_jstjpg(x)	((x->ftype & JPG_MSK) == JPG_JST)
+#define IS_maxjpg(x)	((x->ftype & JPG_MSK) == JPG_MAX)
+
 /* the types are from the jpeg lib */
 static void jpeg_error (j_common_ptr cinfo);
 static void init_source(j_decompress_ptr cinfo);
@@ -297,11 +304,7 @@ static ImBuf * ibJpegImageFromCinfo(struct jpeg_decompress_struct * cinfo, int f
 			
 			for (y = ibuf->y - 1; y >= 0; y--) {
 				jpeg_read_scanlines(cinfo, row_pointer, 1);
-				if (flags & IB_ttob) {
-					rect = (uchar *) (ibuf->rect + (ibuf->y - 1 - y) * ibuf->x);
-				} else {
-					rect = (uchar *) (ibuf->rect + y * ibuf->x);
-				}
+				rect = (uchar *) (ibuf->rect + y * ibuf->x);
 				buffer = row_pointer[0];
 				
 				switch(depth) {
@@ -378,8 +381,8 @@ static ImBuf * ibJpegImageFromCinfo(struct jpeg_decompress_struct * cinfo, int f
 					 * the information when we write
 					 * it back to disk.
 					 */
-					IMB_imginfo_add_field(ibuf, "None", (char *) marker->data);
-					ibuf->flags |= IB_imginfo;
+					IMB_metadata_add_field(ibuf, "None", (char *) marker->data);
+					ibuf->flags |= IB_metadata;
 					goto next_stamp_marker;
 				}
 
@@ -404,8 +407,8 @@ static ImBuf * ibJpegImageFromCinfo(struct jpeg_decompress_struct * cinfo, int f
 
 				*value = '\0'; /* need finish the key string */
 				value++;
-				IMB_imginfo_add_field(ibuf, key, value);
-				ibuf->flags |= IB_imginfo;
+				IMB_metadata_add_field(ibuf, key, value);
+				ibuf->flags |= IB_metadata;
 				MEM_freeN(str);
 next_stamp_marker:
 				marker= marker->next;
@@ -453,11 +456,13 @@ ImBuf * imb_ibJpegImageFromFilename (const char * filename, int flags)
 	return(ibuf);
 }
 
-ImBuf * imb_ibJpegImageFromMemory (unsigned char * buffer, int size, int flags)
+ImBuf * imb_load_jpeg (unsigned char * buffer, int size, int flags)
 {
 	struct jpeg_decompress_struct _cinfo, *cinfo = &_cinfo;
 	struct my_error_mgr jerr;
 	ImBuf * ibuf;
+
+	if(!imb_is_a_jpeg(buffer)) return NULL;
 	
 	cinfo->err = jpeg_std_error(&jerr.pub);
 	jerr.pub.error_exit = jpeg_error;
@@ -487,7 +492,7 @@ static void write_jpeg(struct jpeg_compress_struct * cinfo, struct ImBuf * ibuf)
 	uchar * rect;
 	int x, y;
 	char neogeo[128];
-	ImgInfo *iptr;
+	ImMetaData *iptr;
 	char *text;
 
 	jpeg_start_compress(cinfo, TRUE);
@@ -498,10 +503,10 @@ static void write_jpeg(struct jpeg_compress_struct * cinfo, struct ImBuf * ibuf)
 	memcpy(neogeo + 6, &ibuf_ftype, 4);
 	jpeg_write_marker(cinfo, 0xe1, (JOCTET*) neogeo, 10);
 
-	if(ibuf->img_info) {
+	if(ibuf->metadata) {
 		/* key + max value + "Blender" */
 		text= MEM_mallocN(530, "stamp info read");
-		iptr= ibuf->img_info;
+		iptr= ibuf->metadata;
 		while(iptr) {
 			if (!strcmp (iptr->key, "None")) {
 				jpeg_write_marker(cinfo, JPEG_COM, (JOCTET *) iptr->value, strlen (iptr->value) + 1);
@@ -526,9 +531,9 @@ next_stamp_info:
 	}
 
 	row_pointer[0] =
-		mallocstruct(JSAMPLE,
+		MEM_mallocN(sizeof(JSAMPLE) *
 					 cinfo->input_components *
-					 cinfo->image_width);
+					 cinfo->image_width, "jpeg row_pointer");
 
 	for(y = ibuf->y - 1; y >= 0; y--){
 		rect = (uchar *) (ibuf->rect + y * ibuf->x);
@@ -561,7 +566,7 @@ next_stamp_info:
 	}
 
 	jpeg_finish_compress(cinfo);
-	free(row_pointer[0]);
+	MEM_freeN(row_pointer[0]);
 }
 
 
@@ -580,7 +585,7 @@ static int init_jpeg(FILE * outfile, struct jpeg_compress_struct * cinfo, struct
 	cinfo->image_height = ibuf->y;
 
 	cinfo->in_color_space = JCS_RGB;
-	if (ibuf->depth == 8 && ibuf->cmap == 0) cinfo->in_color_space = JCS_GRAYSCALE;
+	if (ibuf->depth == 8) cinfo->in_color_space = JCS_GRAYSCALE;
 	if (ibuf->depth == 32) cinfo->in_color_space = JCS_UNKNOWN;
 	
 	switch(cinfo->in_color_space){
diff --git a/source/blender/imbuf/intern/matrix.h b/source/blender/imbuf/intern/matrix.h
deleted file mode 100644
index 79b9b2dbc14..00000000000
--- a/source/blender/imbuf/intern/matrix.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/**
- * matrix.c
- *
- * $Id$
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-/* rgbyuv is identiek aan rgbbeta */
-
-float rgbyuv[4][4]={				/* afgeleid uit videoframer = Y Cr Cb in kopieen van Francois*/
-									/* is identriek aan matrix van jpeg */
-		{ .50000,	.11400,		-.08131,	0.0,},	/* b */
-		{-.33126,	.58700,		-.41869,	0.0,},	/* g */
-		{-.16874,	.29900,		 .50000,	0.0,},	/* r */
-		{  128.0,	0.0,		128.0,		1.0}};
-		  
-		/* b-y (u)	y	r-y (v)  */
-
-
-float rgbbeta[4][4]={				/* afgeleid uit videoframer = Y Cr Cb in kopieen van Francois*/
-									/* is identriek aan matrix van jpeg */
-		{.50000,	.11400,		-.08131,	0.0,},	/* b-y	-> b */
-		{-.33126,	.58700,		-.41869,	0.0,},	/* y	-> g */
-		{-.16874,	.29900,		 .50000,	0.0,},	/* r-y	-> r */
-		{  128.0,	0.0,		128.0,		1.0}};
-		  
-		/* b-y		y	r-y	*/
-
-
-
-float yuvrgb[4][4]={
-	{1.77200,	-0.34414,		0.0,		0.0, },
-	{1.0,		 1.0,			1.0,		0.0, },
-	{0.0,		-0.71414,		1.40200,	0.0, },
-	{-226.816,	135.460,		-179.456,	1.0}};
-
-float rgb_to_bw[4][4]={
-		 {.299,	.299,	.299,	0.0,},
-		 {.587,	.587,	.587,	0.0,},
-		 {.114,	.114,	.114,	0.0,},
-		 { 0.5,	 0.5,	 0.5,	1.0}};
-
-float dyuvrgb_oud[4][4]={
-		{1.0 ,	1.0 ,	1.0,	0.0,},
-		{1.733,	-0.337,	0.0,	0.0,},
-		{0.0,	-.698,	1.371,	0.0,},
-		{-221.8,	132.47, -175.5,	1.0}};
-
-float dyuvrgb[4][4]={
-		{1.164 ,	1.164 ,	1.164,	0.0,},
-		{2.018,	-0.391,	0.0,	0.0,},
-		{0.0,	-0.813,	1.596,	0.0,},
-		{-276.7,	135.6, -222.7,	1.0}};
-
-float rgbdyuv[4][4]={
-		{0.439,	0.098,	-0.071,	0.0,},
-		{-0.291,	0.504,	-0.368,	0.0,},
-		{-0.148,	0.257,	0.439,	0.0,},
-		{128.0,	16.0,	128.0,	1.0}};
-
diff --git a/source/blender/imbuf/intern/imginfo.c b/source/blender/imbuf/intern/metadata.c
index 4101045b45e..66fe1089aea 100644
--- a/source/blender/imbuf/intern/imginfo.c
+++ b/source/blender/imbuf/intern/metadata.c
@@ -1,5 +1,5 @@
 /**
- * $Id$ 
+ * $Id: metadata.c 28209 2010-04-15 15:49:48Z blendix $ 
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
@@ -36,22 +36,22 @@
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
-#include "IMB_imginfo.h"
+#include "IMB_metadata.h"
 
 
 
-void IMB_imginfo_free(struct ImBuf* img)
+void IMB_metadata_free(struct ImBuf* img)
 {
-	ImgInfo *info;
+	ImMetaData *info;
 
 	if (!img)
 		return;
-	if (!img->img_info) {
+	if (!img->metadata) {
 		return;
 	}
-	info = img->img_info;
+	info = img->metadata;
 	while (info) {
-		ImgInfo* next = info->next;
+		ImMetaData* next = info->next;
 		MEM_freeN(info->key);
 		MEM_freeN(info->value);
 		MEM_freeN(info);
@@ -59,17 +59,17 @@ void IMB_imginfo_free(struct ImBuf* img)
 	}
 }
 
-int IMB_imginfo_get_field(struct ImBuf* img, const char* key, char* field, int len)
+int IMB_metadata_get_field(struct ImBuf* img, const char* key, char* field, int len)
 {
-	ImgInfo *info;
+	ImMetaData *info;
 	int retval = 0;
 
 	if (!img)
 		return 0;
-	if (!img->img_info) {
+	if (!img->metadata) {
 		return 0;
 	}
-	info = img->img_info;
+	info = img->metadata;
 	while (info) {
 		if (strcmp(key, info->key) == 0) {
 			BLI_strncpy(field, info->value, len);
@@ -81,25 +81,25 @@ int IMB_imginfo_get_field(struct ImBuf* img, const char* key, char* field, int l
 	return retval;
 }
 
-int IMB_imginfo_add_field(struct ImBuf* img, const char* key, const char* field)
+int IMB_metadata_add_field(struct ImBuf* img, const char* key, const char* field)
 {
-	ImgInfo *info;
-	ImgInfo *last;
+	ImMetaData *info;
+	ImMetaData *last;
 
 	if (!img)
 		return 0;
 
-	if (!img->img_info) {
-		img->img_info = MEM_callocN(sizeof(ImgInfo), "ImgInfo");
-		info = img->img_info;
+	if (!img->metadata) {
+		img->metadata = MEM_callocN(sizeof(ImMetaData), "ImMetaData");
+		info = img->metadata;
 	} else {
-		info = img->img_info;
+		info = img->metadata;
 		last = info;
 		while (info) {
 			last = info;
 			info = info->next;
 		}
-		info = MEM_callocN(sizeof(ImgInfo), "ImgInfo");
+		info = MEM_callocN(sizeof(ImMetaData), "ImMetaData");
 		last->next = info;
 	}
 	info->key = BLI_strdup(key);
@@ -107,21 +107,21 @@ int IMB_imginfo_add_field(struct ImBuf* img, const char* key, const char* field)
 	return 1;
 }
 
-int IMB_imginfo_del_field(struct ImBuf *img, const char *key)
+int IMB_metadata_del_field(struct ImBuf *img, const char *key)
 {
-	ImgInfo *p, *p1;
+	ImMetaData *p, *p1;
 
-	if ((!img) || (!img->img_info))
+	if ((!img) || (!img->metadata))
 		return (0);
 
-	p = img->img_info;
+	p = img->metadata;
 	p1 = NULL;
 	while (p) {
 		if (!strcmp (key, p->key)) {
 			if (p1)
 				p1->next = p->next;
 			else
-				img->img_info = p->next;
+				img->metadata = p->next;
 
 			MEM_freeN(p->key);
 			MEM_freeN(p->value);
@@ -134,17 +134,17 @@ int IMB_imginfo_del_field(struct ImBuf *img, const char *key)
 	return (0);
 }
 
-int IMB_imginfo_change_field(struct ImBuf *img, const char *key, const char *field)
+int IMB_metadata_change_field(struct ImBuf *img, const char *key, const char *field)
 {
-	ImgInfo *p;
+	ImMetaData *p;
 
 	if (!img)
 		return (0);
 
-	if (!img->img_info)
-		return (IMB_imginfo_add_field (img, key, field));
+	if (!img->metadata)
+		return (IMB_metadata_add_field (img, key, field));
 
-	p = img->img_info;
+	p = img->metadata;
 	while (p) {
 		if (!strcmp (key, p->key)) {
 			MEM_freeN (p->value);
@@ -154,5 +154,6 @@ int IMB_imginfo_change_field(struct ImBuf *img, const char *key, const char *fie
 		p = p->next;
 	}
 
-	return (IMB_imginfo_add_field (img, key, field));
+	return (IMB_metadata_add_field (img, key, field));
 }
+
diff --git a/source/blender/imbuf/intern/IMB_ham.h b/source/blender/imbuf/intern/module.c
index d455f9b519a..5438066d164 100644
--- a/source/blender/imbuf/intern/IMB_ham.h
+++ b/source/blender/imbuf/intern/module.c
@@ -1,6 +1,4 @@
 /*
- * IMB_ham.h
- *
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
@@ -19,27 +17,24 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
+ * Contributor(s): Blender Foundation, 2010.
  *
  * ***** END GPL LICENSE BLOCK *****
  */
-/**
- * \file IMB_ham.h
- * \ingroup imbuf
- * \brief Function declarations for ham.c
- */
-
-#ifndef IMB_HAM_H
-#define IMB_HAM_H
 
-struct ImBuf;
+#include "IMB_imbuf.h"
+#include "IMB_filetype.h"
 
-short imb_converttoham(struct ImBuf *ibuf);
+void IMB_init(void)
+{
+	imb_filetypes_init();
+	imb_tile_cache_init();
+}
 
-#endif
+void IMB_exit(void)
+{
+	IMB_free_cache_limiter();
+	imb_tile_cache_exit();
+	imb_filetypes_exit();
+}
 
diff --git a/source/blender/imbuf/intern/openexr/openexr_api.cpp b/source/blender/imbuf/intern/openexr/openexr_api.cpp
index c9859f8d5bd..72d2dd01ffe 100644
--- a/source/blender/imbuf/intern/openexr/openexr_api.cpp
+++ b/source/blender/imbuf/intern/openexr/openexr_api.cpp
@@ -50,6 +50,7 @@ _CRTIMP void __cdecl _invalid_parameter_noinfo(void)
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 #include "IMB_allocimbuf.h"
+#include "IMB_metadata.h"
 
 #include "openexr_multi.h"
 }
@@ -177,7 +178,15 @@ static void openexr_header_compression(Header *header, int compression)
 	}
 }
 
-static short imb_save_openexr_half(struct ImBuf *ibuf, char *name, int flags)
+static void openexr_header_metadata(Header *header, struct ImBuf *ibuf)
+{
+	ImMetaData* info;
+
+	for(info= ibuf->metadata; info; info= info->next)
+		header->insert(info->key, StringAttribute(info->value));
+}
+
+static int imb_save_openexr_half(struct ImBuf *ibuf, char *name, int flags)
 {
 	int channels = ibuf->channels;
 	int width = ibuf->x;
@@ -189,6 +198,7 @@ static short imb_save_openexr_half(struct ImBuf *ibuf, char *name, int flags)
 		Header header (width, height);
 		
 		openexr_header_compression(&header, ibuf->ftype & OPENEXR_COMPRESS);
+		openexr_header_metadata(&header, ibuf);
 		
 		header.channels().insert ("R", Channel (HALF));
 		header.channels().insert ("G", Channel (HALF));
@@ -269,7 +279,7 @@ static short imb_save_openexr_half(struct ImBuf *ibuf, char *name, int flags)
 	return (1);
 }
 
-static short imb_save_openexr_float(struct ImBuf *ibuf, char *name, int flags)
+static int imb_save_openexr_float(struct ImBuf *ibuf, char *name, int flags)
 {
 	int channels = ibuf->channels;
 	int width = ibuf->x;
@@ -281,6 +291,7 @@ static short imb_save_openexr_float(struct ImBuf *ibuf, char *name, int flags)
 		Header header (width, height);
 		
 		openexr_header_compression(&header, ibuf->ftype & OPENEXR_COMPRESS);
+		openexr_header_metadata(&header, ibuf);
 		
 		header.channels().insert ("R", Channel (FLOAT));
 		header.channels().insert ("G", Channel (FLOAT));
@@ -326,7 +337,7 @@ static short imb_save_openexr_float(struct ImBuf *ibuf, char *name, int flags)
 }
 
 
-short imb_save_openexr(struct ImBuf *ibuf, char *name, int flags)
+int imb_save_openexr(struct ImBuf *ibuf, char *name, int flags)
 {
 	if (flags & IB_mem) 
 	{
@@ -435,6 +446,7 @@ void IMB_exr_add_channel(void *handle, const char *layname, const char *passname
 	BLI_addtail(&data->channels, echan);
 }
 
+/* only used for writing temp. render results (not image files) */
 void IMB_exr_begin_write(void *handle, char *filename, int width, int height, int compress)
 {
 	ExrHandle *data= (ExrHandle *)handle;
@@ -448,6 +460,7 @@ void IMB_exr_begin_write(void *handle, char *filename, int width, int height, in
 		header.channels().insert (echan->name, Channel (FLOAT));
 	
 	openexr_header_compression(&header, compress);
+	// openexr_header_metadata(&header, ibuf); // no imbuf. cant write
 	/* header.lineOrder() = DECREASING_Y; this crashes in windows for file read! */
 	
 	header.insert ("BlenderMultiChannel", StringAttribute ("Blender V2.43 and newer"));
@@ -575,7 +588,12 @@ void IMB_exr_write_channels(void *handle)
 													echan->xstride*sizeof(float), echan->ystride*sizeof(float)));
 		
 		data->ofile->setFrameBuffer (frameBuffer);
-		data->ofile->writePixels (data->height);	
+		try {
+			data->ofile->writePixels (data->height);	
+		}
+		catch (const std::exception &exc) {
+			std::cerr << "OpenEXR-writePixels: ERROR: " << exc.what() << std::endl;
+		}
 	}
 	else {
 		printf("Error: attempt to save MultiLayer without layers.\n");
@@ -598,7 +616,13 @@ void IMB_exr_read_channels(void *handle)
 	}
 	
 	data->ifile->setFrameBuffer (frameBuffer);
-	data->ifile->readPixels (0, data->height-1);	
+
+	try {
+		data->ifile->readPixels (0, data->height-1);	
+	}
+	catch (const std::exception &exc) {
+		std::cerr << "OpenEXR-readPixels: ERROR: " << exc.what() << std::endl;
+	}
 }
 
 void IMB_exr_multilayer_convert(void *handle, void *base,  
diff --git a/source/blender/imbuf/intern/openexr/openexr_api.h b/source/blender/imbuf/intern/openexr/openexr_api.h
index a6892dcbaed..c23b47d1480 100644
--- a/source/blender/imbuf/intern/openexr/openexr_api.h
+++ b/source/blender/imbuf/intern/openexr/openexr_api.h
@@ -46,7 +46,7 @@ extern "C" {
   
 int		imb_is_a_openexr			(unsigned char *mem);
 	
-short	imb_save_openexr			(struct ImBuf *ibuf, char *name, int flags);
+int		imb_save_openexr			(struct ImBuf *ibuf, char *name, int flags);
 
 struct ImBuf *imb_load_openexr		(unsigned char *mem, int size, int flags);
 
diff --git a/source/blender/imbuf/intern/png.c b/source/blender/imbuf/intern/png.c
index 2dafa043da6..68a3324816c 100644
--- a/source/blender/imbuf/intern/png.c
+++ b/source/blender/imbuf/intern/png.c
@@ -33,15 +33,13 @@
 #include "BLI_blenlib.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
 #include "IMB_allocimbuf.h"
-#include "IMB_cmap.h"
-#include "IMB_imginfo.h"
-#include "IMB_png.h"
+#include "IMB_metadata.h"
+#include "IMB_filetype.h"
 
 typedef struct PNGReadStruct {
 	unsigned char *data;
@@ -53,7 +51,7 @@ static void ReadData( png_structp png_ptr, png_bytep data, png_size_t length);
 static void WriteData( png_structp png_ptr, png_bytep data, png_size_t length);
 static void Flush( png_structp png_ptr);
 
-int imb_is_a_png(void *mem)
+int imb_is_a_png(unsigned char *mem)
 {
 	int ret_val = 0;
 
@@ -94,7 +92,7 @@ static void ReadData( png_structp png_ptr, png_bytep data, png_size_t length)
 	longjmp(png_jmpbuf(png_ptr), 1);
 }
 
-short imb_savepng(struct ImBuf *ibuf, char *name, int flags)
+int imb_savepng(struct ImBuf *ibuf, char *name, int flags)
 {
 	png_structp png_ptr;
 	png_infop info_ptr;
@@ -219,30 +217,30 @@ short imb_savepng(struct ImBuf *ibuf, char *name, int flags)
 		 PNG_FILTER_TYPE_DEFAULT);
 
 	/* image text info */
-	if (ibuf->img_info) {
-		png_text*  imginfo;
-		ImgInfo* iptr;
+	if (ibuf->metadata) {
+		png_text*  metadata;
+		ImMetaData* iptr;
 		int  num_text = 0;
-		iptr = ibuf->img_info;
+		iptr = ibuf->metadata;
 		while (iptr) {
 			num_text++;
 			iptr = iptr->next;
 		}
 		
-		imginfo = MEM_callocN(num_text*sizeof(png_text), "png_imginfo");
-		iptr = ibuf->img_info;
+		metadata = MEM_callocN(num_text*sizeof(png_text), "png_metadata");
+		iptr = ibuf->metadata;
 		num_text = 0;
 		while (iptr) {
 			
-			imginfo[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
-			imginfo[num_text].key = iptr->key;
-			imginfo[num_text].text = iptr->value;
+			metadata[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+			metadata[num_text].key = iptr->key;
+			metadata[num_text].text = iptr->value;
 			num_text++;
 			iptr = iptr->next;
 		}
 		
-		png_set_text(png_ptr, info_ptr, imginfo, num_text);
-		MEM_freeN(imginfo);
+		png_set_text(png_ptr, info_ptr, metadata, num_text);
+		MEM_freeN(metadata);
 
 	}
 
@@ -437,12 +435,12 @@ struct ImBuf *imb_loadpng(unsigned char *mem, int size, int flags)
 			break;
 		}
 
-		if (flags & IB_imginfo) {
+		if (flags & IB_metadata) {
 			png_text* text_chunks;
 			int count = png_get_text(png_ptr, info_ptr, &text_chunks, NULL);
 			for(i = 0; i < count; i++) {
-				IMB_imginfo_add_field(ibuf, text_chunks[i].key, text_chunks[i].text);
-				ibuf->flags |= IB_imginfo;				
+				IMB_metadata_add_field(ibuf, text_chunks[i].key, text_chunks[i].text);
+				ibuf->flags |= IB_metadata;				
 			 }
 		}
 
diff --git a/source/blender/imbuf/intern/radiance_hdr.c b/source/blender/imbuf/intern/radiance_hdr.c
index 9ad28abeae4..dabb6780ea3 100644
--- a/source/blender/imbuf/intern/radiance_hdr.c
+++ b/source/blender/imbuf/intern/radiance_hdr.c
@@ -43,14 +43,12 @@
 #include "BLI_blenlib.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
 #include "IMB_allocimbuf.h"
-#include "IMB_cmap.h"
-#include "IMB_radiance_hdr.h"
+#include "IMB_filetype.h"
 
 /* needed constants */
 #define MINELEN 8
@@ -160,7 +158,7 @@ static void FLOAT2RGBE(fCOLOR fcol, RGBE rgbe)
 
 /* ImBuf read */
 
-int imb_is_a_hdr(void *buf)
+int imb_is_a_hdr(unsigned char *buf)
 {
 	// For recognition, Blender only loads first 32 bytes, so use #?RADIANCE id instead
 	// update: actually, the 'RADIANCE' part is just an optional program name, the magic word is really only the '#?' part
@@ -205,7 +203,6 @@ struct ImBuf *imb_loadhdr(unsigned char *mem, int size, int flags)
 			if (ibuf==NULL) return NULL;
 			ibuf->ftype = RADHDR;
 			ibuf->profile = IB_PROFILE_LINEAR_RGB;
-			ibuf->xorig = ibuf->yorig = 0;
 
 			if (flags & IB_test) return ibuf;
 
@@ -331,7 +328,7 @@ static void writeHeader(FILE *file, int width, int height)
 	fputc(10, file);
 }
 
-short imb_savehdr(struct ImBuf *ibuf, char *name, int flags)
+int imb_savehdr(struct ImBuf *ibuf, char *name, int flags)
 {
 	FILE* file = fopen(name, "wb");
 	float *fp= NULL;
diff --git a/source/blender/imbuf/intern/readimage.c b/source/blender/imbuf/intern/readimage.c
index c23daacb919..3f4e177c78b 100644
--- a/source/blender/imbuf/intern/readimage.c
+++ b/source/blender/imbuf/intern/readimage.c
@@ -42,275 +42,159 @@
 #include "BLI_blenlib.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
+#include "IMB_filetype.h"
 
-#include "IMB_amiga.h"
-#include "IMB_iris.h"
-#include "IMB_targa.h"
-#include "IMB_png.h"
-#include "IMB_hamx.h"
-#include "IMB_jpeg.h"
-#include "IMB_bmp.h"
-#include "IMB_radiance_hdr.h"
-#include "IMB_dpxcineon.h"
-#include "BKE_global.h"
-
-#if defined(__APPLE__) && defined(IMBUF_COCOA)
-#include "IMB_cocoa.h"
-#else
-#include "IMB_tiff.h"
-#endif
-
-#ifdef WITH_OPENJPEG
-#include "IMB_jp2.h"
-#endif
-
-#ifdef WITH_OPENEXR
-#include "openexr/openexr_api.h"
-#endif
-
-#ifdef WITH_DDS
-#include "dds/dds_api.h"
-#endif
+ImBuf *IMB_ibImageFromMemory(unsigned char *mem, int size, int flags)
+{
+	ImBuf *ibuf;
+	ImFileType *type;
 
-#ifdef WITH_QUICKTIME
-#if defined(_WIN32) || defined (__APPLE__)
-#include "quicktime_import.h"
-#endif
-#endif
-
-/* actually hard coded endianness */
-#define GET_BIG_LONG(x) (((uchar *) (x))[0] << 24 | ((uchar *) (x))[1] << 16 | ((uchar *) (x))[2] << 8 | ((uchar *) (x))[3])
-#define GET_LITTLE_LONG(x) (((uchar *) (x))[3] << 24 | ((uchar *) (x))[2] << 16 | ((uchar *) (x))[1] << 8 | ((uchar *) (x))[0])
-#define SWAP_L(x) (((x << 24) & 0xff000000) | ((x << 8) & 0xff0000) | ((x >> 8) & 0xff00) | ((x >> 24) & 0xff))
-#define SWAP_S(x) (((x << 8) & 0xff00) | ((x >> 8) & 0xff))
-
-/* more endianness... should move to a separate file... */
-#if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined(__hppa__) || defined (__BIG_ENDIAN__)
-#define GET_ID GET_BIG_LONG
-#define LITTLE_LONG SWAP_LONG
-#else
-#define GET_ID GET_LITTLE_LONG
-#define LITTLE_LONG ENDIAN_NOP
-#endif
-
-/* from misc_util: flip the bytes from x  */
-#define GS(x) (((unsigned char *)(x))[0] << 8 | ((unsigned char *)(x))[1])
-
-/* this one is only def-ed once, strangely... */
-#define GSS(x) (((uchar *)(x))[1] << 8 | ((uchar *)(x))[0])
-
-int IB_verbose = TRUE;
+	if(mem == NULL) {
+		printf("Error in ibImageFromMemory: NULL pointer\n");
+		return NULL;
+	}
 
-ImBuf *IMB_ibImageFromMemory(int *mem, int size, int flags) {
-	int len;
-	struct ImBuf *ibuf;
+	for(type=IMB_FILE_TYPES; type->is_a; type++) {
+		if(type->load) {
+			ibuf= type->load(mem, size, flags);
+			if(ibuf) {
+				if(flags & IB_premul) {
+					IMB_premultiply_alpha(ibuf);
+					ibuf->flags |= IB_premul;
+				}
 
-	if (mem == NULL) {
-		printf("Error in ibImageFromMemory: NULL pointer\n");
-	} else {
-		if ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC)){
-			return (imb_loadiris((uchar *) mem, flags));
-		} else if (imb_is_a_jpeg((uchar *)mem)) {
-			return (imb_ibJpegImageFromMemory((uchar *)mem, size, flags));
-		}
-		
-		if (GET_ID(mem) == CAT){
-			mem += 3;
-			size -= 4;
-			while (size > 0){
-				if (GET_ID(mem) == FORM){
-					len = ((GET_BIG_LONG(mem+1) + 1) & ~1) + 8;
-					if ((GET_ID(mem+2) == ILBM) || (GET_ID(mem+2) == ANIM)) break;
-					mem = (int *)((uchar *)mem +len);
-					size -= len;
-				} else return(0);
+				return ibuf;
 			}
 		}
+	}
+
+	fprintf(stderr, "Unknown fileformat\n");
 	
-		if (size > 0){
-			if (GET_ID(mem) == FORM){
-				if (GET_ID(mem+2) == ILBM){
-					return (imb_loadamiga(mem, flags));
-				} else if (GET_ID(mem+5) == ILBM){			/* animaties */
-					return (imb_loadamiga(mem+3, flags));
-				} else if (GET_ID(mem+2) == ANIM){
-					return (imb_loadanim(mem, flags));
-				}
-			}
-		}
+	return NULL;
+}
 
-		ibuf = imb_loadpng((uchar *)mem, size, flags);
-		if (ibuf) return(ibuf);
+ImBuf *IMB_loadifffile(int file, int flags)
+{
+	ImBuf *ibuf;
+	unsigned char *mem;
+	int size;
 
-		ibuf = imb_bmp_decode((uchar *)mem, size, flags);
-		if (ibuf) return(ibuf);
+	if(file == -1) return 0;
 
-		ibuf = imb_loadtarga((uchar *)mem, size, flags);
-		if (ibuf) return(ibuf);
+	size= BLI_filesize(file);
 
-		ibuf = imb_loaddpx((uchar *)mem, size, flags);
-		if (ibuf) return(ibuf);
+	mem= mmap(0, size, PROT_READ, MAP_SHARED, file, 0);
+	if(mem==(unsigned char*)-1) {
+		fprintf(stderr, "Couldn't get mapping\n");
+		return 0;
+	}
 
-		ibuf = imb_loadcineon((uchar *)mem, size, flags);
-		if (ibuf) return(ibuf);
-	
-#if defined(__APPLE__) && defined(IMBUF_COCOA)
-		ibuf = imb_cocoaLoadImage((uchar *)mem, size, flags);
-		if(ibuf) {
-			ibuf->ftype = TIF;
-			ibuf->profile = IB_PROFILE_SRGB;
-			return ibuf;
-		}
-#else
-		if (G.have_libtiff) {
-			ibuf = imb_loadtiff((uchar *)mem, size, flags);
-			if (ibuf) return(ibuf);
-		}
-#endif
-		
-		ibuf = imb_loadhdr((uchar*)mem, size, flags);
-		if (ibuf) return (ibuf);
+	ibuf= IMB_ibImageFromMemory(mem, size, flags);
 
-#ifdef WITH_OPENEXR
-		ibuf = imb_load_openexr((uchar *)mem, size, flags);
-		if (ibuf) return (ibuf);
-#endif
+	if(munmap(mem, size))
+		fprintf(stderr, "Couldn't unmap file.\n");
 
-#ifdef WITH_OPENJPEG
-		ibuf = imb_jp2_decode((uchar *)mem, size, flags);
-		if (ibuf) return (ibuf);
-#endif
+	return ibuf;
+}
 
-#ifdef WITH_DDS
-		ibuf = imb_load_dds((uchar *)mem, size, flags);
-		if (ibuf) return (ibuf);
-#endif
-	
-#ifdef WITH_QUICKTIME
-#if defined(_WIN32) || defined (__APPLE__)
-		if(G.have_quicktime) {
-			ibuf = imb_quicktime_decode((uchar *)mem, size, flags);
-			if (ibuf) return(ibuf);
-		}
-#endif
-#endif	
+static void imb_cache_filename(char *filename, const char *name, int flags)
+{
+	/* read .tx instead if it exists and is not older */
+	if(flags & IB_tilecache) {
+		BLI_strncpy(filename, name, IB_FILENAME_SIZE);
+		if(!BLI_replace_extension(filename, IB_FILENAME_SIZE, ".tx"))
+			return;
 
-		if (IB_verbose) fprintf(stderr, "Unknown fileformat\n");
+		if(BLI_file_older(name, filename))
+			return;
 	}
-	
-	return (0);
+
+	BLI_strncpy(filename, name, IB_FILENAME_SIZE);
 }
 
+ImBuf *IMB_loadiffname(const char *name, int flags)
+{
+	ImBuf *ibuf;
+	int file, a;
+	char filename[IB_FILENAME_SIZE];
 
-struct ImBuf *IMB_loadiffmem(int *mem, int flags) {
-	int len,maxlen;
-	struct ImBuf *ibuf;
+	imb_cache_filename(filename, name, flags);
 
-	// IMB_loadiffmem shouldn't be used anymore in new development
-	// it's still here to be backwards compatible...
+	file = open(filename, O_BINARY|O_RDONLY);
+	if(file < 0) return 0;
 
-	maxlen= (GET_BIG_LONG(mem+1) + 1) & ~1;
+	ibuf= IMB_loadifffile(file, flags);
 
-	if (GET_ID(mem) == CAT){
-		mem += 3;
-		maxlen -= 4;
-		while(maxlen > 0){
-			if (GET_ID(mem) == FORM){
-				len = ((GET_BIG_LONG(mem+1) + 1) & ~1) + 8;
-				if ((GET_ID(mem+2) == ILBM) || (GET_ID(mem+2) == ANIM)) break;
-				 mem = (int *)((uchar *)mem +len);
-				maxlen -= len;
-			} else return(0);
-		}
+	if(ibuf) {
+		BLI_strncpy(ibuf->name, name, sizeof(ibuf->name));
+		BLI_strncpy(ibuf->cachename, filename, sizeof(ibuf->cachename));
+		for(a=1; a<ibuf->miptot; a++)
+			BLI_strncpy(ibuf->mipmap[a-1]->cachename, filename, sizeof(ibuf->cachename));
+		if(flags & IB_fields) IMB_de_interlace(ibuf);
 	}
 
-	if (maxlen > 0){
-		if (GET_ID(mem) == FORM){
-			if (GET_ID(mem+2) == ILBM){
-				return (imb_loadamiga(mem, flags));
-			} else if (GET_ID(mem+5) == ILBM){			/* animaties */
-				return (imb_loadamiga(mem+3, flags));
-			} else if (GET_ID(mem+2) == ANIM){
-				return (imb_loadanim(mem, flags));
-			}
-		} else if ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC)){
-			return (imb_loadiris((uchar *) mem,flags));
-		} else if ((BIG_LONG(mem[0]) & 0xfffffff0) == 0xffd8ffe0) {
-			return (0);
-		}
-	}
-
-	ibuf = imb_loadtarga((uchar *) mem,maxlen,flags);
-	if (ibuf) return(ibuf);
+	close(file);
 
-	if (IB_verbose) fprintf(stderr,"Unknown fileformat\n");
-	return (0);
+	return ibuf;
 }
 
-struct ImBuf *IMB_loadifffile(int file, int flags) {
-	struct ImBuf *ibuf;
-	int size, *mem;
+ImBuf *IMB_testiffname(char *name, int flags)
+{
+	ImBuf *ibuf;
+	int file;
+	char filename[IB_FILENAME_SIZE];
 
-	if (file == -1) return (0);
+	imb_cache_filename(filename, name, flags);
 
-	size = BLI_filesize(file);
+	file = open(filename,O_BINARY|O_RDONLY);
+	if(file < 0) return 0;
 
-	mem= (int *)mmap(0,size,PROT_READ,MAP_SHARED,file,0);
-	if (mem==(int *)-1){
-		printf("Couldn't get mapping\n");
-		return (0);
+	ibuf=IMB_loadifffile(file, flags|IB_test);
+	if(ibuf) {
+		BLI_strncpy(ibuf->name, name, sizeof(ibuf->name));
+		BLI_strncpy(ibuf->cachename, filename, sizeof(ibuf->cachename));
 	}
 
-	ibuf = IMB_ibImageFromMemory(mem, size, flags);
+	close(file);
 
-	if (munmap( (void *) mem, size)){
-		printf("Couldn't unmap file.\n");
-	}
-	return(ibuf);
+	return ibuf;
 }
 
+static void imb_loadtilefile(ImBuf *ibuf, int file, int tx, int ty, unsigned int *rect)
+{
+	ImFileType *type;
+	unsigned char *mem;
+	int size;
 
-struct ImBuf *IMB_loadiffname(const char *naam, int flags) {
-	int file;
-	struct ImBuf *ibuf;
-	int buf[1];
-
-	file = open(naam, O_BINARY|O_RDONLY);
-
-	if (file < 0) return (0);
+	if(file == -1) return;
 
-	ibuf= IMB_loadifffile(file, flags);
+	size= BLI_filesize(file);
 
-	if (ibuf == NULL) {
-		if (read(file, buf, 4) != 4) buf[0] = 0;
-		if ((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
-			ibuf = imb_ibJpegImageFromFilename(naam, flags);			
+	mem= mmap(0, size, PROT_READ, MAP_SHARED, file, 0);
+	if(mem==(unsigned char*)-1) {
+		fprintf(stderr, "Couldn't get memory mapping for %s\n", ibuf->cachename);
+		return;
 	}
 
-	if (ibuf) {
-		strncpy(ibuf->name, naam, sizeof(ibuf->name));
-		if (flags & IB_fields) IMB_de_interlace(ibuf);
-	}
-	close(file);
-	return(ibuf);
+	for(type=IMB_FILE_TYPES; type->is_a; type++)
+		if(type->load_tile && type->ftype(type, ibuf))
+			type->load_tile(ibuf, mem, size, tx, ty, rect);
+
+	if(munmap(mem, size))
+		fprintf(stderr, "Couldn't unmap memory for %s.\n", ibuf->cachename);
 }
 
-struct ImBuf *IMB_testiffname(char *naam,int flags) {
+void imb_loadtile(ImBuf *ibuf, int tx, int ty, unsigned int *rect)
+{
 	int file;
-	struct ImBuf *ibuf;
 
-	flags |= IB_test;
-	file = open(naam,O_BINARY|O_RDONLY);
+	file = open(ibuf->cachename, O_BINARY|O_RDONLY);
+	if(file < 0) return;
 
-	if (file < 0) return (0);
+	imb_loadtilefile(ibuf, file, tx, ty, rect);
 
-	ibuf=IMB_loadifffile(file,flags);
-	if (ibuf) {
-		strncpy(ibuf->name, naam, sizeof(ibuf->name));
-	}
 	close(file);
-	return(ibuf);
 }
+
diff --git a/source/blender/imbuf/intern/rectop.c b/source/blender/imbuf/intern/rectop.c
index 3202413a494..53385743bb8 100644
--- a/source/blender/imbuf/intern/rectop.c
+++ b/source/blender/imbuf/intern/rectop.c
@@ -32,7 +32,6 @@
 #include "BLI_blenlib.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
diff --git a/source/blender/imbuf/intern/rotate.c b/source/blender/imbuf/intern/rotate.c
index 2369c83bbd3..e0e52bb7094 100644
--- a/source/blender/imbuf/intern/rotate.c
+++ b/source/blender/imbuf/intern/rotate.c
@@ -33,7 +33,6 @@
 #include  "BKE_utildefines.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
diff --git a/source/blender/imbuf/intern/scaling.c b/source/blender/imbuf/intern/scaling.c
index b3e25b52140..335e16402f9 100644
--- a/source/blender/imbuf/intern/scaling.c
+++ b/source/blender/imbuf/intern/scaling.c
@@ -32,7 +32,6 @@
 #include "BLI_blenlib.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
@@ -347,142 +346,6 @@ struct ImBuf *IMB_onehalf(struct ImBuf *ibuf1)
 }
 
 
-
-struct ImBuf *IMB_onethird(struct ImBuf *ibuf1)
-{
-	struct ImBuf *ibuf2;
-	uchar *p1,*p2,*p3,*dest;
-	float *p1f, *p2f, *p3f, *destf;
-	int do_rect, do_float;
-	short a,r,g,b,x,y,i;
-	float af,rf,gf,bf;
-
-	p2= p3= NULL;
-	p2f= p3f= NULL;
-	if (ibuf1==NULL) return (0);
-	if (ibuf1->rect==NULL && ibuf1->rect_float==NULL) return (0);
-
-	do_rect= (ibuf1->rect != NULL);
-	do_float= (ibuf1->rect_float != NULL);
-
-	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--){
-		if (do_rect) {
-			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--){
-				if (do_rect) {
-					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++);
-				}
-			}
-			if (do_rect) {
-				*(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;
-			}
-		}
-		if (do_rect) p1=p3;
-		if (do_float) p1f = p3f;
-	}
-	return (ibuf2);
-}
-
-
-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_rect, do_float;
-
-	p2= NULL;
-	p2f= NULL;
-	if (ibuf1==NULL) return (0);
-	if (ibuf1->rect==NULL && ibuf1->rect_float==NULL) return (0);
-
-	do_rect= (ibuf1->rect != NULL);
-	do_float= (ibuf1->rect_float != NULL);
-
-	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--){
-		if (do_rect) 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--){
-				if (do_rect) {
-					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++);
-				}
-			}
-			if (do_rect) {
-				*(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;
-			}
-		}
-		if (do_rect) p1 = p2;
-		if (do_float) p1f = p2f;
-	}
-	return (ibuf2);
-}
-
 /* q_scale_linear_interpolation helper functions */
 
 static void enlarge_picture_byte(
@@ -1687,55 +1550,3 @@ struct ImBuf *IMB_scalefastImBuf(struct ImBuf *ibuf, short newx, short newy)
 	return(ibuf);
 }
 
-
-static struct ImBuf *generic_fieldscale(struct ImBuf *ibuf, short newx, short newy, struct ImBuf *(*scalefunc)(ImBuf *, short, short) )
-{
-	struct ImBuf *sbuf1, *sbuf2;
-	
-	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) */
-	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);
-	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) */
-	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;
-	
-	IMB_freeImBuf(sbuf1);
-	IMB_freeImBuf(sbuf2);
-	
-	return(ibuf);
-}
-
-
-struct ImBuf *IMB_scalefastfieldImBuf(struct ImBuf *ibuf, short newx, short newy)
-{
-	return(generic_fieldscale(ibuf, newx, newy, IMB_scalefastImBuf));
-}
-
-struct ImBuf *IMB_scalefieldImBuf(struct ImBuf *ibuf, short newx, short newy)
-{
-	return(generic_fieldscale(ibuf, newx, newy, IMB_scaleImBuf));
-}
-
diff --git a/source/blender/imbuf/intern/targa.c b/source/blender/imbuf/intern/targa.c
index 092c52d427b..3c14189a292 100644
--- a/source/blender/imbuf/intern/targa.c
+++ b/source/blender/imbuf/intern/targa.c
@@ -33,14 +33,12 @@
 #include "BLI_blenlib.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
 #include "IMB_allocimbuf.h"
-#include "IMB_cmap.h"
-#include "IMB_targa.h"
+#include "IMB_filetype.h"
 
 
 /* this one is only def-ed once, strangely... related to GS? */
@@ -234,11 +232,10 @@ static int dumptarga(struct ImBuf * ibuf, FILE * file)
 }
 
 
-short imb_savetarga(struct ImBuf * ibuf, char *name, int flags)
+int imb_savetarga(struct ImBuf * ibuf, char *name, int flags)
 {
 	char buf[20];
 	FILE *fildes;
-	int i;
 	short ok = 0;
 
 	if (ibuf == 0) return (0);
@@ -249,19 +246,7 @@ short imb_savetarga(struct ImBuf * ibuf, char *name, int flags)
 	/* buf[0] = 0;  length string */
 
 	buf[16] = (ibuf->depth + 0x7 ) & ~0x7;
-	if (ibuf->cmap) {
-		buf[1] = 1;
-		buf[2] = 9;
-		buf[3] = ibuf->mincol & 0xff;
-		buf[4] = ibuf->mincol >> 8;
-		buf[5] = ibuf->maxcol & 0xff;
-		buf[6] = ibuf->maxcol >> 8;
-		buf[7] = 24;
-		if ((flags & IB_ttob) == 0) {
-			IMB_flipy(ibuf);
-			buf[17] = 0x20;
-		}
-	} else if (ibuf->depth > 8 ){
+	if (ibuf->depth > 8 ){
 		buf[2] = 10;
 	} else{
 		buf[2] = 11;
@@ -269,18 +254,16 @@ short imb_savetarga(struct ImBuf * ibuf, char *name, int flags)
 
 	if (ibuf->ftype == RAWTGA) buf[2] &= ~8;
 	
-	buf[8] = ibuf->xorig & 0xff;
-	buf[9] = ibuf->xorig >> 8;
-	buf[10] = ibuf->yorig & 0xff;
-	buf[11] = ibuf->yorig >> 8;
+	buf[8] = 0;
+	buf[9] = 0;
+	buf[10] = 0;
+	buf[11] = 0;
 
 	buf[12] = ibuf->x & 0xff;
 	buf[13] = ibuf->x >> 8;
 	buf[14] = ibuf->y & 0xff;
 	buf[15] = ibuf->y >> 8;
 
-	if (flags & IB_ttob) buf[17] ^= 0x20;
-
 	/* Don't forget to indicate that your 32 bit
 	 * targa uses 8 bits for the alpha channel! */
 	if (ibuf->depth==32) {
@@ -294,17 +277,6 @@ short imb_savetarga(struct ImBuf * ibuf, char *name, int flags)
 		return (0);
 	}
 
-	if (ibuf->cmap){
-		for (i = 0 ; i<ibuf->maxcol ; i++){
-			if (fwrite(((uchar *)(ibuf->cmap + i)) + 1,1,3,fildes) != 3) {
-				fclose(fildes);
-				return (0);
-			}
-		}
-	}
-	
-	if (ibuf->cmap && (flags & IB_cmap) == 0) IMB_converttocmap(ibuf);
-	
 	if (ibuf->ftype == RAWTGA) {
 		ok = dumptarga(ibuf, fildes);
 	} else {		
@@ -365,7 +337,7 @@ static int checktarga(TARGA *tga, unsigned char *mem)
 	return(1);
 }
 
-int imb_is_a_targa(void *buf) {
+int imb_is_a_targa(unsigned char *buf) {
 	TARGA tga;
 	
 	return checktarga(&tga, buf);
@@ -559,7 +531,7 @@ struct ImBuf *imb_loadtarga(unsigned char *mem, int mem_size, int flags)
 	TARGA tga;
 	struct ImBuf * ibuf;
 	int col, count, size;
-	unsigned int * rect;
+	unsigned int *rect, *cmap= NULL, mincol= 0, maxcol= 0;
 	uchar * cp = (uchar *) &col;
 	
 	if (checktarga(&tga,mem) == 0) return(0);
@@ -570,19 +542,18 @@ struct ImBuf *imb_loadtarga(unsigned char *mem, int mem_size, int flags)
 	if (ibuf == 0) return(0);
 	ibuf->ftype = TGA;
 	ibuf->profile = IB_PROFILE_SRGB;
-	ibuf->xorig = tga.xorig;
-	ibuf->yorig = tga.yorig;
 	mem = mem + 18 + tga.numid;
 	
 	cp[0] = 0xff;
 	cp[1] = cp[2] = 0;
 	
 	if (tga.mapsize){
-		ibuf->mincol = tga.maporig;
-		ibuf->maxcol = tga.mapsize;
-		imb_addcmapImBuf(ibuf);
-		ibuf->cbits = 8;
-		for (count = 0 ; count < ibuf->maxcol ; count ++) {
+		/* load color map */
+		mincol = tga.maporig;
+		maxcol = tga.mapsize;
+		cmap = MEM_callocN(sizeof(unsigned int)*maxcol, "targa cmap");
+
+		for (count = 0 ; count < maxcol ; count ++) {
 			switch (tga.mapbits >> 3) {
 				case 4:
 					cp[0] = mem[3];
@@ -606,21 +577,24 @@ struct ImBuf *imb_loadtarga(unsigned char *mem, int mem_size, int flags)
 					col = *mem++;
 					break;
 			}
-			ibuf->cmap[count] = col;
+			cmap[count] = col;
 		}
 		
 		size = 0;
-		for (col = ibuf->maxcol - 1; col > 0; col >>= 1) size++;
+		for (col = maxcol - 1; col > 0; col >>= 1) size++;
 		ibuf->depth = size;
 
 		if (tga.mapbits != 32) {	/* set alpha bits  */
-			ibuf->cmap[0] &= BIG_LONG(0x00ffffff);
+			cmap[0] &= BIG_LONG(0x00ffffff);
 		}
 	}
 	
 	if (flags & IB_test) return (ibuf);
 
-	if (tga.imgtyp != 1 && tga.imgtyp != 9) IMB_freecmapImBuf(ibuf); /* happens sometimes (beuh) */
+	if (tga.imgtyp != 1 && tga.imgtyp != 9) { /* happens sometimes (beuh) */
+		MEM_freeN(cmap); 
+		cmap= NULL;
+	}
 
 	switch(tga.imgtyp){
 	case 1:
@@ -641,11 +615,18 @@ struct ImBuf *imb_loadtarga(unsigned char *mem, int mem_size, int flags)
 		break;
 	}
 	
-	if (ibuf->cmap){
-		if ((flags & IB_cmap) == 0) IMB_applycmap(ibuf);
+	if(cmap) {
+		/* apply color map */
+		rect = ibuf->rect;
+		for(size = ibuf->x * ibuf->y; size>0; --size, ++rect) {
+			col = *rect;
+			if (col >= 0 && col < maxcol) *rect = cmap[col];
+		}
+
+		MEM_freeN(cmap);
 	}
 	
-	if (tga.pixsize == 16 && ibuf->cmap == 0){
+	if (tga.pixsize == 16) {
 		rect = ibuf->rect;
 		for (size = ibuf->x * ibuf->y; size > 0; --size, ++rect){
 			col = *rect;
@@ -679,13 +660,10 @@ struct ImBuf *imb_loadtarga(unsigned char *mem, int mem_size, int flags)
 		}
 	}
 	
-	if (flags & IB_ttob) tga.imgdes ^= 0x20;
 	if (tga.imgdes & 0x20) IMB_flipy(ibuf);
 
-	if (ibuf) {
-		if (ibuf->rect && (flags & IB_cmap)==0) 
-			IMB_convert_rgba_to_abgr(ibuf);
-	}
+	if (ibuf && ibuf->rect)
+		IMB_convert_rgba_to_abgr(ibuf);
 	
 	return(ibuf);
 }
diff --git a/source/blender/imbuf/intern/thumbs.c b/source/blender/imbuf/intern/thumbs.c
index 5e0504155dc..45fbf49dbbd 100644
--- a/source/blender/imbuf/intern/thumbs.c
+++ b/source/blender/imbuf/intern/thumbs.c
@@ -37,7 +37,7 @@
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 #include "IMB_thumbs.h"
-#include "IMB_imginfo.h"
+#include "IMB_metadata.h"
 
 #include "md5.h"
 
@@ -282,11 +282,11 @@ ImBuf* IMB_thumb_create(const char* path, ThumbSize size, ThumbSource source)
 			return NULL;
 		}
 		if (size == THB_FAIL) {
-			img = IMB_allocImBuf(0,0,32, IB_rect | IB_imginfo, 0);
+			img = IMB_allocImBuf(0,0,32, IB_rect | IB_metadata, 0);
 			if (!img) return 0;
 		} else {
 			if (THB_SOURCE_IMAGE == source) {
-				img = IMB_loadiffname(path, IB_rect | IB_imginfo);
+				img = IMB_loadiffname(path, IB_rect | IB_metadata);
 				if (img != NULL) {
 					stat(path, &info);
 					sprintf(mtime, "%ld", info.st_mtime);
@@ -295,7 +295,7 @@ ImBuf* IMB_thumb_create(const char* path, ThumbSize size, ThumbSource source)
 				}
 			} else if (THB_SOURCE_MOVIE == source) {
 				struct anim * anim = NULL;
-				anim = IMB_open_anim(path, IB_rect | IB_imginfo);
+				anim = IMB_open_anim(path, IB_rect | IB_metadata);
 				if (anim != NULL) {
 					img = IMB_anim_absolute(anim, 0);
 					if (img == NULL) {
@@ -325,17 +325,17 @@ ImBuf* IMB_thumb_create(const char* path, ThumbSize size, ThumbSource source)
 			IMB_scaleImBuf(img, ex, ey);
 		}
 		sprintf(desc, "Thumbnail for %s", uri);
-		IMB_imginfo_change_field(img, "Description", desc);
-		IMB_imginfo_change_field(img, "Software", "Blender");
-		IMB_imginfo_change_field(img, "Thumb::URI", uri);
-		IMB_imginfo_change_field(img, "Thumb::MTime", mtime);
+		IMB_metadata_change_field(img, "Description", desc);
+		IMB_metadata_change_field(img, "Software", "Blender");
+		IMB_metadata_change_field(img, "Thumb::URI", uri);
+		IMB_metadata_change_field(img, "Thumb::MTime", mtime);
 		if (THB_SOURCE_IMAGE == source) {
-			IMB_imginfo_change_field(img, "Thumb::Image::Width", cwidth);
-			IMB_imginfo_change_field(img, "Thumb::Image::Height", cheight);
+			IMB_metadata_change_field(img, "Thumb::Image::Width", cwidth);
+			IMB_metadata_change_field(img, "Thumb::Image::Height", cheight);
 		}
 		img->ftype = PNG;
 		img->depth = 32;		
-		if (IMB_saveiff(img, temp, IB_rect | IB_imginfo)) {
+		if (IMB_saveiff(img, temp, IB_rect | IB_metadata)) {
 #ifndef WIN32
 			chmod(temp, S_IRUSR | S_IWUSR);
 #endif
@@ -358,7 +358,7 @@ ImBuf* IMB_thumb_read(const char* path, ThumbSize size)
 		return NULL;
 	}
 	if (thumbpath_from_uri(uri, thumb, size)) {		
-		img = IMB_loadiffname(thumb, IB_rect | IB_imginfo);
+		img = IMB_loadiffname(thumb, IB_rect | IB_metadata);
 	}
 
 	return img;
@@ -409,10 +409,10 @@ ImBuf* IMB_thumb_manage(const char* path, ThumbSize size, ThumbSource source)
 		if (strncmp(path, thumb, strlen(thumb)) == 0) {
 			img = IMB_loadiffname(path, IB_rect);
 		} else {
-			img = IMB_loadiffname(thumb, IB_rect | IB_imginfo);
+			img = IMB_loadiffname(thumb, IB_rect | IB_metadata);
 			if (img) {
 				char mtime[40];
-				if (!IMB_imginfo_get_field(img, "Thumb::MTime", mtime, 40)) {
+				if (!IMB_metadata_get_field(img, "Thumb::MTime", mtime, 40)) {
 					/* illegal thumb, forget it! */
 					IMB_freeImBuf(img);
 					img = 0;
diff --git a/source/blender/imbuf/intern/tiff.c b/source/blender/imbuf/intern/tiff.c
index dd18c77c5c6..e7309eefb56 100644
--- a/source/blender/imbuf/intern/tiff.c
+++ b/source/blender/imbuf/intern/tiff.c
@@ -43,16 +43,17 @@
 #include <string.h>
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 
 #include "BKE_global.h"
 
+#include "BLI_string.h"
+
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
 #include "IMB_allocimbuf.h"
-#include "IMB_cmap.h"
-#include "IMB_tiff.h"
+#include "IMB_filetype.h"
+#include "IMB_filter.h"
 
 #include "dynlibtiff.h"
 
@@ -72,12 +73,12 @@ static void    imb_tiff_DummyUnmapProc(thandle_t fd, tdata_t base, toff_t size);
 
 
 /* Structure for in-memory TIFF file. */
-struct ImbTIFFMemFile {
+typedef struct ImbTIFFMemFile {
 	unsigned char *mem;	/* Location of first byte of TIFF file. */
 	toff_t offset;		/* Current offset within the file.      */
 	tsize_t size;		/* Size of the TIFF file.               */
-};
-#define IMB_TIFF_GET_MEMFILE(x) ((struct ImbTIFFMemFile*)(x));
+} ImbTIFFMemFile;
+#define IMB_TIFF_GET_MEMFILE(x) ((ImbTIFFMemFile*)(x));
 
 
 
@@ -108,28 +109,28 @@ static int imb_tiff_DummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
 static tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n)
 {
 	tsize_t nRemaining, nCopy;
-	struct ImbTIFFMemFile* mfile;
+	ImbTIFFMemFile* mfile;
 	void *srcAddr;
 
 	/* get the pointer to the in-memory file */
 	mfile = IMB_TIFF_GET_MEMFILE(handle);
-	if (!mfile || !mfile->mem) {
+	if(!mfile || !mfile->mem) {
 		fprintf(stderr, "imb_tiff_ReadProc: !mfile || !mfile->mem!\n");
 		return 0;
 	}
 
 	/* find the actual number of bytes to read (copy) */
 	nCopy = n;
-	if ((tsize_t)mfile->offset >= mfile->size)
+	if((tsize_t)mfile->offset >= mfile->size)
 		nRemaining = 0;
 	else
 		nRemaining = mfile->size - mfile->offset;
 	
-	if (nCopy > nRemaining)
+	if(nCopy > nRemaining)
 		nCopy = nRemaining;
 	
 	/* on EOF, return immediately and read (copy) nothing */
-	if (nCopy <= 0)
+	if(nCopy <= 0)
 		return (0);
 
 	/* all set -> do the read (copy) */
@@ -171,12 +172,12 @@ static tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n)
  */
 static toff_t imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence)
 {
-	struct ImbTIFFMemFile *mfile;
+	ImbTIFFMemFile *mfile;
 	toff_t new_offset;
 
 	/* get the pointer to the in-memory file */
 	mfile = IMB_TIFF_GET_MEMFILE(handle);
-	if (!mfile || !mfile->mem) {
+	if(!mfile || !mfile->mem) {
 		fprintf(stderr, "imb_tiff_SeekProc: !mfile || !mfile->mem!\n");
 		return (-1);
 	}
@@ -218,11 +219,11 @@ static toff_t imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence)
  */
 static int imb_tiff_CloseProc(thandle_t handle)
 {
-	struct ImbTIFFMemFile *mfile;
+	ImbTIFFMemFile *mfile;
 
 	/* get the pointer to the in-memory file */
 	mfile = IMB_TIFF_GET_MEMFILE(handle);
-	if (!mfile || !mfile->mem) {
+	if(!mfile || !mfile->mem) {
 		fprintf(stderr,"imb_tiff_CloseProc: !mfile || !mfile->mem!\n");
 		return (0);
 	}
@@ -244,11 +245,11 @@ static int imb_tiff_CloseProc(thandle_t handle)
  */
 static toff_t imb_tiff_SizeProc(thandle_t handle)
 {
-	struct ImbTIFFMemFile* mfile;
+	ImbTIFFMemFile* mfile;
 
 	/* get the pointer to the in-memory file */
 	mfile = IMB_TIFF_GET_MEMFILE(handle);
-	if (!mfile || !mfile->mem) {
+	if(!mfile || !mfile->mem) {
 		fprintf(stderr,"imb_tiff_SizeProc: !mfile || !mfile->mem!\n");
 		return (0);
 	}
@@ -257,14 +258,23 @@ static toff_t imb_tiff_SizeProc(thandle_t handle)
 	return (toff_t)(mfile->size);
 }
 
+static TIFF *imb_tiff_client_open(ImbTIFFMemFile *memFile, unsigned char *mem, int size)
+{
+	/* open the TIFF client layer interface to the in-memory file */
+	memFile->mem = mem;
+	memFile->offset = 0;
+	memFile->size = size;
 
+	return libtiff_TIFFClientOpen("(Blender TIFF Interface Layer)", 
+		"r", (thandle_t)(memFile),
+		imb_tiff_ReadProc, imb_tiff_WriteProc,
+		imb_tiff_SeekProc, imb_tiff_CloseProc,
+		imb_tiff_SizeProc, imb_tiff_DummyMapProc, imb_tiff_DummyUnmapProc);
+}
 
 /**
  * Checks whether a given memory buffer contains a TIFF file.
  *
- * FIXME: Possible memory leak if mem is less than IMB_TIFF_NCB bytes long.
- *        However, changing this will require up-stream modifications.
- *
  * This method uses the format identifiers from:
  *     http://www.faqs.org/faqs/graphics/fileformats-faq/part4/section-9.html
  * The first four bytes of big-endian and little-endian TIFF files
@@ -278,7 +288,7 @@ static toff_t imb_tiff_SizeProc(thandle_t handle)
  * hence my manual comparison. - Jonathan Merritt (lancelet) 4th Sept 2005.
  */
 #define IMB_TIFF_NCB 4		/* number of comparison bytes used */
-int imb_is_a_tiff(void *mem)
+int imb_is_a_tiff(unsigned char *mem)
 {
 	char big_endian[IMB_TIFF_NCB] = { 0x4d, 0x4d, 0x00, 0x2a };
 	char lil_endian[IMB_TIFF_NCB] = { 0x49, 0x49, 0x2a, 0x00 };
@@ -287,7 +297,31 @@ int imb_is_a_tiff(void *mem)
 		 (memcmp(lil_endian, mem, IMB_TIFF_NCB) == 0) );
 }
 
+static int imb_read_tiff_pixels(ImBuf *ibuf, TIFF *image, int premul)
+{
+	ImBuf *tmpibuf;
+	int success;
+
+	tmpibuf= IMB_allocImBuf(ibuf->x, ibuf->y, 32, IB_rect, 0);
+	success= libtiff_TIFFReadRGBAImage(image, ibuf->x, ibuf->y, tmpibuf->rect, 0);
+
+	if(ENDIAN_ORDER == B_ENDIAN)
+		IMB_convert_rgba_to_abgr(tmpibuf);
+	if(premul) {
+		IMB_premultiply_alpha(tmpibuf);
+		ibuf->flags |= IB_premul;
+	}
+
+	/* assign rect last */
+	ibuf->rect= tmpibuf->rect;
+	ibuf->mall |= IB_rect;
+	ibuf->flags |= IB_rect;
 
+	tmpibuf->mall &= ~IB_rect;
+	IMB_freeImBuf(tmpibuf);
+
+	return success;
+}
 
 /**
  * Loads a TIFF file.
@@ -303,52 +337,42 @@ int imb_is_a_tiff(void *mem)
  *
  * @return: A newly allocated ImBuf structure if successful, otherwise NULL.
  */
-struct ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags)
+ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags)
 {
 	TIFF *image = NULL;
-	struct ImBuf *ibuf = NULL;
-	struct ImbTIFFMemFile memFile;
+	ImBuf *ibuf = NULL, *hbuf;
+	ImbTIFFMemFile memFile;
 	uint32 width, height;
-	int bytesperpixel, bitspersample;
-	int success;
-	unsigned int pixel_i, byte_i;
-	uint32 *raster = NULL;
-	uint32 pixel;
-	unsigned char *to = NULL;
+	char *format = NULL;
+	int level;
 
-	memFile.mem = mem;
-	memFile.offset = 0;
-	memFile.size = size;
+	if(!G.have_libtiff)
+		return NULL;
 
 	/* check whether or not we have a TIFF file */
-	if (size < IMB_TIFF_NCB) {
+	if(size < IMB_TIFF_NCB) {
 		fprintf(stderr, "imb_loadtiff: size < IMB_TIFF_NCB\n");
 		return NULL;
 	}
-	if (imb_is_a_tiff(mem) == 0)
+	if(imb_is_a_tiff(mem) == 0)
 		return NULL;
 
-	/* open the TIFF client layer interface to the in-memory file */
-	image = libtiff_TIFFClientOpen("(Blender TIFF Interface Layer)", 
-		"r", (thandle_t)(&memFile),
-		imb_tiff_ReadProc, imb_tiff_WriteProc,
-		imb_tiff_SeekProc, imb_tiff_CloseProc,
-		imb_tiff_SizeProc, imb_tiff_DummyMapProc, imb_tiff_DummyUnmapProc);
-	if (image == NULL) {
+	image = imb_tiff_client_open(&memFile, mem, size);
+
+	if(image == NULL) {
 		printf("imb_loadtiff: could not open TIFF IO layer.\n");
 		return NULL;
 	}
 
 	/* allocate the image buffer */
-	bytesperpixel = 4;  /* 1 byte per channel, 4 channels */
 	libtiff_TIFFGetField(image, TIFFTAG_IMAGEWIDTH,  &width);
 	libtiff_TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
-	libtiff_TIFFGetField(image, TIFFTAG_BITSPERSAMPLE, &bitspersample);
-	ibuf = IMB_allocImBuf(width, height, 8*bytesperpixel, 0, 0);
-	if (ibuf) {
+	ibuf = IMB_allocImBuf(width, height, 32, 0, 0);
+	if(ibuf) {
 		ibuf->ftype = TIF;
 		ibuf->profile = IB_PROFILE_SRGB;
-	} else {
+	}
+	else {
 		fprintf(stderr, 
 			"imb_loadtiff: could not allocate memory for TIFF " \
 			"image.\n");
@@ -356,65 +380,109 @@ struct ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags)
 		return NULL;
 	}
 
-	/* read in the image data */
-	if (!(flags & IB_test)) {
+	/* if testing, we're done */
+	if(flags & IB_test) {
+		libtiff_TIFFClose(image);
+		return ibuf;
+	}
 
-		/* allocate memory for the ibuf->rect */
-		imb_addrectImBuf(ibuf);
+	/* detect if we are reading a tiled/mipmapped texture, in that case
+	   we don't read pixels but leave it to the cache to load tiles */
+	if(flags & IB_tilecache) {
+		format= NULL;
+		libtiff_TIFFGetField(image, TIFFTAG_PIXAR_TEXTUREFORMAT, &format);
 
-		/* perform actual read */
-		raster = (uint32*)libtiff__TIFFmalloc(
-				width*height * sizeof(uint32));
-		if (raster == NULL) {
-			libtiff_TIFFClose(image);
-			return NULL;
-		}
-		success = libtiff_TIFFReadRGBAImage(
-				image, width, height, raster, 0);
-		if (!success) {
-			fprintf(stderr,
-				"imb_loadtiff: This TIFF format is not " 
-				"currently supported by Blender.\n");
-			libtiff__TIFFfree(raster);
-			libtiff_TIFFClose(image);
-			return NULL;
-		}
+		if(format && strcmp(format, "Plain Texture")==0 && libtiff_TIFFIsTiled(image)) {
+			int numlevel = libtiff_TIFFNumberOfDirectories(image);
 
-		/* copy raster to ibuf->rect; we do a fast copy if possible,
-		 * otherwise revert to a slower component-wise copy */
-		if (sizeof(unsigned int) == sizeof(uint32)) {
-			memcpy(ibuf->rect, raster, 
-				width*height*sizeof(uint32));
-		} else {
-			/* this may not be entirely necessary, but is put here
-			 * in case sizeof(unsigned int) is not a 32-bit
-			 * quantity */
-			fprintf(stderr,
-				"imb_loadtiff: using (slower) component-wise "
-				"buffer copy.\n");
-			to = (unsigned char*)ibuf->rect;
-			for (pixel_i=0; pixel_i < width*height; pixel_i++)
-			{	
-				byte_i = sizeof(unsigned int)*pixel_i;
-				pixel = raster[pixel_i];
-	
-				to[byte_i++] = (unsigned char)TIFFGetR(pixel);
-				to[byte_i++] = (unsigned char)TIFFGetG(pixel);
-				to[byte_i++] = (unsigned char)TIFFGetB(pixel);
-				to[byte_i++] = (unsigned char)TIFFGetA(pixel);
+			/* create empty mipmap levels in advance */
+			for(level=0; level<numlevel; level++) {
+				if(!libtiff_TIFFSetDirectory(image, level))
+					break;
+
+				if(level > 0) {
+					width= (width > 1)? width/2: 1;
+					height= (height > 1)? height/2: 1;
+
+					hbuf= IMB_allocImBuf(width, height, 32, 0, 0);
+					hbuf->miplevel= level;
+					hbuf->flags |= IB_tilecache;
+					hbuf->ftype= ibuf->ftype;
+					ibuf->mipmap[level-1] = hbuf;
+
+					if(flags & IB_premul)
+						hbuf->flags |= IB_premul;
+				}
+				else
+					hbuf= ibuf;
+
+				libtiff_TIFFGetField(image, TIFFTAG_TILEWIDTH, &hbuf->tilex);
+				libtiff_TIFFGetField(image, TIFFTAG_TILELENGTH, &hbuf->tiley);
+
+				hbuf->xtiles= ceil(hbuf->x/(float)hbuf->tilex);
+				hbuf->ytiles= ceil(hbuf->y/(float)hbuf->tiley);
+
+				imb_addtilesImBuf(hbuf);
+
+				ibuf->miptot++;
 			}
 		}
+	}
 
-		libtiff__TIFFfree(raster);
+	/* read pixels */
+	if(!(ibuf->flags & IB_tilecache) && !imb_read_tiff_pixels(ibuf, image, 0)) {
+		fprintf(stderr, "imb_loadtiff: Failed to read tiff image.\n");
+		libtiff_TIFFClose(image);
+		return NULL;
 	}
 
 	/* close the client layer interface to the in-memory file */
 	libtiff_TIFFClose(image);
 
-	if (ENDIAN_ORDER == B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf);
-
 	/* return successfully */
-	return (ibuf);
+	return ibuf;
+}
+
+void imb_loadtiletiff(ImBuf *ibuf, unsigned char *mem, int size, int tx, int ty, unsigned int *rect)
+{
+	TIFF *image = NULL;
+	uint32 width, height;
+	ImbTIFFMemFile memFile;
+
+	image = imb_tiff_client_open(&memFile, mem, size);
+
+	if(image == NULL) {
+		printf("imb_loadtiff: could not open TIFF IO layer for loading mipmap level.\n");
+		return;
+	}
+
+   	if(libtiff_TIFFSetDirectory(image, ibuf->miplevel)) {
+		/* allocate the image buffer */
+		libtiff_TIFFGetField(image, TIFFTAG_IMAGEWIDTH,  &width);
+		libtiff_TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
+
+		if(width == ibuf->x && height == ibuf->y) {
+			if(rect) {
+				/* tiff pixels are bottom to top, tiles are top to bottom */
+				if(libtiff_TIFFReadRGBATile(image, tx*ibuf->tilex, (ibuf->ytiles - 1 - ty)*ibuf->tiley, rect) == 1) {
+					if(ibuf->tiley > ibuf->y)
+						memmove(rect, rect+ibuf->tilex*(ibuf->tiley - ibuf->y), sizeof(int)*ibuf->tilex*ibuf->y);
+
+					if(ibuf->flags & IB_premul)
+						IMB_premultiply_rect(rect, 32, ibuf->tilex, ibuf->tiley);
+				}
+				else
+					printf("imb_loadtiff: failed to read tiff tile at mipmap level %d\n", ibuf->miplevel);
+			}
+		}
+		else
+			printf("imb_loadtiff: mipmap level %d has unexpected size %dx%d instead of %dx%d\n", ibuf->miplevel, width, height, ibuf->x, ibuf->y);
+	}
+	else
+		printf("imb_loadtiff: could not find mipmap level %d\n", ibuf->miplevel);
+
+	/* close the client layer interface to the in-memory file */
+	libtiff_TIFFClose(image);
 }
 
 /**
@@ -435,7 +503,7 @@ struct ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags)
 
 #define FTOUSHORT(val) ((val >= 1.0f-0.5f/65535)? 65535: (val <= 0.0f)? 0: (unsigned short)(val*65535.0f + 0.5f))
 
-short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
+int imb_savetiff(ImBuf *ibuf, char *name, int flags)
 {
 	TIFF *image = NULL;
 	uint16 samplesperpixel, bitspersample;
@@ -446,12 +514,17 @@ short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
 	float *fromf = NULL;
 	int x, y, from_i, to_i, i;
 	int extraSampleTypes[1] = { EXTRASAMPLE_ASSOCALPHA };
+	
+	if(!G.have_libtiff) {
+		fprintf(stderr, "imb_savetiff: no tiff library available.\n");
+		return (0);
+	}
 
 	/* check for a valid number of bytes per pixel.  Like the PNG writer,
 	 * the TIFF writer supports 1, 3 or 4 bytes per pixel, corresponding
 	 * to gray, RGB, RGBA respectively. */
 	samplesperpixel = (uint16)((ibuf->depth + 7) >> 3);
-	if ((samplesperpixel > 4) || (samplesperpixel == 2)) {
+	if((samplesperpixel > 4) || (samplesperpixel == 2)) {
 		fprintf(stderr,
 			"imb_savetiff: unsupported number of bytes per " 
 			"pixel: %d\n", samplesperpixel);
@@ -464,17 +537,18 @@ short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
 		bitspersample = 8;
 
 	/* open TIFF file for writing */
-	if (flags & IB_mem) {
+	if(flags & IB_mem) {
 		/* bork at the creation of a TIFF in memory */
 		fprintf(stderr,
 			"imb_savetiff: creation of in-memory TIFF files is " 
 			"not yet supported.\n");
 		return (0);
-	} else {
+	}
+	else {
 		/* create image as a file */
 		image = libtiff_TIFFOpen(name, "w");
 	}
-	if (image == NULL) {
+	if(image == NULL) {
 		fprintf(stderr,
 			"imb_savetiff: could not open TIFF for writing.\n");
 		return (0);
@@ -489,7 +563,7 @@ short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
 		pixels = (unsigned char*)libtiff__TIFFmalloc(npixels *
 			samplesperpixel * sizeof(unsigned char));
 
-	if (pixels == NULL && pixels16 == NULL) {
+	if(pixels == NULL && pixels16 == NULL) {
 		fprintf(stderr,
 			"imb_savetiff: could not allocate pixels array.\n");
 		libtiff_TIFFClose(image);
@@ -529,17 +603,17 @@ short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
 	}
 
 	/* copy pixel data.  While copying, we flip the image vertically. */
-	for (x = 0; x < ibuf->x; x++) {
-		for (y = 0; y < ibuf->y; y++) {
+	for(x = 0; x < ibuf->x; x++) {
+		for(y = 0; y < ibuf->y; y++) {
 			from_i = 4*(y*ibuf->x+x);
 			to_i   = samplesperpixel*((ibuf->y-y-1)*ibuf->x+x);
 
 			if(pixels16) {
-				for (i = 0; i < samplesperpixel; i++, to_i++, from_i++)
+				for(i = 0; i < samplesperpixel; i++, to_i++, from_i++)
 					to16[to_i] = FTOUSHORT(fromf[from_i]);
 			}
 			else {
-				for (i = 0; i < samplesperpixel; i++, to_i++, from_i++)
+				for(i = 0; i < samplesperpixel; i++, to_i++, from_i++)
 					to[to_i] = from[from_i];
 			}
 		}
@@ -555,7 +629,7 @@ short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
 	libtiff_TIFFSetField(image, TIFFTAG_XRESOLUTION,     150.0);
 	libtiff_TIFFSetField(image, TIFFTAG_YRESOLUTION,     150.0);
 	libtiff_TIFFSetField(image, TIFFTAG_RESOLUTIONUNIT,  RESUNIT_INCH);
-	if (libtiff_TIFFWriteEncodedStrip(image, 0,
+	if(libtiff_TIFFWriteEncodedStrip(image, 0,
 			(bitspersample == 16)? (unsigned char*)pixels16: pixels,
 			ibuf->x*ibuf->y*samplesperpixel*bitspersample/8) == -1) {
 		fprintf(stderr,
diff --git a/source/blender/imbuf/intern/util.c b/source/blender/imbuf/intern/util.c
index b1ca414434f..aff05b4eaff 100644
--- a/source/blender/imbuf/intern/util.c
+++ b/source/blender/imbuf/intern/util.c
@@ -42,36 +42,16 @@
 #include "BKE_global.h"
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
-
-#include "IMB_targa.h"
-#include "IMB_png.h"
-
-#ifdef WITH_DDS
-#include "dds/dds_api.h"
-#endif
-
-#include "IMB_bmp.h"
-#include "IMB_tiff.h"
-#include "IMB_radiance_hdr.h"
-#include "IMB_dpxcineon.h"
+#include "IMB_filetype.h"
 
 #include "IMB_anim.h"
 
-#ifdef WITH_OPENEXR
-#include "openexr/openexr_api.h"
-#endif
-
 #ifdef WITH_QUICKTIME
 #include "quicktime_import.h"
 #endif
 
-#ifdef WITH_OPENJPEG
-#include "IMB_jp2.h"
-#endif
-
 #ifdef WITH_FFMPEG
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
@@ -88,90 +68,46 @@
 
 #define UTIL_DEBUG 0
 
-/* from misc_util: flip the bytes from x  */
-#define GS(x) (((unsigned char *)(x))[0] << 8 | ((unsigned char *)(x))[1])
-
-/* this one is only def-ed once, strangely... */
-#define GSS(x) (((uchar *)(x))[1] << 8 | ((uchar *)(x))[0])
-
 static int IMB_ispic_name(char *name)
 {
+	ImFileType *type;
 	struct stat st;
 	int fp, buf[10];
-	int ofs = 0;
 
 	if(UTIL_DEBUG) printf("IMB_ispic_name: loading %s\n", name);
 	
-	if (ib_stat(name,&st) == -1) return(0);
-	if (((st.st_mode) & S_IFMT) == S_IFREG){
-		if ((fp = open(name,O_BINARY|O_RDONLY)) >= 0){
-			if (read(fp,buf,32)==32){
-				close(fp);
-				if (buf[ofs] == CAT) ofs += 3;
-				if (buf[ofs] == FORM){
-					if (buf[ofs + 2] == ILBM) return(AMI);
-					if (buf[ofs + 2] == ANIM){
-						if (buf[ofs + 3] == FORM){
-							return(ANIM);
-						}else{
-							return(Anim);
-						}
-					}
-				} else {
-					if (GS(buf) == IMAGIC) return(IMAGIC);
-					if (GSS(buf) == IMAGIC) return(IMAGIC);
-					if ((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0) return(JPG);
-
-					/* at windows there are ".ffl" files with the same magic numnber... 
-					   besides that,  tim images are not really important anymore! */
-					/* if ((BIG_LONG(buf[0]) == 0x10000000) && ((BIG_LONG(buf[1]) & 0xf0ffffff) == 0)) return(TIM); */
-
-				}
-				if (imb_is_a_png(buf)) return(PNG);
-#ifdef WITH_DDS
-				if (imb_is_a_dds((uchar *)buf)) return(DDS);
-#endif
-				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);
-				if (imb_is_dpx(buf)) return (DPX);
-				if (imb_is_cineon(buf)) return(CINEON);
-				/* radhdr: check if hdr format */
-				if (imb_is_a_hdr(buf)) return(RADHDR);
-
-/*
-				if (imb_is_a_bmp(buf)) return(BMP);
-*/
-				
-#ifdef WITH_OPENJPEG
-				if (imb_is_a_jp2(buf)) return(JP2);
-#endif
-				
-#ifdef WITH_QUICKTIME
-#if defined(_WIN32) || defined(__APPLE__)
-				if(G.have_quicktime) {
-					if (imb_is_a_quicktime(name)) return(QUICKTIME);
-				}
-#endif
-#endif
+	if(stat(name,&st) == -1)
+		return FALSE;
+	if(((st.st_mode) & S_IFMT) != S_IFREG)
+		return FALSE;
 
-				return(FALSE);
-			}
-			close(fp);
-		}
+	if((fp = open(name,O_BINARY|O_RDONLY)) < 0)
+		return FALSE;
+
+	if(read(fp, buf, 32) != 32) {
+		close(fp);
+		return FALSE;
 	}
-	return(FALSE);
-}
 
+	close(fp);
+
+	/* XXX move this exception */
+	if((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
+		return JPG;
 
+	for(type=IMB_FILE_TYPES; type->is_a; type++)
+		if(type->is_a((uchar*)buf))
+			return type->filetype;
+
+	return FALSE;
+}
 
 int IMB_ispic(char *filename)
 {
 	if(U.uiflag & USER_FILTERFILEEXTS) {
 		if (G.have_libtiff && (BLI_testextensie(filename, ".tif")
-				||	BLI_testextensie(filename, ".tiff"))) {
+				||	BLI_testextensie(filename, ".tiff")
+				||	BLI_testextensie(filename, ".tx"))) {
 				return IMB_ispic_name(filename);
 		}
 		if (G.have_quicktime){
@@ -179,6 +115,7 @@ int IMB_ispic(char *filename)
 				||	BLI_testextensie(filename, ".jpeg")
 				||	BLI_testextensie(filename, ".tif")
 				||	BLI_testextensie(filename, ".tiff")
+				||	BLI_testextensie(filename, ".tx")
 				||	BLI_testextensie(filename, ".hdr")
 				||	BLI_testextensie(filename, ".tga")
 				||	BLI_testextensie(filename, ".rgb")
@@ -391,14 +328,14 @@ int imb_get_anim_type(char * name) {
 	/* stat test below fails on large files > 4GB */
 	if (isffmpeg(name)) return (ANIM_FFMPEG);
 #	endif
-	if (ib_stat(name,&st) == -1) return(0);
+	if (stat(name,&st) == -1) return(0);
 	if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
 
 	if (isavi(name)) return (ANIM_AVI);
 
 	if (ismovie(name)) return (ANIM_MOVIE);
 #else
-	if (ib_stat(name,&st) == -1) return(0);
+	if (stat(name,&st) == -1) return(0);
 	if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
 
 	if (ismovie(name)) return (ANIM_MOVIE);
@@ -414,7 +351,6 @@ int imb_get_anim_type(char * name) {
 	if (isredcode(name)) return (ANIM_REDCODE);
 #endif
 	type = IMB_ispic(name);
-	if (type == ANIM) return (ANIM_ANIM5);
 	if (type) return(ANIM_SEQUENCE);
 	return(0);
 }
diff --git a/source/blender/imbuf/intern/writeimage.c b/source/blender/imbuf/intern/writeimage.c
index 808fbc25c24..b55ce4b1df4 100644
--- a/source/blender/imbuf/intern/writeimage.c
+++ b/source/blender/imbuf/intern/writeimage.c
@@ -31,180 +31,32 @@
 
 #include <stdio.h>
 
-#include "BKE_global.h"
-#include "BLI_blenlib.h"
-
-#include "imbuf.h"
-#include "imbuf_patch.h"
-
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
+#include "IMB_filetype.h"
 
-#include "IMB_allocimbuf.h"
-
-#include "IMB_dpxcineon.h"
-#include "IMB_targa.h"
-#include "IMB_jpeg.h"
-#include "IMB_iris.h"
-#include "IMB_ham.h"
-#include "IMB_hamx.h"
-#include "IMB_amiga.h"
-#include "IMB_png.h"
-#include "IMB_bmp.h"
-#include "IMB_radiance_hdr.h"
-
-#if defined(__APPLE__) && defined(IMBUF_COCOA)
-#include "IMB_cocoa.h"
-#else
-#include "IMB_tiff.h"
-#endif
-
-#ifdef WITH_OPENJPEG
-#include "IMB_jp2.h"
-#endif
-
-#ifdef WITH_OPENEXR
-#include "openexr/openexr_api.h"
-#endif
-
-#ifdef WITH_DDS
-#include "dds/dds_api.h"
-#endif
-
-#include "IMB_iff.h"
-#include "IMB_bitplanes.h"
-#include "IMB_divers.h"
-
-#ifdef WIN32
-#include <io.h>
-#include "BLI_winstuff.h"
-#endif
-/* added facility to copy with saving non-float rects */
+#include "imbuf.h"
 
 short IMB_saveiff(struct ImBuf *ibuf, char *name, int flags)
 {
-	short ok=TRUE,delpl=FALSE;
-	int file = -1;
+	ImFileType *type;
 
-	if (ibuf==0) return (FALSE);
+	if(ibuf == NULL) return (FALSE);
 	ibuf->flags = flags;
 
-	/* Put formats that take a filename here */
-	if (IS_jpg(ibuf)) {
-		if(ibuf->rect==NULL && ibuf->rect_float)
-			IMB_rect_from_float(ibuf);
-		return imb_savejpeg(ibuf, name, flags);
-	}
-	if (IS_radhdr(ibuf)) {
-		return imb_savehdr(ibuf, name, flags);
-	}
-	if (IS_png(ibuf)) {
-		if(ibuf->rect==NULL && ibuf->rect_float)
-			IMB_rect_from_float(ibuf);
-		return imb_savepng(ibuf, name, flags);
-	}
-	if (IS_bmp(ibuf)) {
-		if(ibuf->rect==NULL && ibuf->rect_float)
-			IMB_rect_from_float(ibuf);
-		return imb_savebmp(ibuf, name, flags);
-	}
-	if (IS_tga(ibuf)) {
-		if(ibuf->rect==NULL && ibuf->rect_float)
-			IMB_rect_from_float(ibuf);
-		return imb_savetarga(ibuf, name, flags);
-	}
-	if (IS_iris(ibuf)) {
-		if(ibuf->rect==NULL && ibuf->rect_float)
-			IMB_rect_from_float(ibuf);
-		return imb_saveiris(ibuf, name, flags);
-	}
-	
-#if defined(__APPLE__) && defined(IMBUF_COCOA)
-	if (IS_tiff(ibuf)) {
-		if(ibuf->rect==NULL && ibuf->rect_float)
-			IMB_rect_from_float(ibuf);
-		return imb_cocoaSaveImage(ibuf, name, flags);
-	}
-#else
-	if (G.have_libtiff && IS_tiff(ibuf)) {
-		if(ibuf->rect==NULL && ibuf->rect_float)
-			IMB_rect_from_float(ibuf);
-		return imb_savetiff(ibuf, name, flags);
-	}
-#endif
-	
-#ifdef WITH_OPENEXR
-	if (IS_openexr(ibuf)) {
-		return imb_save_openexr(ibuf, name, flags);
-	}
-#endif
-/* not supported yet
-#ifdef WITH_DDS
-	if (IS_dds(ibuf)) {
-		return imb_save_dds(ibuf, name, flags);
-	}
-#endif
-*/
-	if (IS_cineon(ibuf)) {
-		return imb_savecineon(ibuf, name, flags);
-		
-	}
-	if (IS_dpx(ibuf)) {
-		return imb_save_dpx(ibuf, name, flags);
-	}
-#ifdef WITH_OPENJPEG
-	if (IS_jp2(ibuf)) {
-		return imb_savejp2(ibuf, name, flags);
-	}
-#endif	
-	file = open(name, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, 0666);
-	if (file < 0) return (FALSE);
-
-	if (flags & IB_rect){
-		if (ibuf->cmap){
-			imb_checkncols(ibuf);
-		}
-	}
-
-	/* Put formats that take a filehandle here */
-	ok = imb_start_iff(ibuf,file);
-	if (IS_amiga(ibuf)){
-		IMB_flipy(ibuf);
-		if (flags & IB_rect){
-			if ((flags & IB_cmap) == 0) {
-				if (IS_ham(ibuf)){
-					if (ok) ok = imb_converttoham(ibuf);
-				}else if (ibuf->cmap){
-					if (ok) ok = IMB_converttocmap(ibuf);
-				}
+	for(type=IMB_FILE_TYPES; type->is_a; type++) {
+		if(type->save && type->ftype(type, ibuf)) {
+			if(!(type->flag & IM_FTYPE_FLOAT)) {
+				if(ibuf->rect==NULL && ibuf->rect_float)
+					IMB_rect_from_float(ibuf);
 			}
-			if (ok){
-				if (ibuf->planes==0){
-					delpl=TRUE;
-					ok=imb_addplanesImBuf(ibuf);
-				}
-				imb_longtobp(ibuf);
-			}
-		}
 
-		if (flags & IB_vert){
-			if (ok) ok = imb_encodebodyv(ibuf,file);
-		}
-		else{
-			if (ok) ok = imb_encodebodyh(ibuf,file);
+			return type->save(ibuf, name, flags);
 		}
-		if (ok) ok = imb_update_iff(file,BODY);
-	}else if (IS_anim(ibuf)) {
-		if (ok) ok = imb_enc_anim(ibuf, file);
-		if (ok) ok = imb_update_iff(file, BODY);
 	}
-	close(file);
 
-	if (ok==FALSE) {
-		fprintf(stderr,"Couldn't save picture.\n");
-	}	
-	if (delpl) imb_freeplanesImBuf(ibuf);
+	fprintf(stderr, "Couldn't save picture.\n");
 
-	return (ok);
+	return FALSE;
 }