file not used. but who knows

git-svn-id: http://svn.miranda-ng.org/main/trunk@2927 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 1309 insertions, 0 deletions

diff --git a/plugins/AdvaImg/src/FreeImage/MNGHelper.cpp b/plugins/AdvaImg/src/FreeImage/MNGHelper.cpp
new file mode 100644
index 0000000000..a4c67a2abe
--- /dev/null
+++ b/plugins/AdvaImg/src/FreeImage/MNGHelper.cpp
@@ -0,0 +1,1309 @@
+// ==========================================================
+// MNG / JNG helpers
+//
+// 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"
+
+/**
+References
+http://www.libpng.org/pub/mng/spec/jng.html
+http://www.w3.org/TR/PNG/
+http://libpng.org/pub/mng/spec/
+*/
+
+// --------------------------------------------------------------------------
+
+#define MNG_INCLUDE_JNG
+
+#ifdef MNG_INCLUDE_JNG
+#define MNG_COLORTYPE_JPEGGRAY           8       /* JHDR */
+#define MNG_COLORTYPE_JPEGCOLOR         10
+#define MNG_COLORTYPE_JPEGGRAYA         12
+#define MNG_COLORTYPE_JPEGCOLORA        14
+
+#define MNG_BITDEPTH_JPEG8               8       /* JHDR */
+#define MNG_BITDEPTH_JPEG12             12
+#define MNG_BITDEPTH_JPEG8AND12         20
+
+#define MNG_COMPRESSION_BASELINEJPEG     8       /* JHDR */
+
+#define MNG_INTERLACE_SEQUENTIAL         0       /* JHDR */
+#define MNG_INTERLACE_PROGRESSIVE        8
+#endif /* MNG_INCLUDE_JNG */
+
+// --------------------------------------------------------------------------
+
+#define JNG_SUPPORTED
+
+/** Size of a JDAT chunk on writing */
+const DWORD JPEG_CHUNK_SIZE	= 8192;
+
+/** PNG signature */
+static const BYTE g_png_signature[8] = { 137, 80, 78, 71, 13, 10, 26, 10 };
+/** JNG signature */
+static const BYTE g_jng_signature[8] = { 139, 74, 78, 71, 13, 10, 26, 10 };
+
+// --------------------------------------------------------------------------
+
+/** Chunk type converted to enum */
+enum eChunckType {
+	UNKNOWN_CHUNCK,
+	MHDR,
+	BACK,
+	BASI,
+	CLIP,
+	CLON,
+	DEFI,
+	DHDR,
+	DISC,
+	ENDL,
+	FRAM,
+	IEND,
+	IHDR,
+	JHDR,
+	LOOP,
+	MAGN,
+	MEND,
+	MOVE,
+	PAST,
+	PLTE,
+	SAVE,
+	SEEK,
+	SHOW,
+	TERM,
+	bKGD,
+	cHRM,
+	gAMA,
+	iCCP,
+	nEED,
+	pHYg,
+	vpAg,
+	pHYs,
+	sBIT,
+	sRGB,
+	tRNS,
+	IDAT,
+	JDAT,
+	JDAA,
+	JdAA,
+	JSEP,
+	oFFs,
+	hIST,
+	iTXt,
+	sPLT,
+	sTER,
+	tEXt,
+	tIME,
+	zTXt
+};
+
+/**
+Helper for map<key, value> where value is a pointer to a string. 
+Used to store tEXt metadata. 
+*/
+typedef std::map<std::string, std::string> tEXtMAP;
+
+// --------------------------------------------------------------------------
+
+/*
+  Constant strings for known chunk types.  If you need to add a chunk,
+  add a string holding the name here.   To make the code more
+  portable, we use ASCII numbers like this, not characters.
+*/
+
+static BYTE mng_MHDR[5]={ 77,  72,  68,  82, (BYTE) '\0'};
+static BYTE mng_BACK[5]={ 66,  65,  67,  75, (BYTE) '\0'};
+static BYTE mng_BASI[5]={ 66,  65,  83,  73, (BYTE) '\0'};
+static BYTE mng_CLIP[5]={ 67,  76,  73,  80, (BYTE) '\0'};
+static BYTE mng_CLON[5]={ 67,  76,  79,  78, (BYTE) '\0'};
+static BYTE mng_DEFI[5]={ 68,  69,  70,  73, (BYTE) '\0'};
+static BYTE mng_DHDR[5]={ 68,  72,  68,  82, (BYTE) '\0'};
+static BYTE mng_DISC[5]={ 68,  73,  83,  67, (BYTE) '\0'};
+static BYTE mng_ENDL[5]={ 69,  78,  68,  76, (BYTE) '\0'};
+static BYTE mng_FRAM[5]={ 70,  82,  65,  77, (BYTE) '\0'};
+static BYTE mng_IEND[5]={ 73,  69,  78,  68, (BYTE) '\0'};
+static BYTE mng_IHDR[5]={ 73,  72,  68,  82, (BYTE) '\0'};
+static BYTE mng_JHDR[5]={ 74,  72,  68,  82, (BYTE) '\0'};
+static BYTE mng_LOOP[5]={ 76,  79,  79,  80, (BYTE) '\0'};
+static BYTE mng_MAGN[5]={ 77,  65,  71,  78, (BYTE) '\0'};
+static BYTE mng_MEND[5]={ 77,  69,  78,  68, (BYTE) '\0'};
+static BYTE mng_MOVE[5]={ 77,  79,  86,  69, (BYTE) '\0'};
+static BYTE mng_PAST[5]={ 80,  65,  83,  84, (BYTE) '\0'};
+static BYTE mng_PLTE[5]={ 80,  76,  84,  69, (BYTE) '\0'};
+static BYTE mng_SAVE[5]={ 83,  65,  86,  69, (BYTE) '\0'};
+static BYTE mng_SEEK[5]={ 83,  69,  69,  75, (BYTE) '\0'};
+static BYTE mng_SHOW[5]={ 83,  72,  79,  87, (BYTE) '\0'};
+static BYTE mng_TERM[5]={ 84,  69,  82,  77, (BYTE) '\0'};
+static BYTE mng_bKGD[5]={ 98,  75,  71,  68, (BYTE) '\0'};
+static BYTE mng_cHRM[5]={ 99,  72,  82,  77, (BYTE) '\0'};
+static BYTE mng_gAMA[5]={103,  65,  77,  65, (BYTE) '\0'};
+static BYTE mng_iCCP[5]={105,  67,  67,  80, (BYTE) '\0'};
+static BYTE mng_nEED[5]={110,  69,  69,  68, (BYTE) '\0'};
+static BYTE mng_pHYg[5]={112,  72,  89, 103, (BYTE) '\0'};
+static BYTE mng_vpAg[5]={118, 112,  65, 103, (BYTE) '\0'};
+static BYTE mng_pHYs[5]={112,  72,  89, 115, (BYTE) '\0'};
+static BYTE mng_sBIT[5]={115,  66,  73,  84, (BYTE) '\0'};
+static BYTE mng_sRGB[5]={115,  82,  71,  66, (BYTE) '\0'};
+static BYTE mng_tRNS[5]={116,  82,  78,  83, (BYTE) '\0'};
+
+#if defined(JNG_SUPPORTED)
+static BYTE mng_IDAT[5]={ 73,  68,  65,  84, (BYTE) '\0'};
+static BYTE mng_JDAT[5]={ 74,  68,  65,  84, (BYTE) '\0'};
+static BYTE mng_JDAA[5]={ 74,  68,  65,  65, (BYTE) '\0'};
+static BYTE mng_JdAA[5]={ 74, 100,  65,  65, (BYTE) '\0'};
+static BYTE mng_JSEP[5]={ 74,  83,  69,  80, (BYTE) '\0'};
+static BYTE mng_oFFs[5]={111,  70,  70, 115, (BYTE) '\0'};
+#endif
+
+static BYTE mng_hIST[5]={104,  73,  83,  84, (BYTE) '\0'};
+static BYTE mng_iTXt[5]={105,  84,  88, 116, (BYTE) '\0'};
+static BYTE mng_sPLT[5]={115,  80,  76,  84, (BYTE) '\0'};
+static BYTE mng_sTER[5]={115,  84,  69,  82, (BYTE) '\0'};
+static BYTE mng_tEXt[5]={116,  69,  88, 116, (BYTE) '\0'};
+static BYTE mng_tIME[5]={116,  73,  77,  69, (BYTE) '\0'};
+static BYTE mng_zTXt[5]={122,  84,  88, 116, (BYTE) '\0'};
+
+
+// --------------------------------------------------------------------------
+
+/**
+Convert a chunk name to a unique ID
+*/
+static eChunckType 
+mng_GetChunckType(const BYTE *mChunkName) {
+	if(memcmp(mChunkName, mng_MHDR, 4) == 0) {
+		return MHDR;
+	}
+	if(memcmp(mChunkName, mng_LOOP, 4) == 0) {
+		return LOOP;
+	}
+	if(memcmp(mChunkName, mng_DEFI, 4) == 0) {
+		return DEFI;
+	}
+	if(memcmp(mChunkName, mng_PLTE, 4) == 0) {
+		return PLTE;
+	}
+	if(memcmp(mChunkName, mng_tRNS, 4) == 0) {
+		return tRNS;
+	}
+	if(memcmp(mChunkName, mng_IHDR, 4) == 0) {
+		return IHDR;
+	}
+	if(memcmp(mChunkName, mng_JHDR, 4) == 0) {
+		return JHDR;
+	}
+	if(memcmp(mChunkName, mng_MEND, 4) == 0) {
+		return MEND;
+	}
+	if(memcmp(mChunkName, mng_IEND, 4) == 0) {
+		return IEND;
+	}
+	if(memcmp(mChunkName, mng_JDAT, 4) == 0) {
+		return JDAT;
+	}
+	if(memcmp(mChunkName, mng_IDAT, 4) == 0) {
+		return IDAT;
+	}
+	if(memcmp(mChunkName, mng_JDAA, 4) == 0) {
+		return JDAA;
+	}
+	if(memcmp(mChunkName, mng_gAMA, 4) == 0) {
+		return gAMA;
+	}
+	if(memcmp(mChunkName, mng_pHYs, 4) == 0) {
+		return pHYs;
+	}
+	if(memcmp(mChunkName, mng_bKGD, 4) == 0) {
+		return bKGD;
+	}
+	if(memcmp(mChunkName, mng_tEXt, 4) == 0) {
+		return tEXt;
+	}
+
+	return UNKNOWN_CHUNCK;
+}
+
+inline void
+mng_SwapShort(WORD *sp) {
+#ifndef FREEIMAGE_BIGENDIAN
+	SwapShort(sp);
+#endif
+}
+
+inline void
+mng_SwapLong(DWORD *lp) {
+#ifndef FREEIMAGE_BIGENDIAN
+	SwapLong(lp);
+#endif
+}
+
+/**
+Returns the size, in bytes, of a FreeImageIO stream, from the current position. 
+*/
+static long
+mng_LOF(FreeImageIO *io, fi_handle handle) {
+	long start_pos = io->tell_proc(handle);
+	io->seek_proc(handle, 0, SEEK_END);
+	long file_length = io->tell_proc(handle);
+	io->seek_proc(handle, start_pos, SEEK_SET);
+	return file_length;
+}
+
+/**
+Count the number of bytes in a PNG stream, from IHDR to IEND. 
+If successful, the stream position, as given by io->tell_proc(handle), 
+should be the end of the PNG stream at the return of the function. 
+@param io
+@param handle
+@param inPos
+@param m_TotalBytesOfChunks
+@return Returns TRUE if successful, returns FALSE otherwise
+*/
+static BOOL 
+mng_CountPNGChunks(FreeImageIO *io, fi_handle handle, long inPos, unsigned *m_TotalBytesOfChunks) {
+	long mLOF;
+	long mPos;
+	BOOL mEnd = FALSE;
+	DWORD mLength = 0;
+	BYTE mChunkName[5];
+
+	*m_TotalBytesOfChunks = 0;
+
+	// get the length of the file
+	mLOF = mng_LOF(io, handle);
+
+	// go to the start of the file
+	io->seek_proc(handle, inPos, SEEK_SET);
+
+	try {
+		// parse chunks
+		while(mEnd == FALSE) {
+			// chunk length
+			mPos = io->tell_proc(handle);
+			if(mPos + 4 > mLOF) {
+				throw(1);
+			}
+			io->read_proc(&mLength, 1, 4, handle);
+			mng_SwapLong(&mLength);
+			// chunk name
+			mPos = io->tell_proc(handle);
+			if(mPos + 4 > mLOF) {
+				throw(1);
+			}
+			io->read_proc(&mChunkName[0], 1, 4, handle);
+			mChunkName[4] = '\0';
+
+			// go to next chunk
+			mPos = io->tell_proc(handle);
+			// 4 = size of the CRC
+			if(mPos + (long)mLength + 4 > mLOF) {
+				throw(1);
+			}
+			io->seek_proc(handle, mLength + 4, SEEK_CUR);
+
+			switch( mng_GetChunckType(mChunkName) ) {
+				case IHDR:
+					if(mLength != 13) {
+						throw(1);
+					}
+					break;
+				
+				case IEND:
+					mEnd = TRUE;		
+					// the length below includes 4 bytes CRC, but no bytes for Length
+					*m_TotalBytesOfChunks = io->tell_proc(handle) - inPos;
+					break;		
+				
+				case UNKNOWN_CHUNCK:
+				default:
+					break;
+			}
+
+		} // while(!mEnd)
+
+		return TRUE;
+		
+	} catch(int) {
+		return FALSE;
+	}
+}
+
+/**
+Retrieve the position of a chunk in a PNG stream
+@param hPngMemory PNG stream handle
+@param chunk_name Name of the chunk to be found
+@param offset Start of the search in the stream
+@param start_pos [returned value] Start position of the chunk
+@param next_pos [returned value] Start position of the next chunk
+@return Returns TRUE if successful, returns FALSE otherwise
+*/
+static BOOL 
+mng_FindChunk(FIMEMORY *hPngMemory, BYTE *chunk_name, long offset, DWORD *start_pos, DWORD *next_pos) {
+	BOOL mEnd = FALSE;
+	DWORD mLength = 0;
+
+	BYTE *data = NULL;
+	DWORD size_in_bytes = 0;
+
+	*start_pos = 0;
+	*next_pos = 0;
+
+	// get a pointer to the stream buffer
+	FreeImage_AcquireMemory(hPngMemory, &data, &size_in_bytes);
+	if(!(data && size_in_bytes) || (size_in_bytes < 20) || (size_in_bytes - offset < 20)) {
+		// not enough space to read a signature(8 bytes) + a chunk(at least 12 bytes)
+		return FALSE;
+	}
+
+	try {
+	
+		// skip the signature and/or any following chunk(s)
+		DWORD chunk_pos = offset;
+
+		while(1) {
+			// get chunk length
+			if(chunk_pos + 4 > size_in_bytes) {
+				break;
+			}
+
+			memcpy(&mLength, &data[chunk_pos], 4);
+			mng_SwapLong(&mLength);
+			chunk_pos += 4;
+
+			const DWORD next_chunk_pos = chunk_pos + 4 + mLength + 4;
+			if(next_chunk_pos > size_in_bytes) {
+				break;
+			}
+
+			// get chunk name
+			if(memcmp(&data[chunk_pos], chunk_name, 4) == 0) {
+				chunk_pos -= 4;	// found chunk
+				*start_pos = chunk_pos;
+				*next_pos = next_chunk_pos;
+				return TRUE;
+			}
+			
+			chunk_pos = next_chunk_pos;
+		}
+
+		return FALSE;
+
+	} catch(int) {
+		return FALSE;
+	}
+}
+
+/**
+Remove a chunk located at (start_pos, next_pos) in the PNG stream
+@param hPngMemory PNG stream handle
+@param start_pos Start position of the chunk
+@param next_pos Start position of the next chunk
+@return Returns TRUE if successfull, returns FALSE otherwise
+*/
+static BOOL 
+mng_CopyRemoveChunks(FIMEMORY *hPngMemory, DWORD start_pos, DWORD next_pos) {
+	BYTE *data = NULL;
+	DWORD size_in_bytes = 0;
+
+	// length of the chunk to remove
+	DWORD chunk_length = next_pos - start_pos;
+	if(chunk_length == 0) {
+		return TRUE;
+	}
+
+	// get a pointer to the stream buffer
+	FreeImage_AcquireMemory(hPngMemory, &data, &size_in_bytes);
+	if(!(data && size_in_bytes) || (size_in_bytes < 20) || (chunk_length >= size_in_bytes)) {
+		// not enough space to read a signature(8 bytes) + a chunk(at least 12 bytes)
+		return FALSE;
+	}
+	
+	// new file length
+	unsigned buffer_size = size_in_bytes + chunk_length;
+
+	BYTE *buffer = (BYTE*)malloc(buffer_size * sizeof(BYTE));
+	if(!buffer) {
+		return FALSE;
+	}
+	memcpy(&buffer[0], &data[0], start_pos);
+	memcpy(&buffer[start_pos], &data[next_pos], size_in_bytes - next_pos);
+
+	// seek to the start of the stream
+	FreeImage_SeekMemory(hPngMemory, 0, SEEK_SET);
+	// re-write the stream
+	FreeImage_WriteMemory(buffer, 1, buffer_size, hPngMemory);
+
+	free(buffer);
+
+	return TRUE;
+}
+
+/**
+Insert a chunk just before the inNextChunkName chunk
+@param hPngMemory PNG stream handle
+@param start_pos Start position of the inNextChunkName chunk
+@param next_pos Start position of the next chunk
+@return Returns TRUE if successfull, returns FALSE otherwise
+*/
+static BOOL 
+mng_CopyInsertChunks(FIMEMORY *hPngMemory, BYTE *inNextChunkName, BYTE *inInsertChunk, DWORD inChunkLength, DWORD start_pos, DWORD next_pos) {
+	BYTE *data = NULL;
+	DWORD size_in_bytes = 0;
+
+	// length of the chunk to check
+	DWORD chunk_length = next_pos - start_pos;
+	if(chunk_length == 0) {
+		return TRUE;
+	}
+
+	// get a pointer to the stream buffer
+	FreeImage_AcquireMemory(hPngMemory, &data, &size_in_bytes);
+	if(!(data && size_in_bytes) || (size_in_bytes < 20) || (chunk_length >= size_in_bytes)) {
+		// not enough space to read a signature(8 bytes) + a chunk(at least 12 bytes)
+		return FALSE;
+	}
+	
+	// new file length
+	unsigned buffer_size = inChunkLength + size_in_bytes;
+
+	BYTE *buffer = (BYTE*)malloc(buffer_size * sizeof(BYTE));
+	if(!buffer) {
+		return FALSE;
+	}
+	unsigned p = 0;
+	memcpy(&buffer[p], &data[0], start_pos);
+	p += start_pos;
+	memcpy(&buffer[p], inInsertChunk, inChunkLength);
+	p += inChunkLength;
+	memcpy(&buffer[p], &data[start_pos], size_in_bytes - start_pos);
+
+	// seek to the start of the stream
+	FreeImage_SeekMemory(hPngMemory, 0, SEEK_SET);
+	// re-write the stream
+	FreeImage_WriteMemory(buffer, 1, buffer_size, hPngMemory);
+
+	free(buffer);
+
+	return TRUE;
+}
+
+static BOOL 
+mng_RemoveChunk(FIMEMORY *hPngMemory, BYTE *chunk_name) {
+	BOOL bResult = FALSE;
+
+	DWORD start_pos = 0;
+	DWORD next_pos = 0;
+	
+	bResult = mng_FindChunk(hPngMemory, chunk_name, 8, &start_pos, &next_pos);
+	if(!bResult) return FALSE;
+
+	bResult = mng_CopyRemoveChunks(hPngMemory, start_pos, next_pos);
+	if(!bResult) return FALSE;
+
+	return TRUE;
+}
+
+static BOOL 
+mng_InsertChunk(FIMEMORY *hPngMemory, BYTE *inNextChunkName, BYTE *inInsertChunk, unsigned chunk_length) {
+	BOOL bResult = FALSE;
+
+	DWORD start_pos = 0;
+	DWORD next_pos = 0;
+	
+	bResult = mng_FindChunk(hPngMemory, inNextChunkName, 8, &start_pos, &next_pos);
+	if(!bResult) return FALSE;
+
+	bResult = mng_CopyInsertChunks(hPngMemory, inNextChunkName, inInsertChunk, chunk_length, start_pos, next_pos);
+	if(!bResult) return FALSE;
+
+	return TRUE;
+}
+
+static FIBITMAP* 
+mng_LoadFromMemoryHandle(FIMEMORY *hmem, int flags = 0) {
+	long offset = 0;
+	FIBITMAP *dib = NULL;
+
+	if(hmem) {
+		// seek to the start of the stream
+		FreeImage_SeekMemory(hmem, offset, SEEK_SET);
+
+		// check the file signature and deduce its format
+		// (the second argument is currently not used by FreeImage)
+		FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem, 0);
+		if(fif != FIF_UNKNOWN) {
+			dib = FreeImage_LoadFromMemory(fif, hmem, flags);
+		}
+	}
+	
+	return dib;
+}
+
+/**
+Write a chunk in a PNG stream from the current position. 
+@param chunk_name Name of the chunk
+@param chunk_data Chunk array
+@param length Chunk length
+@param hPngMemory PNG stream handle
+*/
+static void
+mng_WriteChunk(BYTE *chunk_name, BYTE *chunk_data, DWORD length, FIMEMORY *hPngMemory) {
+	DWORD crc_file = 0;
+	// write a PNG chunk ...
+	// - length
+	mng_SwapLong(&length);
+	FreeImage_WriteMemory(&length, 1, 4, hPngMemory);
+	mng_SwapLong(&length);
+	// - chunk name
+	FreeImage_WriteMemory(chunk_name, 1, 4, hPngMemory);
+	if(chunk_data && length) {
+		// - chunk data
+		FreeImage_WriteMemory(chunk_data, 1, length, hPngMemory);
+		// - crc
+		crc_file = FreeImage_ZLibCRC32(0, chunk_name, 4);
+		crc_file = FreeImage_ZLibCRC32(crc_file, chunk_data, length);
+		mng_SwapLong(&crc_file);
+		FreeImage_WriteMemory(&crc_file, 1, 4, hPngMemory);
+	} else {
+		// - crc
+		crc_file = FreeImage_ZLibCRC32(0, chunk_name, 4);
+		mng_SwapLong(&crc_file);
+		FreeImage_WriteMemory(&crc_file, 1, 4, hPngMemory);
+	}
+
+}
+
+/**
+Wrap a IDAT chunk as a PNG stream. 
+The stream has the structure { g_png_signature, IHDR, IDAT, IEND }
+The image is assumed to be a greyscale image. 
+
+@param jng_width Image width
+@param jng_height Image height
+@param jng_alpha_sample_depth Bits per pixel
+@param mChunk PNG grayscale IDAT format
+@param mLength IDAT chunk length
+@param hPngMemory Output memory stream
+*/
+static void 
+mng_WritePNGStream(DWORD jng_width, DWORD jng_height, BYTE jng_alpha_sample_depth, BYTE *mChunk, DWORD mLength, FIMEMORY *hPngMemory) {
+	// PNG grayscale IDAT format
+
+	BYTE data[14];
+
+	// wrap the IDAT chunk as a PNG stream
+
+	// write PNG file signature
+	FreeImage_WriteMemory(g_png_signature, 1, 8, hPngMemory);
+
+	// write a IHDR chunk ...
+	/*
+	The IHDR chunk must appear FIRST. It contains:
+	Width:              4 bytes
+	Height:             4 bytes
+	Bit depth:          1 byte
+	Color type:         1 byte
+	Compression method: 1 byte
+	Filter method:      1 byte
+	Interlace method:   1 byte
+	*/
+	// - chunk data
+	mng_SwapLong(&jng_width);
+	mng_SwapLong(&jng_height);
+	memcpy(&data[0], &jng_width, 4);
+	memcpy(&data[4], &jng_height, 4);
+	mng_SwapLong(&jng_width);
+	mng_SwapLong(&jng_height);
+	data[8] = jng_alpha_sample_depth;
+	data[9] = 0;	// color_type gray (jng_color_type)
+	data[10] = 0;	// compression method 0 (jng_alpha_compression_method)
+	data[11] = 0;	// filter_method 0 (jng_alpha_filter_method)
+	data[12] = 0;	// interlace_method 0 (jng_alpha_interlace_method)
+
+	mng_WriteChunk(mng_IHDR, &data[0], 13, hPngMemory);
+
+	// write a IDAT chunk ...
+	mng_WriteChunk(mng_IDAT, mChunk, mLength, hPngMemory);
+
+	// write a IEND chunk ...
+	mng_WriteChunk(mng_IEND, NULL, 0, hPngMemory);
+
+}
+
+// --------------------------------------------------------------------------
+
+/**
+Build and set a FITAG whose type is FIDT_ASCII. 
+The tag must be destroyed by the caller using FreeImage_DeleteTag.
+@param model Metadata model to be filled
+@param dib Image to be filled
+@param key Tag key
+@param value Tag value
+@return Returns TRUE if successful, returns FALSE otherwise
+*/
+static BOOL 
+mng_SetKeyValue(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, const char *key, const char *value) {
+	if(!dib || !key || !value) {
+		return FALSE;
+	}
+	// create a tag
+	FITAG *tag = FreeImage_CreateTag();
+	if(tag) {
+		BOOL bSuccess = TRUE;
+		// fill the tag
+		DWORD tag_length = (DWORD)(strlen(value) + 1);
+		bSuccess &= FreeImage_SetTagKey(tag, key);
+		bSuccess &= FreeImage_SetTagLength(tag, tag_length);
+		bSuccess &= FreeImage_SetTagCount(tag, tag_length);
+		bSuccess &= FreeImage_SetTagType(tag, FIDT_ASCII);
+		bSuccess &= FreeImage_SetTagValue(tag, value);
+		if(bSuccess) {
+			// set the tag
+			FreeImage_SetMetadata(model, dib, FreeImage_GetTagKey(tag), tag);
+		}
+		FreeImage_DeleteTag(tag);
+		return bSuccess;
+	}
+
+	return FALSE;
+}
+
+/**
+Read a tEXt chunk and extract the key/value pair. 
+@param key_value_pair [returned value] Array of key/value pairs
+@param mChunk Chunk data
+@param mLength Chunk length
+@return Returns TRUE if successful, returns FALSE otherwise
+*/
+static BOOL 
+mng_SetMetadata_tEXt(tEXtMAP &key_value_pair, const BYTE *mChunk, DWORD mLength) {
+	std::string key;
+	std::string value;
+	BYTE *buffer = (BYTE*)malloc(mLength * sizeof(BYTE));
+	if(!buffer) {
+		return FALSE;
+	}
+	DWORD pos = 0;
+
+	memset(buffer, 0, mLength * sizeof(BYTE));
+
+	for(DWORD i = 0; i < mLength; i++) {
+		buffer[pos++] = mChunk[i];
+		if(mChunk[i] == '\0') {
+			if(key.size() == 0) {
+				key = (char*)buffer;
+				pos = 0;
+				memset(buffer, 0, mLength * sizeof(BYTE));
+			} else {
+				break;
+			}
+		}
+	}
+	value = (char*)buffer;
+	free(buffer);
+
+	key_value_pair[key] = value;
+
+	return TRUE;
+}
+
+// --------------------------------------------------------------------------
+
+/**
+Load a FIBITMAP from a MNG or a JNG stream
+@param format_id ID of the caller
+@param io Stream i/o functions
+@param handle Stream handle
+@param Offset Start of the first chunk
+@param flags Loading flags
+@return Returns a dib if successful, returns NULL otherwise
+*/
+FIBITMAP* 
+mng_ReadChunks(int format_id, FreeImageIO *io, fi_handle handle, long Offset, int flags = 0) {
+	DWORD mLength = 0;
+	BYTE mChunkName[5];
+	BYTE *mChunk = NULL;
+	DWORD crc_file;
+	long LastOffset;
+	long mOrigPos;
+	BYTE *PLTE_file_chunk = NULL;	// whole PLTE chunk (lentgh, name, array, crc)
+	DWORD PLTE_file_size = 0;		// size of PLTE chunk
+
+	BOOL m_HasGlobalPalette = FALSE; // may turn to TRUE in PLTE chunk
+	unsigned m_TotalBytesOfChunks = 0;
+	FIBITMAP *dib = NULL;
+	FIBITMAP *dib_alpha = NULL;
+
+	FIMEMORY *hJpegMemory = NULL;
+	FIMEMORY *hPngMemory = NULL;
+	FIMEMORY *hIDATMemory = NULL;
+
+	// ---
+	DWORD jng_width = 0;
+	DWORD jng_height = 0;
+	BYTE jng_color_type = 0;
+	BYTE jng_image_sample_depth = 0;
+	BYTE jng_image_compression_method = 0;
+
+	BYTE jng_alpha_sample_depth = 0;
+	BYTE jng_alpha_compression_method = 0;
+	BYTE jng_alpha_filter_method = 0;
+	BYTE jng_alpha_interlace_method = 0;
+
+	DWORD mng_frame_width = 0;
+	DWORD mng_frame_height = 0;
+	DWORD mng_ticks_per_second = 0;
+	DWORD mng_nominal_layer_count = 0;
+	DWORD mng_nominal_frame_count = 0;
+	DWORD mng_nominal_play_time = 0;
+	DWORD mng_simplicity_profile = 0;
+
+
+	DWORD res_x = 2835;	// 72 dpi
+	DWORD res_y = 2835;	// 72 dpi
+	RGBQUAD rgbBkColor = {0, 0, 0, 0};
+	WORD bk_red, bk_green, bk_blue;
+	BOOL hasBkColor = FALSE;
+	BOOL mHasIDAT = FALSE;
+
+	tEXtMAP key_value_pair;
+
+	// ---
+
+	BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS;
+	
+	// get the file size
+	const long mLOF = mng_LOF(io, handle);
+	// go to the first chunk
+	io->seek_proc(handle, Offset, SEEK_SET);
+
+	try {
+		BOOL mEnd = FALSE;
+
+		while(mEnd == FALSE) {
+			// start of the chunk
+			LastOffset = io->tell_proc(handle);
+			// read length
+			mLength = 0;			
+			io->read_proc(&mLength, 1, sizeof(mLength), handle);
+			mng_SwapLong(&mLength);
+			// read name			
+			io->read_proc(&mChunkName[0], 1, 4, handle);
+			mChunkName[4] = '\0';
+
+			if(mLength > 0) {
+				mChunk = (BYTE*)realloc(mChunk, mLength);
+				if(!mChunk) {
+					FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: out of memory", mChunkName);
+					throw (const char*)NULL;
+				}				
+				Offset = io->tell_proc(handle);
+				if(Offset + (long)mLength > mLOF) {
+					FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: unexpected end of file", mChunkName);
+					throw (const char*)NULL;
+				}
+				// read chunk
+				io->read_proc(mChunk, 1, mLength, handle);
+			}
+			// read crc
+			io->read_proc(&crc_file, 1, sizeof(crc_file), handle);
+			mng_SwapLong(&crc_file);
+			// check crc
+			DWORD crc_check = FreeImage_ZLibCRC32(0, &mChunkName[0], 4);
+			crc_check = FreeImage_ZLibCRC32(crc_check, mChunk, mLength);
+			if(crc_check != crc_file) {
+				FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: bad CRC", mChunkName);
+				throw (const char*)NULL;
+			}		
+
+			switch( mng_GetChunckType(mChunkName) ) {
+				case MHDR:
+					// The MHDR chunk is always first in all MNG datastreams except for those 
+					// that consist of a single PNG or JNG datastream with a PNG or JNG signature. 
+					if(mLength == 28) {
+						memcpy(&mng_frame_width, &mChunk[0], 4);
+						memcpy(&mng_frame_height, &mChunk[4], 4);
+						memcpy(&mng_ticks_per_second, &mChunk[8], 4);
+						memcpy(&mng_nominal_layer_count, &mChunk[12], 4);
+						memcpy(&mng_nominal_frame_count, &mChunk[16], 4);
+						memcpy(&mng_nominal_play_time, &mChunk[20], 4);
+						memcpy(&mng_simplicity_profile, &mChunk[24], 4);
+
+						mng_SwapLong(&mng_frame_width);
+						mng_SwapLong(&mng_frame_height);
+						mng_SwapLong(&mng_ticks_per_second);
+						mng_SwapLong(&mng_nominal_layer_count);
+						mng_SwapLong(&mng_nominal_frame_count);
+						mng_SwapLong(&mng_nominal_play_time);
+						mng_SwapLong(&mng_simplicity_profile);
+
+					} else {
+						FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: size is %d instead of 28", mChunkName, mLength);
+					}
+					break;
+
+				case MEND:
+					mEnd = TRUE;
+					break;
+
+				case LOOP:
+				case ENDL:
+					break;
+				case DEFI:
+					break;
+				case SAVE:
+				case SEEK:
+				case TERM:
+					break;
+				case BACK:
+					break;
+
+					// Global "PLTE" and "tRNS" (if any).  PNG "PLTE" will be of 0 byte, as it uses global data.
+				case PLTE:	// Global
+					m_HasGlobalPalette = TRUE;
+					PLTE_file_size = mLength + 12; // (lentgh, name, array, crc) = (4, 4, mLength, 4)
+					PLTE_file_chunk = (BYTE*)realloc(PLTE_file_chunk, PLTE_file_size);
+					if(!PLTE_file_chunk) {
+						FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: out of memory", mChunkName);
+						throw (const char*)NULL;
+					} else {
+						mOrigPos = io->tell_proc(handle);
+						// seek to the start of the chunk
+						io->seek_proc(handle, LastOffset, SEEK_SET);
+						// load the whole chunk
+						io->read_proc(PLTE_file_chunk, 1, PLTE_file_size, handle);
+						// go to the start of the next chunk
+						io->seek_proc(handle, mOrigPos, SEEK_SET);
+					}
+					break;
+
+				case tRNS:	// Global
+					break;
+					
+				case IHDR:
+					Offset = LastOffset;
+					// parse the PNG file and get its file size
+					if(mng_CountPNGChunks(io, handle, Offset, &m_TotalBytesOfChunks) == FALSE) {
+						// reach an unexpected end of file
+						mEnd = TRUE;
+						FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: unexpected end of PNG file", mChunkName);
+						break;
+					}
+					
+					// wrap the { IHDR, ..., IEND } chunks as a PNG stream
+					if(hPngMemory == NULL) {
+						hPngMemory = FreeImage_OpenMemory();
+					}
+
+					mOrigPos = io->tell_proc(handle);
+
+					// write PNG file signature
+					FreeImage_SeekMemory(hPngMemory, 0, SEEK_SET);
+					FreeImage_WriteMemory(g_png_signature, 1, 8, hPngMemory);
+
+					mChunk = (BYTE*)realloc(mChunk, m_TotalBytesOfChunks);
+					if(!mChunk) {
+						FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: out of memory", mChunkName);
+						throw (const char*)NULL;
+					}
+					
+					// on calling CountPNGChunks earlier, we were in Offset pos,
+					// go back there
+					io->seek_proc(handle, Offset, SEEK_SET);
+					io->read_proc(mChunk, 1, m_TotalBytesOfChunks, handle);
+					// Put back to original pos
+					io->seek_proc(handle, mOrigPos, SEEK_SET);
+					// write the PNG chunks
+					FreeImage_WriteMemory(mChunk, 1, m_TotalBytesOfChunks, hPngMemory);
+
+					// plug in global PLTE if local PLTE exists
+					if(m_HasGlobalPalette) {
+						// ensure we remove some local chunks, so that global
+						// "PLTE" can be inserted right before "IDAT".
+						mng_RemoveChunk(hPngMemory, mng_PLTE);
+						mng_RemoveChunk(hPngMemory, mng_tRNS);
+						mng_RemoveChunk(hPngMemory, mng_bKGD);
+						// insert global "PLTE" chunk in its entirety before "IDAT"
+						mng_InsertChunk(hPngMemory, mng_IDAT, PLTE_file_chunk, PLTE_file_size);
+					}
+
+					if(dib) FreeImage_Unload(dib);
+					dib = mng_LoadFromMemoryHandle(hPngMemory, flags);
+
+					// stop after the first image
+					mEnd = TRUE;
+					break;
+
+				case JHDR:
+					if(mLength == 16) {
+						memcpy(&jng_width, &mChunk[0], 4);
+						memcpy(&jng_height, &mChunk[4], 4);
+						mng_SwapLong(&jng_width);
+						mng_SwapLong(&jng_height);
+
+						jng_color_type = mChunk[8];
+						jng_image_sample_depth = mChunk[9];
+						jng_image_compression_method = mChunk[10];
+						BYTE jng_image_interlace_method = mChunk[11];
+
+						jng_alpha_sample_depth = mChunk[12];
+						jng_alpha_compression_method = mChunk[13];
+						jng_alpha_filter_method = mChunk[14];
+						jng_alpha_interlace_method = mChunk[15];
+					} else {
+						FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: invalid chunk length", mChunkName);
+						throw (const char*)NULL;
+					}
+					break;
+
+				case JDAT:
+					if(hJpegMemory == NULL) {
+						hJpegMemory = FreeImage_OpenMemory();
+					}
+					// as there may be several JDAT chunks, concatenate them
+					FreeImage_WriteMemory(mChunk, 1, mLength, hJpegMemory);
+					break;
+
+				case IDAT:
+					if(!header_only && (jng_alpha_compression_method == 0)) {
+						// PNG grayscale IDAT format
+						if(hIDATMemory == NULL) {
+							hIDATMemory = FreeImage_OpenMemory();
+							mHasIDAT = TRUE;
+						}
+						// as there may be several IDAT chunks, concatenate them
+						FreeImage_WriteMemory(mChunk, 1, mLength, hIDATMemory);
+					}
+					break;
+
+				case IEND:
+					if(!hJpegMemory) {
+						mEnd = TRUE;
+						break;
+					}
+					// load the JPEG
+					if(dib) FreeImage_Unload(dib);
+					dib = mng_LoadFromMemoryHandle(hJpegMemory, flags);
+
+					// load the PNG alpha layer
+					if(mHasIDAT) {
+						BYTE *data = NULL;
+						DWORD size_in_bytes = 0;
+
+						// get a pointer to the IDAT buffer
+						FreeImage_AcquireMemory(hIDATMemory, &data, &size_in_bytes);
+						if(data && size_in_bytes) {
+							// wrap the IDAT chunk as a PNG stream
+							if(hPngMemory == NULL) {
+								hPngMemory = FreeImage_OpenMemory();
+							}
+							mng_WritePNGStream(jng_width, jng_height, jng_alpha_sample_depth, data, size_in_bytes, hPngMemory);
+							// load the PNG
+							if(dib_alpha) FreeImage_Unload(dib_alpha);
+							dib_alpha = mng_LoadFromMemoryHandle(hPngMemory, flags);
+						}
+					}
+					// stop the parsing
+					mEnd = TRUE;
+					break;
+
+				case JDAA:
+					break;
+
+				case gAMA:
+					break;
+
+				case pHYs:
+					// unit is pixels per meter
+					memcpy(&res_x, &mChunk[0], 4);
+					mng_SwapLong(&res_x);
+					memcpy(&res_y, &mChunk[4], 4);
+					mng_SwapLong(&res_y);
+					break;
+
+				case bKGD:
+					memcpy(&bk_red, &mChunk[0], 2);
+					mng_SwapShort(&bk_red);
+					rgbBkColor.rgbRed = (BYTE)bk_red;
+					memcpy(&bk_green, &mChunk[2], 2);
+					mng_SwapShort(&bk_green);
+					rgbBkColor.rgbGreen = (BYTE)bk_green;
+					memcpy(&bk_blue, &mChunk[4], 2);
+					mng_SwapShort(&bk_blue);
+					rgbBkColor.rgbBlue = (BYTE)bk_blue;
+					hasBkColor = TRUE;
+					break;
+				
+				case tEXt:
+					mng_SetMetadata_tEXt(key_value_pair, mChunk, mLength);
+					break;
+
+				case UNKNOWN_CHUNCK:
+				default:
+					break;
+
+
+			} // switch( GetChunckType )
+		} // while(!mEnd)
+
+		FreeImage_CloseMemory(hJpegMemory);
+		FreeImage_CloseMemory(hPngMemory);
+		FreeImage_CloseMemory(hIDATMemory);
+		free(mChunk);
+		free(PLTE_file_chunk);
+
+		// convert to 32-bit if a transparent layer is available
+		if(!header_only && dib_alpha) {
+			FIBITMAP *dst = FreeImage_ConvertTo32Bits(dib);
+			if((FreeImage_GetBPP(dib_alpha) == 8) && (FreeImage_GetImageType(dib_alpha) == FIT_BITMAP)) {
+				FreeImage_SetChannel(dst, dib_alpha, FICC_ALPHA);
+			} else {
+				FIBITMAP *dst_alpha = FreeImage_ConvertTo8Bits(dib_alpha);
+				FreeImage_SetChannel(dst, dst_alpha, FICC_ALPHA);
+				FreeImage_Unload(dst_alpha);
+			}			
+			FreeImage_Unload(dib);
+			dib = dst;
+		}
+		FreeImage_Unload(dib_alpha);
+
+		if(dib) {
+			// set metadata
+			FreeImage_SetDotsPerMeterX(dib, res_x);
+			FreeImage_SetDotsPerMeterY(dib, res_y);
+			if(hasBkColor) {
+				FreeImage_SetBackgroundColor(dib, &rgbBkColor);
+			}
+			if(key_value_pair.size()) {
+				for(tEXtMAP::iterator j = key_value_pair.begin(); j != key_value_pair.end(); j++) {
+					std::string key = (*j).first;
+					std::string value = (*j).second;
+					mng_SetKeyValue(FIMD_COMMENTS, dib, key.c_str(), value.c_str());
+				}
+			}
+		}
+			
+		return dib;
+
+	} catch(const char *text) {
+		FreeImage_CloseMemory(hJpegMemory);
+		FreeImage_CloseMemory(hPngMemory);
+		FreeImage_CloseMemory(hIDATMemory);
+		free(mChunk);
+		free(PLTE_file_chunk);
+		FreeImage_Unload(dib);
+		FreeImage_Unload(dib_alpha);
+		if(text) {
+			FreeImage_OutputMessageProc(format_id, text);
+		}
+		return NULL;
+	}
+}
+
+// --------------------------------------------------------------------------
+
+/**
+Write a FIBITMAP to a JNG stream
+@param format_id ID of the caller
+@param io Stream i/o functions
+@param dib Image to be saved
+@param handle Stream handle
+@param flags Saving flags
+@return Returns TRUE if successful, returns FALSE otherwise
+*/
+BOOL 
+mng_WriteJNG(int format_id, FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int flags) {
+	DWORD jng_width = 0;
+	DWORD jng_height = 0;
+	BYTE jng_color_type = 0;
+	BYTE jng_image_sample_depth = 8;
+	BYTE jng_image_compression_method = 8;	//  8: ISO-10918-1 Huffman-coded baseline JPEG.
+	BYTE jng_image_interlace_method = 0;
+
+	BYTE jng_alpha_sample_depth = 0;
+	BYTE jng_alpha_compression_method = 0;
+	BYTE jng_alpha_filter_method = 0;
+	BYTE jng_alpha_interlace_method = 0;
+
+	BYTE buffer[16];
+
+	FIMEMORY *hJngMemory = NULL;
+	FIMEMORY *hJpegMemory = NULL;
+	FIMEMORY *hPngMemory = NULL;
+
+	FIBITMAP *dib_rgb = NULL;
+	FIBITMAP *dib_alpha = NULL;
+
+	if(!dib || (FreeImage_GetImageType(dib) != FIT_BITMAP)) {
+		return FALSE;
+	}
+
+	unsigned bpp = FreeImage_GetBPP(dib);
+
+	switch(bpp) {
+		case 8:
+			if(FreeImage_GetColorType(dib) == FIC_MINISBLACK) {
+				dib_rgb = dib;
+				jng_color_type = MNG_COLORTYPE_JPEGGRAY;
+			} else {
+				// JPEG plugin will convert other types (FIC_MINISWHITE, FIC_PALETTE) to 24-bit on the fly
+				//dib_rgb = FreeImage_ConvertTo24Bits(dib);
+				dib_rgb = dib;
+				jng_color_type = MNG_COLORTYPE_JPEGCOLOR;
+
+			}
+			break;
+		case 24:
+			dib_rgb = dib;
+			jng_color_type = MNG_COLORTYPE_JPEGCOLOR;
+			break;
+		case 32:
+			dib_rgb = FreeImage_ConvertTo24Bits(dib);
+			jng_color_type = MNG_COLORTYPE_JPEGCOLORA;
+			jng_alpha_sample_depth = 8;
+			break;
+		default:
+			return FALSE;
+	}
+
+	jng_width = (DWORD)FreeImage_GetWidth(dib);
+	jng_height = (DWORD)FreeImage_GetHeight(dib);
+
+	try {
+		hJngMemory = FreeImage_OpenMemory();
+
+		// --- write JNG file signature ---
+		FreeImage_WriteMemory(g_jng_signature, 1, 8, hJngMemory);
+
+		// --- write a JHDR chunk ---
+		SwapLong(&jng_width);
+		SwapLong(&jng_height);
+		memcpy(&buffer[0], &jng_width, 4);
+		memcpy(&buffer[4], &jng_height, 4);
+		SwapLong(&jng_width);
+		SwapLong(&jng_height);
+		buffer[8] = jng_color_type;
+		buffer[9] = jng_image_sample_depth;
+		buffer[10] = jng_image_compression_method;
+		buffer[11] = jng_image_interlace_method;
+		buffer[12] = jng_alpha_sample_depth;
+		buffer[13] = jng_alpha_compression_method;
+		buffer[14] = jng_alpha_filter_method;
+		buffer[15] = jng_alpha_interlace_method;
+		mng_WriteChunk(mng_JHDR, &buffer[0], 16, hJngMemory);
+
+		// --- write a sequence of JDAT chunks ---
+		hJpegMemory = FreeImage_OpenMemory();
+		flags |= JPEG_BASELINE;
+		if(!FreeImage_SaveToMemory(FIF_JPEG, dib_rgb, hJpegMemory, flags)) {
+			throw (const char*)NULL;
+		}
+		if(dib_rgb != dib) {
+			FreeImage_Unload(dib_rgb);
+			dib_rgb = NULL;
+		}
+		{
+			BYTE *jpeg_data = NULL;
+			DWORD size_in_bytes = 0;
+			
+			// get a pointer to the stream buffer
+			FreeImage_AcquireMemory(hJpegMemory, &jpeg_data, &size_in_bytes);
+			// write chunks
+			for(DWORD k = 0; k < size_in_bytes;) {
+				DWORD bytes_left = size_in_bytes - k;
+				DWORD chunk_size = MIN(JPEG_CHUNK_SIZE, bytes_left);
+				mng_WriteChunk(mng_JDAT, &jpeg_data[k], chunk_size, hJngMemory);
+				k += chunk_size;
+			}
+		}
+		FreeImage_CloseMemory(hJpegMemory);
+		hJpegMemory = NULL;
+
+		// --- write alpha layer as a sequence of IDAT chunk ---
+		if((bpp == 32) && (jng_color_type == MNG_COLORTYPE_JPEGCOLORA)) {
+			dib_alpha = FreeImage_GetChannel(dib, FICC_ALPHA);
+
+			hPngMemory = FreeImage_OpenMemory();
+			if(!FreeImage_SaveToMemory(FIF_PNG, dib_alpha, hPngMemory, PNG_DEFAULT)) {
+				throw (const char*)NULL;
+			}
+			FreeImage_Unload(dib_alpha);
+			dib_alpha = NULL;
+			// get the IDAT chunk
+			{		
+				BOOL bResult = FALSE;
+				DWORD start_pos = 0;
+				DWORD next_pos = 0;
+				long offset = 8;
+				
+				do {
+					// find the next IDAT chunk from 'offset' position
+					bResult = mng_FindChunk(hPngMemory, mng_IDAT, offset, &start_pos, &next_pos);
+					if(!bResult) break;
+					
+					BYTE *png_data = NULL;
+					DWORD size_in_bytes = 0;
+					
+					// get a pointer to the stream buffer
+					FreeImage_AcquireMemory(hPngMemory, &png_data, &size_in_bytes);
+					// write the IDAT chunk
+					mng_WriteChunk(mng_IDAT, &png_data[start_pos+8], next_pos - start_pos - 12, hJngMemory);
+
+					offset = next_pos;
+
+				} while(bResult);
+			}
+
+			FreeImage_CloseMemory(hPngMemory);
+			hPngMemory = NULL;
+		}
+
+		// --- write a IEND chunk ---
+		mng_WriteChunk(mng_IEND, NULL, 0, hJngMemory);
+
+		// write the JNG on output stream
+		{
+			BYTE *jng_data = NULL;
+			DWORD size_in_bytes = 0;
+			FreeImage_AcquireMemory(hJngMemory, &jng_data, &size_in_bytes);
+			io->write_proc(jng_data, 1, size_in_bytes, handle);			
+		}
+
+		FreeImage_CloseMemory(hJngMemory);
+		FreeImage_CloseMemory(hJpegMemory);
+		FreeImage_CloseMemory(hPngMemory);
+
+		return TRUE;
+
+	} catch(const char *text) {
+		FreeImage_CloseMemory(hJngMemory);
+		FreeImage_CloseMemory(hJpegMemory);
+		FreeImage_CloseMemory(hPngMemory);
+		if(dib_rgb && (dib_rgb != dib)) {
+			FreeImage_Unload(dib_rgb);
+		}
+		FreeImage_Unload(dib_alpha);
+		if(text) {
+			FreeImage_OutputMessageProc(format_id, text);
+		}
+		return FALSE;
+	}
+}