| Index: third_party/libpng/pngwutil.c
|
| ===================================================================
|
| --- third_party/libpng/pngwutil.c (revision 7204)
|
| +++ third_party/libpng/pngwutil.c (working copy)
|
| @@ -1,7 +1,7 @@
|
|
|
| /* pngwutil.c - utilities to write a PNG file
|
| *
|
| - * 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
|
| * Copyright (c) 1998-2008 Glenn Randers-Pehrson
|
| * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
| @@ -49,6 +49,24 @@
|
| buf[1] = (png_byte)(i & 0xff);
|
| }
|
|
|
| +/* Simple function to write the signature. If we have already written
|
| + * the magic bytes of the signature, or more likely, the PNG stream is
|
| + * being embedded into another stream and doesn't need its own signature,
|
| + * we should call png_set_sig_bytes() to tell libpng how many of the
|
| + * bytes have already been written.
|
| + */
|
| +void /* PRIVATE */
|
| +png_write_sig(png_structp png_ptr)
|
| +{
|
| + png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
|
| +
|
| + /* write the rest of the 8 byte signature */
|
| + png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
|
| + (png_size_t)(8 - png_ptr->sig_bytes));
|
| + if (png_ptr->sig_bytes < 3)
|
| + png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
|
| +}
|
| +
|
| /* Write a PNG chunk all at once. The type is an array of ASCII characters
|
| * representing the chunk name. The array must be at least 4 bytes in
|
| * length, and does not need to be null terminated. To be safe, pass the
|
| @@ -62,9 +80,9 @@
|
| png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
|
| png_bytep data, png_size_t length)
|
| {
|
| - if(png_ptr == NULL) return;
|
| + if (png_ptr == NULL) return;
|
| png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);
|
| - png_write_chunk_data(png_ptr, data, length);
|
| + png_write_chunk_data(png_ptr, data, (png_size_t)length);
|
| png_write_chunk_end(png_ptr);
|
| }
|
|
|
| @@ -76,16 +94,18 @@
|
| png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
|
| png_uint_32 length)
|
| {
|
| - png_byte buf[4];
|
| - png_debug2(0, "Writing %s chunk (%lu bytes)\n", chunk_name, length);
|
| - if(png_ptr == NULL) return;
|
| + png_byte buf[8];
|
|
|
| - /* write the length */
|
| + png_debug2(0, "Writing %s chunk, length = %lu\n", chunk_name,
|
| + (unsigned long)length);
|
| + if (png_ptr == NULL) return;
|
| +
|
| + /* write the length and the chunk name */
|
| png_save_uint_32(buf, length);
|
| - png_write_data(png_ptr, buf, (png_size_t)4);
|
| -
|
| - /* write the chunk name */
|
| - png_write_data(png_ptr, chunk_name, (png_size_t)4);
|
| + png_memcpy(buf + 4, chunk_name, 4);
|
| + png_write_data(png_ptr, buf, (png_size_t)8);
|
| + /* put the chunk name into png_ptr->chunk_name */
|
| + png_memcpy(png_ptr->chunk_name, chunk_name, 4);
|
| /* reset the crc and run it over the chunk name */
|
| png_reset_crc(png_ptr);
|
| png_calculate_crc(png_ptr, chunk_name, (png_size_t)4);
|
| @@ -100,11 +120,14 @@
|
| png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)
|
| {
|
| /* write the data, and run the CRC over it */
|
| - if(png_ptr == NULL) return;
|
| + if (png_ptr == NULL) return;
|
| if (data != NULL && length > 0)
|
| {
|
| + png_write_data(png_ptr, data, length);
|
| + /* update the CRC after writing the data,
|
| + * in case that the user I/O routine alters it.
|
| + */
|
| png_calculate_crc(png_ptr, data, length);
|
| - png_write_data(png_ptr, data, length);
|
| }
|
| }
|
|
|
| @@ -114,31 +137,14 @@
|
| {
|
| png_byte buf[4];
|
|
|
| - if(png_ptr == NULL) return;
|
| + if (png_ptr == NULL) return;
|
|
|
| - /* write the crc */
|
| + /* write the crc in a single operation */
|
| png_save_uint_32(buf, png_ptr->crc);
|
|
|
| png_write_data(png_ptr, buf, (png_size_t)4);
|
| }
|
|
|
| -/* Simple function to write the signature. If we have already written
|
| - * the magic bytes of the signature, or more likely, the PNG stream is
|
| - * being embedded into another stream and doesn't need its own signature,
|
| - * we should call png_set_sig_bytes() to tell libpng how many of the
|
| - * bytes have already been written.
|
| - */
|
| -void /* PRIVATE */
|
| -png_write_sig(png_structp png_ptr)
|
| -{
|
| - png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
|
| - /* write the rest of the 8 byte signature */
|
| - png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
|
| - (png_size_t)8 - png_ptr->sig_bytes);
|
| - if(png_ptr->sig_bytes < 3)
|
| - png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
|
| -}
|
| -
|
| #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)
|
| /*
|
| * This pair of functions encapsulates the operation of (a) compressing a
|
| @@ -239,20 +245,21 @@
|
|
|
| old_ptr = comp->output_ptr;
|
| comp->output_ptr = (png_charpp)png_malloc(png_ptr,
|
| - (png_uint_32)(comp->max_output_ptr *
|
| - png_sizeof (png_charpp)));
|
| + (png_uint_32)
|
| + (comp->max_output_ptr * png_sizeof(png_charpp)));
|
| png_memcpy(comp->output_ptr, old_ptr, old_max
|
| - * png_sizeof (png_charp));
|
| + * png_sizeof(png_charp));
|
| png_free(png_ptr, old_ptr);
|
| }
|
| else
|
| comp->output_ptr = (png_charpp)png_malloc(png_ptr,
|
| - (png_uint_32)(comp->max_output_ptr *
|
| - png_sizeof (png_charp)));
|
| + (png_uint_32)
|
| + (comp->max_output_ptr * png_sizeof(png_charp)));
|
| }
|
|
|
| /* save the data */
|
| - comp->output_ptr[comp->num_output_ptr] = (png_charp)png_malloc(png_ptr,
|
| + comp->output_ptr[comp->num_output_ptr] =
|
| + (png_charp)png_malloc(png_ptr,
|
| (png_uint_32)png_ptr->zbuf_size);
|
| png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
|
| png_ptr->zbuf_size);
|
| @@ -291,20 +298,21 @@
|
| /* This could be optimized to realloc() */
|
| comp->output_ptr = (png_charpp)png_malloc(png_ptr,
|
| (png_uint_32)(comp->max_output_ptr *
|
| - png_sizeof (png_charpp)));
|
| + png_sizeof(png_charp)));
|
| png_memcpy(comp->output_ptr, old_ptr,
|
| - old_max * png_sizeof (png_charp));
|
| + old_max * png_sizeof(png_charp));
|
| png_free(png_ptr, old_ptr);
|
| }
|
| else
|
| comp->output_ptr = (png_charpp)png_malloc(png_ptr,
|
| (png_uint_32)(comp->max_output_ptr *
|
| - png_sizeof (png_charp)));
|
| + png_sizeof(png_charp)));
|
| }
|
|
|
| /* save off the data */
|
| comp->output_ptr[comp->num_output_ptr] =
|
| - (png_charp)png_malloc(png_ptr, (png_uint_32)png_ptr->zbuf_size);
|
| + (png_charp)png_malloc(png_ptr,
|
| + (png_uint_32)png_ptr->zbuf_size);
|
| png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
|
| png_ptr->zbuf_size);
|
| comp->num_output_ptr++;
|
| @@ -349,18 +357,18 @@
|
| /* write saved output buffers, if any */
|
| for (i = 0; i < comp->num_output_ptr; i++)
|
| {
|
| - png_write_chunk_data(png_ptr,(png_bytep)comp->output_ptr[i],
|
| - png_ptr->zbuf_size);
|
| + png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i],
|
| + (png_size_t)png_ptr->zbuf_size);
|
| png_free(png_ptr, comp->output_ptr[i]);
|
| - comp->output_ptr[i]=NULL;
|
| + comp->output_ptr[i]=NULL;
|
| }
|
| if (comp->max_output_ptr != 0)
|
| png_free(png_ptr, comp->output_ptr);
|
| - comp->output_ptr=NULL;
|
| + comp->output_ptr=NULL;
|
| /* write anything left in zbuf */
|
| if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)
|
| png_write_chunk_data(png_ptr, png_ptr->zbuf,
|
| - png_ptr->zbuf_size - png_ptr->zstream.avail_out);
|
| + (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));
|
|
|
| /* reset zlib for another zTXt/iTXt or image data */
|
| deflateReset(&png_ptr->zstream);
|
| @@ -396,7 +404,7 @@
|
| case 4:
|
| case 8:
|
| case 16: png_ptr->channels = 1; break;
|
| - default: png_error(png_ptr,"Invalid bit depth for grayscale image");
|
| + default: png_error(png_ptr, "Invalid bit depth for grayscale image");
|
| }
|
| break;
|
| case PNG_COLOR_TYPE_RGB:
|
| @@ -496,7 +504,7 @@
|
| buf[12] = (png_byte)interlace_type;
|
|
|
| /* write the chunk */
|
| - png_write_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
|
| + png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);
|
|
|
| /* initialize zlib with PNG info */
|
| png_ptr->zstream.zalloc = png_zalloc;
|
| @@ -589,7 +597,8 @@
|
| png_ptr->num_palette = (png_uint_16)num_pal;
|
| png_debug1(3, "num_palette = %d\n", png_ptr->num_palette);
|
|
|
| - png_write_chunk_start(png_ptr, png_PLTE, num_pal * 3);
|
| + png_write_chunk_start(png_ptr, (png_bytep)png_PLTE,
|
| + (png_uint_32)(num_pal * 3));
|
| #ifndef PNG_NO_POINTER_INDEXING
|
| for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
|
| {
|
| @@ -661,7 +670,7 @@
|
| "Invalid zlib compression method or flags in IDAT");
|
| }
|
|
|
| - png_write_chunk(png_ptr, png_IDAT, data, length);
|
| + png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length);
|
| png_ptr->mode |= PNG_HAVE_IDAT;
|
| }
|
|
|
| @@ -673,7 +682,7 @@
|
| PNG_IEND;
|
| #endif
|
| png_debug(1, "in png_write_IEND\n");
|
| - png_write_chunk(png_ptr, png_IEND, png_bytep_NULL,
|
| + png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL,
|
| (png_size_t)0);
|
| png_ptr->mode |= PNG_HAVE_IEND;
|
| }
|
| @@ -694,7 +703,7 @@
|
| /* file_gamma is saved in 1/100,000ths */
|
| igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);
|
| png_save_uint_32(buf, igamma);
|
| - png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
|
| + png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
|
| }
|
| #endif
|
| #ifdef PNG_FIXED_POINT_SUPPORTED
|
| @@ -709,7 +718,7 @@
|
| png_debug(1, "in png_write_gAMA\n");
|
| /* file_gamma is saved in 1/100,000ths */
|
| png_save_uint_32(buf, (png_uint_32)file_gamma);
|
| - png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
|
| + png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
|
| }
|
| #endif
|
| #endif
|
| @@ -725,11 +734,11 @@
|
| png_byte buf[1];
|
|
|
| png_debug(1, "in png_write_sRGB\n");
|
| - if(srgb_intent >= PNG_sRGB_INTENT_LAST)
|
| + if (srgb_intent >= PNG_sRGB_INTENT_LAST)
|
| png_warning(png_ptr,
|
| "Invalid sRGB rendering intent specified");
|
| buf[0]=(png_byte)srgb_intent;
|
| - png_write_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
|
| + png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);
|
| }
|
| #endif
|
|
|
| @@ -770,34 +779,35 @@
|
|
|
| if (profile_len > 3)
|
| embedded_profile_len =
|
| - ((*( (png_bytep)profile ))<<24) |
|
| - ((*( (png_bytep)profile+1))<<16) |
|
| - ((*( (png_bytep)profile+2))<< 8) |
|
| - ((*( (png_bytep)profile+3)) );
|
| + ((*( (png_bytep)profile ))<<24) |
|
| + ((*( (png_bytep)profile + 1))<<16) |
|
| + ((*( (png_bytep)profile + 2))<< 8) |
|
| + ((*( (png_bytep)profile + 3)) );
|
|
|
| if (profile_len < embedded_profile_len)
|
| - {
|
| - png_warning(png_ptr,
|
| - "Embedded profile length too large in iCCP chunk");
|
| - return;
|
| - }
|
| + {
|
| + png_warning(png_ptr,
|
| + "Embedded profile length too large in iCCP chunk");
|
| + return;
|
| + }
|
|
|
| if (profile_len > embedded_profile_len)
|
| - {
|
| - png_warning(png_ptr,
|
| - "Truncating profile to actual length in iCCP chunk");
|
| - profile_len = embedded_profile_len;
|
| - }
|
| + {
|
| + png_warning(png_ptr,
|
| + "Truncating profile to actual length in iCCP chunk");
|
| + profile_len = embedded_profile_len;
|
| + }
|
|
|
| if (profile_len)
|
| - profile_len = png_text_compress(png_ptr, profile, (png_size_t)profile_len,
|
| - PNG_COMPRESSION_TYPE_BASE, &comp);
|
| + profile_len = png_text_compress(png_ptr, profile,
|
| + (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);
|
|
|
| /* make sure we include the NULL after the name and the compression type */
|
| - png_write_chunk_start(png_ptr, png_iCCP,
|
| - (png_uint_32)name_len+profile_len+2);
|
| - new_name[name_len+1]=0x00;
|
| - png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 2);
|
| + png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,
|
| + (png_uint_32)(name_len + profile_len + 2));
|
| + new_name[name_len + 1] = 0x00;
|
| + png_write_chunk_data(png_ptr, (png_bytep)new_name,
|
| + (png_size_t)(name_len + 2));
|
|
|
| if (profile_len)
|
| png_write_compressed_data_out(png_ptr, &comp);
|
| @@ -834,54 +844,55 @@
|
| }
|
|
|
| /* make sure we include the NULL after the name */
|
| - png_write_chunk_start(png_ptr, png_sPLT,
|
| - (png_uint_32)(name_len + 2 + palette_size));
|
| - png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 1);
|
| - png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, 1);
|
| + png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,
|
| + (png_uint_32)(name_len + 2 + palette_size));
|
| + png_write_chunk_data(png_ptr, (png_bytep)new_name,
|
| + (png_size_t)(name_len + 1));
|
| + png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, (png_size_t)1);
|
|
|
| /* loop through each palette entry, writing appropriately */
|
| #ifndef PNG_NO_POINTER_INDEXING
|
| - for (ep = spalette->entries; ep<spalette->entries+spalette->nentries; ep++)
|
| + for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
|
| {
|
| - if (spalette->depth == 8)
|
| - {
|
| - entrybuf[0] = (png_byte)ep->red;
|
| - entrybuf[1] = (png_byte)ep->green;
|
| - entrybuf[2] = (png_byte)ep->blue;
|
| - entrybuf[3] = (png_byte)ep->alpha;
|
| - png_save_uint_16(entrybuf + 4, ep->frequency);
|
| - }
|
| - else
|
| - {
|
| - png_save_uint_16(entrybuf + 0, ep->red);
|
| - png_save_uint_16(entrybuf + 2, ep->green);
|
| - png_save_uint_16(entrybuf + 4, ep->blue);
|
| - png_save_uint_16(entrybuf + 6, ep->alpha);
|
| - png_save_uint_16(entrybuf + 8, ep->frequency);
|
| - }
|
| - png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
|
| + if (spalette->depth == 8)
|
| + {
|
| + entrybuf[0] = (png_byte)ep->red;
|
| + entrybuf[1] = (png_byte)ep->green;
|
| + entrybuf[2] = (png_byte)ep->blue;
|
| + entrybuf[3] = (png_byte)ep->alpha;
|
| + png_save_uint_16(entrybuf + 4, ep->frequency);
|
| + }
|
| + else
|
| + {
|
| + png_save_uint_16(entrybuf + 0, ep->red);
|
| + png_save_uint_16(entrybuf + 2, ep->green);
|
| + png_save_uint_16(entrybuf + 4, ep->blue);
|
| + png_save_uint_16(entrybuf + 6, ep->alpha);
|
| + png_save_uint_16(entrybuf + 8, ep->frequency);
|
| + }
|
| + png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
|
| }
|
| #else
|
| ep=spalette->entries;
|
| for (i=0; i>spalette->nentries; i++)
|
| {
|
| - if (spalette->depth == 8)
|
| - {
|
| - entrybuf[0] = (png_byte)ep[i].red;
|
| - entrybuf[1] = (png_byte)ep[i].green;
|
| - entrybuf[2] = (png_byte)ep[i].blue;
|
| - entrybuf[3] = (png_byte)ep[i].alpha;
|
| - png_save_uint_16(entrybuf + 4, ep[i].frequency);
|
| - }
|
| - else
|
| - {
|
| - png_save_uint_16(entrybuf + 0, ep[i].red);
|
| - png_save_uint_16(entrybuf + 2, ep[i].green);
|
| - png_save_uint_16(entrybuf + 4, ep[i].blue);
|
| - png_save_uint_16(entrybuf + 6, ep[i].alpha);
|
| - png_save_uint_16(entrybuf + 8, ep[i].frequency);
|
| - }
|
| - png_write_chunk_data(png_ptr, entrybuf, entry_size);
|
| + if (spalette->depth == 8)
|
| + {
|
| + entrybuf[0] = (png_byte)ep[i].red;
|
| + entrybuf[1] = (png_byte)ep[i].green;
|
| + entrybuf[2] = (png_byte)ep[i].blue;
|
| + entrybuf[3] = (png_byte)ep[i].alpha;
|
| + png_save_uint_16(entrybuf + 4, ep[i].frequency);
|
| + }
|
| + else
|
| + {
|
| + png_save_uint_16(entrybuf + 0, ep[i].red);
|
| + png_save_uint_16(entrybuf + 2, ep[i].green);
|
| + png_save_uint_16(entrybuf + 4, ep[i].blue);
|
| + png_save_uint_16(entrybuf + 6, ep[i].alpha);
|
| + png_save_uint_16(entrybuf + 8, ep[i].frequency);
|
| + }
|
| + png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
|
| }
|
| #endif
|
|
|
| @@ -942,7 +953,7 @@
|
| buf[size++] = sbit->alpha;
|
| }
|
|
|
| - png_write_chunk(png_ptr, png_sBIT, buf, size);
|
| + png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);
|
| }
|
| #endif
|
|
|
| @@ -967,7 +978,7 @@
|
| {
|
| png_warning(png_ptr, "Invalid cHRM white point specified");
|
| #if !defined(PNG_NO_CONSOLE_IO)
|
| - fprintf(stderr,"white_x=%f, white_y=%f\n",white_x, white_y);
|
| + fprintf(stderr, "white_x=%f, white_y=%f\n", white_x, white_y);
|
| #endif
|
| return;
|
| }
|
| @@ -1006,7 +1017,7 @@
|
| itemp = (png_uint_32)(blue_y * 100000.0 + 0.5);
|
| png_save_uint_32(buf + 28, itemp);
|
|
|
| - png_write_chunk(png_ptr, png_cHRM, buf, (png_size_t)32);
|
| + png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
|
| }
|
| #endif
|
| #ifdef PNG_FIXED_POINT_SUPPORTED
|
| @@ -1027,7 +1038,8 @@
|
| {
|
| png_warning(png_ptr, "Invalid fixed cHRM white point specified");
|
| #if !defined(PNG_NO_CONSOLE_IO)
|
| - fprintf(stderr,"white_x=%ld, white_y=%ld\n",white_x, white_y);
|
| + fprintf(stderr, "white_x=%ld, white_y=%ld\n", (unsigned long)white_x,
|
| + (unsigned long)white_y);
|
| #endif
|
| return;
|
| }
|
| @@ -1058,7 +1070,7 @@
|
| png_save_uint_32(buf + 24, (png_uint_32)blue_x);
|
| png_save_uint_32(buf + 28, (png_uint_32)blue_y);
|
|
|
| - png_write_chunk(png_ptr, png_cHRM, buf, (png_size_t)32);
|
| + png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
|
| }
|
| #endif
|
| #endif
|
| @@ -1079,23 +1091,24 @@
|
| {
|
| if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
|
| {
|
| - png_warning(png_ptr,"Invalid number of transparent colors specified");
|
| + png_warning(png_ptr, "Invalid number of transparent colors specified");
|
| return;
|
| }
|
| /* write the chunk out as it is */
|
| - png_write_chunk(png_ptr, png_tRNS, trans, (png_size_t)num_trans);
|
| + png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans,
|
| + (png_size_t)num_trans);
|
| }
|
| else if (color_type == PNG_COLOR_TYPE_GRAY)
|
| {
|
| /* one 16 bit value */
|
| - if(tran->gray >= (1 << png_ptr->bit_depth))
|
| + if (tran->gray >= (1 << png_ptr->bit_depth))
|
| {
|
| png_warning(png_ptr,
|
| "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
|
| return;
|
| }
|
| png_save_uint_16(buf, tran->gray);
|
| - png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)2);
|
| + png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);
|
| }
|
| else if (color_type == PNG_COLOR_TYPE_RGB)
|
| {
|
| @@ -1103,13 +1116,13 @@
|
| png_save_uint_16(buf, tran->red);
|
| png_save_uint_16(buf + 2, tran->green);
|
| png_save_uint_16(buf + 4, tran->blue);
|
| - if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
|
| - {
|
| - png_warning(png_ptr,
|
| - "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
|
| - return;
|
| - }
|
| - png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)6);
|
| + if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
|
| + {
|
| + png_warning(png_ptr,
|
| + "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
|
| + return;
|
| + }
|
| + png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);
|
| }
|
| else
|
| {
|
| @@ -1142,31 +1155,31 @@
|
| return;
|
| }
|
| buf[0] = back->index;
|
| - png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)1);
|
| + png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1);
|
| }
|
| else if (color_type & PNG_COLOR_MASK_COLOR)
|
| {
|
| png_save_uint_16(buf, back->red);
|
| png_save_uint_16(buf + 2, back->green);
|
| png_save_uint_16(buf + 4, back->blue);
|
| - if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
|
| - {
|
| - png_warning(png_ptr,
|
| - "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
|
| - return;
|
| - }
|
| - png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)6);
|
| + if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
|
| + {
|
| + png_warning(png_ptr,
|
| + "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
|
| + return;
|
| + }
|
| + png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6);
|
| }
|
| else
|
| {
|
| - if(back->gray >= (1 << png_ptr->bit_depth))
|
| + if (back->gray >= (1 << png_ptr->bit_depth))
|
| {
|
| png_warning(png_ptr,
|
| "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
|
| return;
|
| }
|
| png_save_uint_16(buf, back->gray);
|
| - png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)2);
|
| + png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2);
|
| }
|
| }
|
| #endif
|
| @@ -1191,7 +1204,8 @@
|
| return;
|
| }
|
|
|
| - png_write_chunk_start(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
|
| + png_write_chunk_start(png_ptr, (png_bytep)png_hIST,
|
| + (png_uint_32)(num_hist * 2));
|
| for (i = 0; i < num_hist; i++)
|
| {
|
| png_save_uint_16(buf, hist[i]);
|
| @@ -1311,13 +1325,13 @@
|
| }
|
| }
|
| *dp = '\0';
|
| - if(kwarn)
|
| + if (kwarn)
|
| png_warning(png_ptr, "extra interior spaces removed from keyword");
|
|
|
| if (key_len == 0)
|
| {
|
| png_free(png_ptr, *new_key);
|
| - *new_key=NULL;
|
| + *new_key=NULL;
|
| png_warning(png_ptr, "Zero length keyword");
|
| }
|
|
|
| @@ -1357,16 +1371,18 @@
|
| text_len = png_strlen(text);
|
|
|
| /* make sure we include the 0 after the key */
|
| - png_write_chunk_start(png_ptr, png_tEXt, (png_uint_32)key_len+text_len+1);
|
| + png_write_chunk_start(png_ptr, (png_bytep)png_tEXt,
|
| + (png_uint_32)(key_len + text_len + 1));
|
| /*
|
| * We leave it to the application to meet PNG-1.0 requirements on the
|
| * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
|
| * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
|
| * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
|
| */
|
| - png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);
|
| + png_write_chunk_data(png_ptr, (png_bytep)new_key,
|
| + (png_size_t)(key_len + 1));
|
| if (text_len)
|
| - png_write_chunk_data(png_ptr, (png_bytep)text, text_len);
|
| + png_write_chunk_data(png_ptr, (png_bytep)text, (png_size_t)text_len);
|
|
|
| png_write_chunk_end(png_ptr);
|
| png_free(png_ptr, new_key);
|
| @@ -1398,6 +1414,7 @@
|
| if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
|
| {
|
| png_warning(png_ptr, "Empty keyword in zTXt chunk");
|
| + png_free(png_ptr, new_key);
|
| return;
|
| }
|
|
|
| @@ -1415,10 +1432,11 @@
|
| &comp);
|
|
|
| /* write start of chunk */
|
| - png_write_chunk_start(png_ptr, png_zTXt, (png_uint_32)
|
| - (key_len+text_len+2));
|
| + png_write_chunk_start(png_ptr, (png_bytep)png_zTXt,
|
| + (png_uint_32)(key_len+text_len + 2));
|
| /* write key */
|
| - png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);
|
| + png_write_chunk_data(png_ptr, (png_bytep)new_key,
|
| + (png_size_t)(key_len + 1));
|
| png_free(png_ptr, new_key);
|
|
|
| buf[0] = (png_byte)compression;
|
| @@ -1483,7 +1501,7 @@
|
| /* make sure we include the compression flag, the compression byte,
|
| * and the NULs after the key, lang, and lang_key parts */
|
|
|
| - png_write_chunk_start(png_ptr, png_iTXt,
|
| + png_write_chunk_start(png_ptr, (png_bytep)png_iTXt,
|
| (png_uint_32)(
|
| 5 /* comp byte, comp flag, terminators for key, lang and lang_key */
|
| + key_len
|
| @@ -1497,7 +1515,8 @@
|
| * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
|
| * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
|
| */
|
| - png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);
|
| + png_write_chunk_data(png_ptr, (png_bytep)new_key,
|
| + (png_size_t)(key_len + 1));
|
|
|
| /* set the compression flag */
|
| if (compression == PNG_ITXT_COMPRESSION_NONE || \
|
| @@ -1507,11 +1526,13 @@
|
| cbuf[0] = 1;
|
| /* set the compression method */
|
| cbuf[1] = 0;
|
| - png_write_chunk_data(png_ptr, cbuf, 2);
|
| + png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);
|
|
|
| cbuf[0] = 0;
|
| - png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf), lang_len + 1);
|
| - png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf), lang_key_len + 1);
|
| + png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf),
|
| + (png_size_t)(lang_len + 1));
|
| + png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf),
|
| + (png_size_t)(lang_key_len + 1));
|
| png_write_compressed_data_out(png_ptr, &comp);
|
|
|
| png_write_chunk_end(png_ptr);
|
| @@ -1539,7 +1560,7 @@
|
| png_save_int_32(buf + 4, y_offset);
|
| buf[8] = (png_byte)unit_type;
|
|
|
| - png_write_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
|
| + png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9);
|
| }
|
| #endif
|
| #if defined(PNG_WRITE_pCAL_SUPPORTED)
|
| @@ -1567,21 +1588,23 @@
|
| png_debug1(3, "pCAL units length = %d\n", (int)units_len);
|
| total_len = purpose_len + units_len + 10;
|
|
|
| - params_len = (png_uint_32p)png_malloc(png_ptr, (png_uint_32)(nparams
|
| - *png_sizeof(png_uint_32)));
|
| + params_len = (png_uint_32p)png_malloc(png_ptr,
|
| + (png_uint_32)(nparams * png_sizeof(png_uint_32)));
|
|
|
| /* Find the length of each parameter, making sure we don't count the
|
| null terminator for the last parameter. */
|
| for (i = 0; i < nparams; i++)
|
| {
|
| params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
|
| - png_debug2(3, "pCAL parameter %d length = %lu\n", i, params_len[i]);
|
| + png_debug2(3, "pCAL parameter %d length = %lu\n", i,
|
| + (unsigned long) params_len[i]);
|
| total_len += (png_size_t)params_len[i];
|
| }
|
|
|
| png_debug1(3, "pCAL total length = %d\n", (int)total_len);
|
| - png_write_chunk_start(png_ptr, png_pCAL, (png_uint_32)total_len);
|
| - png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len);
|
| + png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len);
|
| + png_write_chunk_data(png_ptr, (png_bytep)new_purpose,
|
| + (png_size_t)purpose_len);
|
| png_save_int_32(buf, X0);
|
| png_save_int_32(buf + 4, X1);
|
| buf[8] = (png_byte)type;
|
| @@ -1640,7 +1663,7 @@
|
| #endif
|
|
|
| png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len);
|
| - png_write_chunk(png_ptr, png_sCAL, (png_bytep)buf, total_len);
|
| + png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len);
|
| }
|
| #else
|
| #ifdef PNG_FIXED_POINT_SUPPORTED
|
| @@ -1670,7 +1693,7 @@
|
| png_memcpy(buf + wlen + 2, height, hlen); /* do NOT append the '\0' here */
|
|
|
| png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len);
|
| - png_write_chunk(png_ptr, png_sCAL, buf, total_len);
|
| + png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len);
|
| }
|
| #endif
|
| #endif
|
| @@ -1696,7 +1719,7 @@
|
| png_save_uint_32(buf + 4, y_pixels_per_unit);
|
| buf[8] = (png_byte)unit_type;
|
|
|
| - png_write_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
|
| + png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);
|
| }
|
| #endif
|
|
|
| @@ -1728,7 +1751,7 @@
|
| buf[5] = mod_time->minute;
|
| buf[6] = mod_time->second;
|
|
|
| - png_write_chunk(png_ptr, png_tIME, buf, (png_size_t)7);
|
| + png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);
|
| }
|
| #endif
|
|
|
| @@ -1758,18 +1781,19 @@
|
|
|
| png_debug(1, "in png_write_start_row\n");
|
| buf_size = (png_size_t)(PNG_ROWBYTES(
|
| - png_ptr->usr_channels*png_ptr->usr_bit_depth,png_ptr->width)+1);
|
| + png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);
|
|
|
| /* set up row buffer */
|
| - png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);
|
| + png_ptr->row_buf = (png_bytep)png_malloc(png_ptr,
|
| + (png_uint_32)buf_size);
|
| png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
|
|
|
| -#ifndef PNG_NO_WRITE_FILTERING
|
| +#ifndef PNG_NO_WRITE_FILTER
|
| /* set up filtering buffer, if using this filter */
|
| if (png_ptr->do_filter & PNG_FILTER_SUB)
|
| {
|
| png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
|
| - (png_ptr->rowbytes + 1));
|
| + (png_uint_32)(png_ptr->rowbytes + 1));
|
| png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
|
| }
|
|
|
| @@ -1777,31 +1801,32 @@
|
| if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
|
| {
|
| /* set up previous row buffer */
|
| - png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);
|
| + png_ptr->prev_row = (png_bytep)png_malloc(png_ptr,
|
| + (png_uint_32)buf_size);
|
| png_memset(png_ptr->prev_row, 0, buf_size);
|
|
|
| if (png_ptr->do_filter & PNG_FILTER_UP)
|
| {
|
| png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
|
| - (png_ptr->rowbytes + 1));
|
| + (png_uint_32)(png_ptr->rowbytes + 1));
|
| png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
|
| }
|
|
|
| if (png_ptr->do_filter & PNG_FILTER_AVG)
|
| {
|
| png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
|
| - (png_ptr->rowbytes + 1));
|
| + (png_uint_32)(png_ptr->rowbytes + 1));
|
| png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
|
| }
|
|
|
| if (png_ptr->do_filter & PNG_FILTER_PAETH)
|
| {
|
| png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
|
| - (png_ptr->rowbytes + 1));
|
| + (png_uint_32)(png_ptr->rowbytes + 1));
|
| png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
|
| }
|
| -#endif /* PNG_NO_WRITE_FILTERING */
|
| }
|
| +#endif /* PNG_NO_WRITE_FILTER */
|
|
|
| #ifdef PNG_WRITE_INTERLACING_SUPPORTED
|
| /* if interlaced, we need to set up width and height of pass */
|
| @@ -1899,7 +1924,7 @@
|
| if (png_ptr->prev_row != NULL)
|
| png_memset(png_ptr->prev_row, 0,
|
| (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
|
| - png_ptr->usr_bit_depth,png_ptr->width))+1);
|
| + png_ptr->usr_bit_depth, png_ptr->width)) + 1);
|
| return;
|
| }
|
| }
|
|
|
Chromium Code Reviews
