| // ========================================================== | |
| // 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 "third_party/zlib/zlib.h" | |
| #include "third_party/png/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; | |
| } |