third_party/libpng/pngset.c - Issue 15041: Update libpng to 1.2.33.

Unified Diff: third_party/libpng/pngset.c

Issue 15041: Update libpng to 1.2.33. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/

Patch Set: Created 12 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: third_party/libpng/pngset.c

===================================================================

--- third_party/libpng/pngset.c (revision 7204)

+++ third_party/libpng/pngset.c (working copy)

@@ -1,7 +1,7 @@

/* pngset.c - storage of image information into info struct

- * Last changed in libpng 1.2.27 [April 29, 2008]

+ * Last changed in libpng 1.2.30 [August 15, 2008]

* For conditions of distribution and use, see copyright notice in png.h

@@ -15,7 +15,6 @@

#define PNG_INTERNAL

#include "png.h"

#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

#if defined(PNG_bKGD_SUPPORTED)

@@ -168,13 +167,13 @@

gamma=21474.83;

}

else

- gamma=file_gamma;

+ gamma = file_gamma;

info_ptr->gamma = (float)gamma;

#ifdef PNG_FIXED_POINT_SUPPORTED

info_ptr->int_gamma = (int)(gamma*100000.+.5);

#endif

info_ptr->valid |= PNG_INFO_gAMA;

- if(gamma == 0.0)

+ if (gamma == 0.0)

png_warning(png_ptr, "Setting gamma=0");

}

#endif

@@ -198,10 +197,10 @@

if (int_gamma < 0)

{

png_warning(png_ptr, "Setting negative gamma to zero");

- gamma=0;

+ gamma = 0;

}

else

- gamma=int_gamma;

+ gamma = int_gamma;

}

#ifdef PNG_FLOATING_POINT_SUPPORTED

info_ptr->gamma = (float)(gamma/100000.);

@@ -210,7 +209,7 @@

info_ptr->int_gamma = gamma;

#endif

info_ptr->valid |= PNG_INFO_gAMA;

- if(gamma == 0)

+ if (gamma == 0)

png_warning(png_ptr, "Setting gamma=0");

}

#endif

@@ -238,7 +237,7 @@

/* 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)(PNG_MAX_PALETTE_LENGTH * 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.");

@@ -319,21 +318,21 @@

* 4. The filter_method is 64 and

* 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");

- if(filter_type != PNG_FILTER_TYPE_BASE)

+ 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");

+ if (filter_type != PNG_FILTER_TYPE_BASE)

{

- if(!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

+ 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_ALPHA)))

png_error(png_ptr, "Unknown filter method in IHDR");

- if(png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)

+ if (png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)

png_warning(png_ptr, "Invalid filter method in IHDR");

}

#else

- if(filter_type != PNG_FILTER_TYPE_BASE)

+ if (filter_type != PNG_FILTER_TYPE_BASE)

png_error(png_ptr, "Unknown filter method in IHDR");

#endif

@@ -363,7 +362,7 @@

- 8) /* extra max_pixel_depth pad */

info_ptr->rowbytes = (png_size_t)0;

else

- info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,width);

+ info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);

}

#if defined(PNG_oFFs_SUPPORTED)

@@ -396,13 +395,14 @@

return;

length = png_strlen(purpose) + 1;

- png_debug1(3, "allocating purpose for info (%lu bytes)\n", length);

+ png_debug1(3, "allocating purpose for info (%lu bytes)\n",

+ (unsigned long)length);

info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);

if (info_ptr->pcal_purpose == NULL)

- {

+ {

png_warning(png_ptr, "Insufficient memory for pCAL purpose.");

- return;

- }

+ return;

+ }

png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);

png_debug(3, "storing X0, X1, type, and nparams in info\n");

@@ -412,35 +412,37 @@

info_ptr->pcal_nparams = (png_byte)nparams;

length = png_strlen(units) + 1;

- png_debug1(3, "allocating units for info (%lu bytes)\n", length);

+ png_debug1(3, "allocating units for info (%lu bytes)\n",

+ (unsigned long)length);

info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);

if (info_ptr->pcal_units == NULL)

- {

+ {

png_warning(png_ptr, "Insufficient memory for pCAL units.");

- return;

- }

+ return;

+ }

png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);

