/* pngset.c - storage of image information into info struct
*
- * libpng 1.2.8 - December 3, 2004
+ * Last changed in libpng 1.2.27 [April 29, 2008]
* For conditions of distribution and use, see copyright notice in png.h
- * Copyright (c) 1998-2004 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
#define PNG_INTERNAL
#include "png.h"
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+
#if defined(PNG_bKGD_SUPPORTED)
void PNGAPI
png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
png_debug1(1, "in %s storage function\n", "cHRM");
if (png_ptr == NULL || info_ptr == NULL)
return;
-
+ if (!(white_x || white_y || red_x || red_y || green_x || green_y ||
+ blue_x || blue_y))
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to set all-zero chromaticity values");
+ return;
+ }
if (white_x < 0.0 || white_y < 0.0 ||
red_x < 0.0 || red_y < 0.0 ||
green_x < 0.0 || green_y < 0.0 ||
if (png_ptr == NULL || info_ptr == NULL)
return;
+ if (!(white_x || white_y || red_x || red_y || green_x || green_y ||
+ blue_x || blue_y))
+ {
+ png_warning(png_ptr,
+ "Ignoring attempt to set all-zero chromaticity values");
+ return;
+ }
if (white_x < 0 || white_y < 0 ||
red_x < 0 || red_y < 0 ||
green_x < 0 || green_y < 0 ||
"Ignoring attempt to set negative chromaticity value");
return;
}
- if (white_x > (double) PNG_UINT_31_MAX ||
- white_y > (double) PNG_UINT_31_MAX ||
- red_x > (double) PNG_UINT_31_MAX ||
- red_y > (double) PNG_UINT_31_MAX ||
- green_x > (double) PNG_UINT_31_MAX ||
- green_y > (double) PNG_UINT_31_MAX ||
- blue_x > (double) PNG_UINT_31_MAX ||
- blue_y > (double) PNG_UINT_31_MAX)
+ if (white_x > (png_fixed_point) PNG_UINT_31_MAX ||
+ white_y > (png_fixed_point) PNG_UINT_31_MAX ||
+ red_x > (png_fixed_point) PNG_UINT_31_MAX ||
+ red_y > (png_fixed_point) PNG_UINT_31_MAX ||
+ green_x > (png_fixed_point) PNG_UINT_31_MAX ||
+ green_y > (png_fixed_point) PNG_UINT_31_MAX ||
+ blue_x > (png_fixed_point) PNG_UINT_31_MAX ||
+ blue_y > (png_fixed_point) PNG_UINT_31_MAX )
{
png_warning(png_ptr,
"Ignoring attempt to set chromaticity value exceeding 21474.83");
png_debug1(1, "in %s storage function\n", "hIST");
if (png_ptr == NULL || info_ptr == NULL)
return;
- if (info_ptr->num_palette == 0)
+ if (info_ptr->num_palette == 0 || info_ptr->num_palette
+ > PNG_MAX_PALETTE_LENGTH)
{
png_warning(png_ptr,
- "Palette size 0, hIST allocation skipped.");
+ "Invalid palette size, hIST allocation skipped.");
return;
}
#ifdef PNG_FREE_ME_SUPPORTED
png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
#endif
- /* Changed from info->num_palette to 256 in version 1.2.1 */
+ /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in version
+ 1.2.1 */
png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
- (png_uint_32)(256 * png_sizeof (png_uint_16)));
+ (png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof (png_uint_16)));
if (png_ptr->hist == NULL)
{
png_warning(png_ptr, "Insufficient memory for hIST chunk data.");
* 5. The color_type is RGB or RGBA
*/
if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted)
- png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n");
+ png_warning(png_ptr,"MNG features are not allowed in a PNG datastream");
if(filter_type != PNG_FILTER_TYPE_BASE)
{
if(!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
(filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
- (color_type == PNG_COLOR_TYPE_RGB ||
+ (color_type == PNG_COLOR_TYPE_RGB ||
color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
png_error(png_ptr, "Unknown filter method in IHDR");
if(png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)
info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
/* check for potential overflow */
- if ( width > (PNG_UINT_32_MAX
+ if (width > (PNG_UINT_32_MAX
>> 3) /* 8-byte RGBA pixels */
- 64 /* bigrowbuf hack */
- 1 /* filter byte */
info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);
if (info_ptr->scal_s_width == NULL)
{
- png_warning(png_ptr, "Memory allocation failed while processing sCAL.");
+ png_warning(png_ptr,
+ "Memory allocation failed while processing sCAL.");
+ return;
}
png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);
if (info_ptr->scal_s_height == NULL)
{
png_free (png_ptr, info_ptr->scal_s_width);
- png_warning(png_ptr, "Memory allocation failed while processing sCAL.");
+ png_warning(png_ptr,
+ "Memory allocation failed while processing sCAL.");
+ return;
}
png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);
-
info_ptr->valid |= PNG_INFO_sCAL;
#ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_SCAL;
if (png_ptr == NULL || info_ptr == NULL)
return;
+ if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
+ {
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ png_error(png_ptr, "Invalid palette length");
+ else
+ {
+ png_warning(png_ptr, "Invalid palette length");
+ return;
+ }
+ }
+
/*
* It may not actually be necessary to set png_ptr->palette here;
* we do it for backward compatibility with the way the png_handle_tRNS
png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
#endif
- /* Changed in libpng-1.2.1 to allocate 256 instead of num_palette entries,
+ /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
+ of num_palette entries,
in case of an invalid PNG file that has too-large sample values. */
png_ptr->palette = (png_colorp)png_malloc(png_ptr,
- 256 * png_sizeof(png_color));
- png_memset(png_ptr->palette, 0, 256 * png_sizeof(png_color));
+ PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
+ png_memset(png_ptr->palette, 0, PNG_MAX_PALETTE_LENGTH *
+ png_sizeof(png_color));
png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof (png_color));
info_ptr->palette = png_ptr->palette;
info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
{
png_charp new_iccp_name;
png_charp new_iccp_profile;
+ png_uint_32 length;
png_debug1(1, "in %s storage function\n", "iCCP");
if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
return;
- new_iccp_name = (png_charp)png_malloc_warn(png_ptr, png_strlen(name)+1);
+ length = png_strlen(name)+1;
+ new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);
if (new_iccp_name == NULL)
{
png_warning(png_ptr, "Insufficient memory to process iCCP chunk.");
return;
}
- png_strcpy(new_iccp_name, name);
+ png_memcpy(new_iccp_name, name, length);
new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);
if (new_iccp_profile == NULL)
{
textp->itxt_length = 0;
#endif
}
- info_ptr->text[info_ptr->num_text]= *textp;
info_ptr->num_text++;
png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text);
}
if (png_ptr == NULL || info_ptr == NULL)
return;
+ png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
+
if (trans != NULL)
{
/*
* we do it for backward compatibility with the way the png_handle_tRNS
* function used to do the allocation.
*/
-#ifdef PNG_FREE_ME_SUPPORTED
- png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
-#endif
- /* Changed from num_trans to 256 in version 1.2.1 */
+
+ /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,
- (png_uint_32)256);
- png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);
-#ifdef PNG_FREE_ME_SUPPORTED
- info_ptr->free_me |= PNG_FREE_TRNS;
-#else
- png_ptr->flags |= PNG_FLAG_FREE_TRNS;
-#endif
+ (png_uint_32)PNG_MAX_PALETTE_LENGTH);
+ if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
+ png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);
}
if (trans_values != NULL)
{
+ int sample_max = (1 << info_ptr->bit_depth);
+ if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
+ (int)trans_values->gray > sample_max) ||
+ (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
+ ((int)trans_values->red > sample_max ||
+ (int)trans_values->green > sample_max ||
+ (int)trans_values->blue > sample_max)))
+ png_warning(png_ptr,
+ "tRNS chunk has out-of-range samples for bit_depth");
png_memcpy(&(info_ptr->trans_values), trans_values,
png_sizeof(png_color_16));
if (num_trans == 0)
num_trans = 1;
}
+
info_ptr->num_trans = (png_uint_16)num_trans;
- info_ptr->valid |= PNG_INFO_tRNS;
+ if (num_trans != 0)
+ {
+ info_ptr->valid |= PNG_INFO_tRNS;
+#ifdef PNG_FREE_ME_SUPPORTED
+ info_ptr->free_me |= PNG_FREE_TRNS;
+#else
+ png_ptr->flags |= PNG_FLAG_FREE_TRNS;
+#endif
+ }
}
#endif
png_sPLT_tp np;
int i;
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
np = (png_sPLT_tp)png_malloc_warn(png_ptr,
(info_ptr->splt_palettes_num + nentries) * png_sizeof(png_sPLT_t));
if (np == NULL)
{
png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
png_sPLT_tp from = entries + i;
+ png_uint_32 length;
- to->name = (png_charp)png_malloc(png_ptr,
- png_strlen(from->name) + 1);
- /* TODO: use png_malloc_warn */
- png_strcpy(to->name, from->name);
- to->entries = (png_sPLT_entryp)png_malloc(png_ptr,
- from->nentries * png_sizeof(png_sPLT_t));
- /* TODO: use png_malloc_warn */
+ length = png_strlen(from->name) + 1;
+ to->name = (png_charp)png_malloc_warn(png_ptr, length);
+ if (to->name == NULL)
+ {
+ png_warning(png_ptr,
+ "Out of memory while processing sPLT chunk");
+ continue;
+ }
+ png_memcpy(to->name, from->name, length);
+ to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,
+ from->nentries * png_sizeof(png_sPLT_entry));
+ if (to->entries == NULL)
+ {
+ png_warning(png_ptr,
+ "Out of memory while processing sPLT chunk");
+ png_free(png_ptr,to->name);
+ to->name = NULL;
+ continue;
+ }
png_memcpy(to->entries, from->entries,
- from->nentries * png_sizeof(png_sPLT_t));
+ from->nentries * png_sizeof(png_sPLT_entry));
to->nentries = from->nentries;
to->depth = from->depth;
}
png_sizeof(png_unknown_chunk));
if (np == NULL)
{
- png_warning(png_ptr, "Out of memory while processing unknown chunk.");
+ png_warning(png_ptr,
+ "Out of memory while processing unknown chunk.");
return;
}
for (i = 0; i < num_unknowns; i++)
{
- png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
- png_unknown_chunkp from = unknowns + i;
-
- png_strncpy((png_charp)to->name, (png_charp)from->name, 5);
- to->data = (png_bytep)png_malloc_warn(png_ptr, from->size);
- if (to->data == NULL)
- {
- png_warning(png_ptr, "Out of memory processing unknown chunk.");
- }
- else
- {
- png_memcpy(to->data, from->data, from->size);
- to->size = from->size;
-
- /* note our location in the read or write sequence */
- to->location = (png_byte)(png_ptr->mode & 0xff);
- }
+ png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
+ png_unknown_chunkp from = unknowns + i;
+
+ png_memcpy((png_charp)to->name,
+ (png_charp)from->name,
+ png_sizeof(from->name));
+ to->name[png_sizeof(to->name)-1] = '\0';
+ to->size = from->size;
+ /* note our location in the read or write sequence */
+ to->location = (png_byte)(png_ptr->mode & 0xff);
+
+ if (from->size == 0)
+ to->data=NULL;
+ else
+ {
+ to->data = (png_bytep)png_malloc_warn(png_ptr, from->size);
+ if (to->data == NULL)
+ {
+ png_warning(png_ptr,
+ "Out of memory while processing unknown chunk.");
+ to->size=0;
+ }
+ else
+ png_memcpy(to->data, from->data, from->size);
+ }
}
info_ptr->unknown_chunks = np;
}
#endif
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \
defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
void PNGAPI
png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
{
/* This function is deprecated in favor of png_permit_mng_features()
- and will be removed from libpng-2.0.0 */
+ and will be removed from libpng-1.3.0 */
png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n");
if (png_ptr == NULL)
return;
png_ptr->mng_features_permitted = (png_byte)
- ((png_ptr->mng_features_permitted & (~(PNG_FLAG_MNG_EMPTY_PLTE))) |
+ ((png_ptr->mng_features_permitted & (~PNG_FLAG_MNG_EMPTY_PLTE)) |
((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE)));
}
#endif
+#endif
#if defined(PNG_MNG_FEATURES_SUPPORTED)
png_uint_32 PNGAPI
{
png_bytep new_list, p;
int i, old_num_chunks;
+ if (png_ptr == NULL)
+ return;
if (num_chunks == 0)
{
if(keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)
png_user_chunk_ptr read_user_chunk_fn)
{
png_debug(1, "in png_set_read_user_chunk_fn\n");
+ if (png_ptr == NULL)
+ return;
png_ptr->read_user_chunk_fn = read_user_chunk_fn;
png_ptr->user_chunk_ptr = user_chunk_ptr;
}
void PNGAPI
png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size)
{
- if(png_ptr->zbuf)
- png_free(png_ptr, png_ptr->zbuf);
+ if (png_ptr == NULL)
+ return;
+ png_free(png_ptr, png_ptr->zbuf);
png_ptr->zbuf_size = (png_size_t)size;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
png_ptr->zstream.next_out = png_ptr->zbuf;
png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
{
if (png_ptr && info_ptr)
- info_ptr->valid &= ~(mask);
+ info_ptr->valid &= ~mask;
}
#ifndef PNG_1_0_X
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
-/* this function was added to libpng 1.2.0 and should always exist by default */
+/* function was added to libpng 1.2.0 and should always exist by default */
void PNGAPI
png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)
{
- png_uint_32 settable_asm_flags;
- png_uint_32 settable_mmx_flags;
-
- settable_mmx_flags =
-#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
- PNG_ASM_FLAG_MMX_READ_COMBINE_ROW |
-#endif
-#ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
- PNG_ASM_FLAG_MMX_READ_INTERLACE |
-#endif
-#ifdef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
- PNG_ASM_FLAG_MMX_READ_FILTER_SUB |
- PNG_ASM_FLAG_MMX_READ_FILTER_UP |
- PNG_ASM_FLAG_MMX_READ_FILTER_AVG |
- PNG_ASM_FLAG_MMX_READ_FILTER_PAETH |
-#endif
- 0;
-
- /* could be some non-MMX ones in the future, but not currently: */
- settable_asm_flags = settable_mmx_flags;
-
- if (!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED) ||
- !(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU))
- {
- /* clear all MMX flags if MMX isn't supported */
- settable_asm_flags &= ~settable_mmx_flags;
- png_ptr->asm_flags &= ~settable_mmx_flags;
- }
-
- /* we're replacing the settable bits with those passed in by the user,
- * so first zero them out of the master copy, then logical-OR in the
- * allowed subset that was requested */
-
- png_ptr->asm_flags &= ~settable_asm_flags; /* zero them */
- png_ptr->asm_flags |= (asm_flags & settable_asm_flags); /* set them */
+/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */
+ if (png_ptr != NULL)
+ png_ptr->asm_flags = 0;
}
-#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
/* this function was added to libpng 1.2.0 */
void PNGAPI
png_set_mmx_thresholds (png_structp png_ptr,
png_byte mmx_bitdepth_threshold,
png_uint_32 mmx_rowbytes_threshold)
{
- png_ptr->mmx_bitdepth_threshold = mmx_bitdepth_threshold;
- png_ptr->mmx_rowbytes_threshold = mmx_rowbytes_threshold;
+/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */
+ if (png_ptr == NULL)
+ return;
}
#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
* rejected by png_set_IHDR(). To accept any PNG datastream
* regardless of dimensions, set both limits to 0x7ffffffL.
*/
+ if(png_ptr == NULL) return;
png_ptr->user_width_max = user_width_max;
png_ptr->user_height_max = user_height_max;
}
#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
#endif /* ?PNG_1_0_X */
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
projects / opencv / blobdiff