FreeImage: update to 3.18.0

23 files changed, 735 insertions, 490 deletions

diff --git a/libs/freeimage/src/CacheFile.h b/libs/freeimage/src/CacheFile.h
index a1e5e782c9..7f1ab72a31 100644
--- a/libs/freeimage/src/CacheFile.h
+++ b/libs/freeimage/src/CacheFile.h
@@ -19,8 +19,8 @@
 // Use at your own risk!
 // ==========================================================
 
-#ifndef CACHEFILE_H
-#define CACHEFILE_H
+#ifndef FREEIMAGE_CACHEFILE_H
+#define FREEIMAGE_CACHEFILE_H
 
 // ----------------------------------------------------------
 
@@ -61,11 +61,12 @@ class CacheFile {
 	typedef std::map<int, PageCacheIt>::iterator PageMapIt;
 
 public :
-	CacheFile(const std::string filename, BOOL keep_in_memory);
+	CacheFile();
 	~CacheFile();
-
-	BOOL open();
+	
+	BOOL open(const std::string& filename = "", BOOL keep_in_memory = TRUE);
 	void close();
+
 	BOOL readFile(BYTE *data, int nr, int size);
 	int writeFile(BYTE *data, int size);
 	void deleteFile(int nr);
@@ -89,4 +90,4 @@ private :
 	BOOL m_keep_in_memory;
 };
 
-#endif // CACHEFILE_H
+#endif // FREEIMAGE_CACHEFILE_H
diff --git a/libs/freeimage/src/FreeImage.h b/libs/freeimage/src/FreeImage.h
index 980360d1ec..c6dd2221ea 100644
--- a/libs/freeimage/src/FreeImage.h
+++ b/libs/freeimage/src/FreeImage.h
@@ -1,4 +1,4 @@
-// ==========================================================
+// ==========================================================
 // FreeImage 3
 //
 // Design and implementation by
@@ -29,7 +29,7 @@
 // Version information ------------------------------------------------------
 
 #define FREEIMAGE_MAJOR_VERSION   3
-#define FREEIMAGE_MINOR_VERSION   17
+#define FREEIMAGE_MINOR_VERSION   18
 #define FREEIMAGE_RELEASE_SERIAL  0
 
 // Compiler options ---------------------------------------------------------
@@ -75,7 +75,7 @@
 // or define any of FREEIMAGE_BIGENDIAN and FREEIMAGE_LITTLEENDIAN directly
 // to specify the desired endianness.
 #if (!defined(FREEIMAGE_BIGENDIAN) && !defined(FREEIMAGE_LITTLEENDIAN))
-	#if (defined(BYTE_ORDER) && BYTE_ORDER==BIG_ENDIAN) || (defined(__BYTE_ORDER) && __BYTE_ORDER==__BIG_ENDIAN) || defined(__BIG_ENDIAN__)
+#if (defined(BYTE_ORDER) && BYTE_ORDER==BIG_ENDIAN) || (defined(__BYTE_ORDER) && __BYTE_ORDER==__BIG_ENDIAN) || (defined(__BYTE_ORDER) && __BYTE_ORDER==__ORDER_BIG_ENDIAN__) || defined(__BIG_ENDIAN__)
 		#define FREEIMAGE_BIGENDIAN
 	#endif // BYTE_ORDER
 #endif // !FREEIMAGE_[BIG|LITTLE]ENDIAN
@@ -733,6 +733,9 @@ typedef void (DLL_CALLCONV *FI_InitProc)(Plugin *plugin, int format_id);
 #define PSD_DEFAULT         0
 #define PSD_CMYK			1		//! reads tags for separated CMYK (default is conversion to RGB)
 #define PSD_LAB				2		//! reads tags for CIELab (default is conversion to RGB)
+#define PSD_NONE			0x0100	//! save without any compression
+#define PSD_RLE				0x0200	//! save using RLE compression
+#define PSD_PSB             0x2000  //! save using Adobe Large Document Format (use | to combine with other save flags)
 #define RAS_DEFAULT         0
 #define RAW_DEFAULT         0		//! load the file as linear RGB 48-bit
 #define RAW_PREVIEW			1		//! try to load the embedded JPEG preview with included Exif Data or default to RGB 24-bit
@@ -880,13 +883,19 @@ DLL_API void DLL_CALLCONV FreeImage_UnlockPage(FIMULTIBITMAP *bitmap, FIBITMAP *
 DLL_API BOOL DLL_CALLCONV FreeImage_MovePage(FIMULTIBITMAP *bitmap, int target, int source);
 DLL_API BOOL DLL_CALLCONV FreeImage_GetLockedPageNumbers(FIMULTIBITMAP *bitmap, int *pages, int *count);
 
-// Filetype request routines ------------------------------------------------
+// File type request routines ------------------------------------------------
 
 DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileType(const char *filename, int size FI_DEFAULT(0));
 DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeU(const wchar_t *filename, int size FI_DEFAULT(0));
 DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size FI_DEFAULT(0));
 DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromMemory(FIMEMORY *stream, int size FI_DEFAULT(0));
 
+DLL_API BOOL DLL_CALLCONV FreeImage_Validate(FREE_IMAGE_FORMAT fif, const char *filename);
+DLL_API BOOL DLL_CALLCONV FreeImage_ValidateU(FREE_IMAGE_FORMAT fif, const wchar_t *filename);
+DLL_API BOOL DLL_CALLCONV FreeImage_ValidateFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle);
+DLL_API BOOL DLL_CALLCONV FreeImage_ValidateFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream);
+
+
 // Image type request routine -----------------------------------------------
 
 DLL_API FREE_IMAGE_TYPE DLL_CALLCONV FreeImage_GetImageType(FIBITMAP *dib);
@@ -986,8 +995,11 @@ DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To24_555(BYTE *target, BYTE *so
 DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To24_565(BYTE *target, BYTE *source, int width_in_pixels);
 DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To24(BYTE *target, BYTE *source, int width_in_pixels);
 DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels);
 DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels);
 DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels);
 DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To32_555(BYTE *target, BYTE *source, int width_in_pixels);
 DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To32_565(BYTE *target, BYTE *source, int width_in_pixels);
 DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To32(BYTE *target, BYTE *source, int width_in_pixels);