info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,

(png_uint_32)((nparams + 1) * png_sizeof(png_charp)));

if (info_ptr->pcal_params == NULL)

- {

+ {

png_warning(png_ptr, "Insufficient memory for pCAL params.");

- return;

- }

+ return;

+ }

info_ptr->pcal_params[nparams] = NULL;

for (i = 0; i < nparams; i++)

{

length = png_strlen(params[i]) + 1;

- png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i, length);

+ png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i,

+ (unsigned long)length);

info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);

if (info_ptr->pcal_params[i] == NULL)

- {

+ {

png_warning(png_ptr, "Insufficient memory for pCAL parameter.");

return;

- }

+ }

png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);

}

@@ -482,7 +484,8 @@

info_ptr->scal_unit = (png_byte)unit;

length = png_strlen(swidth) + 1;

- png_debug1(3, "allocating unit for info (%d bytes)\n", length);

+ png_debug1(3, "allocating unit for info (%u bytes)\n",

+ (unsigned int)length);

info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);

if (info_ptr->scal_s_width == NULL)

{

@@ -493,11 +496,13 @@

png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);

length = png_strlen(sheight) + 1;

- png_debug1(3, "allocating unit for info (%d bytes)\n", length);

+ png_debug1(3, "allocating unit for info (%u bytes)\n",

+ (unsigned int)length);

info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);

if (info_ptr->scal_s_height == NULL)

{

png_free (png_ptr, info_ptr->scal_s_width);

+ info_ptr->scal_s_width = NULL;

png_warning(png_ptr,

"Memory allocation failed while processing sCAL.");

return;

@@ -564,7 +569,7 @@

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));

+ 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;

@@ -586,7 +591,7 @@

if (png_ptr == NULL || info_ptr == NULL)

return;

- png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof (png_color_8));

+ png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));

info_ptr->valid |= PNG_INFO_sBIT;

}

#endif

@@ -700,7 +705,8 @@

if (new_iccp_profile == NULL)

{

png_free (png_ptr, new_iccp_name);

- png_warning(png_ptr, "Insufficient memory to process iCCP profile.");

+ png_warning(png_ptr,

+ "Insufficient memory to process iCCP profile.");

return;

}

png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);

@@ -726,7 +732,7 @@

int num_text)

{

int ret;

- ret=png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);

+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);

if (ret)

png_error(png_ptr, "Insufficient memory to store text");

}

@@ -757,7 +763,7 @@

info_ptr->max_text = info_ptr->num_text + num_text + 8;

old_text = info_ptr->text;

info_ptr->text = (png_textp)png_malloc_warn(png_ptr,

- (png_uint_32)(info_ptr->max_text * png_sizeof (png_text)));

+ (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));

if (info_ptr->text == NULL)

{

png_free(png_ptr, old_text);

@@ -772,7 +778,7 @@

info_ptr->max_text = num_text + 8;

info_ptr->num_text = 0;

info_ptr->text = (png_textp)png_malloc_warn(png_ptr,

- (png_uint_32)(info_ptr->max_text * png_sizeof (png_text)));

+ (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));

if (info_ptr->text == NULL)

return(1);

#ifdef PNG_FREE_ME_SUPPORTED

@@ -784,8 +790,8 @@

}

for (i = 0; i < num_text; i++)

{

- png_size_t text_length,key_len;

- png_size_t lang_len,lang_key_len;

+ png_size_t text_length, key_len;

+ png_size_t lang_len, lang_key_len;

png_textp textp = &(info_ptr->text[info_ptr->num_text]);

if (text_ptr[i].key == NULL)

@@ -793,7 +799,7 @@

key_len = png_strlen(text_ptr[i].key);

- if(text_ptr[i].compression <= 0)

+ if (text_ptr[i].compression <= 0)

{

lang_len = 0;

lang_key_len = 0;

@@ -822,7 +828,7 @@

{

text_length = 0;

#ifdef PNG_iTXt_SUPPORTED

- if(text_ptr[i].compression > 0)

+ if (text_ptr[i].compression > 0)

textp->compression = PNG_ITXT_COMPRESSION_NONE;

else

#endif

@@ -835,26 +841,28 @@

}

textp->key = (png_charp)png_malloc_warn(png_ptr,

- (png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4));

+ (png_uint_32)

+ (key_len + text_length + lang_len + lang_key_len + 4));

if (textp->key == NULL)

return(1);

png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n",

- (png_uint_32)(key_len + lang_len + lang_key_len + text_length + 4),

+ (png_uint_32)

+ (key_len + lang_len + lang_key_len + text_length + 4),

(int)textp->key);

