% November 1997 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/blob.h"
#include "MagickCore/blob-private.h"
#include "MagickCore/cache.h"
+#include "MagickCore/channel.h"
#include "MagickCore/color.h"
#include "MagickCore/color-private.h"
#include "MagickCore/colormap.h"
#define PNG_SETJMP_NOT_THREAD_SAFE
#endif
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
static SemaphoreInfo
*ping_semaphore = (SemaphoreInfo *) NULL;
#endif
portable, we use ASCII numbers like this, not characters.
*/
-static png_byte FARDATA mng_MHDR[5]={ 77, 72, 68, 82, (png_byte) '\0'};
-static png_byte FARDATA mng_BACK[5]={ 66, 65, 67, 75, (png_byte) '\0'};
-static png_byte FARDATA mng_BASI[5]={ 66, 65, 83, 73, (png_byte) '\0'};
-static png_byte FARDATA mng_CLIP[5]={ 67, 76, 73, 80, (png_byte) '\0'};
-static png_byte FARDATA mng_CLON[5]={ 67, 76, 79, 78, (png_byte) '\0'};
-static png_byte FARDATA mng_DEFI[5]={ 68, 69, 70, 73, (png_byte) '\0'};
-static png_byte FARDATA mng_DHDR[5]={ 68, 72, 68, 82, (png_byte) '\0'};
-static png_byte FARDATA mng_DISC[5]={ 68, 73, 83, 67, (png_byte) '\0'};
-static png_byte FARDATA mng_ENDL[5]={ 69, 78, 68, 76, (png_byte) '\0'};
-static png_byte FARDATA mng_FRAM[5]={ 70, 82, 65, 77, (png_byte) '\0'};
-static png_byte FARDATA mng_IEND[5]={ 73, 69, 78, 68, (png_byte) '\0'};
-static png_byte FARDATA mng_IHDR[5]={ 73, 72, 68, 82, (png_byte) '\0'};
-static png_byte FARDATA mng_JHDR[5]={ 74, 72, 68, 82, (png_byte) '\0'};
-static png_byte FARDATA mng_LOOP[5]={ 76, 79, 79, 80, (png_byte) '\0'};
-static png_byte FARDATA mng_MAGN[5]={ 77, 65, 71, 78, (png_byte) '\0'};
-static png_byte FARDATA mng_MEND[5]={ 77, 69, 78, 68, (png_byte) '\0'};
-static png_byte FARDATA mng_MOVE[5]={ 77, 79, 86, 69, (png_byte) '\0'};
-static png_byte FARDATA mng_PAST[5]={ 80, 65, 83, 84, (png_byte) '\0'};
-static png_byte FARDATA mng_PLTE[5]={ 80, 76, 84, 69, (png_byte) '\0'};
-static png_byte FARDATA mng_SAVE[5]={ 83, 65, 86, 69, (png_byte) '\0'};
-static png_byte FARDATA mng_SEEK[5]={ 83, 69, 69, 75, (png_byte) '\0'};
-static png_byte FARDATA mng_SHOW[5]={ 83, 72, 79, 87, (png_byte) '\0'};
-static png_byte FARDATA mng_TERM[5]={ 84, 69, 82, 77, (png_byte) '\0'};
-static png_byte FARDATA mng_bKGD[5]={ 98, 75, 71, 68, (png_byte) '\0'};
-static png_byte FARDATA mng_cHRM[5]={ 99, 72, 82, 77, (png_byte) '\0'};
-static png_byte FARDATA mng_gAMA[5]={103, 65, 77, 65, (png_byte) '\0'};
-static png_byte FARDATA mng_iCCP[5]={105, 67, 67, 80, (png_byte) '\0'};
-static png_byte FARDATA mng_nEED[5]={110, 69, 69, 68, (png_byte) '\0'};
-static png_byte FARDATA mng_pHYg[5]={112, 72, 89, 103, (png_byte) '\0'};
-static png_byte FARDATA mng_vpAg[5]={118, 112, 65, 103, (png_byte) '\0'};
-static png_byte FARDATA mng_pHYs[5]={112, 72, 89, 115, (png_byte) '\0'};
-static png_byte FARDATA mng_sBIT[5]={115, 66, 73, 84, (png_byte) '\0'};
-static png_byte FARDATA mng_sRGB[5]={115, 82, 71, 66, (png_byte) '\0'};
-static png_byte FARDATA mng_tRNS[5]={116, 82, 78, 83, (png_byte) '\0'};
+static png_byte mng_MHDR[5]={ 77, 72, 68, 82, (png_byte) '\0'};
+static png_byte mng_BACK[5]={ 66, 65, 67, 75, (png_byte) '\0'};
+static png_byte mng_BASI[5]={ 66, 65, 83, 73, (png_byte) '\0'};
+static png_byte mng_CLIP[5]={ 67, 76, 73, 80, (png_byte) '\0'};
+static png_byte mng_CLON[5]={ 67, 76, 79, 78, (png_byte) '\0'};
+static png_byte mng_DEFI[5]={ 68, 69, 70, 73, (png_byte) '\0'};
+static png_byte mng_DHDR[5]={ 68, 72, 68, 82, (png_byte) '\0'};
+static png_byte mng_DISC[5]={ 68, 73, 83, 67, (png_byte) '\0'};
+static png_byte mng_ENDL[5]={ 69, 78, 68, 76, (png_byte) '\0'};
+static png_byte mng_FRAM[5]={ 70, 82, 65, 77, (png_byte) '\0'};
+static png_byte mng_IEND[5]={ 73, 69, 78, 68, (png_byte) '\0'};
+static png_byte mng_IHDR[5]={ 73, 72, 68, 82, (png_byte) '\0'};
+static png_byte mng_JHDR[5]={ 74, 72, 68, 82, (png_byte) '\0'};
+static png_byte mng_LOOP[5]={ 76, 79, 79, 80, (png_byte) '\0'};
+static png_byte mng_MAGN[5]={ 77, 65, 71, 78, (png_byte) '\0'};
+static png_byte mng_MEND[5]={ 77, 69, 78, 68, (png_byte) '\0'};
+static png_byte mng_MOVE[5]={ 77, 79, 86, 69, (png_byte) '\0'};
+static png_byte mng_PAST[5]={ 80, 65, 83, 84, (png_byte) '\0'};
+static png_byte mng_PLTE[5]={ 80, 76, 84, 69, (png_byte) '\0'};
+static png_byte mng_SAVE[5]={ 83, 65, 86, 69, (png_byte) '\0'};
+static png_byte mng_SEEK[5]={ 83, 69, 69, 75, (png_byte) '\0'};
+static png_byte mng_SHOW[5]={ 83, 72, 79, 87, (png_byte) '\0'};
+static png_byte mng_TERM[5]={ 84, 69, 82, 77, (png_byte) '\0'};
+static png_byte mng_bKGD[5]={ 98, 75, 71, 68, (png_byte) '\0'};
+static png_byte mng_cHRM[5]={ 99, 72, 82, 77, (png_byte) '\0'};
+static png_byte mng_gAMA[5]={103, 65, 77, 65, (png_byte) '\0'};
+static png_byte mng_iCCP[5]={105, 67, 67, 80, (png_byte) '\0'};
+static png_byte mng_nEED[5]={110, 69, 69, 68, (png_byte) '\0'};
+static png_byte mng_pHYg[5]={112, 72, 89, 103, (png_byte) '\0'};
+static png_byte mng_vpAg[5]={118, 112, 65, 103, (png_byte) '\0'};
+static png_byte mng_pHYs[5]={112, 72, 89, 115, (png_byte) '\0'};
+static png_byte mng_sBIT[5]={115, 66, 73, 84, (png_byte) '\0'};
+static png_byte mng_sRGB[5]={115, 82, 71, 66, (png_byte) '\0'};
+static png_byte mng_tRNS[5]={116, 82, 78, 83, (png_byte) '\0'};
#if defined(JNG_SUPPORTED)
-static png_byte FARDATA mng_IDAT[5]={ 73, 68, 65, 84, (png_byte) '\0'};
-static png_byte FARDATA mng_JDAT[5]={ 74, 68, 65, 84, (png_byte) '\0'};
-static png_byte FARDATA mng_JDAA[5]={ 74, 68, 65, 65, (png_byte) '\0'};
-static png_byte FARDATA mng_JdAA[5]={ 74, 100, 65, 65, (png_byte) '\0'};
-static png_byte FARDATA mng_JSEP[5]={ 74, 83, 69, 80, (png_byte) '\0'};
-static png_byte FARDATA mng_oFFs[5]={111, 70, 70, 115, (png_byte) '\0'};
+static png_byte mng_IDAT[5]={ 73, 68, 65, 84, (png_byte) '\0'};
+static png_byte mng_JDAT[5]={ 74, 68, 65, 84, (png_byte) '\0'};
+static png_byte mng_JDAA[5]={ 74, 68, 65, 65, (png_byte) '\0'};
+static png_byte mng_JdAA[5]={ 74, 100, 65, 65, (png_byte) '\0'};
+static png_byte mng_JSEP[5]={ 74, 83, 69, 80, (png_byte) '\0'};
+static png_byte mng_oFFs[5]={111, 70, 70, 115, (png_byte) '\0'};
#endif
/*
Other known chunks that are not yet supported by ImageMagick:
-static png_byte FARDATA mng_hIST[5]={104, 73, 83, 84, (png_byte) '\0'};
-static png_byte FARDATA mng_iCCP[5]={105, 67, 67, 80, (png_byte) '\0'};
-static png_byte FARDATA mng_iTXt[5]={105, 84, 88, 116, (png_byte) '\0'};
-static png_byte FARDATA mng_sPLT[5]={115, 80, 76, 84, (png_byte) '\0'};
-static png_byte FARDATA mng_sTER[5]={115, 84, 69, 82, (png_byte) '\0'};
-static png_byte FARDATA mng_tEXt[5]={116, 69, 88, 116, (png_byte) '\0'};
-static png_byte FARDATA mng_tIME[5]={116, 73, 77, 69, (png_byte) '\0'};
-static png_byte FARDATA mng_zTXt[5]={122, 84, 88, 116, (png_byte) '\0'};
+static png_byte mng_hIST[5]={104, 73, 83, 84, (png_byte) '\0'};
+static png_byte mng_iCCP[5]={105, 67, 67, 80, (png_byte) '\0'};
+static png_byte mng_iTXt[5]={105, 84, 88, 116, (png_byte) '\0'};
+static png_byte mng_sPLT[5]={115, 80, 76, 84, (png_byte) '\0'};
+static png_byte mng_sTER[5]={115, 84, 69, 82, (png_byte) '\0'};
+static png_byte mng_tEXt[5]={116, 69, 88, 116, (png_byte) '\0'};
+static png_byte mng_tIME[5]={116, 73, 77, 69, (png_byte) '\0'};
+static png_byte mng_zTXt[5]={122, 84, 88, 116, (png_byte) '\0'};
*/
typedef struct _MngBox
}
#endif /* MAGICKCORE_QUANTUM_DEPTH >= 16 */
+static const char* PngColorTypeToString(const unsigned int color_type)
+{
+ const char
+ *result = "Unknown";
+
+ switch (color_type)
+ {
+ case PNG_COLOR_TYPE_GRAY:
+ result = "Gray";
+ break;
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ result = "Gray+Alpha";
+ break;
+ case PNG_COLOR_TYPE_PALETTE:
+ result = "Palette";
+ break;
+ case PNG_COLOR_TYPE_RGB:
+ result = "RGB";
+ break;
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ result = "RGB+Alpha";
+ break;
+ }
+
+ return result;
+}
+
static int
Magick_RenderingIntent_to_PNG_RenderingIntent(const RenderingIntent intent)
{
return(y);
}
-static inline ssize_t MagickMin(const ssize_t x,const ssize_t y)
+static const char *
+Magick_ColorType_from_PNG_ColorType(const int ping_colortype)
{
- if (x < y)
- return(x);
+ switch (ping_colortype)
+ {
+ case 0:
+ return "Grayscale";
- return(y);
-}
+ case 2:
+ return "Truecolor";
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% I m a g e I s G r a y %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% Like IsImageGray except does not change DirectClass to PseudoClass %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-*/
-static MagickBooleanType ImageIsGray(Image *image,ExceptionInfo *exception)
-{
- register const Quantum
- *p;
+ case 3:
+ return "Indexed";
- register ssize_t
- i,
- x,
- y;
+ case 4:
+ return "GrayAlpha";
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ case 6:
+ return "RGBA";
- if (image->storage_class == PseudoClass)
- {
- for (i=0; i < (ssize_t) image->colors; i++)
- if (IsPixelInfoGray(image->colormap+i) == MagickFalse)
- return(MagickFalse);
- return(MagickTrue);
- }
- for (y=0; y < (ssize_t) image->rows; y++)
- {
- p=GetVirtualPixels(image,0,y,image->columns,1,exception);
- if (p == (const Quantum *) NULL)
- return(MagickFalse);
- for (x=(ssize_t) image->columns-1; x >= 0; x--)
- {
- if (IsPixelGray(image,p) == MagickFalse)
- return(MagickFalse);
- p+=GetPixelChannels(image);
+ default:
+ return "UndefinedColorType";
}
- }
- return(MagickTrue);
+}
+
+
+static inline ssize_t MagickMin(const ssize_t x,const ssize_t y)
+{
+ if (x < y)
+ return(x);
+
+ return(y);
}
#endif /* PNG_LIBPNG_VER > 10011 */
#endif /* MAGICKCORE_PNG_DELEGATE */
#ifdef PNG_USER_MEM_SUPPORTED
static png_voidp Magick_png_malloc(png_structp png_ptr,png_uint_32 size)
{
-#if (PNG_LIBPNG_VER < 10011)
- png_voidp
- ret;
-
- png_ptr=png_ptr;
- ret=((png_voidp) AcquireMagickMemory((size_t) size));
-
- if (ret == NULL)
- png_error("Insufficient memory.");
-
- return(ret);
-#else
- png_ptr=png_ptr;
+ (void) png_ptr;
return((png_voidp) AcquireMagickMemory((size_t) size));
-#endif
}
/*
*/
static png_free_ptr Magick_png_free(png_structp png_ptr,png_voidp ptr)
{
- png_ptr=png_ptr;
+ (void) png_ptr;
ptr=RelinquishMagickMemory(ptr);
return((png_free_ptr) NULL);
}
#endif
static int
-Magick_png_read_raw_profile(Image *image, const ImageInfo *image_info,
- png_textp text,int ii,ExceptionInfo *exception)
+Magick_png_read_raw_profile(png_struct *ping,Image *image,
+ const ImageInfo *image_info, png_textp text,int ii,ExceptionInfo *exception)
{
register ssize_t
i;
/* allocate space */
if (length == 0)
{
- (void) ThrowMagickException(exception,GetMagickModule(),
- CoderWarning,"UnableToCopyProfile","`%s'","invalid profile length");
+ png_warning(ping,"invalid profile length");
return(MagickFalse);
}
if (profile == (StringInfo *) NULL)
{
- (void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",
- "unable to copy profile");
+ png_warning(ping, "unable to copy profile");
return(MagickFalse);
}
{
if (*sp == '\0')
{
- (void) ThrowMagickException(exception,GetMagickModule(),
- CoderWarning,"UnableToCopyProfile","`%s'","ran out of data");
+ png_warning(ping, "ran out of profile data");
profile=DestroyStringInfo(profile);
return(MagickFalse);
}
num_text,
num_text_total,
num_passes,
+ number_colors,
pass,
ping_bit_depth,
ping_color_type,
png_uint_32
ping_height,
ping_width,
- ping_rowbytes,
x_resolution,
y_resolution;
*ping_pixels;
ssize_t
+ ping_rowbytes,
y;
register unsigned char
ssize_t
j;
-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
png_byte unused_chunks[]=
{
104, 73, 83, 84, (png_byte) '\0', /* hIST */
115, 67, 65, 76, (png_byte) '\0', /* sCAL */
115, 80, 76, 84, (png_byte) '\0', /* sPLT */
116, 73, 77, 69, (png_byte) '\0', /* tIME */
+#ifdef PNG_APNG_SUPPORTED /* libpng was built with APNG patch; */
+ /* ignore the APNG chunks */
+ 97, 99, 84, 76, (png_byte) '\0', /* acTL */
+ 102, 99, 84, 76, (png_byte) '\0', /* fcTL */
+ 102, 100, 65, 84, (png_byte) '\0', /* fdAT */
+#endif
};
#endif
logging=LogMagickEvent(CoderEvent,GetMagickModule(),
" Enter ReadOnePNGImage()");
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
- LockSemaphoreInfo(ping_semaphore);
-#endif
-
#if (PNG_LIBPNG_VER < 10200)
if (image_info->verbose)
printf("Your PNG library (libpng-%s) is rather old.\n",
transparent_color.blue=65537;
transparent_color.alpha=65537;
+ number_colors=0;
num_text = 0;
num_text_total = 0;
num_raw_profiles = 0;
PNG image is corrupt.
*/
png_destroy_read_struct(&ping,&ping_info,&end_info);
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
+
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
UnlockSemaphoreInfo(ping_semaphore);
#endif
+
+ if (ping_pixels != (unsigned char *) NULL)
+ ping_pixels=(unsigned char *) RelinquishMagickMemory(ping_pixels);
+
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" exit ReadOnePNGImage() with error.");
return(GetFirstImageInList(image));
}
+
+ /* { For navigation to end of SETJMP-protected block. Within this
+ * block, use png_error() instead of Throwing an Exception, to ensure
+ * that libpng is able to clean up, and that the semaphore is unlocked.
+ */
+
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
+ LockSemaphoreInfo(ping_semaphore);
+#endif
+
/*
Prepare PNG for reading.
*/
png_set_read_user_chunk_fn(ping, image, read_vpag_chunk_callback);
#endif
+#ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
+ /* Disable new libpng-1.5.10 feature */
+ png_set_check_for_invalid_index (ping, 0);
+#endif
+
#if (PNG_LIBPNG_VER < 10400)
# if defined(PNG_USE_PNGGCCRD) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) && \
(PNG_LIBPNG_VER >= 10200) && (PNG_LIBPNG_VER < 10220) && defined(__i386__)
image->depth=ping_bit_depth;
image->depth=GetImageQuantumDepth(image,MagickFalse);
image->interlace=ping_interlace_method != 0 ? PNGInterlace : NoInterlace;
+ if (((int) ping_color_type == PNG_COLOR_TYPE_GRAY) ||
+ ((int) ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
+ {
+ image->rendering_intent=UndefinedIntent;
+ image->gamma=1.000;
+ (void) ResetMagickMemory(&image->chromaticity,0,
+ sizeof(image->chromaticity));
+ }
if (logging != MagickFalse)
{
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Reading PNG iCCP chunk.");
profile=BlobToStringInfo(info,profile_length);
if (profile == (StringInfo *) NULL)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",
- "unable to copy profile");
- return((Image *) NULL);
- }
- SetStringInfoDatum(profile,(const unsigned char *) info);
- (void) SetImageProfile(image,"icc",profile,exception);
- profile=DestroyStringInfo(profile);
+ {
+ png_warning(ping, "ICC profile is NULL");
+ profile=DestroyStringInfo(profile);
+ }
+ else
+ {
+ (void) SetImageProfile(image,"icc",profile,exception);
+ profile=DestroyStringInfo(profile);
+ }
}
}
#endif
#if defined(PNG_READ_sRGB_SUPPORTED)
{
if (mng_info->have_global_srgb)
- image->rendering_intent=Magick_RenderingIntent_from_PNG_RenderingIntent
- (mng_info->global_srgb_intent);
+ {
+ image->rendering_intent=Magick_RenderingIntent_from_PNG_RenderingIntent
+ (mng_info->global_srgb_intent);
+ }
if (png_get_sRGB(ping,ping_info,&intent))
{
png_set_sRGB(ping,ping_info,
Magick_RenderingIntent_to_PNG_RenderingIntent
(image->rendering_intent));
- png_set_gAMA(ping,ping_info,0.45455f);
+ png_set_gAMA(ping,ping_info,1.000f/2.200f);
png_set_cHRM(ping,ping_info,
0.6400f, 0.3300f, 0.3000f, 0.6000f,
0.1500f, 0.0600f, 0.3127f, 0.3290f);
if (png_get_valid(ping,ping_info,PNG_INFO_PLTE))
{
- int
- number_colors;
-
png_colorp
palette;
(int) mng_info->global_plte_length);
if (!png_get_valid(ping,ping_info,PNG_INFO_tRNS))
+ {
if (mng_info->global_trns_length)
{
- if (mng_info->global_trns_length >
- mng_info->global_plte_length)
- (void) ThrowMagickException(exception,
- GetMagickModule(),CoderError,
- "global tRNS has more entries than global PLTE",
- "`%s'",image_info->filename);
- png_set_tRNS(ping,ping_info,mng_info->global_trns,
- (int) mng_info->global_trns_length,NULL);
+ png_warning(ping,
+ "global tRNS has more entries than global PLTE");
}
+ else
+ {
+ png_set_tRNS(ping,ping_info,mng_info->global_trns,
+ (int) mng_info->global_trns_length,NULL);
+ }
+ }
#ifdef PNG_READ_bKGD_SUPPORTED
if (
#ifndef PNG_READ_EMPTY_PLTE_SUPPORTED
#endif
}
else
- (void) ThrowMagickException(exception,GetMagickModule(),
- CoderError,"No global PLTE in file","`%s'",
- image_info->filename);
+ png_error(ping,"No global PLTE in file");
}
}
image->compression=ZipCompression;
image->columns=ping_width;
image->rows=ping_height;
+
+ if (((int) ping_color_type == PNG_COLOR_TYPE_GRAY) ||
+ ((int) ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
+ {
+ if (!png_get_valid(ping,ping_info,PNG_INFO_gAMA) &&
+ !png_get_valid(ping,ping_info,PNG_INFO_cHRM) &&
+ !png_get_valid(ping,ping_info,PNG_INFO_sRGB))
+ {
+ /* Set image->gamma to 1.0, image->rendering_intent to Undefined,
+ * and reset image->chromaticity.
+ */
+ SetImageColorspace(image,GRAYColorspace,exception);
+ }
+ }
+
if (((int) ping_color_type == PNG_COLOR_TYPE_PALETTE) ||
((int) ping_color_type == PNG_COLOR_TYPE_GRAY))
{
#endif
if ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE)
{
- int
- number_colors;
-
png_colorp
palette;
Initialize image colormap.
*/
if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
- ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+ png_error(ping,"Memory allocation failed");
if ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE)
{
- int
- number_colors;
-
png_colorp
palette;
(void) FormatLocaleString(msg,MaxTextExtent,
"%d, %d",(int) ping_width, (int) ping_height);
- (void) SetImageProperty(image,"PNG:IHDR.width,height ",msg,exception);
+ (void) SetImageProperty(image,"png:IHDR.width,height ",msg,exception);
(void) FormatLocaleString(msg,MaxTextExtent,"%d",(int) ping_bit_depth);
- (void) SetImageProperty(image,"PNG:IHDR.bit_depth ",msg,exception);
+ (void) SetImageProperty(image,"png:IHDR.bit_depth ",msg,exception);
- (void) FormatLocaleString(msg,MaxTextExtent,"%d",(int) ping_color_type);
- (void) SetImageProperty(image,"PNG:IHDR.color_type ",msg,exception);
+ (void) FormatLocaleString(msg,MaxTextExtent,"%d (%s)",
+ (int) ping_color_type,
+ Magick_ColorType_from_PNG_ColorType((int)ping_color_type));
+ (void) SetImageProperty(image,"png:IHDR.color_type ",msg,exception);
+
+ if (ping_interlace_method == 0)
+ {
+ (void) FormatLocaleString(msg,MaxTextExtent,"%d (Not interlaced)",
+ (int) ping_interlace_method);
+ }
+ else if (ping_interlace_method == 1)
+ {
+ (void) FormatLocaleString(msg,MaxTextExtent,"%d (Adam7 method)",
+ (int) ping_interlace_method);
+ }
+ else
+ {
+ (void) FormatLocaleString(msg,MaxTextExtent,"%d (Unknown method)",
+ (int) ping_interlace_method);
+ }
+ (void) SetImageProperty(image,"png:IHDR.interlace_method",msg,exception);
- (void) FormatLocaleString(msg,MaxTextExtent,"%d",
- (int) ping_interlace_method);
- (void) SetImageProperty(image,"PNG:IHDR.interlace_method",msg,exception);
+ if (number_colors != 0)
+ {
+ (void) FormatLocaleString(msg,MaxTextExtent,"%d",
+ (int) number_colors);
+ (void) SetImageProperty(image,"png:PLTE.number_colors ",msg,
+ exception);
+ }
}
/*
(image_info->number_scenes != 0) && (mng_info->scenes_found > (ssize_t)
(image_info->first_scene+image_info->number_scenes))))
{
+ /* This happens later in non-ping decodes */
+ if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
+ image->storage_class=DirectClass;
+
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Skipping PNG image data for scene %.20g",(double)
mng_info->scenes_found-1);
png_destroy_read_struct(&ping,&ping_info,&end_info);
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
+
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
UnlockSemaphoreInfo(ping_semaphore);
#endif
+
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" exit ReadOnePNGImage().");
sizeof(*ping_pixels));
if (ping_pixels == (unsigned char *) NULL)
- ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+ png_error(ping,"Memory allocation failed");
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
/*
Convert PNG pixels to pixel packets.
*/
- if (setjmp(png_jmpbuf(ping)))
- {
- /*
- PNG image is corrupt.
- */
- png_destroy_read_struct(&ping,&ping_info,&end_info);
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
- UnlockSemaphoreInfo(ping_semaphore);
-#endif
- if (quantum_info != (QuantumInfo *) NULL)
- quantum_info = DestroyQuantumInfo(quantum_info);
-
- if (ping_pixels != (unsigned char *) NULL)
- ping_pixels=(unsigned char *) RelinquishMagickMemory(ping_pixels);
-
- if (logging != MagickFalse)
- (void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " exit ReadOnePNGImage() with error.");
-
- if (image != (Image *) NULL)
- {
- InheritException(exception,exception);
- image->columns=0;
- }
-
- return(GetFirstImageInList(image));
- }
-
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
- ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+ png_error(ping,"Failed to allocate quantum_info");
{
row_offset=0;
png_read_row(ping,ping_pixels+row_offset,NULL);
- q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
+ q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
(image->matte ? 2 : 1)*sizeof(*quantum_scanline));
if (quantum_scanline == (Quantum *) NULL)
- ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+ png_error(ping,"Memory allocation failed");
for (y=0; y < (ssize_t) image->rows; y++)
{
ping_pixels=(unsigned char *) RelinquishMagickMemory(ping_pixels);
image->colors=2;
(void) SetImageBackgroundColor(image,exception);
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
UnlockSemaphoreInfo(ping_semaphore);
#endif
if (logging != MagickFalse)
{
for (x=0; x < ping_num_trans; x++)
{
+ image->colormap[x].matte=MagickTrue;
image->colormap[x].alpha =
ScaleCharToQuantum((unsigned char)ping_trans_alpha[x]);
}
if (ScaleQuantumToShort(image->colormap[x].red) ==
transparent_color.alpha)
{
+ image->colormap[x].matte=MagickTrue;
image->colormap[x].alpha = (Quantum) TransparentAlpha;
}
}
image->storage_class=DirectClass;
}
- if ((ping_color_type == PNG_COLOR_TYPE_GRAY) ||
- (ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
- image->colorspace=GRAYColorspace;
-
for (j = 0; j < 2; j++)
{
if (j == 0)
if (memcmp(text[i].key, "Raw profile type ",17) == 0)
{
- (void) Magick_png_read_raw_profile(image,image_info,text,(int) i,
- exception);
+ (void) Magick_png_read_raw_profile(ping,image,image_info,text,
+ (int) i,exception);
num_raw_profiles++;
}
sizeof(*value));
if (value == (char *) NULL)
{
- (void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",
- image->filename);
+ png_error(ping,"Memory allocation failed");
break;
}
*value='\0';
mng_info->ob[object_id]->frozen)
{
if (mng_info->ob[object_id] == (MngBuffer *) NULL)
- (void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",
- image->filename);
+ png_error(ping,"Memory allocation failed");
if (mng_info->ob[object_id]->frozen)
- (void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"Cannot overwrite frozen MNG object buffer",
- "`%s'",image->filename);
+ png_error(ping,"Cannot overwrite frozen MNG object buffer");
}
else
mng_info->ob[object_id]->image->file=(FILE *) NULL;
else
- (void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"Cloning image for object buffer failed",
- "`%s'",image->filename);
+ png_error(ping, "Cloning image for object buffer failed");
if (ping_width > 250000L || ping_height > 250000L)
png_error(ping,"PNG Image dimensions are too large.");
if (png_get_valid(ping,ping_info,PNG_INFO_PLTE))
{
- int
- number_colors;
-
png_colorp
plte;
/* libpng doesn't tell us whether they were tEXt, zTXt, or iTXt */
(void) FormatLocaleString(msg,MaxTextExtent,
"%d tEXt/zTXt/iTXt chunks were found", num_text_total);
- (void) SetImageProperty(image,"PNG:text ",msg,
+ (void) SetImageProperty(image,"png:text ",msg,
exception);
}
{
(void) FormatLocaleString(msg,MaxTextExtent,
"%d were found", num_raw_profiles);
- (void) SetImageProperty(image,"PNG:text-encoded profiles",msg,
+ (void) SetImageProperty(image,"png:text-encoded profiles",msg,
exception);
}
{
(void) FormatLocaleString(msg,MaxTextExtent,"%s",
"chunk was found (see Chromaticity, above)");
- (void) SetImageProperty(image,"PNG:cHRM ",msg,
+ (void) SetImageProperty(image,"png:cHRM ",msg,
exception);
}
{
(void) FormatLocaleString(msg,MaxTextExtent,"%s",
"chunk was found (see Background color, above)");
- (void) SetImageProperty(image,"PNG:bKGD ",msg,
+ (void) SetImageProperty(image,"png:bKGD ",msg,
exception);
}
"chunk was found");
if (png_get_valid(ping,ping_info,PNG_INFO_iCCP))
- (void) SetImageProperty(image,"PNG:iCCP ",msg,
+ (void) SetImageProperty(image,"png:iCCP ",msg,
exception);
if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
- (void) SetImageProperty(image,"PNG:tRNS ",msg,
+ (void) SetImageProperty(image,"png:tRNS ",msg,
exception);
#if defined(PNG_sRGB_SUPPORTED)
if (png_get_valid(ping,ping_info,PNG_INFO_sRGB))
{
(void) FormatLocaleString(msg,MaxTextExtent,
- "intent=%d (See Rendering intent)",
- (int) intent);
- (void) SetImageProperty(image,"PNG:sRGB ",msg,
- exception);
+ "intent=%d (See Rendering intent)", (int) intent);
+ (void) SetImageProperty(image,"png:sRGB ",msg,
+ exception);
}
#endif
(void) FormatLocaleString(msg,MaxTextExtent,
"gamma=%.8g (See Gamma, above)",
file_gamma);
- (void) SetImageProperty(image,"PNG:gAMA ",msg,
+ (void) SetImageProperty(image,"png:gAMA ",msg,
exception);
}
(void) FormatLocaleString(msg,MaxTextExtent,
"x_res=%.10g, y_res=%.10g, units=%d",
(double) x_resolution,(double) y_resolution, unit_type);
- (void) SetImageProperty(image,"PNG:pHYs ",msg,
+ (void) SetImageProperty(image,"png:pHYs ",msg,
exception);
}
#endif
{
(void) FormatLocaleString(msg,MaxTextExtent,"x_off=%.20g, y_off=%.20g",
(double) image->page.x,(double) image->page.y);
- (void) SetImageProperty(image,"PNG:oFFs ",msg,
+ (void) SetImageProperty(image,"png:oFFs ",msg,
exception);
}
#endif
(void) FormatLocaleString(msg,MaxTextExtent,
"width=%.20g, height=%.20g",
(double) image->page.width,(double) image->page.height);
- (void) SetImageProperty(image,"PNG:vpAg ",msg,
+ (void) SetImageProperty(image,"png:vpAg ",msg,
exception);
}
}
png_destroy_read_struct(&ping,&ping_info,&end_info);
ping_pixels=(unsigned char *) RelinquishMagickMemory(ping_pixels);
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
- UnlockSemaphoreInfo(ping_semaphore);
-#endif
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" exit ReadOnePNGImage()");
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
+ UnlockSemaphoreInfo(ping_semaphore);
+#endif
+
+ /* } for navigation to beginning of SETJMP-protected block, revert to
+ * Throwing an Exception when an error occurs.
+ */
+
return(image);
/* end of reading one PNG image */
ThrowReaderException(CorruptImageError,"CorruptImage");
}
+ if ((IssRGBColorspace(image->colorspace) != MagickFalse) &&
+ (image->gamma == 1.0))
+ SetImageColorspace(image,RGBColorspace,exception);
+
if (LocaleCompare(image_info->magick,"PNG24") == 0)
{
(void) SetImageType(image,TrueColorType,exception);
{
image->rendering_intent=
Magick_RenderingIntent_from_PNG_RenderingIntent(p[0]);
- image->gamma=0.45455f;
+ image->gamma=1.000f/2.200f;
image->chromaticity.red_primary.x=0.6400f;
image->chromaticity.red_primary.y=0.3300f;
image->chromaticity.green_primary.x=0.3000f;
if (object_id > MNG_MAX_OBJECTS)
{
/*
- Instead ofsuing a warning we should allocate a larger
+ Instead of using a warning we should allocate a larger
MngInfo structure and continue.
*/
(void) ThrowMagickException(exception,GetMagickModule(),
" Magnify the rows to %.20g",(double) large_image->rows);
m=(ssize_t) mng_info->magn_mt;
yy=0;
- length=(size_t) image->columns;
+ length=(size_t) image->columns*GetPixelChannels(image);
next=(Quantum *) AcquireQuantumMemory(length,sizeof(*next));
prev=(Quantum *) AcquireQuantumMemory(length,sizeof(*prev));
n=next;
q=GetAuthenticPixels(large_image,0,yy,large_image->columns,
1,exception);
- q+=(large_image->columns-image->columns);
+ q+=(large_image->columns-image->columns)*
+ GetPixelChannels(large_image);
for (x=(ssize_t) image->columns-1; x >= 0; x--)
{
#if (MAGICKCORE_QUANTUM_DEPTH > 16)
/* PNG does not handle depths greater than 16 so reduce it even
- * if lossy
+ * if lossy.
*/
if (image->depth > 16)
image->depth=16;
#endif
#if (MAGICKCORE_QUANTUM_DEPTH > 8)
+ if (image->depth > 8)
+ {
+ /* To do: fill low byte properly */
+ image->depth=16;
+ }
+
if (LosslessReduceDepthOK(image,exception) != MagickFalse)
image->depth = 8;
#endif
entry->note=ConstantString(JNGNote);
(void) RegisterMagickInfo(entry);
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
ping_semaphore=AllocateSemaphoreInfo();
#endif
(void) UnregisterMagickInfo("PNG32");
(void) UnregisterMagickInfo("JNG");
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
if (ping_semaphore != (SemaphoreInfo *) NULL)
DestroySemaphoreInfo(&ping_semaphore);
#endif
if (image_info == (ImageInfo *) NULL)
ThrowWriterException(ResourceLimitError, "MemoryAllocationFailed");
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
- LockSemaphoreInfo(ping_semaphore);
-#endif
-
/* Initialize some stuff */
ping_bit_depth=0,
ping_color_type=0,
" storage_class=PseudoClass");
}
- if (image->storage_class == PseudoClass &&
+ if (image->storage_class == PseudoClass &&
(mng_info->write_png8 || mng_info->write_png24 || mng_info->write_png32 ||
(mng_info->write_png_colortype != 0 &&
mng_info->write_png_colortype != 4)))
}
}
- if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace,exception);
+ if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
/*
Sometimes we get PseudoClass images whose RGB values don't match
for (y=0; y < (ssize_t) image->rows; y++)
{
- r=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ r=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
LBR16PixelRGBA(r);
- r++;
+ r+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
for (x=0; x < (ssize_t) image->columns; x++)
{
LBR08PixelRGBA(r);
- r++;
+ r+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
for (y=0; y < (ssize_t) image->rows; y++)
{
- r=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ r=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
LBR04PixelRGBA(r);
- r++;
+ r+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
for (y=0; y < (ssize_t) image->rows; y++)
{
- r=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ r=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
LBR02PixelRGBA(r);
- r++;
+ r+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
for (y=0; y < (ssize_t) image->rows; y++)
{
- r=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ r=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
LBR01PixelRGBA(r);
- r++;
+ r+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
#endif
#if (MAGICKCORE_QUANTUM_DEPTH > 8)
+ if (image->depth > 8)
+ {
+ /* To do: fill low byte properly */
+ image->depth=16;
+ }
+
if (image->depth == 16 && mng_info->write_png_depth != 16)
if (mng_info->write_png8 || LosslessReduceDepthOK(image,exception) != MagickFalse)
image->depth = 8;
" image->colors=%d",(int) image->colors);
if (image->colors == 0)
- (void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " (zero means unknown)");
+ (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+ " (zero means unknown)");
if (ping_preserve_colormap == MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
break;
}
- if (i == (ssize_t) number_opaque &&
- number_opaque < 259)
+ if (i == (ssize_t) number_opaque && number_opaque < 259)
{
number_opaque++;
GetPixelInfoPixel(image, q, opaque+i);
{
opaque[i] = image->background_color;
ping_background.index = i;
+ number_opaque++;
if (logging != MagickFalse)
{
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
if (mng_info->write_png_colortype != 7) /* We won't need this info */
{
ping_have_color=MagickFalse;
+ if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+ ping_have_color=MagickTrue;
ping_have_non_bw=MagickFalse;
if(image_colors > 256)
for (y=0; y < (ssize_t) image->rows; y++)
{
- q=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
-
for (x=0; x < (ssize_t) image->columns; x++)
{
for (i=0; i< (ssize_t) image_colors; i++)
for (y=0; y < (ssize_t) image->rows; y++)
{
- r=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ r=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
{
for (y=0; y < (ssize_t) image->rows; y++)
{
- r=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ r=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
{
if (GetPixelAlpha(image,r) == OpaqueAlpha)
LBR04PixelRGB(r);
- r++;
+ r+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
{
for (y=0; y < (ssize_t) image->rows; y++)
{
- r=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ r=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
{
if (GetPixelAlpha(image,r) == OpaqueAlpha)
LBR03RGB(r);
- r++;
+ r+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
{
for (y=0; y < (ssize_t) image->rows; y++)
{
- r=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ r=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
{
if (GetPixelAlpha(image,r) == OpaqueAlpha)
LBR02PixelBlue(r);
- r++;
+ r+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
{
for (y=0; y < (ssize_t) image->rows; y++)
{
- r=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ r=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
(void) ThrowMagickException(exception,GetMagickModule(),CoderError,
"Cannot write PNG8 or color-type 3; colormap is NULL",
"`%s'",IMimage->filename);
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
- UnlockSemaphoreInfo(ping_semaphore);
-#endif
return(MagickFalse);
}
(void) printf("PNG write has failed.\n");
#endif
png_destroy_write_struct(&ping,&ping_info);
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
UnlockSemaphoreInfo(ping_semaphore);
#endif
+
+ if (ping_pixels != (unsigned char *) NULL)
+ ping_pixels=(unsigned char *) RelinquishMagickMemory(ping_pixels);
+
+ if (quantum_info != (QuantumInfo *) NULL)
+ quantum_info=DestroyQuantumInfo(quantum_info);
+
if (ping_have_blob != MagickFalse)
(void) CloseBlob(image);
image_info=DestroyImageInfo(image_info);
image=DestroyImage(image);
return(MagickFalse);
}
+
+ /* { For navigation to end of SETJMP-protected block. Within this
+ * block, use png_error() instead of Throwing an Exception, to ensure
+ * that libpng is able to clean up, and that the semaphore is unlocked.
+ */
+
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
+ LockSemaphoreInfo(ping_semaphore);
+#endif
+
/*
Prepare PNG for writing.
*/
+
#if defined(PNG_MNG_FEATURES_SUPPORTED)
if (mng_info->write_mng)
+ {
(void) png_permit_mng_features(ping,PNG_ALL_MNG_FEATURES);
+# ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
+ /* Disable new libpng-1.5.10 feature when writing a MNG because
+ * zero-length PLTE is OK
+ */
+ png_set_check_for_invalid_index (ping, 0);
+# endif
+ }
#else
# ifdef PNG_WRITE_EMPTY_PLTE_SUPPORTED
if (image->colors == 0)
{
/* DO SOMETHING */
- (void) ThrowMagickException(exception,
- GetMagickModule(),CoderError,
- "image has 0 colors", "`%s'","");
+ png_error(ping,"image has 0 colors");
}
while ((int) (one << ping_bit_depth) < (ssize_t) image_colors)
if (logging != MagickFalse)
{
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " Tentative PNG color type: %.20g",(double) ping_color_type);
+ " Tentative PNG color type: %s (%.20g)",
+ PngColorTypeToString(ping_color_type),
+ (double) ping_color_type);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" image_info->type: %.20g",(double) image_info->type);
for (i=0; i < ping_num_trans; i++)
{
- ping_trans_alpha[i]= (png_byte)
+ ping_trans_alpha[i]= (png_byte)
ScaleQuantumToChar(image->colormap[i].alpha);
}
}
if (ping_exclude_bKGD == MagickFalse)
{
- ping_background.gray=(png_uint_16)
- ((maxval/255.)*((GetPixelInfoIntensity(&image->background_color)))
- +.5);
+ ping_background.gray=(png_uint_16) ((maxval/65535.)*
+ (ScaleQuantumToShort(((GetPixelInfoIntensity(
+ &image->background_color))) +.5)));
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " PNG color type: %d",ping_color_type);
+ " PNG color type: %s (%d)", PngColorTypeToString(ping_color_type),
+ ping_color_type);
/*
Initialize compression level and filtering.
*/
5: libpng adaptive filtering if compression level > 5
libpng filter type "none" if compression level <= 5
or if image is grayscale or palette
-
+
6: libpng adaptive filtering
7: "LOCO" filtering (intrapixel differing) if writing
Note that using the -quality option, not all combinations of
PNG filter type, zlib compression level, and zlib compression
strategy are possible. This will be addressed soon in a
- release that accomodates "-define PNG:compression-strategy", etc.
+ release that accomodates "-define png:compression-strategy", etc.
*/
if (mng_info->write_png_compression_strategy == 0)
mng_info->write_png_compression_strategy = Z_HUFFMAN_ONLY+1;
}
-
+
else if (mng_info->write_png_compression_level == 0)
{
int
if (mng_info->write_png_compression_strategy == 0)
{
if ((quality %10) == 8 || (quality %10) == 9)
- mng_info->write_png_compression_strategy=Z_RLE;
+#ifdef Z_RLE /* Z_RLE was added to zlib-1.2.0 */
+ mng_info->write_png_compression_strategy=Z_RLE+1;
+#else
+ mng_info->write_png_compression_strategy = Z_DEFAULT_STRATEGY+1;
+#endif
}
if (mng_info->write_png_compression_filter == 0)
#if defined(PNG_WRITE_sRGB_SUPPORTED)
if ((mng_info->have_write_global_srgb == 0) &&
- ((image->rendering_intent != UndefinedIntent) ||
- (image->colorspace == sRGBColorspace)))
+ (image->rendering_intent != UndefinedIntent))
{
if (ping_exclude_sRGB == MagickFalse)
{
if (mng_info->write_mng)
png_set_sig_bytes(ping,8);
- /* Bail out if cannot meet defined PNG:bit-depth or PNG:color-type */
+ /* Bail out if cannot meet defined png:bit-depth or png:color-type */
if (mng_info->write_png_colortype != 0)
{
if (mng_info->write_png_depth)
{
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " Defined PNG:bit-depth=%u, Computed depth=%u",
+ " Defined png:bit-depth=%u, Computed depth=%u",
mng_info->write_png_depth,
ping_bit_depth);
}
if (mng_info->write_png_colortype)
{
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " Defined PNG:color-type=%u, Computed color type=%u",
+ " Defined png:color-type=%u, Computed color type=%u",
mng_info->write_png_colortype-1,
ping_color_type);
}
}
png_warning(ping,
- "Cannot write image with defined PNG:bit-depth or PNG:color-type.");
+ "Cannot write image with defined png:bit-depth or png:color-type.");
}
if (image_matte != MagickFalse && image->matte == MagickFalse)
sizeof(*ping_pixels));
if (ping_pixels == (unsigned char *) NULL)
- ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
+ png_error(ping,"Allocation of memory for pixels failed");
/*
Initialize image scanlines.
*/
- if (setjmp(png_jmpbuf(ping)))
- {
- /*
- PNG write failed.
- */
-#ifdef PNG_DEBUG
- if (image_info->verbose)
- (void) printf("PNG write has failed.\n");
-#endif
- png_destroy_write_struct(&ping,&ping_info);
- if (quantum_info != (QuantumInfo *) NULL)
- quantum_info=DestroyQuantumInfo(quantum_info);
- if (ping_pixels != (unsigned char *) NULL)
- ping_pixels=(unsigned char *) RelinquishMagickMemory(ping_pixels);
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
- UnlockSemaphoreInfo(ping_semaphore);
-#endif
- if (ping_have_blob != MagickFalse)
- (void) CloseBlob(image);
- image_info=DestroyImageInfo(image_info);
- image=DestroyImage(image);
- return(MagickFalse);
- }
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
- ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
+ png_error(ping,"Memory allocation for quantum_info failed");
quantum_info->format=UndefinedQuantumFormat;
quantum_info->depth=image_depth;
num_passes=png_set_interlace_handling(ping);
{
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,
- exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1, exception);
if (p == (const Quantum *) NULL)
break;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" pass %d, Image Is RGB, 16-bit GRAY, or GRAY_ALPHA",pass);
- p=GetVirtualPixels(image,0,y,image->columns,1,
- exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1, exception);
if (p == (const Quantum *) NULL)
break;
if (mng_info->write_png_depth)
{
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " Defined PNG:bit-depth: %d",mng_info->write_png_depth);
+ " Defined png:bit-depth: %d",mng_info->write_png_depth);
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
if (mng_info->write_png_colortype)
{
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " Defined PNG:color-type: %d",mng_info->write_png_colortype-1);
+ " Defined png:color-type: %d",mng_info->write_png_colortype-1);
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
}
if (mng_info->write_mng && !mng_info->need_fram &&
((int) image->dispose == 3))
- (void) ThrowMagickException(exception,GetMagickModule(),
- CoderError,"Cannot convert GIF with disposal method 3 to MNG-LC",
- "`%s'",image->filename);
+ png_error(ping, "Cannot convert GIF with disposal method 3 to MNG-LC");
/*
Free PNG resources.
ping_pixels=(unsigned char *) RelinquishMagickMemory(ping_pixels);
-#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
- UnlockSemaphoreInfo(ping_semaphore);
-#endif
-
if (ping_have_blob != MagickFalse)
(void) CloseBlob(image);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" exit WriteOnePNGImage()");
+#ifdef PNG_SETJMP_NOT_THREAD_SAFE
+ UnlockSemaphoreInfo(ping_semaphore);
+#endif
+
+ /* } for navigation to beginning of SETJMP-protected block. Revert to
+ * Throwing an Exception when an error occurs.
+ */
+
return(MagickTrue);
/* End write one PNG image */
+
}
/*
%
% While the datastream written is always in PNG format and normally would
% be given the "png" file extension, this method also writes the following
-% pseudo-formats which are subsets of PNG:
+% pseudo-formats which are subsets of png:
%
% o PNG8: An 8-bit indexed PNG datastream is written. If the image has
% a depth greater than 8, the depth is reduced. If transparency
% o Opaque matte channel is removed when writing an indexed PNG.
% o Grayscale images are reduced to 1, 2, or 4 bit depth if
% this can be done without loss and a larger bit depth N was not
-% requested via the "-define PNG:bit-depth=N" option.
+% requested via the "-define png:bit-depth=N" option.
% o If matte channel is present but only one transparent color is
% present, RGB+tRNS is written instead of RGBA
% o Opaque matte channel is removed (or added, if color-type 4 or 6
mng_info->write_png24=LocaleCompare(image_info->magick,"PNG24") == 0;
mng_info->write_png32=LocaleCompare(image_info->magick,"PNG32") == 0;
+ value=GetImageOption(image_info,"png:format");
+
+ if (value != (char *) NULL)
+ {
+ if (LocaleCompare(value,"png8") == 0)
+ {
+ mng_info->write_png8 = MagickTrue;
+ mng_info->write_png24 = MagickFalse;
+ mng_info->write_png32 = MagickFalse;
+ }
+
+ else if (LocaleCompare(value,"png24") == 0)
+ {
+ mng_info->write_png8 = MagickFalse;
+ mng_info->write_png24 = MagickTrue;
+ mng_info->write_png32 = MagickFalse;
+ }
+
+ else if (LocaleCompare(value,"png32") == 0)
+ {
+ mng_info->write_png8 = MagickFalse;
+ mng_info->write_png24 = MagickFalse;
+ mng_info->write_png32 = MagickTrue;
+ }
+ }
if (mng_info->write_png8)
{
mng_info->write_png_colortype = /* 3 */ 4;
if (LocaleCompare(value,"0") == 0)
mng_info->write_png_colortype = 1;
+ else if (LocaleCompare(value,"1") == 0)
+ mng_info->write_png_colortype = 2;
+
else if (LocaleCompare(value,"2") == 0)
mng_info->write_png_colortype = 3;
* The default is to not exclude any known chunks except for any
* listed in the "unused_chunks" array, above.
*
- * Chunks can be listed for exclusion via a "PNG:exclude-chunk"
+ * Chunks can be listed for exclusion via a "png:exclude-chunk"
* define (in the image properties or in the image artifacts)
* or via a mng_info member. For convenience, in addition
* to or instead of a comma-separated list of chunks, the
*
* The exclude-chunk define takes priority over the mng_info.
*
- * A "PNG:include-chunk" define takes priority over both the
- * mng_info and the "PNG:exclude-chunk" define. Like the
+ * A "png:include-chunk" define takes priority over both the
+ * mng_info and the "png:exclude-chunk" define. Like the
* "exclude-chunk" string, it can define "all" or "none" as
* well as a comma-separated list. Chunks that are unknown to
* ImageMagick are always excluded, regardless of their "copy-safe"
* status according to the PNG specification, and even if they
- * appear in the "include-chunk" list.
+ * appear in the "include-chunk" list. Such defines appearing among
+ * the image options take priority over those found among the image
+ * artifacts.
*
* Finally, all chunks listed in the "unused_chunks" array are
* automatically excluded, regardless of the other instructions
if (LocaleCompare(value,"0") == 0)
mng_info->write_png_compression_level = 1;
- if (LocaleCompare(value,"1") == 0)
+ else if (LocaleCompare(value,"1") == 0)
mng_info->write_png_compression_level = 2;
else if (LocaleCompare(value,"2") == 0)
if (excluding != MagickFalse && logging != MagickFalse)
{
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " Chunks to be excluded from the output PNG:");
+ " Chunks to be excluded from the output png:");
if (mng_info->ping_exclude_bKGD != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" bKGD");
transparent;
size_t
+ jng_alpha_quality,
jng_quality;
logging=LogMagickEvent(CoderEvent,GetMagickModule(),
status=MagickTrue;
transparent=image_info->type==GrayscaleMatteType ||
- image_info->type==TrueColorMatteType;
- jng_color_type=10;
- jng_alpha_sample_depth=0;
- jng_quality=image_info->quality == 0UL ? 75UL : image_info->quality;
- jng_alpha_compression_method=0;
+ image_info->type==TrueColorMatteType || image->matte != MagickFalse;
- if (image->matte != MagickFalse)
- {
- /* if any pixels are transparent */
- transparent=MagickTrue;
- if (image_info->compression==JPEGCompression)
- jng_alpha_compression_method=8;
- }
+ jng_quality=image_info->quality == 0UL ? 75UL : image_info->quality%1000;
+
+ jng_alpha_compression_method=image->compression==JPEGCompression? 8 : 0;
+
+ jng_alpha_quality=image_info->quality == 0UL ? 75UL :
+ image_info->quality;
+
+ if (jng_alpha_quality >= 1000)
+ jng_alpha_quality /= 1000;
if (transparent)
{
- ChannelType
- channel_mask;
-
jng_color_type=14;
/* Create JPEG blob, image, and image_info */
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Creating jpeg_image.");
- jpeg_image=CloneImage(image,0,0,MagickTrue,exception);
-
+ jpeg_image=SeparateImage(image,AlphaChannel,exception);
if (jpeg_image == (Image *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
-
(void) CopyMagickString(jpeg_image->magick,"JPEG",MaxTextExtent);
- channel_mask=SetPixelChannelMask(jpeg_image,AlphaChannel);
- status=SeparateImage(jpeg_image,exception);
- (void) SetPixelChannelMap(jpeg_image,channel_mask);
jpeg_image->matte=MagickFalse;
-
- if (jng_quality >= 1000)
- jpeg_image_info->quality=jng_quality/1000;
-
- else
- jpeg_image_info->quality=jng_quality;
-
+ jpeg_image->quality=jng_alpha_quality;
jpeg_image_info->type=GrayscaleType;
(void) SetImageType(jpeg_image,GrayscaleType,exception);
(void) AcquireUniqueFilename(jpeg_image->filename);
(void) FormatLocaleString(jpeg_image_info->filename,MaxTextExtent,
"%s",jpeg_image->filename);
}
+ else
+ {
+ jng_alpha_compression_method=0;
+ jng_color_type=10;
+ jng_alpha_sample_depth=0;
+ }
/* To do: check bit depth of PNG alpha channel */
/* Check if image is grayscale. */
if (image_info->type != TrueColorMatteType && image_info->type !=
- TrueColorType && ImageIsGray(image,exception))
+ TrueColorType && IsImageGray(image,exception))
jng_color_type-=2;
+ if (logging != MagickFalse)
+ {
+ (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+ " JNG Quality = %d",(int) jng_quality);
+ (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+ " JNG Color Type = %d",jng_color_type);
+ if (transparent)
+ {
+ (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+ " JNG Alpha Compression = %d",jng_alpha_compression_method);
+ (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+ " JNG Alpha Depth = %d",jng_alpha_sample_depth);
+ (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+ " JNG Alpha Quality = %d",(int) jng_alpha_quality);
+ }
+ }
+
if (transparent)
{
if (jng_alpha_compression_method==0)
(void) CopyMagickString(jpeg_image->magick,"PNG",MaxTextExtent);
jpeg_image_info->interlace=NoInterlace;
+ /* Exclude all ancillary chunks */
+ (void) SetImageArtifact(jpeg_image,"png:exclude-chunks","all");
+
blob=ImageToBlob(jpeg_image_info,jpeg_image,&length,
exception);
if (jng_color_type == 8 || jng_color_type == 12)
jpeg_image_info->type=GrayscaleType;
- jpeg_image_info->quality=jng_quality % 1000;
+ jpeg_image_info->quality=jng_quality;
+ jpeg_image->quality=jng_quality;
(void) CopyMagickString(jpeg_image_info->magick,"JPEG",MaxTextExtent);
(void) CopyMagickString(jpeg_image->magick,"JPEG",MaxTextExtent);
if (need_local_plte == 0)
{
- if (ImageIsGray(image,exception) == MagickFalse)
+ if (IsImageGray(image,exception) == MagickFalse)
all_images_are_gray=MagickFalse;
mng_info->equal_palettes=PalettesAreEqual(image,next_image);
if (use_global_plte == 0)
static MagickBooleanType WritePNGImage(const ImageInfo *image_info,Image *image)
{
- image=image;
+ (void) image;
printf("Your PNG library is too old: You have libpng-%s\n",
PNG_LIBPNG_VER_STRING);
projects / imagemagick / blobdiff