@@ -1099,8 +1111,6 @@ DLL_API BOOL DLL_CALLCONV FreeImage_JPEGTransformCombinedFromMemory(FIMEMORY* sr
 // --------------------------------------------------------------------------
 
 // rotation and flipping
-/// @deprecated see FreeImage_Rotate
-DLL_API FIBITMAP *DLL_CALLCONV FreeImage_RotateClassic(FIBITMAP *dib, double angle);
 DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Rotate(FIBITMAP *dib, double angle, const void *bkcolor FI_DEFAULT(NULL));
 DLL_API FIBITMAP *DLL_CALLCONV FreeImage_RotateEx(FIBITMAP *dib, double angle, double x_shift, double y_shift, double x_origin, double y_origin, BOOL use_mask);
 DLL_API BOOL DLL_CALLCONV FreeImage_FlipHorizontal(FIBITMAP *dib);
@@ -1137,7 +1147,7 @@ DLL_API BOOL DLL_CALLCONV FreeImage_Paste(FIBITMAP *dst, FIBITMAP *src, int left
 DLL_API FIBITMAP *DLL_CALLCONV FreeImage_CreateView(FIBITMAP *dib, unsigned left, unsigned top, unsigned right, unsigned bottom);
 
 DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Composite(FIBITMAP *fg, BOOL useFileBkg FI_DEFAULT(FALSE), RGBQUAD *appBkColor FI_DEFAULT(NULL), FIBITMAP *bg FI_DEFAULT(NULL));
-DLL_API BOOL DLL_CALLCONV FreeImage_PremultiplyWithAlpha(FIBITMAP *dib);
+DLL_API BOOL DLL_CALLCONV FreeImage_PreMultiplyWithAlpha(FIBITMAP *dib);
 
 // background filling routines
 DLL_API BOOL DLL_CALLCONV FreeImage_FillBackground(FIBITMAP *dib, const void *color, int options FI_DEFAULT(0));
diff --git a/libs/freeimage/src/FreeImage/BitmapAccess.cpp b/libs/freeimage/src/FreeImage/BitmapAccess.cpp
index c3be7a1742..e77344e1e1 100644
--- a/libs/freeimage/src/FreeImage/BitmapAccess.cpp
+++ b/libs/freeimage/src/FreeImage/BitmapAccess.cpp
@@ -1,4 +1,4 @@
-// ==========================================================
+// ==========================================================
 // FreeImage implementation
 //
 // Design and implementation by
@@ -537,6 +537,7 @@ FreeImage_Clone(FIBITMAP *dib) {
 	unsigned height	= FreeImage_GetHeight(dib);
 	unsigned bpp	= FreeImage_GetBPP(dib);
 
+	// if the FIBITMAP is a wrapper to a user provided pixel buffer, get a pointer to this buffer
 	const BYTE *ext_bits = ((FREEIMAGEHEADER *)dib->data)->external_bits;
 	
 	// check for pixel availability ...
@@ -558,7 +559,7 @@ FreeImage_Clone(FIBITMAP *dib) {
 		METADATAMAP *src_metadata = ((FREEIMAGEHEADER *)dib->data)->metadata;
 		METADATAMAP *dst_metadata = ((FREEIMAGEHEADER *)new_dib->data)->metadata;
 
-		// calculate the size of the src image
+		// calculate the size of the dst image
 		// align the palette and the pixels on a FIBITMAP_ALIGNMENT bytes alignment boundary
 		// palette is aligned on a 16 bytes boundary
 		// pixels are aligned on a 16 bytes boundary
@@ -579,6 +580,10 @@ FreeImage_Clone(FIBITMAP *dib) {
 		// reset thumbnail link for new_dib
 		((FREEIMAGEHEADER *)new_dib->data)->thumbnail = NULL;
 
+		// reset external wrapped buffer link for new_dib
+		((FREEIMAGEHEADER *)new_dib->data)->external_bits = NULL;
+		((FREEIMAGEHEADER *)new_dib->data)->external_pitch = 0;
+
 		// copy possible ICC profile
 		FreeImage_CreateICCProfile(new_dib, src_iccProfile->data, src_iccProfile->size);
 		dst_iccProfile->flags = src_iccProfile->flags;
@@ -697,12 +702,14 @@ FreeImage_GetColorType(FIBITMAP *dib) {
 				return FIC_MINISBLACK;
 			}
 			break;
+
 			case FIT_RGB16:
 			case FIT_RGBF:
 				return FIC_RGB;
+
 			case FIT_RGBA16:
 			case FIT_RGBAF:
-				return FIC_RGBALPHA;
+				return (((FreeImage_GetICCProfile(dib)->flags) & FIICC_COLOR_IS_CMYK) == FIICC_COLOR_IS_CMYK) ? FIC_CMYK : FIC_RGBALPHA;
 		}
 
 		return FIC_MINISBLACK;
@@ -767,7 +774,7 @@ FreeImage_GetColorType(FIBITMAP *dib) {
 
 		case 32:
 		{
-			if (FreeImage_GetICCProfile(dib)->flags & FIICC_COLOR_IS_CMYK) {
+			if (((FreeImage_GetICCProfile(dib)->flags) & FIICC_COLOR_IS_CMYK) == FIICC_COLOR_IS_CMYK) {
 				return FIC_CMYK;
 			}
 
@@ -944,7 +951,7 @@ FreeImage_IsTransparent(FIBITMAP *dib) {
 				break;
 			case FIT_RGBA16:
 			case FIT_RGBAF:
-				return TRUE;
+				return (((FreeImage_GetICCProfile(dib)->flags) & FIICC_COLOR_IS_CMYK) == FIICC_COLOR_IS_CMYK) ? FALSE : TRUE;
 			default:
 				break;
 		}
@@ -1085,6 +1092,9 @@ FreeImage_DestroyICCProfile(FIBITMAP *dib) {
 		profile->data = NULL;
 		profile->size = 0;
 	}
+
+	// destroy also Exif-Main ICC profile
+	FreeImage_SetMetadata(FIMD_EXIF_MAIN, dib, "InterColorProfile", NULL);
 }
 
 // ----------------------------------------------------------
@@ -1194,12 +1204,12 @@ FreeImage_FindFirstMetadata(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, FITAG **tag
 		FIMETADATA 	*handle = (FIMETADATA *)malloc(sizeof(FIMETADATA));
 		if(handle) {
 			// calculate the size of a METADATAHEADER
-			int header_size = sizeof(METADATAHEADER);
+			const size_t header_size = sizeof(METADATAHEADER);
 
-			handle->data = (BYTE *)malloc(header_size * sizeof(BYTE));
+			handle->data = (BYTE *)malloc(header_size);
 			
 			if(handle->data) {
-				memset(handle->data, 0, header_size * sizeof(BYTE));
+				memset(handle->data, 0, header_size);
 
 				// write out the METADATAHEADER
 				METADATAHEADER *mdh = (METADATAHEADER *)handle->data;
@@ -1334,6 +1344,11 @@ FreeImage_SetMetadata(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, const char *key,
 
 	if(key != NULL) {
 
+		if ((tag == NULL) && !tagmap) {
+			// remove a tag from an unknown tagmap, nothing to do
+			return TRUE;
+		}
+
 		if(!tagmap) {
 			// this model, doesn't exist: create it 
 			tagmap = new(std::nothrow) TAGMAP();
diff --git a/libs/freeimage/src/FreeImage/CacheFile.cpp b/libs/freeimage/src/FreeImage/CacheFile.cpp
index 086393bf03..e98906d39e 100644
--- a/libs/freeimage/src/FreeImage/CacheFile.cpp
+++ b/libs/freeimage/src/FreeImage/CacheFile.cpp
@@ -4,6 +4,7 @@
 // Design and implementation by
 // - Floris van den Berg (flvdberg@wxs.nl)
 // - checkered (checkered@users.sourceforge.net)
+// - Mihail Naydenov (mnaydenov@users.sourceforge.net)
 //
 // This file is part of FreeImage 3
 //
@@ -28,25 +29,31 @@
 
 // ----------------------------------------------------------
 
-CacheFile::CacheFile(const std::string filename, BOOL keep_in_memory) :
+CacheFile::CacheFile() :
 m_file(NULL),
-m_filename(filename),
 m_free_pages(),
 m_page_cache_mem(),
 m_page_cache_disk(),
 m_page_map(),
 m_page_count(0),
 m_current_block(NULL),
-m_keep_in_memory(keep_in_memory) {
+m_keep_in_memory(TRUE) {
 }
 
 CacheFile::~CacheFile() {
+  close();
 }
 
 BOOL
-CacheFile::open() {
+CacheFile::open(const std::string& filename, BOOL keep_in_memory) {
+
+  assert(!m_file);
+
+  m_filename = filename;
+  m_keep_in_memory = keep_in_memory;
+
 	if ((!m_filename.empty()) && (!m_keep_in_memory)) {
-		m_file = fopen(m_filename.c_str(), "w+b");
+		m_file = fopen(m_filename.c_str(), "w+b"); 
 		return (m_file != NULL);
 	}
 
@@ -72,11 +79,10 @@ CacheFile::close() {
 
 	if (m_file) {
 		// close the file
-
 		fclose(m_file);
-
+		m_file = NULL;
+		
 		// delete the file
-
 		remove(m_filename.c_str());
 	}
 }
@@ -164,10 +170,8 @@ BOOL
 CacheFile::unlockBlock(int nr) {
 	if (m_current_block) {
 		m_current_block = NULL;
-
 		return TRUE;
 	}
-
 	return FALSE;
 }
 
@@ -178,8 +182,9 @@ CacheFile::deleteBlock(int nr) {
 
 		// remove block from cache
 
-		if (it != m_page_map.end())
+		if (it != m_page_map.end()) {
 			m_page_map.erase(nr);
+		}
 
 		// add block to free page list
 
diff --git a/libs/freeimage/src/FreeImage/Conversion.cpp b/libs/freeimage/src/FreeImage/Conversion.cpp
index 9ef49f393b..f8d8ce4512 100644
--- a/libs/freeimage/src/FreeImage/Conversion.cpp
+++ b/libs/freeimage/src/FreeImage/Conversion.cpp
@@ -28,8 +28,17 @@
 // ----------------------------------------------------------
 
 #define CONVERT(from, to) case to : FreeImage_ConvertLine##from##To##to(bits, scanline, FreeImage_GetWidth(dib)); break;
+
 #define CONVERTWITHPALETTE(from, to) case to : FreeImage_ConvertLine##from##To##to(bits, scanline, FreeImage_GetWidth(dib), FreeImage_GetPalette(dib)); break;
 
+#define CONVERTTO32WITHPALETTE(from) case 32 : \
+    if (bIsTransparent) { \
+        FreeImage_ConvertLine##from##To32MapTransparency(bits, scanline, FreeImage_GetWidth(dib), FreeImage_GetPalette(dib), FreeImage_GetTransparencyTable(dib), FreeImage_GetTransparencyCount(dib)); \
+    } else { \
+        FreeImage_ConvertLine##from##To32(bits, scanline, FreeImage_GetWidth(dib), FreeImage_GetPalette(dib)); \
+    } \
+    break;
+
 #define CONVERTTO16(from) \
 	case 16 : \
 		if ((red_mask == FI16_555_RED_MASK) && (green_mask == FI16_555_GREEN_MASK) && (blue_mask == FI16_555_BLUE_MASK)) { \
@@ -491,14 +500,15 @@ FreeImage_ConvertToRawBits(BYTE *bits, FIBITMAP *dib, int pitch, unsigned bpp, u
 					}
 				}
 			} else if (FreeImage_GetBPP(dib) != bpp) {
+                BOOL bIsTransparent = FreeImage_IsTransparent(dib);
 				switch(FreeImage_GetBPP(dib)) {
 					case 1 :
 						switch(bpp) {
 							CONVERT(1, 8)
 							CONVERTTO16WITHPALETTE(1)
 							CONVERTWITHPALETTE(1, 24)
-							CONVERTWITHPALETTE(1, 32)
-						}
+                            CONVERTTO32WITHPALETTE(1)
+                        }
 
 						break;
 
@@ -507,7 +517,7 @@ FreeImage_ConvertToRawBits(BYTE *bits, FIBITMAP *dib, int pitch, unsigned bpp, u
 							CONVERT(4, 8)
 							CONVERTTO16WITHPALETTE(4)
 							CONVERTWITHPALETTE(4, 24)
-							CONVERTWITHPALETTE(4, 32)
+                            CONVERTTO32WITHPALETTE(4)
 						}
 
 						break;
@@ -516,7 +526,7 @@ FreeImage_ConvertToRawBits(BYTE *bits, FIBITMAP *dib, int pitch, unsigned bpp, u
 						switch(bpp) {
 							CONVERTTO16WITHPALETTE(8)
 							CONVERTWITHPALETTE(8, 24)
-							CONVERTWITHPALETTE(8, 32)
+                            CONVERTTO32WITHPALETTE(8)
 						}
 
 						break;
diff --git a/libs/freeimage/src/FreeImage/Conversion32.cpp b/libs/freeimage/src/FreeImage/Conversion32.cpp
index f5eb0c2103..17dbe7e7b8 100644
--- a/libs/freeimage/src/FreeImage/Conversion32.cpp
+++ b/libs/freeimage/src/FreeImage/Conversion32.cpp
@@ -131,7 +131,7 @@ FreeImage_ConvertLine24To32(BYTE *target, BYTE *source, int width_in_pixels) {
 
 // ----------------------------------------------------------
 
-inline void 
+void DLL_CALLCONV
 FreeImage_ConvertLine1To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels) {
 	for (int cols = 0; cols < width_in_pixels; cols++) {
 		int index = (source[cols>>3] & (0x80 >> (cols & 0x07))) != 0 ? 1 : 0;
@@ -144,7 +144,7 @@ FreeImage_ConvertLine1To32MapTransparency(BYTE *target, BYTE *source, int width_
 	}	
 }
 
-inline void 
+void DLL_CALLCONV
 FreeImage_ConvertLine4To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels) {
 	BOOL low_nibble = FALSE;
 	int x = 0;
@@ -170,7 +170,7 @@ FreeImage_ConvertLine4To32MapTransparency(BYTE *target, BYTE *source, int width_
 	}
 }
 
-inline void 
+void DLL_CALLCONV
 FreeImage_ConvertLine8To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels) {
 	for (int cols = 0; cols < width_in_pixels; cols++) {
 		target[FI_RGBA_BLUE]	= palette[source[cols]].rgbBlue;
diff --git a/libs/freeimage/src/FreeImage/GetType.cpp b/libs/freeimage/src/FreeImage/GetType.cpp
index b2991a0e49..625b81246a 100644
--- a/libs/freeimage/src/FreeImage/GetType.cpp
+++ b/libs/freeimage/src/FreeImage/GetType.cpp
@@ -1,8 +1,9 @@
-// ==========================================================
-// GetType
+// ==========================================================
+// GetType / Validate
 //
 // Design and implementation by
 // - Floris van den Berg (flvdberg@wxs.nl)
+// - Hervé Drolon (drolon@infonie.fr)
 //
 // This file is part of FreeImage 3
 //
@@ -25,7 +26,9 @@
 
 #include "../stdafx.h"
 
-// ----------------------------------------------------------
+// =====================================================================
+// Generic stream file type access
+// =====================================================================
 
 FREE_IMAGE_FORMAT DLL_CALLCONV
 FreeImage_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size) {
@@ -34,7 +37,7 @@ FreeImage_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size) {
 
 		for (int i = 0; i < fif_count; ++i) {
 			FREE_IMAGE_FORMAT fif = (FREE_IMAGE_FORMAT)i;
-			if (FreeImage_Validate(fif, io, handle)) {
+			if (FreeImage_ValidateFIF(fif, io, handle)) {
 				/*if(fif == FIF_TIFF) {
 					// many camera raw files use a TIFF signature ...
 					// ... try to revalidate against FIF_RAW (even if it breaks the code genericity)
@@ -50,6 +53,10 @@ FreeImage_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size) {
 	return FIF_UNKNOWN;
 }
 
+// =====================================================================
+// File stream file type access
+// =====================================================================
+
 FREE_IMAGE_FORMAT DLL_CALLCONV
 FreeImage_GetFileType(const char *filename, int size) {
 	FreeImageIO io;
@@ -86,3 +93,70 @@ FreeImage_GetFileTypeU(const wchar_t *filename, int size) {
 	return FIF_UNKNOWN;
 }
 
+// =====================================================================
+// Memory stream file type access
+// =====================================================================
+
+FREE_IMAGE_FORMAT DLL_CALLCONV
+FreeImage_GetFileTypeFromMemory(FIMEMORY *stream, int size) {
+	FreeImageIO io;
+	SetMemoryIO(&io);
+
+	if (stream != NULL) {
+		return FreeImage_GetFileTypeFromHandle(&io, (fi_handle)stream, size);
+	}
+
+	return FIF_UNKNOWN;
+}
+
+// --------------------------------------------------------------------------
+
+BOOL DLL_CALLCONV
+FreeImage_ValidateFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle) {
+	return FreeImage_ValidateFIF(fif, io, handle);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_Validate(FREE_IMAGE_FORMAT fif, const char *filename) {
+	FreeImageIO io;
+	SetDefaultIO(&io);
+
+	FILE *handle = fopen(filename, "rb");
+
+	if (handle != NULL) {
+		BOOL bIsValidFIF = FreeImage_ValidateFromHandle(fif, &io, (fi_handle)handle);
+		fclose(handle);
+		return bIsValidFIF;
+	}
+
+	return FALSE;
+}
+
+BOOL DLL_CALLCONV
+FreeImage_ValidateU(FREE_IMAGE_FORMAT fif, const wchar_t *filename) {
+#ifdef _WIN32	
+	FreeImageIO io;
+	SetDefaultIO(&io);
+	FILE *handle = _wfopen(filename, L"rb");
+
+	if (handle != NULL) {
+		BOOL bIsValidFIF = FreeImage_ValidateFromHandle(fif, &io, (fi_handle)handle);
+		fclose(handle);
+		return bIsValidFIF;
+	}
+#endif
+	return FALSE;
+}
+
+BOOL DLL_CALLCONV
+FreeImage_ValidateFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream) {
+	FreeImageIO io;
+	SetMemoryIO(&io);
+
+	if (stream != NULL) {
+		BOOL bIsValidFIF = FreeImage_ValidateFromHandle(fif, &io, (fi_handle)stream);
+		return bIsValidFIF;
+	}
+
+	return FALSE;
+}
diff --git a/libs/freeimage/src/FreeImage/MemoryIO.cpp b/libs/freeimage/src/FreeImage/MemoryIO.cpp
index c04612373a..cda97e1e71 100644
--- a/libs/freeimage/src/FreeImage/MemoryIO.cpp
+++ b/libs/freeimage/src/FreeImage/MemoryIO.cpp
@@ -126,22 +126,6 @@ FreeImage_AcquireMemory(FIMEMORY *stream, BYTE **data, DWORD *size_in_bytes) {
 }
 
 // =====================================================================
-// Memory stream file type access
-// =====================================================================
-
-FREE_IMAGE_FORMAT DLL_CALLCONV
-FreeImage_GetFileTypeFromMemory(FIMEMORY *stream, int size) {
-	FreeImageIO io;
-	SetMemoryIO(&io);
-
-	if (stream != NULL) {
-		return FreeImage_GetFileTypeFromHandle(&io, (fi_handle)stream, size);
-	}
-
-	return FIF_UNKNOWN;
-}
-
-// =====================================================================
 // Seeking in Memory stream
 // =====================================================================
 
diff --git a/libs/freeimage/src/FreeImage/MultiPage.cpp b/libs/freeimage/src/FreeImage/MultiPage.cpp
index 0d49f46633..5788d241fd 100644
--- a/libs/freeimage/src/FreeImage/MultiPage.cpp
+++ b/libs/freeimage/src/FreeImage/MultiPage.cpp
@@ -10,6 +10,7 @@
 // - Vadim Alexandrov (vadimalexandrov@users.sourceforge.net
 // - Martin Dyring-Andersen (mda@spamfighter.com)
 // - Volodymyr Goncharov (volodymyr.goncharov@gmail.com)
+// - Mihail Naydenov (mnaydenov@users.sourceforge.net)
 //
 // This file is part of FreeImage 3
 //
@@ -32,58 +33,89 @@
 
 #include "../stdafx.h"
 
+namespace {
+
 // ----------------------------------------------------------
 
 enum BlockType { BLOCK_CONTINUEUS, BLOCK_REFERENCE };
 
 // ----------------------------------------------------------
 
-struct BlockTypeS {
-	BlockType m_type;
-
-	BlockTypeS(BlockType type) : m_type(type) {
-	}
-	virtual ~BlockTypeS() {}
-};
-
-struct BlockContinueus : public BlockTypeS {
-	int       m_start;
-	int       m_end;
-
-	BlockContinueus(int s, int e) : BlockTypeS(BLOCK_CONTINUEUS),
-	m_start(s),
-	m_end(e) {
-	}	
-};
-
-struct BlockReference : public BlockTypeS {
-	int       m_reference;
-	int       m_size;
-
-	BlockReference(int r, int size) : BlockTypeS(BLOCK_REFERENCE),
-	m_reference(r),
-	m_size(size) {
-	}
+class PageBlock {
+
+  union {
+    struct {
+      int  m_start;
+      int  m_end;
+    };
+    struct {
+      int  m_reference;
+      int  m_size;
+    };
+  };
+
+public:
+  BlockType m_type;
+
+  PageBlock(BlockType type = BLOCK_CONTINUEUS, int val1 = -1, int val2 = -1) : m_type(type)
+  {
+    if(m_type == BLOCK_CONTINUEUS)
+    {
+      m_start = val1;
+      m_end = val2;
+    }
+    else
+    {
+      m_reference = val1;
+      m_size = val2;
+    }
+  }
+
+  bool isValid() const { return !(m_type == BLOCK_CONTINUEUS && m_start == -1 && m_end == -1); }
+  /*explicit*/ operator bool() const { return isValid(); }
+
+  int getStart() const { assert(isValid() && m_type == BLOCK_CONTINUEUS); return m_start; }
+  int getEnd() const { assert(isValid() && m_type == BLOCK_CONTINUEUS); return m_end; }
+
+  bool isSinglePage() const { assert(isValid()); return m_type == BLOCK_CONTINUEUS ? (m_start == m_end) : true; }
+  int getPageCount() const { assert(isValid()); return m_type == BLOCK_CONTINUEUS ? (m_end - m_start + 1) : 1;}
+
+  int getReference() const { assert(isValid() && m_type == BLOCK_REFERENCE); return m_reference; }
+  int getSize() const { assert(isValid() && m_type == BLOCK_REFERENCE); return m_size;  }
 };
 
 // ----------------------------------------------------------
 
-typedef std::list<BlockTypeS *> BlockList;
-typedef std::list<BlockTypeS *>::iterator BlockListIterator;
+typedef std::list<PageBlock> BlockList;
+typedef BlockList::iterator BlockListIterator;
 
 // ----------------------------------------------------------
 
-FI_STRUCT (MULTIBITMAPHEADER) {
+struct MULTIBITMAPHEADER {
+	
+	MULTIBITMAPHEADER()
+		: node(NULL)
+		, fif(FIF_UNKNOWN)
+		, handle(NULL)
+		, changed(FALSE)
+		, page_count(0)
+		, read_only(TRUE)
+		, cache_fif(fif)
+		, load_flags(0)
+	{
+		SetDefaultIO(&io);
+	}
+	
 	PluginNode *node;
 	FREE_IMAGE_FORMAT fif;
-	FreeImageIO *io;
+	FreeImageIO io;
 	fi_handle handle;
-	CacheFile *m_cachefile;
+	CacheFile m_cachefile;
 	std::map<FIBITMAP *, int> locked_pages;
 	BOOL changed;
 	int page_count;
 	BlockList m_blocks;
-	char *m_filename;
+	std::string m_filename;
 	BOOL read_only;
 	FREE_IMAGE_FORMAT cache_fif;
 	int load_flags;
@@ -107,6 +139,9 @@ ReplaceExtension(std::string& dst_filename, const std::string& src_filename, con
 	}
 }
 
+} //< ns
+
+
 // =====================================================================
 // Internal Multipage functions
 // =====================================================================
@@ -127,77 +162,55 @@ FreeImage_FindBlock(FIMULTIBITMAP *bitmap, int position) {
 	int prev_count = 0;
 	int count = 0;
 	BlockListIterator i;
-	BlockTypeS *current_block = NULL;
 
 	for (i = header->m_blocks.begin(); i != header->m_blocks.end(); ++i) {
 		prev_count = count;
+		
+		count += i->getPageCount();
 
-		switch((*i)->m_type) {
-			case BLOCK_CONTINUEUS :
-				count += ((BlockContinueus *)(*i))->m_end - ((BlockContinueus *)(*i))->m_start + 1;
-				break;
-
-			case BLOCK_REFERENCE :
-				count++;
-				break;
-		}
-
-		current_block = *i;
-
-		if (count > position)
+		if (count > position) {
 			break;
+		}
 	}
 
 	// step 2: make sure we found the node. from here it gets a little complicated:
-	// * if the block is there, just return it
-	// * if the block is a series of blocks, split it in max 3 new blocks
-	//   and return the splitted block
-
-	if ((current_block) && (count > position)) {
-		switch(current_block->m_type) {
-			case BLOCK_REFERENCE :
-				return i;
-
-			case BLOCK_CONTINUEUS :
-			{
-				BlockContinueus *block = (BlockContinueus *)current_block;
-
-				if (block->m_start != block->m_end) {
-					int item = block->m_start + (position - prev_count);
-
-					// left part
-
-					if (item != block->m_start) {
-						BlockContinueus *block_a = new BlockContinueus(block->m_start, item - 1);
-						header->m_blocks.insert(i, (BlockTypeS *)block_a);
-					}
-
-					// middle part
-
-					BlockContinueus *block_b = new BlockContinueus(item, item);
-					BlockListIterator block_target = header->m_blocks.insert(i, (BlockTypeS *)block_b);
-
-					// right part
-
-					if (item != block->m_end) {
-						BlockContinueus *block_c = new BlockContinueus(item + 1, block->m_end);
-						header->m_blocks.insert(i, (BlockTypeS *)block_c);
-					}
-
-					// remove the old block that was just splitted
-
-					header->m_blocks.remove((BlockTypeS *)block);
-					delete block;
-
-					// return the splitted block
-					
-					return block_target;
-				}
-
-				return i;
-			}
+	// * if the block is single page, just return it
+	// * if the block is a span of pages, split it in 3 new blocks
+	//   and return the middle block, which is now a single page
+	
+	if ((i != header->m_blocks.end()) && (count > position)) {
+		
+		if (i->isSinglePage()) {
+			return i;
+		}
+		
+		const int item = i->getStart() + (position - prev_count);
+		
+		// left part
+		
+		if (item != i->getStart()) {
+			header->m_blocks.insert(i, PageBlock(BLOCK_CONTINUEUS, i->getStart(), item - 1));
+		}
+		
+		// middle part
+		
+		BlockListIterator block_target = header->m_blocks.insert(i, PageBlock(BLOCK_CONTINUEUS, item, item));
+		
+		// right part
+		
+		if (item != i->getEnd()) {
+			header->m_blocks.insert(i, PageBlock(BLOCK_CONTINUEUS, item + 1, i->getEnd()));
 		}
+		
+		// remove the old block that was just splitted
+		
+		header->m_blocks.erase(i);
+		
+		// return the splitted block
+		
+		return block_target;
 	}
+	
 	// we should never go here ...
 	assert(false);
 	return header->m_blocks.end();
@@ -208,19 +221,19 @@ FreeImage_InternalGetPageCount(FIMULTIBITMAP *bitmap) {
 	if (bitmap) {
 		if (((MULTIBITMAPHEADER *)bitmap->data)->handle) {
 			MULTIBITMAPHEADER *header = FreeImage_GetMultiBitmapHeader(bitmap);
-
-			header->io->seek_proc(header->handle, 0, SEEK_SET);
-
-   			void *data = FreeImage_Open(header->node, header->io, header->handle, TRUE);
-
-			int page_count = (header->node->m_plugin->pagecount_proc != NULL) ? header->node->m_plugin->pagecount_proc(header->io, header->handle, data) : 1;
-
-			FreeImage_Close(header->node, header->io, header->handle, data);
-
+			
+			header->io.seek_proc(header->handle, 0, SEEK_SET);
+			
+			void *data = FreeImage_Open(header->node, &header->io, header->handle, TRUE);
+			
+			int page_count = (header->node->m_plugin->pagecount_proc != NULL) ? header->node->m_plugin->pagecount_proc(&header->io, header->handle, data) : 1;
+			
+			FreeImage_Close(header->node, &header->io, header->handle, data);
+			
 			return page_count;
 		}
 	}
-
+	
 	return 0;
 }
 
@@ -247,10 +260,6 @@ FreeImage_OpenMultiBitmap(FREE_IMAGE_FORMAT fif, const char *filename, BOOL crea
 			PluginNode *node = list->FindNodeFromFIF(fif);
 
 			if (node) {
-				std::auto_ptr<FreeImageIO> io (new FreeImageIO);
-
-				SetDefaultIO(io.get());
-
 				if (!create_new) {
 					handle = fopen(filename, "rb");
 					if (handle == NULL) {
@@ -260,15 +269,12 @@ FreeImage_OpenMultiBitmap(FREE_IMAGE_FORMAT fif, const char *filename, BOOL crea
 
 				std::auto_ptr<FIMULTIBITMAP> bitmap (new FIMULTIBITMAP);
 				std::auto_ptr<MULTIBITMAPHEADER> header (new MULTIBITMAPHEADER);
-				header->m_filename = new char[strlen(filename) + 1];
-				strcpy(header->m_filename, filename);
+				header->m_filename = filename;
+				// io is default
 				header->node = node;
 				header->fif = fif;
-				header->io = io.get ();
 				header->handle = handle;						
-				header->changed = FALSE;						
 				header->read_only = read_only;
-				header->m_cachefile = NULL;
 				header->cache_fif = fif;
 				header->load_flags = flags;
 
@@ -283,7 +289,7 @@ FreeImage_OpenMultiBitmap(FREE_IMAGE_FORMAT fif, const char *filename, BOOL crea
 				// allocate a continueus block to describe the bitmap
 
 				if (!create_new) {
-					header->m_blocks.push_back((BlockTypeS *)new BlockContinueus(0, header->page_count - 1));
+					header->m_blocks.push_back(PageBlock(BLOCK_CONTINUEUS, 0, header->page_count - 1));
 				}
 
 				// set up the cache
@@ -291,13 +297,8 @@ FreeImage_OpenMultiBitmap(FREE_IMAGE_FORMAT fif, const char *filename, BOOL crea
 				if (!read_only) {
 					std::string cache_name;
 					ReplaceExtension(cache_name, filename, "ficache");
-
-					std::auto_ptr<CacheFile> cache_file (new CacheFile(cache_name, keep_cache_in_memory));
-
-					if (cache_file->open()) {
-						// we can use release() as std::bad_alloc won't be thrown from here on
-						header->m_cachefile = cache_file.release();
-					} else {
+					
+					if (!header->m_cachefile.open(cache_name, keep_cache_in_memory)) {
 						// an error occured ...
 						fclose(handle);
 						return NULL;
@@ -306,15 +307,15 @@ FreeImage_OpenMultiBitmap(FREE_IMAGE_FORMAT fif, const char *filename, BOOL crea
 				// return the multibitmap
 				// std::bad_alloc won't be thrown from here on
 				header.release(); // now owned by bitmap
-				io.release();	  // now owned by bitmap
 				return bitmap.release(); // now owned by caller
 			}
 		}
 	} catch (std::bad_alloc &) {
 		/** @todo report error */
 	}
-	if (handle)
+	if (handle) {
 		fclose(handle);
+	}
 	return NULL;
 }
 
@@ -350,15 +351,11 @@ FreeImage_OpenMultiBitmapFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_h
 				if (node) {
 					std::auto_ptr<FIMULTIBITMAP> bitmap (new FIMULTIBITMAP);
 					std::auto_ptr<MULTIBITMAPHEADER> header (new MULTIBITMAPHEADER);
-					std::auto_ptr<FreeImageIO> tmp_io (new FreeImageIO (*io));
-					header->io = tmp_io.get();
-					header->m_filename = NULL;
+					header->io = *io;
 					header->node = node;
 					header->fif = fif;
 					header->handle = handle;						
-					header->changed = FALSE;						
 					header->read_only = read_only;	
-					header->m_cachefile = NULL;
 					header->cache_fif = fif;
 					header->load_flags = flags;
 							
@@ -371,18 +368,11 @@ FreeImage_OpenMultiBitmapFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_h
 					header->page_count = FreeImage_InternalGetPageCount(bitmap.get());
 
 					// allocate a continueus block to describe the bitmap
+					
+					header->m_blocks.push_back(PageBlock(BLOCK_CONTINUEUS, 0, header->page_count - 1));
+					
+					// no need to open cache - it is in-memory by default
 
-					header->m_blocks.push_back((BlockTypeS *)new BlockContinueus(0, header->page_count - 1));
-
-					if (!read_only) {
-						// set up the cache
-						std::auto_ptr<CacheFile> cache_file (new CacheFile("", TRUE));
-						
-						if (cache_file->open()) {
-							header->m_cachefile = cache_file.release();
-						}
-					}
-					tmp_io.release();
 					header.release();
 					return bitmap.release();
 				}
@@ -418,8 +408,8 @@ FreeImage_SaveMultiBitmapToHandle(FREE_IMAGE_FORMAT fif, FIMULTIBITMAP *bitmap,
 			
 			if(header->handle) {
 				// open src
-				header->io->seek_proc(header->handle, 0, SEEK_SET);
-				data_read = FreeImage_Open(header->node, header->io, header->handle, TRUE);
+				header->io.seek_proc(header->handle, 0, SEEK_SET);
+				data_read = FreeImage_Open(header->node, &header->io, header->handle, TRUE);
 			}
 			
 			// write all the pages to the file using handle and io
@@ -428,15 +418,13 @@ FreeImage_SaveMultiBitmapToHandle(FREE_IMAGE_FORMAT fif, FIMULTIBITMAP *bitmap,
 			
 			for (BlockListIterator i = header->m_blocks.begin(); i != header->m_blocks.end(); i++) {
 				if (success) {
-					switch((*i)->m_type) {
+					switch(i->m_type) {
 						case BLOCK_CONTINUEUS:
 						{
-							BlockContinueus *block = (BlockContinueus *)(*i);
-							
-							for (int j = block->m_start; j <= block->m_end; j++) {
-
+							for (int j = i->getStart(); j <= i->getEnd(); j++) {
+								
 								// load the original source data
-								FIBITMAP *dib = header->node->m_plugin->load_proc(header->io, header->handle, j, header->load_flags, data_read);
+								FIBITMAP *dib = header->node->m_plugin->load_proc(&header->io, header->handle, j, header->load_flags, data_read);
 								
 								// save the data
 								success = node->m_plugin->save_proc(io, dib, handle, count, flags, data);
@@ -450,17 +438,15 @@ FreeImage_SaveMultiBitmapToHandle(FREE_IMAGE_FORMAT fif, FIMULTIBITMAP *bitmap,
 						
 						case BLOCK_REFERENCE:
 						{
-							BlockReference *ref = (BlockReference *)(*i);
-							
 							// read the compressed data
 							
-							BYTE *compressed_data = (BYTE*)malloc(ref->m_size * sizeof(BYTE));
+							BYTE *compressed_data = (BYTE*)malloc(i->getSize() * sizeof(BYTE));
 							
-							header->m_cachefile->readFile((BYTE *)compressed_data, ref->m_reference, ref->m_size);
+							header->m_cachefile.readFile((BYTE *)compressed_data, i->getReference(), i->getSize());
 							
 							// uncompress the data
 							
-							FIMEMORY *hmem = FreeImage_OpenMemory(compressed_data, ref->m_size);
+							FIMEMORY *hmem = FreeImage_OpenMemory(compressed_data, i->getSize());
 							FIBITMAP *dib = FreeImage_LoadFromMemory(header->cache_fif, hmem, 0);
 							FreeImage_CloseMemory(hmem);
 							
@@ -486,7 +472,7 @@ FreeImage_SaveMultiBitmapToHandle(FREE_IMAGE_FORMAT fif, FIMULTIBITMAP *bitmap,
 			
 			// close the files
 			
-			FreeImage_Close(header->node, header->io, header->handle, data_read);
+			FreeImage_Close(header->node, &header->io, header->handle, data_read);
 
 			FreeImage_Close(node, io, handle, data); 
 			
@@ -507,7 +493,7 @@ FreeImage_CloseMultiBitmap(FIMULTIBITMAP *bitmap, int flags) {
 			MULTIBITMAPHEADER *header = FreeImage_GetMultiBitmapHeader(bitmap);			
 			
 			// saves changes only of images loaded directly from a file
-			if (header->changed && header->m_filename) {
+			if (header->changed && !header->m_filename.empty()) {
 				try {
 					// open a temp file
 
@@ -524,7 +510,7 @@ FreeImage_CloseMultiBitmap(FIMULTIBITMAP *bitmap, int flags) {
 						FreeImage_OutputMessageProc(header->fif, "Failed to open %s, %s", spool_name.c_str(), strerror(errno));
 						success = FALSE;
 					} else {
-						success = FreeImage_SaveMultiBitmapToHandle(header->fif, bitmap, header->io, (fi_handle)f, flags);
+						success = FreeImage_SaveMultiBitmapToHandle(header->fif, bitmap, &header->io, (fi_handle)f, flags);
 
 						// close the files
 
@@ -540,10 +526,10 @@ FreeImage_CloseMultiBitmap(FIMULTIBITMAP *bitmap, int flags) {
 					// applies changes to the destination file
 
 					if (success) {
-						remove(header->m_filename);
-						success = (rename(spool_name.c_str(), header->m_filename) == 0) ? TRUE:FALSE;
+						remove(header->m_filename.c_str());
+						success = (rename(spool_name.c_str(), header->m_filename.c_str()) == 0) ? TRUE:FALSE;
 						if(!success) {
-							FreeImage_OutputMessageProc(header->fif, "Failed to rename %s to %s", spool_name.c_str(), header->m_filename);
+							FreeImage_OutputMessageProc(header->fif, "Failed to rename %s to %s", spool_name.c_str(), header->m_filename.c_str());
 						}
 					} else {
 						remove(spool_name.c_str());
@@ -553,24 +539,11 @@ FreeImage_CloseMultiBitmap(FIMULTIBITMAP *bitmap, int flags) {
 				}
 
 			} else {
-				if (header->handle && header->m_filename) {
+				if (header->handle && !header->m_filename.empty()) {
 					fclose((FILE *)header->handle);
 				}
 			}
 
-			// clear the blocks list
-
-			for (BlockListIterator i = header->m_blocks.begin(); i != header->m_blocks.end(); ++i) {
-				delete *i;
-			}
-
-			// flush and dispose the cache
-
-			if (header->m_cachefile) {
-				header->m_cachefile->close();
-				delete header->m_cachefile;
-			}
-
 			// delete the last open bitmaps
 
 			while (!header->locked_pages.empty()) {
@@ -579,16 +552,6 @@ FreeImage_CloseMultiBitmap(FIMULTIBITMAP *bitmap, int flags) {
 				header->locked_pages.erase(header->locked_pages.begin()->first);
 			}
 
-			// get rid of the IO structure
-
-			delete header->io;
-
-			// delete the filename
-
-			if(header->m_filename) {
-				delete[] header->m_filename;
-			}
-
 			// delete the FIMULTIBITMAPHEADER
 
 			delete header;
@@ -611,15 +574,7 @@ FreeImage_GetPageCount(FIMULTIBITMAP *bitmap) {
 			header->page_count = 0;
 
 			for (BlockListIterator i = header->m_blocks.begin(); i != header->m_blocks.end(); ++i) {
-				switch((*i)->m_type) {
-					case BLOCK_CONTINUEUS :
-						header->page_count += ((BlockContinueus *)(*i))->m_end - ((BlockContinueus *)(*i))->m_start + 1;
-						break;
-
-					case BLOCK_REFERENCE :
-						header->page_count++;
-						break;
-				}
+				header->page_count += i->getPageCount();
 			}
 		}
 
@@ -629,10 +584,13 @@ FreeImage_GetPageCount(FIMULTIBITMAP *bitmap) {
 	return 0;
 }
 
-static BlockReference* 
+static PageBlock
 FreeImage_SavePageToBlock(MULTIBITMAPHEADER *header, FIBITMAP *data) {
-	if (header->read_only || !header->locked_pages.empty())
-		return NULL;
+	PageBlock res;
+	
+	if (header->read_only || !header->locked_pages.empty()) {
+		return res;
+	}
 
 	DWORD compressed_size = 0;
 	BYTE *compressed_data = NULL;
@@ -641,66 +599,69 @@ FreeImage_SavePageToBlock(MULTIBITMAPHEADER *header, FIBITMAP *data) {
 
 	// open a memory handle
 	FIMEMORY *hmem = FreeImage_OpenMemory();
-	if(hmem==NULL) return NULL;
+	if(hmem==NULL) {
+		return res;
+	}
 	// save the file to memory
 	if(!FreeImage_SaveToMemory(header->cache_fif, data, hmem, 0)) {
 		FreeImage_CloseMemory(hmem);
-		return NULL;
+		return res;
 	}
 	// get the buffer from the memory stream
 	if(!FreeImage_AcquireMemory(hmem, &compressed_data, &compressed_size)) {
 		FreeImage_CloseMemory(hmem);
-		return NULL;
+		return res;
 	}
-
+	
 	// write the compressed data to the cache
-	int ref = header->m_cachefile->writeFile(compressed_data, compressed_size);
+	int ref = header->m_cachefile.writeFile(compressed_data, compressed_size);
 	// get rid of the compressed data
 	FreeImage_CloseMemory(hmem);
-
-	return new(std::nothrow) BlockReference(ref, compressed_size);
+	
+	res = PageBlock(BLOCK_REFERENCE, ref, compressed_size);
+	
+	return res;
 }
 
 void DLL_CALLCONV
 FreeImage_AppendPage(FIMULTIBITMAP *bitmap, FIBITMAP *data) {
-	if (!bitmap || !data) 
+	if (!bitmap || !data) {
 		return;
-
+	}
+	
 	MULTIBITMAPHEADER *header = FreeImage_GetMultiBitmapHeader(bitmap);
-
-	BlockReference *block = FreeImage_SavePageToBlock(header, data);
-	if(block==NULL) return;
-
-	// add the block
-	header->m_blocks.push_back((BlockTypeS *)block);
-	header->changed = TRUE;
-	header->page_count = -1;
+	
+	if(const PageBlock block = FreeImage_SavePageToBlock(header, data)) {
+		// add the block
+		header->m_blocks.push_back(block);
+		header->changed = TRUE;
+		header->page_count = -1;
+	}
 }
 
 void DLL_CALLCONV
 FreeImage_InsertPage(FIMULTIBITMAP *bitmap, int page, FIBITMAP *data) {
-	if (!bitmap || !data) 
+	if (!bitmap || !data) {
 		return;
-
-	if (page >= FreeImage_GetPageCount(bitmap)) 
+	}
+	if (page >= FreeImage_GetPageCount(bitmap)) {
 		return;
-			
+	}
+	
 	MULTIBITMAPHEADER *header = FreeImage_GetMultiBitmapHeader(bitmap);
-
-	BlockReference *block = FreeImage_SavePageToBlock(header, data);
-	if(block==NULL) return;
-
-	// add a block
-	if (page > 0) {
-		BlockListIterator block_source = FreeImage_FindBlock(bitmap, page);		
-
-		header->m_blocks.insert(block_source, (BlockTypeS *)block);
-	} else {
-		header->m_blocks.push_front((BlockTypeS *)block);
+	
+	if(const PageBlock block = FreeImage_SavePageToBlock(header, data)) {
+		// add a block
+		if (page > 0) {
+			BlockListIterator block_source = FreeImage_FindBlock(bitmap, page);
+			header->m_blocks.insert(block_source, block);
+		} else {
+			header->m_blocks.push_front(block);
+		}
+		
+		header->changed = TRUE;
+		header->page_count = -1;
 	}
-
-	header->changed = TRUE;
-	header->page_count = -1;
 }
 
 void DLL_CALLCONV
@@ -711,21 +672,19 @@ FreeImage_DeletePage(FIMULTIBITMAP *bitmap, int page) {
 		if ((!header->read_only) && (header->locked_pages.empty())) {
 			if (FreeImage_GetPageCount(bitmap) > 1) {
 				BlockListIterator i = FreeImage_FindBlock(bitmap, page);
-
+				
 				if (i != header->m_blocks.end()) {
-					switch((*i)->m_type) {
+					switch(i->m_type) {
 						case BLOCK_CONTINUEUS :
-							delete *i;
 							header->m_blocks.erase(i);
 							break;
-
+							
 						case BLOCK_REFERENCE :
-							header->m_cachefile->deleteFile(((BlockReference *)(*i))->m_reference);
-							delete *i;
+							header->m_cachefile.deleteFile(i->getReference());
 							header->m_blocks.erase(i);
 							break;
 					}
-
+					
 					header->changed = TRUE;
 					header->page_count = -1;
 				}
@@ -734,7 +693,6 @@ FreeImage_DeletePage(FIMULTIBITMAP *bitmap, int page) {
 	}
 }
 
-
 FIBITMAP * DLL_CALLCONV
 FreeImage_LockPage(FIMULTIBITMAP *bitmap, int page) {
 	if (bitmap) {
@@ -749,19 +707,19 @@ FreeImage_LockPage(FIMULTIBITMAP *bitmap, int page) {
 		}
 
 		// open the bitmap
-
-		header->io->seek_proc(header->handle, 0, SEEK_SET);
-
-   		void *data = FreeImage_Open(header->node, header->io, header->handle, TRUE);
-
+		
+		header->io.seek_proc(header->handle, 0, SEEK_SET);
+		
+		void *data = FreeImage_Open(header->node, &header->io, header->handle, TRUE);
+		
 		// load the bitmap data
-
+		
 		if (data != NULL) {
-			FIBITMAP *dib = (header->node->m_plugin->load_proc != NULL) ? header->node->m_plugin->load_proc(header->io, header->handle, page, header->load_flags, data) : NULL;
+			FIBITMAP *dib = (header->node->m_plugin->load_proc != NULL) ? header->node->m_plugin->load_proc(&header->io, header->handle, page, header->load_flags, data) : NULL;
 
 			// close the file
-
-			FreeImage_Close(header->node, header->io, header->handle, data);
+			
+			FreeImage_Close(header->node, &header->io, header->handle, data);
 
 			// if there was still another bitmap open, get rid of it
 
@@ -787,7 +745,7 @@ FreeImage_UnlockPage(FIMULTIBITMAP *bitmap, FIBITMAP *page, BOOL changed) {
 
 		if (header->locked_pages.find(page) != header->locked_pages.end()) {
 			// store the bitmap compressed in the cache for later writing
-
+			
 			if (changed && !header->read_only) {
 				header->changed = TRUE;
 
@@ -808,35 +766,15 @@ FreeImage_UnlockPage(FIMULTIBITMAP *bitmap, FIBITMAP *page, BOOL changed) {
 				FreeImage_AcquireMemory(hmem, &compressed_data, &compressed_size);
 
 				// write the data to the cache
-
-				switch ((*i)->m_type) {
-					case BLOCK_CONTINUEUS :
-					{
-						int iPage = header->m_cachefile->writeFile(compressed_data, compressed_size);
-
-						delete (*i);
-
-						*i = (BlockTypeS *)new BlockReference(iPage, compressed_size);
-
-						break;
-					}
-
-					case BLOCK_REFERENCE :
-					{
-						BlockReference *reference = (BlockReference *)(*i);
-
-						header->m_cachefile->deleteFile(reference->m_reference);
-
-						delete (*i);
-
-						int iPage = header->m_cachefile->writeFile(compressed_data, compressed_size);
-
-						*i = (BlockTypeS *)new BlockReference(iPage, compressed_size);
-
-						break;
-					}
+				
+				if (i->m_type == BLOCK_REFERENCE) {
+					header->m_cachefile.deleteFile(i->getReference());
 				}
-
+				
+				int iPage = header->m_cachefile.writeFile(compressed_data, compressed_size);
+				
+				*i = PageBlock(BLOCK_REFERENCE, iPage, compressed_size);
+				
 				// get rid of the compressed data
 
 				FreeImage_CloseMemory(hmem);
@@ -863,9 +801,9 @@ FreeImage_MovePage(FIMULTIBITMAP *bitmap, int target, int source) {
 
 				header->m_blocks.insert(block_target, *block_source);			
 				header->m_blocks.erase(block_source);
-
+				
 				header->changed = TRUE;
-
+				
 				return TRUE;
 			}
 		}
@@ -889,8 +827,9 @@ FreeImage_GetLockedPageNumbers(FIMULTIBITMAP *bitmap, int *pages, int *count) {
 
 				c++;
 
-				if (c == *count)
+				if (c == *count) {
 					break;
+				}
 			}
 		}
 
@@ -916,10 +855,6 @@ FreeImage_LoadMultiBitmapFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream, int
 		PluginNode *node = list->FindNodeFromFIF(fif);
 
 		if (node) {
-			FreeImageIO *io = new(std::nothrow) FreeImageIO;
-
-			if (io) {
-				SetMemoryIO(io);
 
 				FIMULTIBITMAP *bitmap = new(std::nothrow) FIMULTIBITMAP;
 
@@ -927,14 +862,11 @@ FreeImage_LoadMultiBitmapFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream, int
 					MULTIBITMAPHEADER *header = new(std::nothrow) MULTIBITMAPHEADER;
 
 					if (header) {
-						header->m_filename = NULL;
 						header->node = node;
 						header->fif = fif;
-						header->io = io;
+						SetMemoryIO(&header->io);
 						header->handle = (fi_handle)stream;						
-						header->changed = FALSE;						
 						header->read_only = read_only;
-						header->m_cachefile = NULL;
 						header->cache_fif = fif;
 						header->load_flags = flags;
 
@@ -947,26 +879,17 @@ FreeImage_LoadMultiBitmapFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream, int
 						header->page_count = FreeImage_InternalGetPageCount(bitmap);
 
 						// allocate a continueus block to describe the bitmap
-
-						header->m_blocks.push_back((BlockTypeS *)new BlockContinueus(0, header->page_count - 1));
 						
-						if (!read_only) {
-							// set up the cache
-							CacheFile *cache_file = new(std::nothrow) CacheFile("", TRUE);
-							
-							if (cache_file && cache_file->open()) {
-								header->m_cachefile = cache_file;
-							}
-						}
+						header->m_blocks.push_back(PageBlock(BLOCK_CONTINUEUS, 0, header->page_count - 1));
+						
+						// no need to open cache - it is in-memory by default
 
 						return bitmap;
 					}
 					
 					delete bitmap;
 				}
-				
-				delete io;
-			}
+
 		}
 	}
 
diff --git a/libs/freeimage/src/FreeImage/Plugin.cpp b/libs/freeimage/src/FreeImage/Plugin.cpp
index 048237a540..0e5452c929 100644
--- a/libs/freeimage/src/FreeImage/Plugin.cpp
+++ b/libs/freeimage/src/FreeImage/Plugin.cpp
@@ -791,7 +791,7 @@ FreeImage_GetFIFFromFilenameU(const wchar_t *filename) {
 }
 
 BOOL DLL_CALLCONV
-FreeImage_Validate(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle) {
+FreeImage_ValidateFIF(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle) {
 	if (s_plugins != NULL) {
 		BOOL validated = FALSE;
 
diff --git a/libs/freeimage/src/FreeImage/PluginBMP.cpp b/libs/freeimage/src/FreeImage/PluginBMP.cpp
index 713a9140f7..ceae053893 100644
--- a/libs/freeimage/src/FreeImage/PluginBMP.cpp
+++ b/libs/freeimage/src/FreeImage/PluginBMP.cpp
@@ -1,4 +1,4 @@
-// ==========================================================
+// ==========================================================
 // BMP Loader and Writer
 //
 // Design and implementation by
@@ -7,6 +7,7 @@
 // - Martin Weber (martweb@gmx.net)
 // - Hervé Drolon (drolon@infonie.fr)
 // - Michal Novotny (michal@etc.cz)
+// - Mihail Naydenov (mnaydenov@users.sourceforge.net)
 //
 // This file is part of FreeImage 3
 //
@@ -579,8 +580,13 @@ LoadWindowsBMP(FreeImageIO *io, fi_handle handle, int flags, unsigned bitmap_bit
 					DWORD bitfields[4];
 					io->read_proc(bitfields, use_bitfields * sizeof(DWORD), 1, handle);
 					dib = FreeImage_AllocateHeader(header_only, width, height, bit_count, bitfields[0], bitfields[1], bitfields[2]);
-				} else
-					dib = FreeImage_AllocateHeader(header_only, width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+				} else {
+					if( bit_count == 32 ) {
+						dib = FreeImage_AllocateHeader(header_only, width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+					} else {
+						dib = FreeImage_AllocateHeader(header_only, width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+					}
+				}
 
 				if (dib == NULL) {
 					throw FI_MSG_ERROR_DIB_MEMORY;
@@ -782,7 +788,11 @@ LoadOS22XBMP(FreeImageIO *io, fi_handle handle, int flags, unsigned bitmap_bits_
 			case 24 :
 			case 32 :
 			{
-				dib = FreeImage_AllocateHeader(header_only, width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+				if( bit_count == 32 ) {
+					dib = FreeImage_AllocateHeader(header_only, width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+				} else {
+					dib = FreeImage_AllocateHeader(header_only, width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+				}
 
 				if (dib == NULL) {
 					throw FI_MSG_ERROR_DIB_MEMORY;
@@ -925,7 +935,11 @@ LoadOS21XBMP(FreeImageIO *io, fi_handle handle, int flags, unsigned bitmap_bits_
 			case 24 :
 			case 32 :
 			{
-				dib = FreeImage_AllocateHeader(header_only, width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+				if( bit_count == 32 ) {
+					dib = FreeImage_AllocateHeader(header_only, width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+				} else {
+					dib = FreeImage_AllocateHeader(header_only, width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+				}
 
 				if (dib == NULL) {
 					throw FI_MSG_ERROR_DIB_MEMORY;						
@@ -1249,16 +1263,24 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 	if ((dib != NULL) && (handle != NULL)) {
 		// write the file header
 
+		const unsigned dst_width = FreeImage_GetWidth(dib);
+		const unsigned dst_height = FreeImage_GetHeight(dib);
+
+		// note that the dib may have been created using FreeImage_CreateView
+		// we need to recalculate the dst pitch here
+		const unsigned dst_bpp = FreeImage_GetBPP(dib);
+		const unsigned dst_pitch = CalculatePitch(CalculateLine(dst_width, dst_bpp));
+
 		BITMAPFILEHEADER bitmapfileheader;
 		bitmapfileheader.bfType = 0x4D42;
 		bitmapfileheader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + FreeImage_GetColorsUsed(dib) * sizeof(RGBQUAD);
-		bitmapfileheader.bfSize = bitmapfileheader.bfOffBits + FreeImage_GetHeight(dib) * FreeImage_GetPitch(dib);
+		bitmapfileheader.bfSize = bitmapfileheader.bfOffBits + dst_height * dst_pitch;
 		bitmapfileheader.bfReserved1 = 0;
 		bitmapfileheader.bfReserved2 = 0;
 
 		// take care of the bit fields data of any
 
-		bool bit_fields = (FreeImage_GetBPP(dib) == 16);
+		bool bit_fields = (dst_bpp == 16) ? true : false;
 
 		if (bit_fields) {
 			bitmapfileheader.bfSize += 3 * sizeof(DWORD);
@@ -1268,28 +1290,33 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 #ifdef FREEIMAGE_BIGENDIAN
 		SwapFileHeader(&bitmapfileheader);
 #endif
-		if (io->write_proc(&bitmapfileheader, sizeof(BITMAPFILEHEADER), 1, handle) != 1)
-			return FALSE;		
+		if (io->write_proc(&bitmapfileheader, sizeof(BITMAPFILEHEADER), 1, handle) != 1) {
+			return FALSE;
+		}
 
 		// update the bitmap info header
 
 		BITMAPINFOHEADER bih;
 		memcpy(&bih, FreeImage_GetInfoHeader(dib), sizeof(BITMAPINFOHEADER));
 
-		if (bit_fields)
+		if (bit_fields) {
 			bih.biCompression = BI_BITFIELDS;
-		else if ((bih.biBitCount == 8) && (flags & BMP_SAVE_RLE))
+		}
+		else if ((bih.biBitCount == 8) && ((flags & BMP_SAVE_RLE) == BMP_SAVE_RLE)) {
 			bih.biCompression = BI_RLE8;
-		else
+		}
+		else {
 			bih.biCompression = BI_RGB;
+		}
 
 		// write the bitmap info header
 
 #ifdef FREEIMAGE_BIGENDIAN
 		SwapInfoHeader(&bih);
 #endif
-		if (io->write_proc(&bih, sizeof(BITMAPINFOHEADER), 1, handle) != 1)
+		if (io->write_proc(&bih, sizeof(BITMAPINFOHEADER), 1, handle) != 1) {
 			return FALSE;
+		}
 
 		// write the bit fields when we are dealing with a 16 bit BMP
 
@@ -1298,18 +1325,21 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 
 			d = FreeImage_GetRedMask(dib);
 
-			if (io->write_proc(&d, sizeof(DWORD), 1, handle) != 1)
+			if (io->write_proc(&d, sizeof(DWORD), 1, handle) != 1) {
 				return FALSE;
+			}
 
 			d = FreeImage_GetGreenMask(dib);
 
-			if (io->write_proc(&d, sizeof(DWORD), 1, handle) != 1)
+			if (io->write_proc(&d, sizeof(DWORD), 1, handle) != 1) {
 				return FALSE;
+			}
 
 			d = FreeImage_GetBlueMask(dib);
 
-			if (io->write_proc(&d, sizeof(DWORD), 1, handle) != 1)
+			if (io->write_proc(&d, sizeof(DWORD), 1, handle) != 1) {
 				return FALSE;
+			}
 		}
 
 		// write the palette
@@ -1322,18 +1352,18 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 				bgra.g = pal[i].rgbGreen;
 				bgra.r = pal[i].rgbRed;
 				bgra.a = pal[i].rgbReserved;
-				if (io->write_proc(&bgra, sizeof(FILE_BGRA), 1, handle) != 1)
+				if (io->write_proc(&bgra, sizeof(FILE_BGRA), 1, handle) != 1) {
 					return FALSE;
+				}
 			}
 		}
 
 		// write the bitmap data... if RLE compression is enable, use it
 
-		unsigned bpp = FreeImage_GetBPP(dib);
-		if ((bpp == 8) && (flags & BMP_SAVE_RLE)) {
-			BYTE *buffer = (BYTE*)malloc(FreeImage_GetPitch(dib) * 2 * sizeof(BYTE));
+		if ((dst_bpp == 8) && ((flags & BMP_SAVE_RLE) == BMP_SAVE_RLE)) {
+			BYTE *buffer = (BYTE*)malloc(dst_pitch * 2 * sizeof(BYTE));
 
-			for (DWORD i = 0; i < FreeImage_GetHeight(dib); ++i) {
+			for (unsigned i = 0; i < dst_height; ++i) {
 				int size = RLEEncodeLine(buffer, FreeImage_GetScanLine(dib, i), FreeImage_GetLine(dib));
 
 				if (io->write_proc(buffer, size, 1, handle) != 1) {
@@ -1353,16 +1383,17 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 			free(buffer);
 #ifdef FREEIMAGE_BIGENDIAN
 		} else if (bpp == 16) {
-			int padding = FreeImage_GetPitch(dib) - FreeImage_GetWidth(dib) * sizeof(WORD);
+			int padding = dst_pitch - dst_width * sizeof(WORD);
 			WORD pad = 0;
 			WORD pixel;
-			for(unsigned y = 0; y < FreeImage_GetHeight(dib); y++) {
+			for(unsigned y = 0; y < dst_height; y++) {
 				BYTE *line = FreeImage_GetScanLine(dib, y);
-				for(unsigned x = 0; x < FreeImage_GetWidth(dib); x++) {
+				for(unsigned x = 0; x < dst_width; x++) {
 					pixel = ((WORD *)line)[x];
 					SwapShort(&pixel);
-					if (io->write_proc(&pixel, sizeof(WORD), 1, handle) != 1)
+					if (io->write_proc(&pixel, sizeof(WORD), 1, handle) != 1) {
 						return FALSE;
+					}
 				}
 				if(padding != 0) {
 					if(io->write_proc(&pad, padding, 1, handle) != 1) {
@@ -1373,18 +1404,19 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 #endif
 #if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_RGB
 		} else if (bpp == 24) {
-			int padding = FreeImage_GetPitch(dib) - FreeImage_GetWidth(dib) * sizeof(FILE_BGR);
+			int padding = dst_pitch - dst_width * sizeof(FILE_BGR);
 			DWORD pad = 0;
 			FILE_BGR bgr;
-			for(unsigned y = 0; y < FreeImage_GetHeight(dib); y++) {
+			for(unsigned y = 0; y < dst_height; y++) {
 				BYTE *line = FreeImage_GetScanLine(dib, y);
-				for(unsigned x = 0; x < FreeImage_GetWidth(dib); x++) {
+				for(unsigned x = 0; x < dst_width; x++) {
 					RGBTRIPLE *triple = ((RGBTRIPLE *)line)+x;
 					bgr.b = triple->rgbtBlue;
 					bgr.g = triple->rgbtGreen;
 					bgr.r = triple->rgbtRed;
-					if (io->write_proc(&bgr, sizeof(FILE_BGR), 1, handle) != 1)
+					if (io->write_proc(&bgr, sizeof(FILE_BGR), 1, handle) != 1) {
 						return FALSE;
+					}
 				}
 				if(padding != 0) {
 					if(io->write_proc(&pad, padding, 1, handle) != 1) {
@@ -1394,24 +1426,36 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 			}
 		} else if (bpp == 32) {
 			FILE_BGRA bgra;
-			for(unsigned y = 0; y < FreeImage_GetHeight(dib); y++) {
+			for(unsigned y = 0; y < dst_height; y++) {
 				BYTE *line = FreeImage_GetScanLine(dib, y);
-				for(unsigned x = 0; x < FreeImage_GetWidth(dib); x++) {
+				for(unsigned x = 0; x < dst_width; x++) {
 					RGBQUAD *quad = ((RGBQUAD *)line)+x;
 					bgra.b = quad->rgbBlue;
 					bgra.g = quad->rgbGreen;
 					bgra.r = quad->rgbRed;
 					bgra.a = quad->rgbReserved;
-					if (io->write_proc(&bgra, sizeof(FILE_BGRA), 1, handle) != 1)
+					if (io->write_proc(&bgra, sizeof(FILE_BGRA), 1, handle) != 1) {
 						return FALSE;
+					}
 				}
 			}
 #endif
-		} else if (io->write_proc(FreeImage_GetBits(dib), FreeImage_GetHeight(dib) * FreeImage_GetPitch(dib), 1, handle) != 1) {
-			return FALSE;
+		} 
+		else if (FreeImage_GetPitch(dib) == dst_pitch) {
+			return (io->write_proc(FreeImage_GetBits(dib), dst_height * dst_pitch, 1, handle) != 1) ? FALSE : TRUE;
+		}
+		else {
+			for (unsigned y = 0; y < dst_height; y++) {
+				BYTE *line = (BYTE*)FreeImage_GetScanLine(dib, y);
+				
+				if (io->write_proc(line, dst_pitch, 1, handle) != 1) {
+					return FALSE;
+				}
+			}
 		}
 
 		return TRUE;
+
 	} else {
 		return FALSE;
 	}
diff --git a/libs/freeimage/src/FreeImage/PluginGIF.cpp b/libs/freeimage/src/FreeImage/PluginGIF.cpp
index 1a7a84041b..8fe0422b31 100644
--- a/libs/freeimage/src/FreeImage/PluginGIF.cpp
+++ b/libs/freeimage/src/FreeImage/PluginGIF.cpp
@@ -3,9 +3,13 @@
 //
 // Design and implementation by
 // - Ryan Rubley <ryan@lostreality.org>
-// - Raphaлl Gaquer <raphael.gaquer@alcer.com>
+// - Raphaël Gaquer <raphael.gaquer@alcer.com>
 // - Aaron Shumate <aaron@shumate.us>
 //
+// References
+// http://www.w3.org/Graphics/GIF/spec-gif87.txt
+// http://www.w3.org/Graphics/GIF/spec-gif89a.txt
+//
 // This file is part of FreeImage 3
 //
 // COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
@@ -41,6 +45,7 @@
 //   Constant/Typedef declarations
 // ==========================================================
 
+
 struct GIFinfo {
 	BOOL read;
 	//only really used when reading
@@ -488,23 +493,20 @@ MimeType() {
 	return "image/gif";
 }
 
-static BOOL DLL_CALLCONV 
+static BOOL DLL_CALLCONV
 Validate(FreeImageIO *io, fi_handle handle) {
-	char buf[6];
-	if( io->read_proc(buf, 6, 1, handle) < 1 ) {
-		return FALSE;
-	}
+	BYTE GIF89a[] = { 0x47, 0x49, 0x46, 0x38, 0x39, 0x61 };	// ASCII code for "GIF89a"
+	BYTE GIF87a[] = { 0x47, 0x49, 0x46, 0x38, 0x37, 0x61 };	// ASCII code for "GIF87a"
+	BYTE signature[6] = { 0, 0, 0, 0, 0, 0 };
 
-	BOOL bResult = FALSE;
-	if( !strncmp(buf, "GIF", 3) ) {
-		if( buf[3] >= '0' && buf[3] <= '9' && buf[4] >= '0' && buf[4] <= '9' && buf[5] >= 'a' && buf[5] <= 'z' ) {
-			bResult = TRUE;
-		}
-	}
+	io->read_proc(signature, 1, 6, handle);
 
-	io->seek_proc(handle, -6, SEEK_CUR);
+	if (memcmp(GIF89a, signature, 6) == 0)
+		return TRUE;
+	if (memcmp(GIF87a, signature, 6) == 0)
+		return TRUE;
 
-	return bResult;
+	return FALSE;
 }
 
 static BOOL DLL_CALLCONV 
@@ -528,18 +530,15 @@ Open(FreeImageIO *io, fi_handle handle, BOOL read) {
 		return NULL;
 	}
 
-	// 25/02/2008 MDA:	Not safe to memset GIFinfo structure with VS 2008 (safe iterators),
-	//					perform initialization in constructor instead.
-	// memset(info, 0, sizeof(GIFinfo));
-
+	// set Read/Write mode
 	info->read = read;
+
 	if( read ) {
 		try {
-			//Header
+			// read Header (6 bytes)
 			if( !Validate(io, handle) ) {
 				throw FI_MSG_ERROR_MAGIC_NUMBER;
 			}
-			io->seek_proc(handle, 6, SEEK_CUR);
 
 			//Logical Screen Descriptor
 			io->seek_proc(handle, 4, SEEK_CUR);
@@ -1013,19 +1012,19 @@ Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
 			}
 			FreeImage_SetMetadataEx(FIMD_ANIMATION, dib, "Loop", ANIMTAG_LOOP, FIDT_LONG, 1, 4, &loop);
 
-			// Comment Extension
-			for (idx = 0; idx < info->comment_extension_offsets.size(); idx++) {
+			//Comment Extension
+			for( idx = 0; idx < info->comment_extension_offsets.size(); idx++ ) {
 				io->seek_proc(handle, (long)info->comment_extension_offsets[idx], SEEK_SET);
 				std::string comment;
 				char buf[255];
 				io->read_proc(&b, 1, 1, handle);
-				while (b) {
+				while( b ) {
 					io->read_proc(buf, b, 1, handle);
 					comment.append(buf, b);
 					io->read_proc(&b, 1, 1, handle);
 				}
 				comment.append(1, '\0');
-				sprintf(buf, "Comment%d", (int)idx);
+				sprintf(buf, "Comment%zd", idx);
 				DWORD comment_size = (DWORD)comment.size();
 				FreeImage_SetMetadataEx(FIMD_COMMENTS, dib, buf, 1, FIDT_ASCII, comment_size, comment_size, comment.c_str());
 			}
diff --git a/libs/freeimage/src/FreeImage/PluginJPEG.cpp b/libs/freeimage/src/FreeImage/PluginJPEG.cpp
index 49e653d9e0..4dbd5d26a6 100644
--- a/libs/freeimage/src/FreeImage/PluginJPEG.cpp
+++ b/libs/freeimage/src/FreeImage/PluginJPEG.cpp
@@ -1,4 +1,4 @@
-// ==========================================================
+// ==========================================================
 // JPEG Loader and writer
 // Based on code developed by The Independent JPEG Group
 //
@@ -1126,8 +1126,9 @@ Validate(FreeImageIO *io, fi_handle handle) {
 static BOOL DLL_CALLCONV
 SupportsExportDepth(int depth) {
 	return (
-			(depth == 8) ||
-			(depth == 24)
+			(depth == 8)  ||
+			(depth == 24) ||
+			(depth == 32)	// only if 32-bit CMYK
 		);
 }
 
@@ -1315,6 +1316,10 @@ Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
 						dst += 3;
 					}
 				}
+				
+				// if original image is CMYK but is converted to RGB, remove ICC profile from Exif-TIFF metadata
+				FreeImage_SetMetadata(FIMD_EXIF_MAIN, dib, "InterColorProfile", NULL);
+
 			} else if((cinfo.out_color_space == JCS_CMYK) && ((flags & JPEG_CMYK) == JPEG_CMYK)) {
 				// convert from LibJPEG CMYK to standard CMYK
 
@@ -1400,12 +1405,12 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 		try {
 			// Check dib format
 
-			const char *sError = "only 24-bit highcolor or 8-bit greyscale/palette bitmaps can be saved as JPEG";
+			const char *sError = "only 24-bit RGB, 8-bit greyscale/palette or 32-bit CMYK bitmaps can be saved as JPEG";
 
 			FREE_IMAGE_COLOR_TYPE color_type = FreeImage_GetColorType(dib);
 			WORD bpp = (WORD)FreeImage_GetBPP(dib);
 
-			if ((bpp != 24) && (bpp != 8)) {
+			if ((bpp != 24) && (bpp != 8) && !(bpp == 32 && (color_type == FIC_CMYK))) {
 				throw sError;
 			}
 
@@ -1454,7 +1459,10 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 					cinfo.in_color_space = JCS_GRAYSCALE;
 					cinfo.input_components = 1;
 					break;
-
+				case FIC_CMYK:
+					cinfo.in_color_space = JCS_CMYK;
+					cinfo.input_components = 4;
+					break;
 				default :
 					cinfo.in_color_space = JCS_RGB;
 					cinfo.input_components = 3;
@@ -1481,14 +1489,14 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 
 			// thumbnail support (JFIF 1.02 extension markers)
 			if(FreeImage_GetThumbnail(dib) != NULL) {
-				cinfo.write_JFIF_header = 1; //<### force it, though when color is CMYK it will be incorrect
+				cinfo.write_JFIF_header = static_cast<boolean>(1); //<### force it, though when color is CMYK it will be incorrect
 				cinfo.JFIF_minor_version = 2;
 			}
 
 			// baseline JPEG support
-			if ((flags & JPEG_BASELINE) ==  JPEG_BASELINE) {
-				cinfo.write_JFIF_header = 0;	// No marker for non-JFIF colorspaces
-				cinfo.write_Adobe_marker = 0;	// write no Adobe marker by default				
+			if ((flags & JPEG_BASELINE) == JPEG_BASELINE) {
+				cinfo.write_JFIF_header = static_cast<boolean>(0);	// No marker for non-JFIF colorspaces
+				cinfo.write_Adobe_marker = static_cast<boolean>(0);	// write no Adobe marker by default				
 			}
 
 			// set subsampling options if required
@@ -1598,6 +1606,33 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 				}
 				free(target);
 			}
+			else if(color_type == FIC_CMYK) {
+				unsigned pitch = FreeImage_GetPitch(dib);
+				BYTE *target = (BYTE*)malloc(pitch * sizeof(BYTE));
+				if (target == NULL) {
+					throw FI_MSG_ERROR_MEMORY;
+				}
+				
+				while (cinfo.next_scanline < cinfo.image_height) {
+					// get a copy of the scanline
+					memcpy(target, FreeImage_GetScanLine(dib, FreeImage_GetHeight(dib) - cinfo.next_scanline - 1), pitch);
+					
+					BYTE *target_p = target;
+					for(unsigned x = 0; x < cinfo.image_width; x++) {
+						// CMYK pixels are inverted
+						target_p[0] = ~target_p[0];	// C
+						target_p[1] = ~target_p[1];	// M
+						target_p[2] = ~target_p[2];	// Y
+						target_p[3] = ~target_p[3];	// K
+
+						target_p += 4;
+					}
+					
+					// write the scanline
+					jpeg_write_scanlines(&cinfo, &target, 1);
+				}
+				free(target);
+			}
 			else if(color_type == FIC_MINISBLACK) {
 				// 8-bit standard greyscale images
 				while (cinfo.next_scanline < cinfo.image_height) {
diff --git a/libs/freeimage/src/FreeImage/PluginPNG.cpp b/libs/freeimage/src/FreeImage/PluginPNG.cpp
index 0753192140..c64f12d465 100644
--- a/libs/freeimage/src/FreeImage/PluginPNG.cpp
+++ b/libs/freeimage/src/FreeImage/PluginPNG.cpp
@@ -1,9 +1,9 @@
-// ==========================================================
+// ==========================================================
 // PNG Loader and Writer
 //
 // Design and implementation by
 // - Floris van den Berg (flvdberg@wxs.nl)
-// - Herve Drolon (drolon@infonie.fr)
+// - Hervé Drolon (drolon@infonie.fr)
 // - Detlev Vendt (detlev.vendt@brillit.de)
 // - Aaron Shumate (trek@startreker.com)
 // - Tanner Helland (tannerhelland@users.sf.net)
@@ -50,6 +50,12 @@ typedef struct {
 } fi_ioStructure, *pfi_ioStructure;
 
 // ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
 // libpng interface
 // ==========================================================
 
@@ -76,8 +82,8 @@ _FlushProc(png_structp png_ptr) {
 
 static void
 error_handler(png_structp png_ptr, const char *error) {
-	(png_structp)png_ptr;
-	throw error;
+	FreeImage_OutputMessageProc(s_format_id, error);
+	png_longjmp(png_ptr, 1);
 }
 
 // in FreeImage warnings disabled
@@ -234,12 +240,6 @@ WriteMetadata(png_structp png_ptr, png_infop info_ptr, FIBITMAP *dib) {
 }
 
 // ==========================================================
-// Plugin Interface
-// ==========================================================
-
-static int s_format_id;
-
-// ==========================================================
 // Plugin Implementation
 // ==========================================================
 
@@ -548,11 +548,13 @@ Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
 
 			// init the IO
 
-			png_set_read_fn(png_ptr, &fio, _ReadProc);
+			png_set_read_fn(png_ptr, &fio, _ReadProc);            
+			
+			// PNG errors will be redirected here
 
-            if (setjmp(png_jmpbuf(png_ptr))) {
-				png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-				return NULL;
+			if (setjmp(png_jmpbuf(png_ptr))) {
+				// assume error_handler was called before by the PNG library
+				throw((const char*)NULL);
 			}
 
 			// because we have already read the signature...
@@ -789,7 +791,9 @@ Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
 			if (dib) {
 				FreeImage_Unload(dib);
 			}
-			FreeImage_OutputMessageProc(s_format_id, text);
+			if (NULL != text) {
+				FreeImage_OutputMessageProc(s_format_id, text);
+			}
 			
 			return NULL;
 		}
@@ -990,6 +994,8 @@ Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void
 
 			FIICCPROFILE *iccProfile = FreeImage_GetICCProfile(dib);
 			if (iccProfile->size && iccProfile->data) {
+				// skip ICC profile check
+				png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, 1);
 				png_set_iCCP(png_ptr, info_ptr, "Embedded Profile", 0, (png_const_bytep)iccProfile->data, iccProfile->size);
 			}
 
diff --git a/libs/freeimage/src/FreeImageToolkit/BSplineRotate.cpp b/libs/freeimage/src/FreeImageToolkit/BSplineRotate.cpp
index c58c46af2b..6c4c7a7bd2 100644
--- a/libs/freeimage/src/FreeImageToolkit/BSplineRotate.cpp
+++ b/libs/freeimage/src/FreeImageToolkit/BSplineRotate.cpp
@@ -1,4 +1,4 @@
-// ==========================================================
+// ==========================================================
 // Bitmap rotation using B-Splines
 //
 // Design and implementation by
@@ -667,7 +667,11 @@ FreeImage_RotateEx(FIBITMAP *dib, double angle, double x_shift, double y_shift,
 			// allocate dst image
 			int width  = FreeImage_GetWidth(dib);
 			int height = FreeImage_GetHeight(dib);
-			dst = FreeImage_Allocate(width, height, bpp, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+			if( bpp == 24 ) {
+				dst = FreeImage_Allocate(width, height, bpp, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+			} else {
+				dst = FreeImage_Allocate(width, height, bpp, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+			}
 			if(!dst) throw(1);
 
 			// allocate a temporary 8-bit dib (no need to build a palette)
diff --git a/libs/freeimage/src/FreeImageToolkit/Display.cpp b/libs/freeimage/src/FreeImageToolkit/Display.cpp
index deaefe5a39..aa61f37493 100644
--- a/libs/freeimage/src/FreeImageToolkit/Display.cpp
+++ b/libs/freeimage/src/FreeImageToolkit/Display.cpp
@@ -1,4 +1,4 @@
-// ==========================================================
+// ==========================================================
 // Display routines
 //
 // Design and implementation by
@@ -191,7 +191,7 @@ channel(x, y) = channel(x, y) * alpha_channel(x, y) / 255
 @return Returns TRUE on success, FALSE otherwise (e.g. when the bitdepth of the source dib cannot be handled). 
 */
 BOOL DLL_CALLCONV 
-FreeImage_PremultiplyWithAlpha(FIBITMAP *dib) {
+FreeImage_PreMultiplyWithAlpha(FIBITMAP *dib) {
 	if (!FreeImage_HasPixels(dib)) return FALSE;
 	
 	if ((FreeImage_GetBPP(dib) != 32) || (FreeImage_GetImageType(dib) != FIT_BITMAP)) {
diff --git a/libs/freeimage/src/MapIntrospector.h b/libs/freeimage/src/MapIntrospector.h
index 091ba68b26..4c10c2cafa 100644
--- a/libs/freeimage/src/MapIntrospector.h
+++ b/libs/freeimage/src/MapIntrospector.h
@@ -19,8 +19,8 @@
 // Use at your own risk!
 // ==========================================================
 
-#ifndef MAPINTROSPECTOR_H_
-#define MAPINTROSPECTOR_H_
+#ifndef FREEIMAGE_MAPINTROSPECTOR_H_
+#define FREEIMAGE_MAPINTROSPECTOR_H_
 
 // we need at least one C++ header included, 
 // that defines the C++ Standard Library's version macro, 
@@ -209,4 +209,5 @@ public:
 
 #endif // Standard C++ Library
 
-#endif // MAPINTROSPECTOR_H_
+#endif // FREEIMAGE_MAPINTROSPECTOR_H_
+
diff --git a/libs/freeimage/src/Metadata/Exif.cpp b/libs/freeimage/src/Metadata/Exif.cpp
index 1d456ab3bd..8c37455b32 100644
--- a/libs/freeimage/src/Metadata/Exif.cpp
+++ b/libs/freeimage/src/Metadata/Exif.cpp
@@ -1,10 +1,11 @@
-// ==========================================================
+// ==========================================================
 // Metadata functions implementation
 // Exif metadata model
 //
 // Design and implementation by
 // - Hervé Drolon (drolon@infonie.fr)
 // - Mihail Naydenov (mnaydenov@users.sourceforge.net)
+// - Garrick Meeker (garrickmeeker@users.sourceforge.net)
 //
 // Based on the following implementations:
 // - metadata-extractor : http://www.drewnoakes.com/code/exif/
@@ -1251,3 +1252,106 @@ tiff_get_ifd_profile(FIBITMAP *dib, FREE_IMAGE_MDMODEL md_model, BYTE **ppbProfi
 		return FALSE;
 	}
 }
+
+// ----------------------------------------------------------
+//   Exif PSD routines
+// ----------------------------------------------------------
+
+/**
+Read and decode PSD image resource (Exif profile)
+@param dib Input FIBITMAP
+@param data Pointer to the resource data
+@param length Resource length
+@return Returns TRUE if successful, FALSE otherwise
+*/
+BOOL
+psd_read_exif_profile(FIBITMAP *dib, const BYTE *data, unsigned int length) {
+	BYTE lsb_first[4] = { 0x49, 0x49, 0x2A, 0x00 };		// Classic TIFF signature - little-endian order
+	BYTE msb_first[4] = { 0x4D, 0x4D, 0x00, 0x2A };		// Classic TIFF signature - big-endian order
+
+	// profile size is up to 32-bit
+	DWORD dwProfileLength = (DWORD)length;
+	BYTE *pbProfile = (BYTE*)data;
+
+	// This is an Exif profile
+	// should contain a TIFF header with up to 2 IFDs (IFD stands for 'Image File Directory')
+	// 0th IFD : the image attributes, 1st IFD : may be used for thumbnail
+
+	// read the TIFF header (8 bytes)
+
+	// check the endianess order
+
+	BOOL bBigEndian = TRUE;
+
+	if(memcmp(pbProfile, lsb_first, sizeof(lsb_first)) == 0) {
+		// Exif section is in little-endian order
+		bBigEndian = FALSE;
+	} else {
+		if(memcmp(pbProfile, msb_first, sizeof(msb_first)) == 0) {
+			// Exif section is in big-endian order
+			bBigEndian = TRUE;
+		} else {
+			// Invalid Exif alignment marker
+			return FALSE;
+		}
+	}
+
+	// this is the offset to the first IFD (Image File Directory)
+	DWORD dwFirstOffset = ReadUint32(bBigEndian, pbProfile + 4);
+	if (dwFirstOffset > dwProfileLength) {
+		// bad Exif data
+		return FALSE;
+	}
+
+	// process Exif directories, starting with Exif-TIFF IFD
+	return jpeg_read_exif_dir(dib, pbProfile, dwFirstOffset, dwProfileLength, 0, bBigEndian, TagLib::EXIF_MAIN);
+}
+
+/**
+Read PSD image resource (Exif profile)
+@param dib Input FIBITMAP
+@param dataptr Pointer to the resource data
+@param datalen Resource length
+@return Returns TRUE if successful, FALSE otherwise
+*/
+BOOL
+psd_read_exif_profile_raw(FIBITMAP *dib, const BYTE *profile, unsigned length) {
+    // marker identifying string for Exif = "Exif\0\0"
+	// used by JPEG not PSD
+    BYTE exif_signature[6] = { 0x45, 0x78, 0x69, 0x66, 0x00, 0x00 };
+
+	if(NULL == profile || length == 0) {
+		return FALSE;
+	}
+
+	DWORD dwProfileLength = (DWORD)length + sizeof(exif_signature);
+	BYTE *pbProfile = (BYTE*)malloc(dwProfileLength);
+	if(NULL == pbProfile) {
+		// out of memory ...
+		return FALSE;
+	}
+	memcpy(pbProfile, exif_signature, sizeof(exif_signature));
+	memcpy(pbProfile + sizeof(exif_signature), profile, length);
+
+	// create a tag
+	FITAG *tag = FreeImage_CreateTag();
+	BOOL bSuccess = FALSE;
+	if(tag) {
+		FreeImage_SetTagKey(tag, g_TagLib_ExifRawFieldName);
+		FreeImage_SetTagLength(tag, dwProfileLength);
+		FreeImage_SetTagCount(tag, dwProfileLength);
+		FreeImage_SetTagType(tag, FIDT_BYTE);
+		FreeImage_SetTagValue(tag, pbProfile);
+
+		// store the tag
+		FreeImage_SetMetadata(FIMD_EXIF_RAW, dib, FreeImage_GetTagKey(tag), tag);
+
+		// destroy the tag
+		FreeImage_DeleteTag(tag);
+
+		bSuccess = TRUE;
+	}
+	free(pbProfile);
+
+	return bSuccess;
+}
diff --git a/libs/freeimage/src/Metadata/FreeImageTag.h b/libs/freeimage/src/Metadata/FreeImageTag.h
index 5a6e4f99f6..728470f806 100644
--- a/libs/freeimage/src/Metadata/FreeImageTag.h
+++ b/libs/freeimage/src/Metadata/FreeImageTag.h
@@ -1,4 +1,4 @@
-// ==========================================================
+// ==========================================================
 // Tag manipulation functions
 //
 // Design and implementation by
@@ -19,8 +19,8 @@
 // Use at your own risk!
 // ==========================================================
 
-#ifndef FREEIMAGETAG_H
-#define FREEIMAGETAG_H
+#ifndef FREEIMAGE_TAG_H
+#define FREEIMAGE_TAG_H
 
 // ==========================================================
 // Exif JPEG tags
@@ -484,7 +484,13 @@ BOOL jpegxr_read_exif_gps_profile(FIBITMAP *dib, const BYTE *profile, unsigned l
 BOOL tiff_get_ifd_profile(FIBITMAP *dib, FREE_IMAGE_MDMODEL md_model, BYTE **ppbProfile, unsigned *uProfileLength);
 
 
-// JPEG / TIFF IPTC profile (see IPTC.cpp)
+// PSD Exif profile (see Exif.cpp)
+// --------------------------------------------------------------------------
+BOOL psd_read_exif_profile(FIBITMAP *dib, const BYTE *dataptr, unsigned datalen);
+BOOL psd_read_exif_profile_raw(FIBITMAP *dib, const BYTE *dataptr, unsigned datalen);
+
+
+// JPEG / PSD / TIFF IPTC profile (see IPTC.cpp)
 // --------------------------------------------------------------------------
 BOOL read_iptc_profile(FIBITMAP *dib, const BYTE *dataptr, unsigned int datalen);
 BOOL write_iptc_profile(FIBITMAP *dib, BYTE **profile, unsigned *profile_size);
@@ -494,6 +500,6 @@ BOOL write_iptc_profile(FIBITMAP *dib, BYTE **profile, unsigned *profile_size);
 #endif
 
 
-#endif // FREEIMAGETAG_H
+#endif // FREEIMAGE_TAG_H
 
 
diff --git a/libs/freeimage/src/Plugin.h b/libs/freeimage/src/Plugin.h
index 76ffc90522..5886fd7721 100644
--- a/libs/freeimage/src/Plugin.h
+++ b/libs/freeimage/src/Plugin.h
@@ -97,7 +97,7 @@ int FreeImage_stricmp(const char *s1, const char *s2);
 // ==========================================================
 
 extern "C" {
-	BOOL DLL_CALLCONV FreeImage_Validate(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle);
+	BOOL DLL_CALLCONV FreeImage_ValidateFIF(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle);
     void * DLL_CALLCONV FreeImage_Open(PluginNode *node, FreeImageIO *io, fi_handle handle, BOOL open_for_reading);
     void DLL_CALLCONV FreeImage_Close(PluginNode *node, FreeImageIO *io, fi_handle handle, void *data); // plugin.cpp
     PluginList * DLL_CALLCONV FreeImage_GetPluginList(); // plugin.cpp
diff --git a/libs/freeimage/src/Quantizers.h b/libs/freeimage/src/Quantizers.h
index a6f0acd17c..23c4b7afca 100644
--- a/libs/freeimage/src/Quantizers.h
+++ b/libs/freeimage/src/Quantizers.h
@@ -1,4 +1,4 @@
-// =============================================================
+// =============================================================
 // Quantizer objects and functions
 //
 // Design and implementation by:
@@ -20,7 +20,8 @@
 // Use at your own risk!
 // =============================================================
 
-#pragma once
+#ifndef FREEIMAGE_QUANTIZER_H
+#define FREEIMAGE_QUANTIZER_H
 
 // 
 ////////////////////////////////////////////////////////////////
@@ -354,3 +355,5 @@ protected:
 	void WritePalette(void *palette);
 
 };
+
+#endif // FREEIMAGE_QUANTIZER_H
diff --git a/libs/freeimage/src/ToneMapping.h b/libs/freeimage/src/ToneMapping.h
index 20f283fee9..692e2ee496 100644
--- a/libs/freeimage/src/ToneMapping.h
+++ b/libs/freeimage/src/ToneMapping.h
@@ -1,4 +1,4 @@
-// ==========================================================
+// ==========================================================
 // High Dynamic Range bitmap conversion routines
 //
 // Design and implementation by
@@ -19,8 +19,8 @@
 // Use at your own risk!
 // ==========================================================
 
-#ifndef TONE_MAPPING_H
-#define TONE_MAPPING_H
+#ifndef FREEIMAGE_TONE_MAPPING_H
+#define FREEIMAGE_TONE_MAPPING_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -41,4 +41,5 @@ FIBITMAP* ClampConvertRGBFTo24(FIBITMAP *src);
 }
 #endif
 
-#endif // TONE_MAPPING_H
+#endif // FREEIMAGE_TONE_MAPPING_H
+
diff --git a/libs/freeimage/src/Utilities.h b/libs/freeimage/src/Utilities.h
index adc16e31eb..8afb1c918a 100644
--- a/libs/freeimage/src/Utilities.h
+++ b/libs/freeimage/src/Utilities.h
@@ -22,8 +22,8 @@
 // Use at your own risk!
 // ==========================================================
 
-#ifndef UTILITIES_H
-#define UTILITIES_H
+#ifndef FREEIMAGE_UTILITIES_H
+#define FREEIMAGE_UTILITIES_H
 
 // ==========================================================
 //   Bitmap palette and pixels alignment
@@ -249,25 +249,26 @@ CalculateUsedBits(int bits) {
 }
 
 inline unsigned
-CalculateLine(unsigned width, unsigned bitdepth) {
+CalculateLine(const unsigned width, const unsigned bitdepth) {
 	return (unsigned)( ((unsigned long long)width * bitdepth + 7) / 8 );
 }
 
 inline unsigned
-CalculatePitch(unsigned line) {
-	return line + 3 & ~3;
+CalculatePitch(const unsigned line) {
+	return (line + 3) & ~3;
 }
 
 inline unsigned
-CalculateUsedPaletteEntries(unsigned bit_count) {
-	if ((bit_count >= 1) && (bit_count <= 8))
+CalculateUsedPaletteEntries(const unsigned bit_count) {
+	if ((bit_count >= 1) && (bit_count <= 8)) {
 		return 1 << bit_count;
+	}
 
 	return 0;
 }
 
-inline unsigned char *
-CalculateScanLine(unsigned char *bits, unsigned pitch, int scanline) {
+inline BYTE*
+CalculateScanLine(BYTE *bits, const unsigned pitch, const int scanline) {
 	return bits ? (bits + ((size_t)pitch * scanline)) : NULL;
 }
 
@@ -406,25 +407,6 @@ __SwapUInt32(DWORD arg) {
 	return result; 
 #endif 
 } 
- 
-/**
-for later use ...
-inline uint64_t 
-SwapInt64(uint64_t arg) { 
-#if defined(_MSC_VER) && _MSC_VER >= 1310 
-	return _byteswap_uint64(arg); 
-#else 
-	union Swap { 
-		uint64_t sv; 
-		uint32_t ul[2]; 
-	} tmp, result; 
-	tmp.sv = arg; 
-	result.ul[0] = SwapInt32(tmp.ul[1]);  
-	result.ul[1] = SwapInt32(tmp.ul[0]); 
-	return result.sv; 
-#endif 
-} 
-*/
 
 inline void
 SwapShort(WORD *sp) {
@@ -435,6 +417,24 @@ inline void
 SwapLong(DWORD *lp) {
 	*lp = __SwapUInt32(*lp);
 }
+ 
+inline void
+SwapInt64(UINT64 *arg) {
+#if defined(_MSC_VER) && _MSC_VER >= 1310
+	*arg = _byteswap_uint64(*arg);
+#else
+	union Swap {
+		UINT64 sv;
+		DWORD ul[2];
+	} tmp, result;
+	tmp.sv = *arg;
+	SwapLong(&tmp.ul[0]);
+	SwapLong(&tmp.ul[1]);
+	result.ul[0] = tmp.ul[1];
+	result.ul[1] = tmp.ul[0];
+	*arg = result.sv;
+#endif
+}
 
 // ==========================================================
 //   Greyscale and color conversion
@@ -458,17 +458,37 @@ A Standard Default Color Space for the Internet - sRGB.
 #define GREY(r, g, b) (BYTE)(((WORD)r * 169 + (WORD)g * 256 + (WORD)b * 87) >> 9)	// .33R + 0.5G + .17B
 */
 
+/**
+Convert a RGB 24-bit value to a 16-bit 565 value
+*/
 #define RGB565(b, g, r) ((((b) >> 3) << FI16_565_BLUE_SHIFT) | (((g) >> 2) << FI16_565_GREEN_SHIFT) | (((r) >> 3) << FI16_565_RED_SHIFT))
+
+/**
+Convert a RGB 24-bit value to a 16-bit 555 value
+*/
 #define RGB555(b, g, r) ((((b) >> 3) << FI16_555_BLUE_SHIFT) | (((g) >> 3) << FI16_555_GREEN_SHIFT) | (((r) >> 3) << FI16_555_RED_SHIFT))
 
+/**
+Returns TRUE if the format of a dib is RGB565
+*/
 #define IS_FORMAT_RGB565(dib) ((FreeImage_GetRedMask(dib) == FI16_565_RED_MASK) && (FreeImage_GetGreenMask(dib) == FI16_565_GREEN_MASK) && (FreeImage_GetBlueMask(dib) == FI16_565_BLUE_MASK))
+
+/**
+Convert a RGB565 or RGB555 RGBQUAD pixel to a WORD
+*/
 #define RGBQUAD_TO_WORD(dib, color) (IS_FORMAT_RGB565(dib) ? RGB565((color)->rgbBlue, (color)->rgbGreen, (color)->rgbRed) : RGB555((color)->rgbBlue, (color)->rgbGreen, (color)->rgbRed))
 
+/**
+Create a greyscale palette
+*/
 #define CREATE_GREYSCALE_PALETTE(palette, entries) \
 	for (unsigned i = 0, v = 0; i < entries; i++, v += 0x00FFFFFF / (entries - 1)) { \
 		((unsigned *)palette)[i] = v; \
 	}
 
+/**
+Create a reverse greyscale palette
+*/
 #define CREATE_GREYSCALE_PALETTE_REVERSE(palette, entries) \
 	for (unsigned i = 0, v = 0x00FFFFFF; i < entries; i++, v -= (0x00FFFFFF / (entries - 1))) { \
 		((unsigned *)palette)[i] = v; \
@@ -486,4 +506,4 @@ static const char *FI_MSG_ERROR_UNSUPPORTED_FORMAT = "Unsupported format";
 static const char *FI_MSG_ERROR_UNSUPPORTED_COMPRESSION = "Unsupported compression type";
 static const char *FI_MSG_WARNING_INVALID_THUMBNAIL = "Warning: attached thumbnail cannot be written to output file (invalid format) - Thumbnail saving aborted";
 
-#endif // UTILITIES_H
+#endif // FREEIMAGE_UTILITIES_H