png_memcpy(textp->key, text_ptr[i].key,

(png_size_t)(key_len));

- *(textp->key+key_len) = '\0';

+ *(textp->key + key_len) = '\0';

#ifdef PNG_iTXt_SUPPORTED

if (text_ptr[i].compression > 0)

{

- textp->lang=textp->key + key_len + 1;

+ textp->lang = textp->key + key_len + 1;

png_memcpy(textp->lang, text_ptr[i].lang, lang_len);

- *(textp->lang+lang_len) = '\0';

- textp->lang_key=textp->lang + lang_len + 1;

+ *(textp->lang + lang_len) = '\0';

+ textp->lang_key = textp->lang + lang_len + 1;

png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);

- *(textp->lang_key+lang_key_len) = '\0';

- textp->text=textp->lang_key + lang_key_len + 1;

+ *(textp->lang_key + lang_key_len) = '\0';

+ textp->text = textp->lang_key + lang_key_len + 1;

}

else

#endif

@@ -863,15 +871,15 @@

textp->lang=NULL;

textp->lang_key=NULL;

#endif

- textp->text=textp->key + key_len + 1;

+ textp->text = textp->key + key_len + 1;

}

- if(text_length)

+ if (text_length)

png_memcpy(textp->text, text_ptr[i].text,

(png_size_t)(text_length));

- *(textp->text+text_length) = '\0';

+ *(textp->text + text_length) = '\0';

#ifdef PNG_iTXt_SUPPORTED

- if(textp->compression > 0)

+ if (textp->compression > 0)

{

textp->text_length = 0;

textp->itxt_length = text_length;

@@ -900,7 +908,7 @@

(png_ptr->mode & PNG_WROTE_tIME))

return;

- png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof (png_time));

+ png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));

info_ptr->valid |= PNG_INFO_tIME;

}

#endif

@@ -914,8 +922,6 @@

if (png_ptr == NULL || info_ptr == NULL)

return;

- png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);

if (trans != NULL)

{

@@ -924,6 +930,10 @@

* 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 PNG_MAX_PALETTE_LENGTH in version 1.2.1 */

png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,

(png_uint_32)PNG_MAX_PALETTE_LENGTH);

@@ -965,6 +975,13 @@

void PNGAPI

png_set_sPLT(png_structp png_ptr,

png_infop info_ptr, png_sPLT_tp entries, int nentries)

+/*

+ * entries - array of png_sPLT_t structures

+ * to be added to the list of palettes

+ * in the info structure.

+ * nentries - number of palette structures to be

+ * added.

+ */

{

png_sPLT_tp np;

int i;

@@ -973,7 +990,8 @@

return;

np = (png_sPLT_tp)png_malloc_warn(png_ptr,

- (info_ptr->splt_palettes_num + nentries) * png_sizeof(png_sPLT_t));

+ (info_ptr->splt_palettes_num + nentries) *

+ (png_uint_32)png_sizeof(png_sPLT_t));

if (np == NULL)

{

png_warning(png_ptr, "No memory for sPLT palettes.");

@@ -1001,12 +1019,12 @@

}

png_memcpy(to->name, from->name, length);

to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,

- from->nentries * png_sizeof(png_sPLT_entry));

+ (png_uint_32)(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);

+ png_free(png_ptr, to->name);

to->name = NULL;

continue;

}

@@ -1037,8 +1055,8 @@

return;

np = (png_unknown_chunkp)png_malloc_warn(png_ptr,

- (info_ptr->unknown_chunks_num + num_unknowns) *

- png_sizeof(png_unknown_chunk));

+ (png_uint_32)((info_ptr->unknown_chunks_num + num_unknowns) *

+ png_sizeof(png_unknown_chunk)));

