AdvaImg:

- freeimage extracted to the separate library;
- FI_INTERFACE removed, all references to it are replaced with direct calls of FreeImage_* functions;
- unified project for AdvaImg

1 files changed, 0 insertions, 1115 deletions

diff --git a/plugins/AdvaImg/src/FreeImage/PluginPNG.cpp b/plugins/AdvaImg/src/FreeImage/PluginPNG.cpp
deleted file mode 100644
index fe80a2b533..0000000000
--- a/plugins/AdvaImg/src/FreeImage/PluginPNG.cpp
+++ /dev/null
@@ -1,1115 +0,0 @@
-// ==========================================================
-// PNG Loader and Writer
-//
-// Design and implementation by
-// - Floris van den Berg (flvdberg@wxs.nl)
-// - Herve Drolon (drolon@infonie.fr)
-// - Detlev Vendt (detlev.vendt@brillit.de)
-// - Aaron Shumate (trek@startreker.com)
-// - Tanner Helland (tannerhelland@users.sf.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!
-// ==========================================================
-
-#ifdef _MSC_VER 
-#pragma warning (disable : 4786) // identifier was truncated to 'number' characters
-#endif
-
-#include "FreeImage.h"
-#include "Utilities.h"
-
-#include "../Metadata/FreeImageTag.h"
-
-// ----------------------------------------------------------
-
-#define PNG_BYTES_TO_CHECK 8
-
-#undef PNG_Z_DEFAULT_COMPRESSION	// already used in ../LibPNG/pnglibconf.h
-
-// ----------------------------------------------------------
-
-#include "zlib.h"
-#include "../LibPNG/png.h"
-
-// ----------------------------------------------------------
-
-typedef struct {
-    FreeImageIO *s_io;
-    fi_handle    s_handle;
-} fi_ioStructure, *pfi_ioStructure;
-
-// ==========================================================
-// libpng interface
-// ==========================================================
-
-static void
-_ReadProc(png_structp png_ptr, unsigned char *data, png_size_t size) {
-    pfi_ioStructure pfio = (pfi_ioStructure)png_get_io_ptr(png_ptr);
-	unsigned n = pfio->s_io->read_proc(data, (unsigned int)size, 1, pfio->s_handle);
-	if(size && (n == 0)) {
-		throw "Read error: invalid or corrupted PNG file";
-	}
-}
-
-static void
-_WriteProc(png_structp png_ptr, unsigned char *data, png_size_t size) {
-    pfi_ioStructure pfio = (pfi_ioStructure)png_get_io_ptr(png_ptr);
-    pfio->s_io->write_proc(data, (unsigned int)size, 1, pfio->s_handle);
-}
-
-static void
-_FlushProc(png_structp png_ptr) {
-	(png_structp)png_ptr;
-	// empty flush implementation
-}
-
-static void
-error_handler(png_structp png_ptr, const char *error) {
-	(png_structp)png_ptr;
-	throw error;
-}
-
-// in FreeImage warnings disabled
-
-static void
-warning_handler(png_structp png_ptr, const char *warning) {
-	(png_structp)png_ptr;
-	(char*)warning;
-}
-
-// ==========================================================
-// Metadata routines
-// ==========================================================
-
-static BOOL 
-ReadMetadata(png_structp png_ptr, png_infop info_ptr, FIBITMAP *dib) {
-	// XMP keyword
-	const char *g_png_xmp_keyword = "XML:com.adobe.xmp";
-
-	FITAG *tag = NULL;
-	png_textp text_ptr = NULL;
-	png_timep mod_time = NULL;
-	int num_text = 0;
-
-	// iTXt/tEXt/zTXt chuncks
-	if(png_get_text(png_ptr, info_ptr, &text_ptr, &num_text) > 0) {
-		for(int i = 0; i < num_text; i++) {
-			// create a tag
-			tag = FreeImage_CreateTag();
-			if(!tag) return FALSE;
-
-			DWORD tag_length = (DWORD) MAX(text_ptr[i].text_length, text_ptr[i].itxt_length);
-
-			FreeImage_SetTagLength(tag, tag_length);
-			FreeImage_SetTagCount(tag, tag_length);
-			FreeImage_SetTagType(tag, FIDT_ASCII);
-			FreeImage_SetTagValue(tag, text_ptr[i].text);
-
-			if(strcmp(text_ptr[i].key, g_png_xmp_keyword) == 0) {
-				// store the tag as XMP
-				FreeImage_SetTagKey(tag, g_TagLib_XMPFieldName);
-				FreeImage_SetMetadata(FIMD_XMP, dib, FreeImage_GetTagKey(tag), tag);
-			} else {
-				// store the tag as a comment
-				FreeImage_SetTagKey(tag, text_ptr[i].key);
-				FreeImage_SetMetadata(FIMD_COMMENTS, dib, FreeImage_GetTagKey(tag), tag);
-			}
-			
-			// destroy the tag
-			FreeImage_DeleteTag(tag);
-		}
-	}
-
-	// timestamp chunk
-	if(png_get_tIME(png_ptr, info_ptr, &mod_time)) {
-		char timestamp[32];
-		// create a tag
-		tag = FreeImage_CreateTag();
-		if(!tag) return FALSE;
-
-		// convert as 'yyyy:MM:dd hh:mm:ss'
-		sprintf(timestamp, "%4d:%02d:%02d %2d:%02d:%02d", mod_time->year, mod_time->month, mod_time->day, mod_time->hour, mod_time->minute, mod_time->second);
-
-		DWORD tag_length = (DWORD)strlen(timestamp) + 1;
-		FreeImage_SetTagLength(tag, tag_length);
-		FreeImage_SetTagCount(tag, tag_length);
-		FreeImage_SetTagType(tag, FIDT_ASCII);
-		FreeImage_SetTagID(tag, TAG_DATETIME);
-		FreeImage_SetTagValue(tag, timestamp);
-
-		// store the tag as Exif-TIFF
-		FreeImage_SetTagKey(tag, "DateTime");
-		FreeImage_SetMetadata(FIMD_EXIF_MAIN, dib, FreeImage_GetTagKey(tag), tag);
-
-		// destroy the tag
-		FreeImage_DeleteTag(tag);
-	}
-
-	return TRUE;
-}
-
-static BOOL 
-WriteMetadata(png_structp png_ptr, png_infop info_ptr, FIBITMAP *dib) {
-	// XMP keyword
-	const char *g_png_xmp_keyword = "XML:com.adobe.xmp";
-
-	FITAG *tag = NULL;
-	FIMETADATA *mdhandle = NULL;
-	BOOL bResult = TRUE;
-
-	png_text text_metadata;
-	png_time mod_time;
-
-	// set the 'Comments' metadata as iTXt chuncks
-
-	mdhandle = FreeImage_FindFirstMetadata(FIMD_COMMENTS, dib, &tag);
-
-	if(mdhandle) {
-		do {
-			memset(&text_metadata, 0, sizeof(png_text));
-			text_metadata.compression = 1;							// iTXt, none
-			text_metadata.key = (char*)FreeImage_GetTagKey(tag);	// keyword, 1-79 character description of "text"
-			text_metadata.text = (char*)FreeImage_GetTagValue(tag);	// comment, may be an empty string (ie "")
-			text_metadata.text_length = FreeImage_GetTagLength(tag);// length of the text string
-			text_metadata.itxt_length = FreeImage_GetTagLength(tag);// length of the itxt string
-			text_metadata.lang = 0;		 // language code, 0-79 characters or a NULL pointer
-			text_metadata.lang_key = 0;	 // keyword translated UTF-8 string, 0 or more chars or a NULL pointer
-
-			// set the tag 
-			png_set_text(png_ptr, info_ptr, &text_metadata, 1);
-
-		} while(FreeImage_FindNextMetadata(mdhandle, &tag));
-
-		FreeImage_FindCloseMetadata(mdhandle);
-		bResult &= TRUE;
-	}
-
-	// set the 'XMP' metadata as iTXt chuncks
-	tag = NULL;
-	FreeImage_GetMetadata(FIMD_XMP, dib, g_TagLib_XMPFieldName, &tag);
-	if(tag && FreeImage_GetTagLength(tag)) {
-		memset(&text_metadata, 0, sizeof(png_text));
-		text_metadata.compression = 1;							// iTXt, none
-		text_metadata.key = (char*)g_png_xmp_keyword;			// keyword, 1-79 character description of "text"
-		text_metadata.text = (char*)FreeImage_GetTagValue(tag);	// comment, may be an empty string (ie "")
-		text_metadata.text_length = FreeImage_GetTagLength(tag);// length of the text string
-		text_metadata.itxt_length = FreeImage_GetTagLength(tag);// length of the itxt string
-		text_metadata.lang = 0;		 // language code, 0-79 characters or a NULL pointer
-		text_metadata.lang_key = 0;	 // keyword translated UTF-8 string, 0 or more chars or a NULL pointer
-
-		// set the tag 
-		png_set_text(png_ptr, info_ptr, &text_metadata, 1);
-		bResult &= TRUE;
-	}
-
-	// set the Exif-TIFF 'DateTime' metadata as a tIME chunk
-	tag = NULL;
-	FreeImage_GetMetadata(FIMD_EXIF_MAIN, dib, "DateTime", &tag);
-	if(tag && FreeImage_GetTagLength(tag)) {
-		int year, month, day, hour, minute, second;
-		const char *value = (char*)FreeImage_GetTagValue(tag);
-		if(sscanf(value, "%4d:%02d:%02d %2d:%02d:%02d", &year, &month, &day, &hour, &minute, &second) == 6) {
-			mod_time.year	= (png_uint_16)year;
-			mod_time.month	= (png_byte)month;
-			mod_time.day	= (png_byte)day;
-			mod_time.hour	= (png_byte)hour;
-			mod_time.minute	= (png_byte)minute;
-			mod_time.second	= (png_byte)second;
-			png_set_tIME (png_ptr, info_ptr, &mod_time);
-		}
-	}
-
-	return bResult;
-}
-
-// ==========================================================
-// Plugin Interface
-// ==========================================================
-
-static int s_format_id;
-
-// ==========================================================
-// Plugin Implementation
-// ==========================================================
-
-static const char * DLL_CALLCONV
-Format() {
-	return "PNG";
-}
-
-static const char * DLL_CALLCONV
-Description() {
-	return "Portable Network Graphics";
-}
-
-static const char * DLL_CALLCONV
-Extension() {
-	return "png";
-}
-
-static const char * DLL_CALLCONV
-RegExpr() {
-	return "^.PNG\r";
-}
-
-static const char * DLL_CALLCONV
-MimeType() {
-	return "image/png";
-}
-
-static BOOL DLL_CALLCONV
-Validate(FreeImageIO *io, fi_handle handle) {
-	BYTE png_signature[8] = { 137, 80, 78, 71, 13, 10, 26, 10 };
-	BYTE signature[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-
-	io->read_proc(&signature, 1, 8, handle);
-
-	return (memcmp(png_signature, signature, 8) == 0);
-}
-
-static BOOL DLL_CALLCONV
-SupportsExportDepth(int depth) {
-	return (
-			(depth == 1) ||
-			(depth == 4) ||
-			(depth == 8) ||
-			(depth == 24) ||
-			(depth == 32)
-		);
-}
-
-static BOOL DLL_CALLCONV 
-SupportsExportType(FREE_IMAGE_TYPE type) {
-	return (
-		(type == FIT_BITMAP) ||
-		(type == FIT_UINT16) ||
-		(type == FIT_RGB16) ||
-		(type == FIT_RGBA16)
-	);
-}
-
-static BOOL DLL_CALLCONV
-SupportsICCProfiles() {
-	return TRUE;
-}
-
-static BOOL DLL_CALLCONV
-SupportsNoPixels() {
-	return TRUE;
-}
-
-// --------------------------------------------------------------------------
-
-/**
-Configure the decoder so that decoded pixels are compatible with a FREE_IMAGE_TYPE format. 
-Set conversion instructions as needed. 
-@param png_ptr PNG handle
-@param info_ptr PNG info handle
-@param flags Decoder flags
-@param output_image_type Returned FreeImage converted image type
-@return Returns TRUE if successful, returns FALSE otherwise
-@see png_read_update_info
-*/
-static BOOL 
-ConfigureDecoder(png_structp png_ptr, png_infop info_ptr, int flags, FREE_IMAGE_TYPE *output_image_type) {
-	// get original image info
-	const int color_type = png_get_color_type(png_ptr, info_ptr);
-	const int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
-	const int pixel_depth = bit_depth * png_get_channels(png_ptr, info_ptr);
-
-	FREE_IMAGE_TYPE image_type = FIT_BITMAP;	// assume standard image type
-
-	// check for transparency table or single transparent color
-	BOOL bIsTransparent = png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) == PNG_INFO_tRNS ? TRUE : FALSE;
-
-	// check allowed combinations of colour type and bit depth
-	// then get converted FreeImage type
-
-	switch(color_type) {
-		case PNG_COLOR_TYPE_GRAY:		// color type '0', bitdepth = 1, 2, 4, 8, 16
-			switch(bit_depth) {
-				case 1:
-				case 2:
-				case 4:
-				case 8:
-					// expand grayscale images to the full 8-bit from 2-bit/pixel
-					if (pixel_depth == 2) {
-						png_set_expand_gray_1_2_4_to_8(png_ptr);
-					}
-
-					// if a tRNS chunk is provided, we must also expand the grayscale data to 8-bits,
-					// this allows us to make use of the transparency table with existing FreeImage methods
-					if (bIsTransparent && (pixel_depth < 8)) {
-						png_set_expand_gray_1_2_4_to_8(png_ptr);
-					}
-					break;
-
-				case 16:
-					image_type = (pixel_depth == 16) ? FIT_UINT16 : FIT_UNKNOWN;
-
-					// 16-bit grayscale images can contain a transparent value (shade)
-					// if found, expand the transparent value to a full alpha channel
-					if (bIsTransparent && (image_type != FIT_UNKNOWN)) {
-						// expand tRNS to a full alpha channel
-						png_set_tRNS_to_alpha(png_ptr);
-						
-						// expand new 16-bit gray + 16-bit alpha to full 64-bit RGBA
-						png_set_gray_to_rgb(png_ptr);
-
-						image_type = FIT_RGBA16;
-					}
-					break;
-
-				default:
-					image_type = FIT_UNKNOWN;
-					break;
-			}
-			break;
-
-		case PNG_COLOR_TYPE_RGB:		// color type '2', bitdepth = 8, 16
-			switch(bit_depth) {
-				case 8:
-					image_type = (pixel_depth == 24) ? FIT_BITMAP : FIT_UNKNOWN;
-					break;
-				case 16:
-					image_type = (pixel_depth == 48) ? FIT_RGB16 : FIT_UNKNOWN;
-					break;
-				default:
-					image_type = FIT_UNKNOWN;
-					break;
-			}
-			// sometimes, 24- or 48-bit images may contain transparency information
-			// check for this use case and convert to an alpha-compatible format
-			if (bIsTransparent && (image_type != FIT_UNKNOWN)) {
-				// if the image is 24-bit RGB, mark it as 32-bit; if it is 48-bit, mark it as 64-bit
-				image_type = (pixel_depth == 24) ? FIT_BITMAP : (pixel_depth == 48) ? FIT_RGBA16 : FIT_UNKNOWN;
-				// expand tRNS chunk to alpha channel
-				png_set_tRNS_to_alpha(png_ptr);
-			}
-			break;
-
-		case PNG_COLOR_TYPE_PALETTE:	// color type '3', bitdepth = 1, 2, 4, 8
-			switch(bit_depth) {
-				case 1:
-				case 2:
-				case 4:
-				case 8:
-					// expand palette images to the full 8 bits from 2 bits/pixel
-					if (pixel_depth == 2) {
-						png_set_packing(png_ptr);
-					}
-
-					// if a tRNS chunk is provided, we must also expand the palletized data to 8-bits,
-					// this allows us to make use of the transparency table with existing FreeImage methods
-					if (bIsTransparent && (pixel_depth < 8)) {
-						png_set_packing(png_ptr);
-					}
-					break;
-
-				default:
-					image_type = FIT_UNKNOWN;
-					break;
-			}
-			break;
-
-		case PNG_COLOR_TYPE_GRAY_ALPHA:	// color type '4', bitdepth = 8, 16
-			switch(bit_depth) {
-				case 8:
-					// 8-bit grayscale + 8-bit alpha => convert to 32-bit RGBA
-					image_type = (pixel_depth == 16) ? FIT_BITMAP : FIT_UNKNOWN;
-					break;
-				case 16:
-					// 16-bit grayscale + 16-bit alpha => convert to 64-bit RGBA
-					image_type = (pixel_depth == 32) ? FIT_RGBA16 : FIT_UNKNOWN;
-					break;
-				default:
-					image_type = FIT_UNKNOWN;
-					break;
-			}
-			// expand 8-bit greyscale + 8-bit alpha to 32-bit
-			// expand 16-bit greyscale + 16-bit alpha to 64-bit
-			png_set_gray_to_rgb(png_ptr);
-			break;
-
-		case PNG_COLOR_TYPE_RGB_ALPHA:	// color type '6', bitdepth = 8, 16
-			switch(bit_depth) {
-				case 8:
-					break;
-				case 16:
-					image_type = (pixel_depth == 64) ? FIT_RGBA16 : FIT_UNKNOWN;
-					break;
-				default:
-					image_type = FIT_UNKNOWN;
-					break;
-			}
-			break;
-	}
-
-	// check for unknown or invalid formats
-	if(image_type == FIT_UNKNOWN) {
-		*output_image_type = image_type;
-		return FALSE;
-	}
-
-#ifndef FREEIMAGE_BIGENDIAN
-	if((image_type == FIT_UINT16) || (image_type == FIT_RGB16) || (image_type == FIT_RGBA16)) {
-		// turn on 16-bit byte swapping
-		png_set_swap(png_ptr);
-	}
-#endif						
-
-#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
-	if((image_type == FIT_BITMAP) && ((color_type == PNG_COLOR_TYPE_RGB) || (color_type == PNG_COLOR_TYPE_RGB_ALPHA))) {
-		// flip the RGB pixels to BGR (or RGBA to BGRA)
-		png_set_bgr(png_ptr);
-	}
-#endif
-
-	// gamma correction
-	// unlike the example in the libpng documentation, we have *no* idea where
-	// this file may have come from--so if it doesn't have a file gamma, don't
-	// do any correction ("do no harm")
-
-	if (png_get_valid(png_ptr, info_ptr, PNG_INFO_gAMA)) {
-		double gamma = 0;
-		double screen_gamma = 2.2;
-
-		if (png_get_gAMA(png_ptr, info_ptr, &gamma) && ( flags & PNG_IGNOREGAMMA ) != PNG_IGNOREGAMMA) {
-			png_set_gamma(png_ptr, screen_gamma, gamma);
-		}
-	}
-
-	// all transformations have been registered; now update info_ptr data		
-	png_read_update_info(png_ptr, info_ptr);
-
-	// return the output image type
-	*output_image_type = image_type;
-
-	return TRUE;
-}
-
-static FIBITMAP * DLL_CALLCONV
-Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
-	png_structp png_ptr = NULL;
-	png_infop info_ptr = NULL;
-	png_uint_32 width, height;
-	int color_type;
-	int bit_depth;
-	int pixel_depth = 0;	// pixel_depth = bit_depth * channels
-
-	FIBITMAP *dib = NULL;
-	png_bytepp row_pointers = NULL;
-
-    fi_ioStructure fio;
-    fio.s_handle = handle;
-	fio.s_io = io;
-    
-	if (handle) {
-		BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS;
-
-		try {		
-			// check to see if the file is in fact a PNG file
-
-			BYTE png_check[PNG_BYTES_TO_CHECK];
-
-			io->read_proc(png_check, PNG_BYTES_TO_CHECK, 1, handle);
-
-			if (png_sig_cmp(png_check, (png_size_t)0, PNG_BYTES_TO_CHECK) != 0) {
-				return NULL;	// Bad signature
-			}
-			
-			// create the chunk manage structure
-
-			png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, error_handler, warning_handler);
-
-			if (!png_ptr) {
-				return NULL;			
-			}
-
-			// create the info structure
-
-		    info_ptr = png_create_info_struct(png_ptr);
-
-			if (!info_ptr) {
-				png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
-				return NULL;
-			}
-
-			// init the IO
-
-			png_set_read_fn(png_ptr, &fio, _ReadProc);
-
-            if (setjmp(png_jmpbuf(png_ptr))) {
-				png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-				return NULL;
-			}
-
-			// because we have already read the signature...
-
-			png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK);
-
-			// read the IHDR chunk
-
-			png_read_info(png_ptr, info_ptr);
-			png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
-
-			// configure the decoder
-
-			FREE_IMAGE_TYPE image_type = FIT_BITMAP;
-
-			if(!ConfigureDecoder(png_ptr, info_ptr, flags, &image_type)) {
-				throw FI_MSG_ERROR_UNSUPPORTED_FORMAT;
-			}
-
-			// update image info
-
-			color_type = png_get_color_type(png_ptr, info_ptr);
-			bit_depth = png_get_bit_depth(png_ptr, info_ptr);
-			pixel_depth = bit_depth * png_get_channels(png_ptr, info_ptr);
-
-			// create a dib and write the bitmap header
-			// set up the dib palette, if needed
-
-			switch (color_type) {
-				case PNG_COLOR_TYPE_RGB:
-				case PNG_COLOR_TYPE_RGB_ALPHA:
-					dib = FreeImage_AllocateHeaderT(header_only, image_type, width, height, pixel_depth, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
-					break;
-
-				case PNG_COLOR_TYPE_PALETTE:
-					dib = FreeImage_AllocateHeaderT(header_only, image_type, width, height, pixel_depth, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
-					if(dib) {
-						png_colorp png_palette = NULL;
-						int palette_entries = 0;
-
-						png_get_PLTE(png_ptr,info_ptr, &png_palette, &palette_entries);
-
-						palette_entries = MIN((unsigned)palette_entries, FreeImage_GetColorsUsed(dib));
-
-						// store the palette
-
-						RGBQUAD *palette = FreeImage_GetPalette(dib);
-						for(int i = 0; i < palette_entries; i++) {
-							palette[i].rgbRed   = png_palette[i].red;
-							palette[i].rgbGreen = png_palette[i].green;
-							palette[i].rgbBlue  = png_palette[i].blue;
-						}
-					}
-					break;
-
-				case PNG_COLOR_TYPE_GRAY:
-					dib = FreeImage_AllocateHeaderT(header_only, image_type, width, height, pixel_depth, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
-
-					if(dib && (pixel_depth <= 8)) {
-						RGBQUAD *palette = FreeImage_GetPalette(dib);
-						const int palette_entries = 1 << pixel_depth;
-
-						for(int i = 0; i < palette_entries; i++) {
-							palette[i].rgbRed   =
-							palette[i].rgbGreen =
-							palette[i].rgbBlue  = (BYTE)((i * 255) / (palette_entries - 1));
-						}
-					}
-					break;
-
-				default:
-					throw FI_MSG_ERROR_UNSUPPORTED_FORMAT;
-			}
-
-			if(!dib) {
-				throw FI_MSG_ERROR_DIB_MEMORY;
-			}
-
-			// store the transparency table
-
-			if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
-				// array of alpha (transparency) entries for palette
-				png_bytep trans_alpha = NULL;
-				// number of transparent entries
-				int num_trans = 0;						
-				// graylevel or color sample values of the single transparent color for non-paletted images
-				png_color_16p trans_color = NULL;
-
-				png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, &trans_color);
-
-				if((color_type == PNG_COLOR_TYPE_GRAY) && trans_color) {
-					// single transparent color
-					if (trans_color->gray < 256) { 
-						BYTE table[256]; 
-						memset(table, 0xFF, 256); 
-						table[trans_color->gray] = 0; 
-						FreeImage_SetTransparencyTable(dib, table, 256); 
-					}
-					// check for a full transparency table, too
-					else if ((trans_alpha) && (pixel_depth <= 8)) {
-						FreeImage_SetTransparencyTable(dib, (BYTE *)trans_alpha, num_trans);
-					}
-
-				} else if((color_type == PNG_COLOR_TYPE_PALETTE) && trans_alpha) {
-					// transparency table
-					FreeImage_SetTransparencyTable(dib, (BYTE *)trans_alpha, num_trans);
-				}
-			}
-
-			// store the background color (only supported for FIT_BITMAP types)
-
-			if ((image_type == FIT_BITMAP) && png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD)) {
-				// Get the background color to draw transparent and alpha images over.
-				// Note that even if the PNG file supplies a background, you are not required to
-				// use it - you should use the (solid) application background if it has one.
-
-				png_color_16p image_background = NULL;
-				RGBQUAD rgbBkColor;
-
-				if (png_get_bKGD(png_ptr, info_ptr, &image_background)) {
-					rgbBkColor.rgbRed      = (BYTE)image_background->red;
-					rgbBkColor.rgbGreen    = (BYTE)image_background->green;
-					rgbBkColor.rgbBlue     = (BYTE)image_background->blue;
-					rgbBkColor.rgbReserved = 0;
-
-					FreeImage_SetBackgroundColor(dib, &rgbBkColor);
-				}
-			}
-
-			// get physical resolution
-
-			if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pHYs)) {
-				png_uint_32 res_x, res_y;
-				
-				// we'll overload this var and use 0 to mean no phys data,
-				// since if it's not in meters we can't use it anyway
-
-				int res_unit_type = PNG_RESOLUTION_UNKNOWN;
-
-				png_get_pHYs(png_ptr,info_ptr, &res_x, &res_y, &res_unit_type);
-
-				if (res_unit_type == PNG_RESOLUTION_METER) {
-					FreeImage_SetDotsPerMeterX(dib, res_x);
-					FreeImage_SetDotsPerMeterY(dib, res_y);
-				}
-			}
-
-			// get possible ICC profile
-
-			if (png_get_valid(png_ptr, info_ptr, PNG_INFO_iCCP)) {
-				png_charp profile_name = NULL;
-				png_bytep profile_data = NULL;
-				png_uint_32 profile_length = 0;
-				int  compression_type;
-
-				png_get_iCCP(png_ptr, info_ptr, &profile_name, &compression_type, &profile_data, &profile_length);
-
-				// copy ICC profile data (must be done after FreeImage_AllocateHeader)
-
-				FreeImage_CreateICCProfile(dib, profile_data, profile_length);
-			}
-
-			// --- header only mode => clean-up and return
-
-			if (header_only) {
-				// get possible metadata (it can be located both before and after the image data)
-				ReadMetadata(png_ptr, info_ptr, dib);
-				if (png_ptr) {
-					// clean up after the read, and free any memory allocated - REQUIRED
-					png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
-				}
-				return dib;
-			}
-
-			// set the individual row_pointers to point at the correct offsets
-
-			row_pointers = (png_bytepp)malloc(height * sizeof(png_bytep));
-
-			if (!row_pointers) {
-				png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-				FreeImage_Unload(dib);
-				return NULL;
-			}
-
-			// read in the bitmap bits via the pointer table
-			// allow loading of PNG with minor errors (such as images with several IDAT chunks)
-
-			for (png_uint_32 k = 0; k < height; k++) {
-				row_pointers[height - 1 - k] = FreeImage_GetScanLine(dib, k);
-			}
-
-			png_set_benign_errors(png_ptr, 1);
-			png_read_image(png_ptr, row_pointers);
-
-			// check if the bitmap contains transparency, if so enable it in the header
-
-			if (FreeImage_GetBPP(dib) == 32) {
-				if (FreeImage_GetColorType(dib) == FIC_RGBALPHA) {
-					FreeImage_SetTransparent(dib, TRUE);
-				} else {
-					FreeImage_SetTransparent(dib, FALSE);
-				}
-			}
-				
-			// cleanup
-
-			if (row_pointers) {
-				free(row_pointers);
-				row_pointers = NULL;
-			}
-
-			// read the rest of the file, getting any additional chunks in info_ptr
-
-			png_read_end(png_ptr, info_ptr);
-
-			// get possible metadata (it can be located both before and after the image data)
-
-			ReadMetadata(png_ptr, info_ptr, dib);
-
-			if (png_ptr) {
-				// clean up after the read, and free any memory allocated - REQUIRED
-				png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
-			}
-
-			return dib;
-
-		} catch (const char *text) {
-			if (png_ptr) {
-				png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
-			}
-			if (row_pointers) {
-				free(row_pointers);
-			}
-			if (dib) {
-				FreeImage_Unload(dib);
-			}
-			FreeImage_OutputMessageProc(s_format_id, text);
-			
-			return NULL;
-		}
-	}			
-
-	return NULL;
-}
-
-// --------------------------------------------------------------------------
-
-static BOOL DLL_CALLCONV
-Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
-	png_structp png_ptr;
-	png_infop info_ptr;
-	png_colorp palette = NULL;
-	png_uint_32 width, height;
-	BOOL has_alpha_channel = FALSE;
-
-	RGBQUAD *pal;					// pointer to dib palette
-	int bit_depth, pixel_depth;		// pixel_depth = bit_depth * channels
-	int palette_entries;
-	int	interlace_type;
-
-	fi_ioStructure fio;
-    fio.s_handle = handle;
-	fio.s_io = io;
-
-	if ((dib) && (handle)) {
-		try {
-			// create the chunk manage structure
-
-			png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, error_handler, warning_handler);
-
-			if (!png_ptr)  {
-				return FALSE;
-			}
-
-			// allocate/initialize the image information data.
-
-			info_ptr = png_create_info_struct(png_ptr);
-
-			if (!info_ptr)  {
-				png_destroy_write_struct(&png_ptr,  (png_infopp)NULL);
-				return FALSE;
-			}
-
-			// Set error handling.  REQUIRED if you aren't supplying your own
-			// error handling functions in the png_create_write_struct() call.
-
-			if (setjmp(png_jmpbuf(png_ptr)))  {
-				// if we get here, we had a problem reading the file
-
-				png_destroy_write_struct(&png_ptr, &info_ptr);
-
-				return FALSE;
-			}
-
-			// init the IO
-            
-			png_set_write_fn(png_ptr, &fio, _WriteProc, _FlushProc);
-
-			// set physical resolution
-
-			png_uint_32 res_x = (png_uint_32)FreeImage_GetDotsPerMeterX(dib);
-			png_uint_32 res_y = (png_uint_32)FreeImage_GetDotsPerMeterY(dib);
-
-			if ((res_x > 0) && (res_y > 0))  {
-				png_set_pHYs(png_ptr, info_ptr, res_x, res_y, PNG_RESOLUTION_METER);
-			}
-	
-			// Set the image information here.  Width and height are up to 2^31,
-			// bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
-			// the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
-			// PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
-			// or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or
-			// PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
-			// currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
-
-			width = FreeImage_GetWidth(dib);
-			height = FreeImage_GetHeight(dib);
-			pixel_depth = FreeImage_GetBPP(dib);
-
-			BOOL bInterlaced = FALSE;
-			if( (flags & PNG_INTERLACED) == PNG_INTERLACED) {
-				interlace_type = PNG_INTERLACE_ADAM7;
-				bInterlaced = TRUE;
-			} else {
-				interlace_type = PNG_INTERLACE_NONE;
-			}
-
-			// set the ZLIB compression level or default to PNG default compression level (ZLIB level = 6)
-			int zlib_level = flags & 0x0F;
-			if((zlib_level >= 1) && (zlib_level <= 9)) {
-				png_set_compression_level(png_ptr, zlib_level);
-			} else if((flags & PNG_Z_NO_COMPRESSION) == PNG_Z_NO_COMPRESSION) {
-				png_set_compression_level(png_ptr, Z_NO_COMPRESSION);
-			}
-
-			// filtered strategy works better for high color images
-			if(pixel_depth >= 16){
-				png_set_compression_strategy(png_ptr, Z_FILTERED);
-				png_set_filter(png_ptr, 0, PNG_FILTER_NONE|PNG_FILTER_SUB|PNG_FILTER_PAETH);
-			} else {
-				png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
-			}
-
-			FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
-			if(image_type == FIT_BITMAP) {
-				// standard image type
-				bit_depth = (pixel_depth > 8) ? 8 : pixel_depth;
-			} else {
-				// 16-bit greyscale or 16-bit RGB(A)
-				bit_depth = 16;
-			}
-
-			// check for transparent images
-			BOOL bIsTransparent = 
-				(image_type == FIT_BITMAP) && FreeImage_IsTransparent(dib) && (FreeImage_GetTransparencyCount(dib) > 0) ? TRUE : FALSE;
-
-			switch (FreeImage_GetColorType(dib)) {
-				case FIC_MINISWHITE:
-					if(!bIsTransparent) {
-						// Invert monochrome files to have 0 as black and 1 as white (no break here)
-						png_set_invert_mono(png_ptr);
-					}
-					// (fall through)
-
-				case FIC_MINISBLACK:
-					if(!bIsTransparent) {
-						png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, 
-							PNG_COLOR_TYPE_GRAY, interlace_type, 
-							PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
-						break;
-					}
-					// If a monochrome image is transparent, save it with a palette
-					// (fall through)
-
-				case FIC_PALETTE:
-				{
-					png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, 
-						PNG_COLOR_TYPE_PALETTE, interlace_type, 
-						PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
-
-					// set the palette
-
-					palette_entries = 1 << bit_depth;
-					palette = (png_colorp)png_malloc(png_ptr, palette_entries * sizeof (png_color));
-					pal = FreeImage_GetPalette(dib);
-
-					for (int i = 0; i < palette_entries; i++) {
-						palette[i].red   = pal[i].rgbRed;
-						palette[i].green = pal[i].rgbGreen;
-						palette[i].blue  = pal[i].rgbBlue;
-					}
-					
-					png_set_PLTE(png_ptr, info_ptr, palette, palette_entries);
-
-					// You must not free palette here, because png_set_PLTE only makes a link to
-					// the palette that you malloced.  Wait until you are about to destroy
-					// the png structure.
-
-					break;
-				}
-
-				case FIC_RGBALPHA :
-					has_alpha_channel = TRUE;
-
-					png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, 
-						PNG_COLOR_TYPE_RGBA, interlace_type, 
-						PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
-
-#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
-					// flip BGR pixels to RGB
-					if(image_type == FIT_BITMAP) {
-						png_set_bgr(png_ptr);
-					}
-#endif
-					break;
-	
-				case FIC_RGB:
-					png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, 
-						PNG_COLOR_TYPE_RGB, interlace_type, 
-						PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
-
-#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
-					// flip BGR pixels to RGB
-					if(image_type == FIT_BITMAP) {
-						png_set_bgr(png_ptr);
-					}
-#endif
-					break;
-					
-				case FIC_CMYK:
-					break;
-			}
-
-			// write possible ICC profile
-
-			FIICCPROFILE *iccProfile = FreeImage_GetICCProfile(dib);
-			if (iccProfile->size && iccProfile->data) {
-				png_set_iCCP(png_ptr, info_ptr, "Embedded Profile", 0, (png_const_bytep)iccProfile->data, iccProfile->size);
-			}
-
-			// write metadata
-
-			WriteMetadata(png_ptr, info_ptr, dib);
-
-			// Optional gamma chunk is strongly suggested if you have any guess
-			// as to the correct gamma of the image.
-			// png_set_gAMA(png_ptr, info_ptr, gamma);
-
-			// set the transparency table
-
-			if (bIsTransparent) {
-				png_set_tRNS(png_ptr, info_ptr, FreeImage_GetTransparencyTable(dib), FreeImage_GetTransparencyCount(dib), NULL);
-			}
-
-			// set the background color
-
-			if(FreeImage_HasBackgroundColor(dib)) {
-				png_color_16 image_background;
-				RGBQUAD rgbBkColor;
-
-				FreeImage_GetBackgroundColor(dib, &rgbBkColor);
-				memset(&image_background, 0, sizeof(png_color_16));
-				image_background.blue  = rgbBkColor.rgbBlue;
-				image_background.green = rgbBkColor.rgbGreen;
-				image_background.red   = rgbBkColor.rgbRed;
-				image_background.index = rgbBkColor.rgbReserved;
-
-				png_set_bKGD(png_ptr, info_ptr, &image_background);
-			}
-			
-			// Write the file header information.
-
-			png_write_info(png_ptr, info_ptr);
-
-			// write out the image data
-
-#ifndef FREEIMAGE_BIGENDIAN
-			if (bit_depth == 16) {
-				// turn on 16 bit byte swapping
-				png_set_swap(png_ptr);
-			}
-#endif
-
-			int number_passes = 1;
-			if (bInterlaced) {
-				number_passes = png_set_interlace_handling(png_ptr);
-			}
-
-			if ((pixel_depth == 32) && (!has_alpha_channel)) {
-				BYTE *buffer = (BYTE *)malloc(width * 3);
-
-				// transparent conversion to 24-bit
-				// the number of passes is either 1 for non-interlaced images, or 7 for interlaced images
-				for (int pass = 0; pass < number_passes; pass++) {
-					for (png_uint_32 k = 0; k < height; k++) {
-						FreeImage_ConvertLine32To24(buffer, FreeImage_GetScanLine(dib, height - k - 1), width);
-						png_write_row(png_ptr, buffer);
-					}
-				}
-				free(buffer);
-			} else {
-				// the number of passes is either 1 for non-interlaced images, or 7 for interlaced images
-				for (int pass = 0; pass < number_passes; pass++) {
-					for (png_uint_32 k = 0; k < height; k++) {
-						png_write_row(png_ptr, FreeImage_GetScanLine(dib, height - k - 1));
-					}
-				}
-			}
-
-			// It is REQUIRED to call this to finish writing the rest of the file
-			// Bug with png_flush
-
-			png_write_end(png_ptr, info_ptr);
-
-			// clean up after the write, and free any memory allocated
-			if (palette) {
-				png_free(png_ptr, palette);
-			}
-
-			png_destroy_write_struct(&png_ptr, &info_ptr);
-
-			return TRUE;
-
-		} catch (const char *text) {
-			if(png_ptr) {
-				png_destroy_write_struct(&png_ptr, &info_ptr);
-			}
-			FreeImage_OutputMessageProc(s_format_id, text);
-		}
-	}
-
-	return FALSE;
-}
-
-// ==========================================================
-//   Init
-// ==========================================================
-
-void DLL_CALLCONV
-InitPNG(Plugin *plugin, int format_id) {
-	s_format_id = format_id;
-
-	plugin->format_proc = Format;
-	plugin->description_proc = Description;
-	plugin->extension_proc = Extension;
-	plugin->regexpr_proc = RegExpr;
-	plugin->open_proc = NULL;
-	plugin->close_proc = NULL;
-	plugin->pagecount_proc = NULL;
-	plugin->pagecapability_proc = NULL;
-	plugin->load_proc = Load;
-	plugin->save_proc = Save;
-	plugin->validate_proc = Validate;
-	plugin->mime_proc = MimeType;
-	plugin->supports_export_bpp_proc = SupportsExportDepth;
-	plugin->supports_export_type_proc = SupportsExportType;
-	plugin->supports_icc_profiles_proc = SupportsICCProfiles;
-	plugin->supports_no_pixels_proc = SupportsNoPixels;
-}