rfreeimage 0.1.0

data/vendor/FreeImage/Source/FreeImageToolkit/Display.cpp

@@ -0,0 +1,230 @@
+// ==========================================================
+// Display routines
+//
+// Design and implementation by
+// - Herv� Drolon (drolon@infonie.fr)
+//
+// This file is part of FreeImage 3
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+
+/**
+@brief Composite a foreground image against a background color or a background image.
+
+The equation for computing a composited sample value is:<br>
+output = alpha * foreground + (1-alpha) * background<br>
+where alpha and the input and output sample values are expressed as fractions in the range 0 to 1. 
+For colour images, the computation is done separately for R, G, and B samples.
+
+@param fg Foreground image
+@param useFileBkg If TRUE and a file background is present, use it as the background color
+@param appBkColor If not equal to NULL, and useFileBkg is FALSE, use this color as the background color
+@param bg If not equal to NULL and useFileBkg is FALSE and appBkColor is NULL, use this as the background image
+@return Returns the composite image if successful, returns NULL otherwise
+@see FreeImage_IsTransparent, FreeImage_HasBackgroundColor
+*/
+FIBITMAP * DLL_CALLCONV
+FreeImage_Composite(FIBITMAP *fg, BOOL useFileBkg, RGBQUAD *appBkColor, FIBITMAP *bg) {
+	if(!FreeImage_HasPixels(fg)) return NULL;
+
+	int width  = FreeImage_GetWidth(fg);
+	int height = FreeImage_GetHeight(fg);
+	int bpp    = FreeImage_GetBPP(fg);
+
+	if((bpp != 8) && (bpp != 32))
+		return NULL;
+
+	if(bg) {
+		int bg_width  = FreeImage_GetWidth(bg);
+		int bg_height = FreeImage_GetHeight(bg);
+		int bg_bpp    = FreeImage_GetBPP(bg);
+		if((bg_width != width) || (bg_height != height) || (bg_bpp != 24))
+			return NULL;
+	}
+
+	int bytespp = (bpp == 8) ? 1 : 4;
+
+	
+	int x, y, c;
+	BYTE alpha = 0, not_alpha;
+	BYTE index;
+	RGBQUAD fgc;	// foreground color
+	RGBQUAD bkc;	// background color
+
+	memset(&fgc, 0, sizeof(RGBQUAD));
+	memset(&bkc, 0, sizeof(RGBQUAD));
+
+	// allocate the composite image
+	FIBITMAP *composite = FreeImage_Allocate(width, height, 24, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
+	if(!composite) return NULL;
+
+	// get the palette
+	RGBQUAD *pal = FreeImage_GetPalette(fg);
+
+	// retrieve the alpha table from the foreground image
+	BOOL bIsTransparent = FreeImage_IsTransparent(fg);
+	BYTE *trns = FreeImage_GetTransparencyTable(fg);
+
+	// retrieve the background color from the foreground image
+	BOOL bHasBkColor = FALSE;
+
+	if(useFileBkg && FreeImage_HasBackgroundColor(fg)) {
+		FreeImage_GetBackgroundColor(fg, &bkc);
+		bHasBkColor = TRUE;
+	} else {
+		// no file background color
+		// use application background color ?
+		if(appBkColor) {
+			memcpy(&bkc, appBkColor, sizeof(RGBQUAD));
+			bHasBkColor = TRUE;
+		}
+		// use background image ?
+		else if(bg) {
+			bHasBkColor = FALSE;
+		}
+	}
+
+	for(y = 0; y < height; y++) {
+		// foreground
+		BYTE *fg_bits = FreeImage_GetScanLine(fg, y);
+		// background
+		BYTE *bg_bits = FreeImage_GetScanLine(bg, y);
+		// composite image
+		BYTE *cp_bits = FreeImage_GetScanLine(composite, y);
+
+		for(x = 0; x < width; x++) {
+
+			// foreground color + alpha
+
+			if(bpp == 8) {
+				// get the foreground color
+				index = fg_bits[0];
+				memcpy(&fgc, &pal[index], sizeof(RGBQUAD));
+				// get the alpha
+				if(bIsTransparent) {
+					alpha = trns[index];
+				} else {
+					alpha = 255;
+				}
+			}
+			else if(bpp == 32) {
+				// get the foreground color
+				fgc.rgbBlue  = fg_bits[FI_RGBA_BLUE];
+				fgc.rgbGreen = fg_bits[FI_RGBA_GREEN];
+				fgc.rgbRed   = fg_bits[FI_RGBA_RED];
+				// get the alpha
+				alpha = fg_bits[FI_RGBA_ALPHA];
+			}
+
+			// background color
+
+			if(!bHasBkColor) {
+				if(bg) {
+					// get the background color from the background image
+					bkc.rgbBlue  = bg_bits[FI_RGBA_BLUE];
+					bkc.rgbGreen = bg_bits[FI_RGBA_GREEN];
+					bkc.rgbRed   = bg_bits[FI_RGBA_RED];
+				}
+				else {
+					// use a checkerboard pattern
+					c = (((y & 0x8) == 0) ^ ((x & 0x8) == 0)) * 192;
+					c = c ? c : 255;
+					bkc.rgbBlue  = (BYTE)c;
+					bkc.rgbGreen = (BYTE)c;
+					bkc.rgbRed   = (BYTE)c;
+				}
+			}
+
+			// composition
+
+			if(alpha == 0) {
+				// output = background
+				cp_bits[FI_RGBA_BLUE] = bkc.rgbBlue;
+				cp_bits[FI_RGBA_GREEN] = bkc.rgbGreen;
+				cp_bits[FI_RGBA_RED] = bkc.rgbRed;
+			}
+			else if(alpha == 255) {
+				// output = foreground
+				cp_bits[FI_RGBA_BLUE] = fgc.rgbBlue;
+				cp_bits[FI_RGBA_GREEN] = fgc.rgbGreen;
+				cp_bits[FI_RGBA_RED] = fgc.rgbRed;
+			}
+			else {
+				// output = alpha * foreground + (1-alpha) * background
+				not_alpha = (BYTE)~alpha;
+				cp_bits[FI_RGBA_BLUE] = (BYTE)((alpha * (WORD)fgc.rgbBlue  + not_alpha * (WORD)bkc.rgbBlue) >> 8);
+				cp_bits[FI_RGBA_GREEN] = (BYTE)((alpha * (WORD)fgc.rgbGreen + not_alpha * (WORD)bkc.rgbGreen) >> 8);
+				cp_bits[FI_RGBA_RED] = (BYTE)((alpha * (WORD)fgc.rgbRed   + not_alpha * (WORD)bkc.rgbRed) >> 8);
+			}
+
+			fg_bits += bytespp;
+			bg_bits += 3;
+			cp_bits += 3;
+		}
+	}
+
+	// copy metadata from src to dst
+	FreeImage_CloneMetadata(composite, fg);
+	
+	return composite;	
+}
+
+/**
+Pre-multiplies a 32-bit image's red-, green- and blue channels with it's alpha channel 
+for to be used with e.g. the Windows GDI function AlphaBlend(). 
+The transformation changes the red-, green- and blue channels according to the following equation:  
+channel(x, y) = channel(x, y) * alpha_channel(x, y) / 255  
+@param dib Input/Output dib to be premultiplied
+@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) {
+	if (!FreeImage_HasPixels(dib)) return FALSE;
+	
+	if ((FreeImage_GetBPP(dib) != 32) || (FreeImage_GetImageType(dib) != FIT_BITMAP)) {
+		return FALSE;
+	}
+
+	int width = FreeImage_GetWidth(dib);
+	int height = FreeImage_GetHeight(dib);
+
+	for(int y = 0; y < height; y++) {
+		BYTE *bits = FreeImage_GetScanLine(dib, y);
+		for (int x = 0; x < width; x++, bits += 4) {
+			const BYTE alpha = bits[FI_RGBA_ALPHA];
+			// slightly faster: care for two special cases
+			if(alpha == 0x00) {
+				// special case for alpha == 0x00
+				// color * 0x00 / 0xFF = 0x00
+				bits[FI_RGBA_BLUE] = 0x00;
+				bits[FI_RGBA_GREEN] = 0x00;
+				bits[FI_RGBA_RED] = 0x00;
+			} else if(alpha == 0xFF) {
+				// nothing to do for alpha == 0xFF
+				// color * 0xFF / 0xFF = color
+				continue;
+			} else {
+				bits[FI_RGBA_BLUE] = (BYTE)( (alpha * (WORD)bits[FI_RGBA_BLUE] + 127) / 255 );
+				bits[FI_RGBA_GREEN] = (BYTE)( (alpha * (WORD)bits[FI_RGBA_GREEN] + 127) / 255 );
+				bits[FI_RGBA_RED] = (BYTE)( (alpha * (WORD)bits[FI_RGBA_RED] + 127) / 255 );
+			}
+		}
+	}
+	return TRUE;
+}
+

data/vendor/FreeImage/Source/FreeImageToolkit/Filters.h

@@ -0,0 +1,287 @@
+// ==========================================================
+// Upsampling / downsampling filters
+//
+// Design and implementation by
+// - Herv� Drolon (drolon@infonie.fr)
+//
+// This file is part of FreeImage 3
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#ifndef _FILTERS_H_
+#define _FILTERS_H_
+
+/**
+ CGenericFilter is a generic abstract filter class used to access to the filter library.<br>
+ Filters used in this library have been mainly taken from the following references : <br>
+<b>Main reference</b> : <br>
+Paul Heckbert, C code to zoom raster images up or down, with nice filtering. 
+UC Berkeley, August 1989. [online] http://www-2.cs.cmu.edu/afs/cs.cmu.edu/Web/People/ph/heckbert.html
+
+<b>Heckbert references</b> : <br>
+<ul>
+<li>Oppenheim A.V., Schafer R.W., Digital Signal Processing, Prentice-Hall, 1975
+<li>Hamming R.W., Digital Filters, Prentice-Hall, Englewood Cliffs, NJ, 1983
+<li>Pratt W.K., Digital Image Processing, John Wiley and Sons, 1978
+<li>Hou H.S., Andrews H.C., "Cubic Splines for Image Interpolation and Digital Filtering", 
+IEEE Trans. Acoustics, Speech, and Signal Proc., vol. ASSP-26, no. 6, pp. 508-517, Dec. 1978.
+</ul>
+
+*/
+class CGenericFilter
+{
+protected:
+
+    #define FILTER_PI  double (3.1415926535897932384626433832795)
+    #define FILTER_2PI double (2.0 * 3.1415926535897932384626433832795)
+    #define FILTER_4PI double (4.0 * 3.1415926535897932384626433832795)
+
+    /// Filter support
+	double  m_dWidth;
+
+public:
+    
+    /// Constructor
+	CGenericFilter (double dWidth) : m_dWidth (dWidth) {}
+	/// Destructor
+    virtual ~CGenericFilter() {}
+
+    /// Returns the filter support
+	double GetWidth()                   { return m_dWidth; }
+	/// Change the filter suport
+    void   SetWidth (double dWidth)     { m_dWidth = dWidth; }
+
+    /// Returns F(dVal) where F is the filter's impulse response
+	virtual double Filter (double dVal) = 0;
+};
+
+// -----------------------------------------------------------------------------------
+// Filters library
+// All filters are centered on 0
+// -----------------------------------------------------------------------------------
+
+/**
+ Box filter<br>
+ Box, pulse, Fourier window, 1st order (constant) b-spline.<br><br>
+
+ <b>Reference</b> : <br>
+ Glassner A.S., Principles of digital image synthesis. Morgan Kaufmann Publishers, Inc, San Francisco, Vol. 2, 1995
+*/
+class CBoxFilter : public CGenericFilter
+{
+public:
+    /**
+	Constructor<br>
+	Default fixed width = 0.5
+	*/
+    CBoxFilter() : CGenericFilter(0.5) {}
+    virtual ~CBoxFilter() {}
+
+    double Filter (double dVal) { return (fabs(dVal) <= m_dWidth ? 1.0 : 0.0); }
+};
+
+/** Bilinear filter
+*/
+class CBilinearFilter : public CGenericFilter
+{
+public:
+
+    CBilinearFilter () : CGenericFilter(1) {}
+    virtual ~CBilinearFilter() {}
+
+    double Filter (double dVal) {
+		dVal = fabs(dVal); 
+		return (dVal < m_dWidth ? m_dWidth - dVal : 0.0); 
+	}
+};
+
+
+/**
+ Mitchell & Netravali's two-param cubic filter<br>
+
+ The parameters b and c can be used to adjust the properties of the cubic. 
+ They are sometimes referred to as "blurring" and "ringing" respectively. 
+ The default is b = 1/3 and c = 1/3, which were the values recommended by 
+ Mitchell and Netravali as yielding the most visually pleasing results in subjective tests of human beings. 
+ Larger values of b and c can produce interesting op-art effects--for example, try b = 0 and c = -5. <br><br>
+
+ <b>Reference</b> : <br>
+ Don P. Mitchell and Arun N. Netravali, Reconstruction filters in computer graphics. 
+ In John Dill, editor, Computer Graphics (SIGGRAPH '88 Proceedings), Vol. 22, No. 4, August 1988, pp. 221-228.
+*/
+class CBicubicFilter : public CGenericFilter
+{
+protected:
+	// data for parameterized Mitchell filter
+    double p0, p2, p3;
+    double q0, q1, q2, q3;
+
+public:
+    /**
+	Constructor<br>
+	Default fixed width = 2
+	@param b Filter parameter (default value is 1/3)
+	@param c Filter parameter (default value is 1/3)
+	*/
+    CBicubicFilter (double b = (1/(double)3), double c = (1/(double)3)) : CGenericFilter(2) {
+		p0 = (6 - 2*b) / 6;
+		p2 = (-18 + 12*b + 6*c) / 6;
+		p3 = (12 - 9*b - 6*c) / 6;
+		q0 = (8*b + 24*c) / 6;
+		q1 = (-12*b - 48*c) / 6;
+		q2 = (6*b + 30*c) / 6;
+		q3 = (-b - 6*c) / 6;
+	}
+    virtual ~CBicubicFilter() {}
+
+    double Filter(double dVal) { 
+		dVal = fabs(dVal);
+		if(dVal < 1)
+			return (p0 + dVal*dVal*(p2 + dVal*p3));
+		if(dVal < 2)
+			return (q0 + dVal*(q1 + dVal*(q2 + dVal*q3)));
+		return 0;
+	}
+};
+
+/**
+ Catmull-Rom spline, Overhauser spline<br>
+
+ When using CBicubicFilter filters, you have to set parameters b and c such that <br>
+ b + 2 * c = 1<br>
+ in order to use the numerically most accurate filter.<br>
+ This gives for b = 0 the maximum value for c = 0.5, which is the Catmull-Rom 
+ spline and a good suggestion for sharpness.<br><br>
+
+
+ <b>References</b> : <br>
+ <ul>
+ <li>Mitchell Don P., Netravali Arun N., Reconstruction filters in computer graphics. 
+ In John Dill, editor, Computer Graphics (SIGGRAPH '88 Proceedings), Vol. 22, No. 4, August 1988, pp. 221-228.
+ <li>Keys R.G., Cubic Convolution Interpolation for Digital Image Processing. 
+ IEEE Trans. Acoustics, Speech, and Signal Processing, vol. 29, no. 6, pp. 1153-1160, Dec. 1981.
+ </ul>
+
+*/
+class CCatmullRomFilter : public CGenericFilter
+{
+public:
+
+    /**
+	Constructor<br>
+	Default fixed width = 2
+	*/
+	CCatmullRomFilter() : CGenericFilter(2) {}
+    virtual ~CCatmullRomFilter() {}
+
+    double Filter(double dVal) { 
+		if(dVal < -2) return 0;
+		if(dVal < -1) return (0.5*(4 + dVal*(8 + dVal*(5 + dVal))));
+		if(dVal < 0)  return (0.5*(2 + dVal*dVal*(-5 - 3*dVal)));
+		if(dVal < 1)  return (0.5*(2 + dVal*dVal*(-5 + 3*dVal)));
+		if(dVal < 2)  return (0.5*(4 + dVal*(-8 + dVal*(5 - dVal))));
+		return 0;
+	}
+};
+
+/**
+ Lanczos-windowed sinc filter<br>
+ 
+ Lanczos3 filter is an alternative to CBicubicFilter with high values of c about 0.6 ... 0.75 
+ which produces quite strong sharpening. It usually offers better quality (fewer artifacts) and a sharp image.<br><br>
+
+*/
+class CLanczos3Filter : public CGenericFilter
+{
+public:
+    /**
+	Constructor<br>
+	Default fixed width = 3
+	*/
+	CLanczos3Filter() : CGenericFilter(3) {}
+    virtual ~CLanczos3Filter() {}
+
+    double Filter(double dVal) { 
+		dVal = fabs(dVal); 
+		if(dVal < m_dWidth)	{
+			return (sinc(dVal) * sinc(dVal / m_dWidth));
+		}
+		return 0;
+	}
+
+private:
+	double sinc(double value) {
+		if(value != 0) {
+			value *= FILTER_PI;
+			return (sin(value) / value);
+		} 
+		return 1;
+	}
+};
+
+/**
+ 4th order (cubic) b-spline<br>
+
+*/
+class CBSplineFilter : public CGenericFilter
+{
+public:
+
+    /**
+	Constructor<br>
+	Default fixed width = 2
+	*/
+	CBSplineFilter() : CGenericFilter(2) {}
+    virtual ~CBSplineFilter() {}
+
+    double Filter(double dVal) { 
+
+		dVal = fabs(dVal);
+		if(dVal < 1) return (4 + dVal*dVal*(-6 + 3*dVal)) / 6;
+		if(dVal < 2) {
+			double t = 2 - dVal;
+			return (t*t*t / 6);
+		}
+		return 0;
+	}
+};
+
+// -----------------------------------------------------------------------------------
+// Window function library
+// -----------------------------------------------------------------------------------
+
+/** 
+ Blackman window
+*/
+class CBlackmanFilter : public CGenericFilter
+{
+public:
+    /**
+	Constructor<br>
+	Default width = 0.5
+	*/
+    CBlackmanFilter (double dWidth = double(0.5)) : CGenericFilter(dWidth) {}
+    virtual ~CBlackmanFilter() {}
+
+    double Filter (double dVal) {
+		if(fabs (dVal) > m_dWidth) {
+			return 0; 
+        }
+        double dN = 2 * m_dWidth + 1; 
+		dVal /= (dN - 1);
+        return 0.42 + 0.5*cos(FILTER_2PI*dVal) + 0.08*cos(FILTER_4PI*dVal); 
+    }
+};
+
+#endif  // _FILTERS_H_

data/vendor/FreeImage/Source/FreeImageToolkit/Flip.cpp

@@ -0,0 +1,166 @@
+// ==========================================================
+// Flipping routines
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Herv� Drolon (drolon@infonie.fr)
+// - Jim Keir (jimkeir@users.sourceforge.net)
+//
+// This file is part of FreeImage 3
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+/**
+Flip the image horizontally along the vertical axis.
+@param src Input image to be processed.
+@return Returns TRUE if successful, FALSE otherwise.
+*/
+BOOL DLL_CALLCONV 
+FreeImage_FlipHorizontal(FIBITMAP *src) {
+	if (!FreeImage_HasPixels(src)) return FALSE;
+
+	unsigned line   = FreeImage_GetLine(src);
+	unsigned width	= FreeImage_GetWidth(src);
+	unsigned height = FreeImage_GetHeight(src);
+
+	unsigned bytespp = FreeImage_GetLine(src) / FreeImage_GetWidth(src);
+
+	// copy between aligned memories
+	BYTE *new_bits = (BYTE*)FreeImage_Aligned_Malloc(line * sizeof(BYTE), FIBITMAP_ALIGNMENT);
+	if (!new_bits) return FALSE;
+
+	// mirror the buffer
+
+	for (unsigned y = 0; y < height; y++) {
+		BYTE *bits = FreeImage_GetScanLine(src, y);
+		memcpy(new_bits, bits, line);
+
+		switch (FreeImage_GetBPP(src)) {
+			case 1 :
+			{				
+				for(unsigned x = 0; x < width; x++) {
+					// get pixel at (x, y)
+					BOOL value = (new_bits[x >> 3] & (0x80 >> (x & 0x07))) != 0;
+					// set pixel at (new_x, y)
+					unsigned new_x = width - 1 - x;
+					value ? bits[new_x >> 3] |= (0x80 >> (new_x & 0x7)) : bits[new_x >> 3] &= (0xff7f >> (new_x & 0x7));
+				}
+			}
+			break;
+
+			case 4 :
+			{
+				for(unsigned c = 0; c < line; c++) {
+					bits[c] = new_bits[line - c - 1];
+
+					BYTE nibble = (bits[c] & 0xF0) >> 4;
+
+					bits[c] = bits[c] << 4;
+					bits[c] |= nibble;
+				}
+			}
+			break;
+
+			case 8:
+			{				
+				BYTE *dst_data = (BYTE*) bits; 				
+				BYTE *src_data = (BYTE*) (new_bits + line - bytespp); 				
+				for(unsigned c = 0; c < width; c++) { 			
+					*dst_data++ = *src_data--;  
+				} 
+			}
+			break;
+
+			case 16:
+			{				
+				WORD *dst_data = (WORD*) bits; 				
+				WORD *src_data = (WORD*) (new_bits + line - bytespp); 				
+				for(unsigned c = 0; c < width; c++) { 			
+					*dst_data++ = *src_data--;  
+				} 
+			}
+			break;
+
+			case 24 :
+			case 32 :
+			case 48:
+			case 64:
+			case 96:
+			case 128:
+			{				
+				BYTE *dst_data = (BYTE*) bits; 				
+				BYTE *src_data = (BYTE*) (new_bits + line - bytespp); 				
+				for(unsigned c = 0; c < width; c++) { 		
+					for(unsigned k = 0; k < bytespp; k++) {
+						*dst_data++ = src_data[k];  
+					}
+					src_data -= bytespp;
+				} 
+			}
+			break;
+
+		}
+	}
+
+	FreeImage_Aligned_Free(new_bits);
+
+	return TRUE;
+}
+
+
+/**
+Flip the image vertically along the horizontal axis.
+@param src Input image to be processed.
+@return Returns TRUE if successful, FALSE otherwise.
+*/
+
+BOOL DLL_CALLCONV 
+FreeImage_FlipVertical(FIBITMAP *src) {
+	BYTE *From, *Mid;
+
+	if (!FreeImage_HasPixels(src)) return FALSE;
+
+	// swap the buffer
+
+	unsigned pitch  = FreeImage_GetPitch(src);
+	unsigned height = FreeImage_GetHeight(src);
+
+	// copy between aligned memories
+	Mid = (BYTE*)FreeImage_Aligned_Malloc(pitch * sizeof(BYTE), FIBITMAP_ALIGNMENT);
+	if (!Mid) return FALSE;
+
+	From = FreeImage_GetBits(src);
+	
+	unsigned line_s = 0;
+	unsigned line_t = (height-1) * pitch;
+
+	for(unsigned y = 0; y < height/2; y++) {
+
+		memcpy(Mid, From + line_s, pitch);
+		memcpy(From + line_s, From + line_t, pitch);
+		memcpy(From + line_t, Mid, pitch);
+
+		line_s += pitch;
+		line_t -= pitch;
+
+	}
+
+	FreeImage_Aligned_Free(Mid);
+
+	return TRUE;
+}
+