if (np == NULL)

{

png_warning(png_ptr,

@@ -1068,12 +1086,13 @@

to->data=NULL;

else

{

- to->data = (png_bytep)png_malloc_warn(png_ptr, from->size);

+ to->data = (png_bytep)png_malloc_warn(png_ptr,

+ (png_uint_32)from->size);

if (to->data == NULL)

{

png_warning(png_ptr,

"Out of memory while processing unknown chunk.");

- to->size=0;

+ to->size = 0;

}

else

png_memcpy(to->data, from->data, from->size);

@@ -1090,7 +1109,7 @@

png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,

int chunk, int location)

{

- if(png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <

+ if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <

(int)info_ptr->unknown_chunks_num)

info_ptr->unknown_chunks[chunk].location = (png_byte)location;

}

@@ -1138,12 +1157,12 @@

return;

if (num_chunks == 0)

{

- if(keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)

+ if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)

png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;

else

png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;

- if(keep == PNG_HANDLE_CHUNK_ALWAYS)

+ if (keep == PNG_HANDLE_CHUNK_ALWAYS)

png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;

else

png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;

@@ -1151,22 +1170,23 @@

}

if (chunk_list == NULL)

return;

- old_num_chunks=png_ptr->num_chunk_list;

+ old_num_chunks = png_ptr->num_chunk_list;

new_list=(png_bytep)png_malloc(png_ptr,

- (png_uint_32)(5*(num_chunks+old_num_chunks)));

- if(png_ptr->chunk_list != NULL)

+ (png_uint_32)

+ (5*(num_chunks + old_num_chunks)));

+ if (png_ptr->chunk_list != NULL)

{

png_memcpy(new_list, png_ptr->chunk_list,

(png_size_t)(5*old_num_chunks));

png_free(png_ptr, png_ptr->chunk_list);

png_ptr->chunk_list=NULL;

}

- png_memcpy(new_list+5*old_num_chunks, chunk_list,

+ png_memcpy(new_list + 5*old_num_chunks, chunk_list,

(png_size_t)(5*num_chunks));

- for (p=new_list+5*old_num_chunks+4, i=0; i<num_chunks; i++, p+=5)

+ for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)

*p=(png_byte)keep;

- png_ptr->num_chunk_list=old_num_chunks+num_chunks;

- png_ptr->chunk_list=new_list;

+ png_ptr->num_chunk_list = old_num_chunks + num_chunks;

+ png_ptr->chunk_list = new_list;

#ifdef PNG_FREE_ME_SUPPORTED

png_ptr->free_me |= PNG_FREE_LIST;

#endif

@@ -1195,17 +1215,18 @@

if (png_ptr == NULL || info_ptr == NULL)

return;

- if(info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))

+ if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))

png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);

info_ptr->row_pointers = row_pointers;

- if(row_pointers)

+ if (row_pointers)

info_ptr->valid |= PNG_INFO_IDAT;

}

#endif

#ifdef PNG_WRITE_SUPPORTED

void PNGAPI

-png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size)

+png_set_compression_buffer_size(png_structp png_ptr,

+ png_uint_32 size)

{

if (png_ptr == NULL)

return;

@@ -1234,6 +1255,7 @@

/* 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;

+ asm_flags = asm_flags; /* Quiet the compiler */

}

/* this function was added to libpng 1.2.0 */

@@ -1245,6 +1267,9 @@

/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */

if (png_ptr == NULL)

return;

+ /* Quiet the compiler */

+ mmx_bitdepth_threshold = mmx_bitdepth_threshold;

+ mmx_rowbytes_threshold = mmx_rowbytes_threshold;

}

#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */

@@ -1258,7 +1283,7 @@

* rejected by png_set_IHDR(). To accept any PNG datastream

* regardless of dimensions, set both limits to 0x7ffffffL.

- if(png_ptr == NULL) return;

+ if (png_ptr == NULL) return;

png_ptr->user_width_max = user_width_max;

png_ptr->user_height_max = user_height_max;

}

« no previous file with comments | « third_party/libpng/pngrutil.c ('k') | third_party/libpng/pngtrans.c » ('j') | no next file with comments »