Housecleaning: revise identation and comments to meet libpng coding style.
diff --git a/ANNOUNCE b/ANNOUNCE
index bf7c5a0..7f42a7f 100644
--- a/ANNOUNCE
+++ b/ANNOUNCE
@@ -448,6 +448,10 @@
Clarified usage of sig_bit versus sig_bit_p in example.c (Vincent Torri)
version 1.4.0beta59 [May 15, 2009]
+ Reformated sources in libpng style (3-space intentation, comment format)
+ Fixed typo in libpng docs (PNG_FILTER_AVE should be PNG_FILTER_AVG)
+ Added sections about the git repository and our coding style to the
+ documentation
version 1.4.0betaN [future]
Build shared libraries with -lz and sometimes -lm.
diff --git a/CHANGES b/CHANGES
index ccee178..dd0c6f4 100644
--- a/CHANGES
+++ b/CHANGES
@@ -2125,6 +2125,10 @@
Clarified usage of sig_bit versus sig_bit_p in example.c (Vincent Torri)
version 1.4.0beta59 [May 15, 2009]
+ Reformated sources in libpng style (3-space intentation, comment format)
+ Fixed typo in libpng docs (PNG_FILTER_AVE should be PNG_FILTER_AVG)
+ Added sections about the git repository and our coding style to the
+ documentation
version 1.4.0betaN [future]
Build shared libraries with -lz and sometimes -lm.
diff --git a/example.c b/example.c
index d543798..7a2abc3 100644
--- a/example.c
+++ b/example.c
@@ -177,11 +177,11 @@
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
&interlace_type, NULL, NULL);
-/* Set up the data transformations you want. Note that these are all
- * optional. Only call them if you want/need them. Many of the
- * transformations only work on specific types of images, and many
- * are mutually exclusive.
- */
+ /* Set up the data transformations you want. Note that these are all
+ * optional. Only call them if you want/need them. Many of the
+ * transformations only work on specific types of images, and many
+ * are mutually exclusive.
+ */
/* Tell libpng to strip 16 bit/color files down to 8 bits/color */
png_set_strip_16(png_ptr);
@@ -230,9 +230,9 @@
png_set_background(png_ptr, &my_background,
PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
- /* Some suggestions as to how to get a screen gamma value */
-
- /* Note that screen gamma is the display_exponent, which includes
+ /* Some suggestions as to how to get a screen gamma value
+ *
+ * Note that screen gamma is the display_exponent, which includes
* the CRT_exponent and any correction for viewing conditions
*/
if (/* We have a user-defined screen gamma value */)
@@ -480,34 +480,35 @@
info_callback(png_structp png_ptr, png_infop info)
{
-/* Do any setup here, including setting any of the transformations
- * mentioned in the Reading PNG files section. For now, you _must_
- * call either png_start_read_image() or png_read_update_info()
- * after all the transformations are set (even if you don't set
- * any). You may start getting rows before png_process_data()
- * returns, so this is your last chance to prepare for that.
- */
+ /* Do any setup here, including setting any of the transformations
+ * mentioned in the Reading PNG files section. For now, you _must_
+ * call either png_start_read_image() or png_read_update_info()
+ * after all the transformations are set (even if you don't set
+ * any). You may start getting rows before png_process_data()
+ * returns, so this is your last chance to prepare for that.
+ */
}
row_callback(png_structp png_ptr, png_bytep new_row,
png_uint_32 row_num, int pass)
{
-/*
- * This function is called for every row in the image. If the
- * image is interlaced, and you turned on the interlace handler,
- * this function will be called for every row in every pass.
- *
- * In this function you will receive a pointer to new row data from
- * libpng called new_row that is to replace a corresponding row (of
- * the same data format) in a buffer allocated by your application.
- *
- * The new row data pointer "new_row" may be NULL, indicating there is
- * no new data to be replaced (in cases of interlace loading).
- *
- * If new_row is not NULL then you need to call
- * png_progressive_combine_row() to replace the corresponding row as
- * shown below:
- */
+ /*
+ * This function is called for every row in the image. If the
+ * image is interlaced, and you turned on the interlace handler,
+ * this function will be called for every row in every pass.
+ *
+ * In this function you will receive a pointer to new row data from
+ * libpng called new_row that is to replace a corresponding row (of
+ * the same data format) in a buffer allocated by your application.
+ *
+ * The new row data pointer "new_row" may be NULL, indicating there is
+ * no new data to be replaced (in cases of interlace loading).
+ *
+ * If new_row is not NULL then you need to call
+ * png_progressive_combine_row() to replace the corresponding row as
+ * shown below:
+ */
+
/* Check if row_num is in bounds. */
if ((row_num >= 0) && (row_num < height))
{
@@ -522,41 +523,41 @@
if ((old_row != NULL) && (new_row != NULL))
png_progressive_combine_row(png_ptr, old_row, new_row);
}
-/*
- * The rows and passes are called in order, so you don't really
- * need the row_num and pass, but I'm supplying them because it
- * may make your life easier.
- *
- * For the non-NULL rows of interlaced images, you must call
- * png_progressive_combine_row() passing in the new row and the
- * old row, as demonstrated above. You can call this function for
- * NULL rows (it will just return) and for non-interlaced images
- * (it just does the png_memcpy for you) if it will make the code
- * easier. Thus, you can just do this for all cases:
- */
+ /*
+ * The rows and passes are called in order, so you don't really
+ * need the row_num and pass, but I'm supplying them because it
+ * may make your life easier.
+ *
+ * For the non-NULL rows of interlaced images, you must call
+ * png_progressive_combine_row() passing in the new row and the
+ * old row, as demonstrated above. You can call this function for
+ * NULL rows (it will just return) and for non-interlaced images
+ * (it just does the png_memcpy for you) if it will make the code
+ * easier. Thus, you can just do this for all cases:
+ */
png_progressive_combine_row(png_ptr, old_row, new_row);
-/* where old_row is what was displayed for previous rows. Note
- * that the first pass (pass == 0 really) will completely cover
- * the old row, so the rows do not have to be initialized. After
- * the first pass (and only for interlaced images), you will have
- * to pass the current row as new_row, and the function will combine
- * the old row and the new row.
- */
+ /* where old_row is what was displayed for previous rows. Note
+ * that the first pass (pass == 0 really) will completely cover
+ * the old row, so the rows do not have to be initialized. After
+ * the first pass (and only for interlaced images), you will have
+ * to pass the current row as new_row, and the function will combine
+ * the old row and the new row.
+ */
}
end_callback(png_structp png_ptr, png_infop info)
{
-/* This function is called when the whole image has been read,
- * including any chunks after the image (up to and including
- * the IEND). You will usually have the same info chunk as you
- * had in the header, although some data may have been added
- * to the comments and time fields.
- *
- * Most people won't do much here, perhaps setting a flag that
- * marks the image as finished.
- */
+ /* This function is called when the whole image has been read,
+ * including any chunks after the image (up to and including
+ * the IEND). You will usually have the same info chunk as you
+ * had in the header, although some data may have been added
+ * to the comments and time fields.
+ *
+ * Most people won't do much here, perhaps setting a flag that
+ * marks the image as finished.
+ */
}
/* Write a png file */
@@ -608,6 +609,7 @@
}
/* One of the following I/O initialization functions is REQUIRED */
+
#ifdef streams /* I/O initialization method 1 */
/* Set up the output control if you are using standard C streams */
png_init_io(png_ptr, fp);
diff --git a/libpng-1.4.0beta59.txt b/libpng-1.4.0beta59.txt
index db25259..531cc8d 100644
--- a/libpng-1.4.0beta59.txt
+++ b/libpng-1.4.0beta59.txt
@@ -3043,7 +3043,113 @@
We removed the trailing '.' from the warning and error messages.
-X. Y2K Compliance in libpng
+
+X. Source code repository
+
+Since about February 2009, version 1.2.34, libpng has been under "git" source
+control. The git repository was built from old libpng-x.y.z.tar.gz files
+going back to version 0.70. You can access the git repository (read only)
+at
+
+ git://libpng.git.sourceforge.net/gitroot/libpng
+
+or you can browse it via "gitweb" at
+
+ http://libpng.git.sourceforge.net/git/gitweb.cgi?p=libpng
+
+Patches can be sent to glennrp at users.sourceforge.net or to
+png-mng-implement at lists.sourceforge.net or you can upload them to
+the libpng bug tracker at
+
+ http://libpng.sourceforge.net
+
+XI. Coding style
+
+Our coding style is similar to the "Allman" style, with curly
+braces on separate lines:
+
+ if (condition)
+ {
+ action;
+ }
+
+ else if (another condition)
+ {
+ another action;
+ }
+
+The braces can be omitted from simple one-line actions:
+
+ if (condition)
+ return (0);
+
+We use 3-space indentation, except for continued statements which
+are usually indented the same as the first line of the statement
+plus four more spaces.
+
+Comments appear with the leading "/*" at the same indentation as
+the statement that follows the comment:
+
+ /* Single-line comment */
+ statement;
+
+ /* Multiple-line
+ * comment
+ */
+ statement;
+
+Very short comments can be placed at the end of the statement
+to which they pertain:
+
+ statement; /* comment */
+
+We don't use C++ style ("//") comments. We have, however,
+used them in the past in some now-abandoned MMX assembler
+code.
+
+Functions and their curly brackets are not indented, and
+exported functions are marked with PNGAPI:
+
+ /* This is a public function that is visible to
+ * application programers. It does thus-and-so.
+ */
+ void PNGAPI
+ png_exported_function(png_ptr, png_info, foo)
+ {
+ body;
+ }
+
+The prototypes for all exported functions appear in png.h.
+
+We mark all non-exported functions with "/* PRIVATE */"":
+
+ void /* PRIVATE */
+ png_non_exported_function(png_ptr, png_info, foo)
+ {
+ body;
+ }
+
+The prototypes for non-exported functions can appear in
+pngpriv.h or in the file where the function is located.
+
+The names of all exported functions and variables begin
+with "png_", and all publicly visible C preprocessor
+macros begin with "PNG_".
+
+We put a space after each comma and after each semicolon
+in "for" statments, and we put spaces before and after each
+C binary operator and after "for" or "while". We don't
+put a space between a typecast and the expression being
+cast, nor do we put one between a function name and the
+left parenthesis that follows it:
+
+ for (i = 2; i > 0; --i)
+ x[i] = a(x) + (int)b;
+
+Other rules can be inferred by inspecting the libpng
+source.
+
+XII. Y2K Compliance in libpng
May 15, 2009
diff --git a/png.c b/png.c
index 8e00ddb..e3847c4 100644
--- a/png.c
+++ b/png.c
@@ -13,7 +13,7 @@
#include "pngpriv.h"
/* Generate a compiler error if there is an old png.h in the search path. */
-typedef version_1_4_0beta58 Your_png_h_is_not_version_1_4_0beta58;
+typedef version_1_4_0beta59 Your_png_h_is_not_version_1_4_0beta59;
/* Version information for C files. This had better match the version
* string defined in png.h. */
@@ -92,7 +92,8 @@
void PNGAPI
png_set_sig_bytes(png_structp png_ptr, int num_bytes)
{
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_debug(1, "in png_set_sig_bytes");
if (num_bytes > 8)
png_error(png_ptr, "Too many bytes for PNG signature");
@@ -138,7 +139,8 @@
png_uint_32 save_flags=p->flags;
png_alloc_size_t num_bytes;
- if (png_ptr == NULL) return (NULL);
+ if (png_ptr == NULL)
+ return (NULL);
if (items > PNG_UINT_32_MAX/size)
{
png_warning (p, "Potential overflow in png_zalloc()");
@@ -207,7 +209,8 @@
png_infop info_ptr;
png_debug(1, "in png_create_info_struct");
- if (png_ptr == NULL) return (NULL);
+ if (png_ptr == NULL)
+ return (NULL);
#ifdef PNG_USER_MEM_SUPPORTED
info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
png_ptr->malloc_fn, png_ptr->mem_ptr);
@@ -229,7 +232,8 @@
png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
{
png_infop info_ptr = NULL;
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_debug(1, "in png_destroy_info_struct");
if (info_ptr_ptr != NULL)
@@ -259,16 +263,17 @@
{
png_infop info_ptr = *ptr_ptr;
- if (info_ptr == NULL) return;
+ if (info_ptr == NULL)
+ return;
png_debug(1, "in png_info_init_3");
if (png_sizeof(png_info) > png_info_struct_size)
- {
- png_destroy_struct(info_ptr);
- info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
- *ptr_ptr = info_ptr;
- }
+ {
+ png_destroy_struct(info_ptr);
+ info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
+ *ptr_ptr = info_ptr;
+ }
/* set everything to 0 */
png_memset(info_ptr, 0, png_sizeof(png_info));
@@ -301,243 +306,243 @@
return;
#if defined(PNG_TEXT_SUPPORTED)
-/* free text item num or (if num == -1) all text items */
+ /* free text item num or (if num == -1) all text items */
#ifdef PNG_FREE_ME_SUPPORTED
-if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
+ if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
#else
-if (mask & PNG_FREE_TEXT)
+ if (mask & PNG_FREE_TEXT)
#endif
-{
- if (num != -1)
{
- if (info_ptr->text && info_ptr->text[num].key)
- {
- png_free(png_ptr, info_ptr->text[num].key);
- info_ptr->text[num].key = NULL;
- }
+ if (num != -1)
+ {
+ if (info_ptr->text && info_ptr->text[num].key)
+ {
+ png_free(png_ptr, info_ptr->text[num].key);
+ info_ptr->text[num].key = NULL;
+ }
+ }
+ else
+ {
+ int i;
+ for (i = 0; i < info_ptr->num_text; i++)
+ png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
+ png_free(png_ptr, info_ptr->text);
+ info_ptr->text = NULL;
+ info_ptr->num_text=0;
+ }
}
- else
- {
- int i;
- for (i = 0; i < info_ptr->num_text; i++)
- png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
- png_free(png_ptr, info_ptr->text);
- info_ptr->text = NULL;
- info_ptr->num_text=0;
- }
-}
#endif
#if defined(PNG_tRNS_SUPPORTED)
-/* free any tRNS entry */
+ /* free any tRNS entry */
#ifdef PNG_FREE_ME_SUPPORTED
-if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
+ if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
#else
-if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
+ if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
#endif
-{
- png_free(png_ptr, info_ptr->trans);
- info_ptr->trans = NULL;
- info_ptr->valid &= ~PNG_INFO_tRNS;
+ {
+ png_free(png_ptr, info_ptr->trans);
+ info_ptr->trans = NULL;
+ info_ptr->valid &= ~PNG_INFO_tRNS;
#ifndef PNG_FREE_ME_SUPPORTED
- png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
+ png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
#endif
-}
+ }
#endif
#if defined(PNG_sCAL_SUPPORTED)
-/* free any sCAL entry */
+ /* free any sCAL entry */
#ifdef PNG_FREE_ME_SUPPORTED
-if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
+ if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
#else
-if (mask & PNG_FREE_SCAL)
+ if (mask & PNG_FREE_SCAL)
#endif
-{
+ {
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
- png_free(png_ptr, info_ptr->scal_s_width);
- png_free(png_ptr, info_ptr->scal_s_height);
- info_ptr->scal_s_width = NULL;
- info_ptr->scal_s_height = NULL;
+ png_free(png_ptr, info_ptr->scal_s_width);
+ png_free(png_ptr, info_ptr->scal_s_height);
+ info_ptr->scal_s_width = NULL;
+ info_ptr->scal_s_height = NULL;
#endif
- info_ptr->valid &= ~PNG_INFO_sCAL;
-}
+ info_ptr->valid &= ~PNG_INFO_sCAL;
+ }
#endif
#if defined(PNG_pCAL_SUPPORTED)
-/* free any pCAL entry */
+ /* free any pCAL entry */
#ifdef PNG_FREE_ME_SUPPORTED
-if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
+ if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
#else
-if (mask & PNG_FREE_PCAL)
+ if (mask & PNG_FREE_PCAL)
#endif
-{
- png_free(png_ptr, info_ptr->pcal_purpose);
- png_free(png_ptr, info_ptr->pcal_units);
- info_ptr->pcal_purpose = NULL;
- info_ptr->pcal_units = NULL;
- if (info_ptr->pcal_params != NULL)
- {
- int i;
- for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
- {
- png_free(png_ptr, info_ptr->pcal_params[i]);
- info_ptr->pcal_params[i]=NULL;
- }
- png_free(png_ptr, info_ptr->pcal_params);
- info_ptr->pcal_params = NULL;
- }
- info_ptr->valid &= ~PNG_INFO_pCAL;
-}
+ {
+ png_free(png_ptr, info_ptr->pcal_purpose);
+ png_free(png_ptr, info_ptr->pcal_units);
+ info_ptr->pcal_purpose = NULL;
+ info_ptr->pcal_units = NULL;
+ if (info_ptr->pcal_params != NULL)
+ {
+ int i;
+ for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
+ {
+ png_free(png_ptr, info_ptr->pcal_params[i]);
+ info_ptr->pcal_params[i]=NULL;
+ }
+ png_free(png_ptr, info_ptr->pcal_params);
+ info_ptr->pcal_params = NULL;
+ }
+ info_ptr->valid &= ~PNG_INFO_pCAL;
+ }
#endif
#if defined(PNG_iCCP_SUPPORTED)
-/* free any iCCP entry */
+ /* free any iCCP entry */
#ifdef PNG_FREE_ME_SUPPORTED
-if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
+ if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
#else
-if (mask & PNG_FREE_ICCP)
+ if (mask & PNG_FREE_ICCP)
#endif
-{
- png_free(png_ptr, info_ptr->iccp_name);
- png_free(png_ptr, info_ptr->iccp_profile);
- info_ptr->iccp_name = NULL;
- info_ptr->iccp_profile = NULL;
- info_ptr->valid &= ~PNG_INFO_iCCP;
-}
+ {
+ png_free(png_ptr, info_ptr->iccp_name);
+ png_free(png_ptr, info_ptr->iccp_profile);
+ info_ptr->iccp_name = NULL;
+ info_ptr->iccp_profile = NULL;
+ info_ptr->valid &= ~PNG_INFO_iCCP;
+ }
#endif
#if defined(PNG_sPLT_SUPPORTED)
-/* free a given sPLT entry, or (if num == -1) all sPLT entries */
+ /* free a given sPLT entry, or (if num == -1) all sPLT entries */
#ifdef PNG_FREE_ME_SUPPORTED
-if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
+ if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
#else
-if (mask & PNG_FREE_SPLT)
+ if (mask & PNG_FREE_SPLT)
#endif
-{
- if (num != -1)
{
- if (info_ptr->splt_palettes)
+ if (num != -1)
{
- png_free(png_ptr, info_ptr->splt_palettes[num].name);
- png_free(png_ptr, info_ptr->splt_palettes[num].entries);
- info_ptr->splt_palettes[num].name = NULL;
- info_ptr->splt_palettes[num].entries = NULL;
+ if (info_ptr->splt_palettes)
+ {
+ png_free(png_ptr, info_ptr->splt_palettes[num].name);
+ png_free(png_ptr, info_ptr->splt_palettes[num].entries);
+ info_ptr->splt_palettes[num].name = NULL;
+ info_ptr->splt_palettes[num].entries = NULL;
+ }
+ }
+ else
+ {
+ if (info_ptr->splt_palettes_num)
+ {
+ int i;
+ for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
+ png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
+
+ png_free(png_ptr, info_ptr->splt_palettes);
+ info_ptr->splt_palettes = NULL;
+ info_ptr->splt_palettes_num = 0;
+ }
+ info_ptr->valid &= ~PNG_INFO_sPLT;
}
}
- else
- {
- if (info_ptr->splt_palettes_num)
- {
- int i;
- for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
- png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
-
- png_free(png_ptr, info_ptr->splt_palettes);
- info_ptr->splt_palettes = NULL;
- info_ptr->splt_palettes_num = 0;
- }
- info_ptr->valid &= ~PNG_INFO_sPLT;
- }
-}
#endif
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
- if (png_ptr->unknown_chunk.data)
- {
- png_free(png_ptr, png_ptr->unknown_chunk.data);
- png_ptr->unknown_chunk.data = NULL;
- }
+ if (png_ptr->unknown_chunk.data)
+ {
+ png_free(png_ptr, png_ptr->unknown_chunk.data);
+ png_ptr->unknown_chunk.data = NULL;
+ }
#ifdef PNG_FREE_ME_SUPPORTED
-if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
+ if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
#else
-if (mask & PNG_FREE_UNKN)
+ if (mask & PNG_FREE_UNKN)
#endif
-{
- if (num != -1)
{
- if (info_ptr->unknown_chunks)
- {
- png_free(png_ptr, info_ptr->unknown_chunks[num].data);
- info_ptr->unknown_chunks[num].data = NULL;
- }
- }
- else
- {
- int i;
+ if (num != -1)
+ {
+ if (info_ptr->unknown_chunks)
+ {
+ png_free(png_ptr, info_ptr->unknown_chunks[num].data);
+ info_ptr->unknown_chunks[num].data = NULL;
+ }
+ }
+ else
+ {
+ int i;
- if (info_ptr->unknown_chunks_num)
- {
- for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
- png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
+ if (info_ptr->unknown_chunks_num)
+ {
+ for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
+ png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
- png_free(png_ptr, info_ptr->unknown_chunks);
- info_ptr->unknown_chunks = NULL;
- info_ptr->unknown_chunks_num = 0;
- }
+ png_free(png_ptr, info_ptr->unknown_chunks);
+ info_ptr->unknown_chunks = NULL;
+ info_ptr->unknown_chunks_num = 0;
+ }
+ }
}
-}
#endif
#if defined(PNG_hIST_SUPPORTED)
-/* free any hIST entry */
+ /* free any hIST entry */
#ifdef PNG_FREE_ME_SUPPORTED
-if ((mask & PNG_FREE_HIST) & info_ptr->free_me)
+ if ((mask & PNG_FREE_HIST) & info_ptr->free_me)
#else
-if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
+ if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
#endif
-{
- png_free(png_ptr, info_ptr->hist);
- info_ptr->hist = NULL;
- info_ptr->valid &= ~PNG_INFO_hIST;
+ {
+ png_free(png_ptr, info_ptr->hist);
+ info_ptr->hist = NULL;
+ info_ptr->valid &= ~PNG_INFO_hIST;
#ifndef PNG_FREE_ME_SUPPORTED
- png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
+ png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
#endif
-}
+ }
#endif
-/* free any PLTE entry that was internally allocated */
+ /* free any PLTE entry that was internally allocated */
#ifdef PNG_FREE_ME_SUPPORTED
-if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
+ if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
#else
-if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
+ if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
#endif
-{
- png_zfree(png_ptr, info_ptr->palette);
- info_ptr->palette = NULL;
- info_ptr->valid &= ~PNG_INFO_PLTE;
+ {
+ png_zfree(png_ptr, info_ptr->palette);
+ info_ptr->palette = NULL;
+ info_ptr->valid &= ~PNG_INFO_PLTE;
#ifndef PNG_FREE_ME_SUPPORTED
- png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
+ png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
#endif
- info_ptr->num_palette = 0;
-}
+ info_ptr->num_palette = 0;
+ }
#if defined(PNG_INFO_IMAGE_SUPPORTED)
-/* free any image bits attached to the info structure */
+ /* free any image bits attached to the info structure */
#ifdef PNG_FREE_ME_SUPPORTED
-if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
+ if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
#else
-if (mask & PNG_FREE_ROWS)
+ if (mask & PNG_FREE_ROWS)
#endif
-{
- if (info_ptr->row_pointers)
- {
- int row;
- for (row = 0; row < (int)info_ptr->height; row++)
- {
- png_free(png_ptr, info_ptr->row_pointers[row]);
- }
- png_free(png_ptr, info_ptr->row_pointers);
- }
- info_ptr->valid &= ~PNG_INFO_IDAT;
-}
+ {
+ if (info_ptr->row_pointers)
+ {
+ int row;
+ for (row = 0; row < (int)info_ptr->height; row++)
+ {
+ png_free(png_ptr, info_ptr->row_pointers[row]);
+ }
+ png_free(png_ptr, info_ptr->row_pointers);
+ }
+ info_ptr->valid &= ~PNG_INFO_IDAT;
+ }
#endif
#ifdef PNG_FREE_ME_SUPPORTED
if (num == -1)
- info_ptr->free_me &= ~mask;
+ info_ptr->free_me &= ~mask;
else
- info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
+ info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
#endif
}
@@ -555,8 +560,8 @@
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
if (png_ptr->num_chunk_list)
{
- png_free(png_ptr, png_ptr->chunk_list);
- png_ptr->num_chunk_list = 0;
+ png_free(png_ptr, png_ptr->chunk_list);
+ png_ptr->num_chunk_list = 0;
}
#endif
@@ -571,7 +576,8 @@
png_voidp PNGAPI
png_get_io_ptr(png_structp png_ptr)
{
- if (png_ptr == NULL) return (NULL);
+ if (png_ptr == NULL)
+ return (NULL);
return (png_ptr->io_ptr);
}
@@ -587,7 +593,8 @@
png_init_io(png_structp png_ptr, png_FILE_p fp)
{
png_debug(1, "in png_init_io");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->io_ptr = (png_voidp)fp;
}
#endif
@@ -603,7 +610,8 @@
{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
- if (png_ptr == NULL) return (NULL);
+ if (png_ptr == NULL)
+ return (NULL);
if (png_ptr->time_buffer == NULL)
{
png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
@@ -641,13 +649,13 @@
#else
#ifdef __STDC__
return ((png_charp) PNG_STRING_NEWLINE \
- "libpng version x 1.4.0beta58 - May 14, 2009" PNG_STRING_NEWLINE \
+ "libpng version x 1.4.0beta59 - May 15, 2009" PNG_STRING_NEWLINE \
"Copyright (c) 1998-2009 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
"Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
"Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
PNG_STRING_NEWLINE);
#else
- return ((png_charp) "libpng version 1.4.0beta58 - May 14, 2009\
+ return ((png_charp) "libpng version 1.4.0beta59 - May 15, 2009\
Copyright (c) 1998-2009 Glenn Randers-Pehrson\
Copyright (c) 1996-1997 Andreas Dilger\
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.");
@@ -717,7 +725,8 @@
int PNGAPI
png_reset_zstream(png_structp png_ptr)
{
- if (png_ptr == NULL) return Z_STREAM_ERROR;
+ if (png_ptr == NULL)
+ return Z_STREAM_ERROR;
return (inflateReset(&png_ptr->zstream));
}
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
@@ -739,9 +748,9 @@
png_size_t PNGAPI
png_convert_size(size_t size)
{
- if (size > (png_size_t)-1)
- PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */
- return ((png_size_t)size);
+ if (size > (png_size_t)-1)
+ PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */
+ return ((png_size_t)size);
}
#endif /* PNG_SIZE_T */
@@ -750,43 +759,44 @@
#if !defined(PNG_NO_CHECK_cHRM)
/*
- Multiply two 32-bit numbers, V1 and V2, using 32-bit
- arithmetic, to produce a 64 bit result in the HI/LO words.
-
- A B
- x C D
- ------
- AD || BD
-AC || CB || 0
-
- where A and B are the high and low 16-bit words of V1,
- C and D are the 16-bit words of V2, AD is the product of
- A and D, and X || Y is (X << 16) + Y.
+ * Multiply two 32-bit numbers, V1 and V2, using 32-bit
+ * arithmetic, to produce a 64 bit result in the HI/LO words.
+ *
+ * A B
+ * x C D
+ * ------
+ * AD || BD
+ * AC || CB || 0
+ *
+ * where A and B are the high and low 16-bit words of V1,
+ * C and D are the 16-bit words of V2, AD is the product of
+ * A and D, and X || Y is (X << 16) + Y.
*/
void png_64bit_product (long v1, long v2, unsigned long *hi_product,
unsigned long *lo_product)
{
- int a, b, c, d;
- long lo, hi, x, y;
+ int a, b, c, d;
+ long lo, hi, x, y;
- a = (v1 >> 16) & 0xffff;
- b = v1 & 0xffff;
- c = (v2 >> 16) & 0xffff;
- d = v2 & 0xffff;
+ a = (v1 >> 16) & 0xffff;
+ b = v1 & 0xffff;
+ c = (v2 >> 16) & 0xffff;
+ d = v2 & 0xffff;
- lo = b * d; /* BD */
- x = a * d + c * b; /* AD + CB */
- y = ((lo >> 16) & 0xffff) + x;
+ lo = b * d; /* BD */
+ x = a * d + c * b; /* AD + CB */
+ y = ((lo >> 16) & 0xffff) + x;
- lo = (lo & 0xffff) | ((y & 0xffff) << 16);
- hi = (y >> 16) & 0xffff;
+ lo = (lo & 0xffff) | ((y & 0xffff) << 16);
+ hi = (y >> 16) & 0xffff;
- hi += a * c; /* AC */
+ hi += a * c; /* AC */
- *hi_product = (unsigned long)hi;
- *lo_product = (unsigned long)lo;
+ *hi_product = (unsigned long)hi;
+ *lo_product = (unsigned long)lo;
}
+
int /* private */
png_check_cHRM_fixed(png_structp png_ptr,
png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
diff --git a/pngerror.c b/pngerror.c
index d0cf557..c9dba8f 100644
--- a/pngerror.c
+++ b/pngerror.c
@@ -39,37 +39,37 @@
char msg[16];
if (png_ptr != NULL)
{
- if (png_ptr->flags&
- (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
- {
+ if (png_ptr->flags&
+ (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
+ {
if (*error_message == PNG_LITERAL_SHARP)
- {
- /* Strip "#nnnn " from beginning of error message. */
- int offset;
- for (offset = 1; offset<15; offset++)
- if (error_message[offset] == ' ')
- break;
- if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
- {
- int i;
- for (i = 0; i < offset - 1; i++)
- msg[i] = error_message[i + 1];
- msg[i - 1] = '\0';
- error_message = msg;
- }
- else
- error_message += offset;
- }
- else
- {
- if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
- {
- msg[0] = '0';
- msg[1] = '\0';
- error_message = msg;
- }
- }
- }
+ {
+ /* Strip "#nnnn " from beginning of error message. */
+ int offset;
+ for (offset = 1; offset<15; offset++)
+ if (error_message[offset] == ' ')
+ break;
+ if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+ {
+ int i;
+ for (i = 0; i < offset - 1; i++)
+ msg[i] = error_message[i + 1];
+ msg[i - 1] = '\0';
+ error_message = msg;
+ }
+ else
+ error_message += offset;
+ }
+ else
+ {
+ if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+ {
+ msg[0] = '0';
+ msg[1] = '\0';
+ error_message = msg;
+ }
+ }
+ }
}
#endif
if (png_ptr != NULL && png_ptr->error_fn != NULL)
@@ -108,14 +108,14 @@
if (png_ptr->flags&
(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
#endif
- {
- if (*warning_message == PNG_LITERAL_SHARP)
- {
- for (offset = 1; offset < 15; offset++)
- if (warning_message[offset] == ' ')
- break;
- }
- }
+ {
+ if (*warning_message == PNG_LITERAL_SHARP)
+ {
+ for (offset = 1; offset < 15; offset++)
+ if (warning_message[offset] == ' ')
+ break;
+ }
+ }
}
if (png_ptr != NULL && png_ptr->warning_fn != NULL)
(*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
@@ -128,10 +128,10 @@
void PNGAPI
png_benign_error(png_structp png_ptr, png_const_charp error_message)
{
- if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
- png_warning(png_ptr, error_message);
- else
- png_error(png_ptr, error_message);
+ if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
+ png_warning(png_ptr, error_message);
+ else
+ png_error(png_ptr, error_message);
}
#endif
@@ -189,11 +189,11 @@
{
char msg[18+PNG_MAX_ERROR_TEXT];
if (png_ptr == NULL)
- png_error(png_ptr, error_message);
+ png_error(png_ptr, error_message);
else
{
- png_format_buffer(png_ptr, msg, error_message);
- png_error(png_ptr, msg);
+ png_format_buffer(png_ptr, msg, error_message);
+ png_error(png_ptr, msg);
}
}
#endif /* PNG_READ_SUPPORTED */
@@ -205,11 +205,11 @@
{
char msg[18+PNG_MAX_ERROR_TEXT];
if (png_ptr == NULL)
- png_warning(png_ptr, warning_message);
+ png_warning(png_ptr, warning_message);
else
{
- png_format_buffer(png_ptr, msg, warning_message);
- png_warning(png_ptr, msg);
+ png_format_buffer(png_ptr, msg, warning_message);
+ png_warning(png_ptr, msg);
}
}
#endif /* PNG_NO_WARNINGS */
@@ -219,10 +219,10 @@
void PNGAPI
png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
{
- if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
- png_chunk_warning(png_ptr, error_message);
- else
- png_chunk_error(png_ptr, error_message);
+ if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
+ png_chunk_warning(png_ptr, error_message);
+ else
+ png_chunk_error(png_ptr, error_message);
}
#endif
#endif /* PNG_READ_SUPPORTED */
@@ -239,26 +239,28 @@
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
if (*error_message == PNG_LITERAL_SHARP)
{
- /* Strip "#nnnn " from beginning of error message. */
- int offset;
- char error_number[16];
- for (offset = 0; offset<15; offset++)
- {
+ /* Strip "#nnnn " from beginning of error message. */
+ int offset;
+ char error_number[16];
+ for (offset = 0; offset<15; offset++)
+ {
error_number[offset] = error_message[offset + 1];
if (error_message[offset] == ' ')
break;
- }
- if ((offset > 1) && (offset < 15))
- {
- error_number[offset - 1] = '\0';
- fprintf(stderr, "libpng error no. %s: %s",
- error_number, error_message + offset + 1);
- fprintf(stderr, PNG_STRING_NEWLINE);
- }
- else
- fprintf(stderr, "libpng error: %s, offset=%d",
- error_message, offset);
- fprintf(stderr, PNG_STRING_NEWLINE);
+ }
+ if ((offset > 1) && (offset < 15))
+ {
+ error_number[offset - 1] = '\0';
+ fprintf(stderr, "libpng error no. %s: %s",
+ error_number, error_message + offset + 1);
+ fprintf(stderr, PNG_STRING_NEWLINE);
+ }
+ else
+ {
+ fprintf(stderr, "libpng error: %s, offset=%d",
+ error_message, offset);
+ fprintf(stderr, PNG_STRING_NEWLINE);
+ }
}
else
#endif
@@ -302,33 +304,33 @@
# ifdef PNG_ERROR_NUMBERS_SUPPORTED
if (*warning_message == PNG_LITERAL_SHARP)
{
- int offset;
- char warning_number[16];
- for (offset = 0; offset < 15; offset++)
- {
- warning_number[offset] = warning_message[offset + 1];
- if (warning_message[offset] == ' ')
+ int offset;
+ char warning_number[16];
+ for (offset = 0; offset < 15; offset++)
+ {
+ warning_number[offset] = warning_message[offset + 1];
+ if (warning_message[offset] == ' ')
break;
- }
- if ((offset > 1) && (offset < 15))
- {
- warning_number[offset + 1] = '\0';
- fprintf(stderr, "libpng warning no. %s: %s",
- warning_number, warning_message + offset);
- fprintf(stderr, PNG_STRING_NEWLINE);
- }
- else
- {
- fprintf(stderr, "libpng warning: %s",
- warning_message);
- fprintf(stderr, PNG_STRING_NEWLINE);
- }
+ }
+ if ((offset > 1) && (offset < 15))
+ {
+ warning_number[offset + 1] = '\0';
+ fprintf(stderr, "libpng warning no. %s: %s",
+ warning_number, warning_message + offset);
+ fprintf(stderr, PNG_STRING_NEWLINE);
+ }
+ else
+ {
+ fprintf(stderr, "libpng warning: %s",
+ warning_message);
+ fprintf(stderr, PNG_STRING_NEWLINE);
+ }
}
else
# endif
{
- fprintf(stderr, "libpng warning: %s", warning_message);
- fprintf(stderr, PNG_STRING_NEWLINE);
+ fprintf(stderr, "libpng warning: %s", warning_message);
+ fprintf(stderr, PNG_STRING_NEWLINE);
}
#else
warning_message = warning_message; /* make compiler happy */
@@ -373,7 +375,7 @@
{
if (png_ptr != NULL)
{
- png_ptr->flags &=
+ png_ptr->flags &=
((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
}
}
diff --git a/pngget.c b/pngget.c
index e7745af..3db2db1 100644
--- a/pngget.c
+++ b/pngget.c
@@ -17,6 +17,7 @@
{
if (png_ptr != NULL && info_ptr != NULL)
return(info_ptr->valid & flag);
+
else
return(0);
}
@@ -26,6 +27,7 @@
{
if (png_ptr != NULL && info_ptr != NULL)
return(info_ptr->rowbytes);
+
else
return(0);
}
@@ -36,20 +38,20 @@
{
if (png_ptr != NULL && info_ptr != NULL)
return(info_ptr->row_pointers);
+
else
return(0);
}
#endif
#ifdef PNG_EASY_ACCESS_SUPPORTED
-/* easy access to info, added in libpng-0.99 */
+/* Easy access to info, added in libpng-0.99 */
png_uint_32 PNGAPI
png_get_image_width(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
- {
return info_ptr->width;
- }
+
return (0);
}
@@ -57,9 +59,8 @@
png_get_image_height(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
- {
return info_ptr->height;
- }
+
return (0);
}
@@ -67,9 +68,8 @@
png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
- {
return info_ptr->bit_depth;
- }
+
return (0);
}
@@ -77,9 +77,8 @@
png_get_color_type(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
- {
return info_ptr->color_type;
- }
+
return (0);
}
@@ -87,9 +86,8 @@
png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
- {
return info_ptr->filter_type;
- }
+
return (0);
}
@@ -97,9 +95,8 @@
png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
- {
return info_ptr->interlace_type;
- }
+
return (0);
}
@@ -107,9 +104,8 @@
png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
- {
return info_ptr->compression_type;
- }
+
return (0);
}
@@ -121,8 +117,10 @@
if (info_ptr->valid & PNG_INFO_pHYs)
{
png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter");
+
if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
return (0);
+
else return (info_ptr->x_pixels_per_unit);
}
#else
@@ -139,8 +137,10 @@
if (info_ptr->valid & PNG_INFO_pHYs)
{
png_debug1(1, "in %s retrieval function", "png_get_y_pixels_per_meter");
+
if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
return (0);
+
else return (info_ptr->y_pixels_per_unit);
}
#else
@@ -157,9 +157,11 @@
if (info_ptr->valid & PNG_INFO_pHYs)
{
png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
+
if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
return (0);
+
else return (info_ptr->x_pixels_per_unit);
}
#else
@@ -174,6 +176,7 @@
{
if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_pHYs_SUPPORTED)
+
if (info_ptr->valid & PNG_INFO_pHYs)
{
png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
@@ -184,7 +187,7 @@
/(float)info_ptr->x_pixels_per_unit));
}
#else
- return (0.0);
+ return (0.0);
#endif
return ((float)0.0);
}
@@ -195,15 +198,18 @@
{
if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED)
+
if (info_ptr->valid & PNG_INFO_oFFs)
{
png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
+
if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
return (0);
+
else return (info_ptr->x_offset);
}
#else
- return (0);
+ return (0);
#endif
return (0);
}
@@ -212,12 +218,15 @@
png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
+
#if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs)
{
png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
+
if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
return (0);
+
else return (info_ptr->y_offset);
}
#else
@@ -230,12 +239,15 @@
png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
+
#if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs)
{
png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
+
if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
return (0);
+
else return (info_ptr->x_offset);
}
#else
@@ -248,12 +260,15 @@
png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
+
#if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs)
{
png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
+
if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
return (0);
+
else return (info_ptr->y_offset);
}
#else
@@ -549,22 +564,29 @@
*height = info_ptr->height;
*bit_depth = info_ptr->bit_depth;
if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16)
- png_error(png_ptr, "Invalid bit depth");
+ png_error(png_ptr, "Invalid bit depth");
+
*color_type = info_ptr->color_type;
+
if (info_ptr->color_type > 6)
- png_error(png_ptr, "Invalid color type");
+ png_error(png_ptr, "Invalid color type");
+
if (compression_type != NULL)
*compression_type = info_ptr->compression_type;
+
if (filter_type != NULL)
*filter_type = info_ptr->filter_type;
+
if (interlace_type != NULL)
*interlace_type = info_ptr->interlace_type;
- /* check for potential overflow of rowbytes */
+ /* Check for potential overflow of rowbytes */
if (*width == 0 || *width > PNG_UINT_31_MAX)
png_error(png_ptr, "Invalid image width");
+
if (*height == 0 || *height > PNG_UINT_31_MAX)
png_error(png_ptr, "Invalid image height");
+
if (info_ptr->width > (PNG_UINT_32_MAX
>> 3) /* 8-byte RGBA pixels */
- 64 /* bigrowbuf hack */
@@ -575,6 +597,7 @@
png_warning(png_ptr,
"Width too large for libpng to process image data");
}
+
return (1);
}
return (0);
@@ -605,8 +628,8 @@
png_charp *units, png_charpp *params)
{
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
- && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
- nparams != NULL && units != NULL && params != NULL)
+ && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
+ nparams != NULL && units != NULL && params != NULL)
{
png_debug1(1, "in %s retrieval function", "pCAL");
*purpose = info_ptr->pcal_purpose;
@@ -629,7 +652,7 @@
int *unit, double *width, double *height)
{
if (png_ptr != NULL && info_ptr != NULL &&
- (info_ptr->valid & PNG_INFO_sCAL))
+ (info_ptr->valid & PNG_INFO_sCAL))
{
*unit = info_ptr->scal_unit;
*width = info_ptr->scal_pixel_width;
@@ -645,7 +668,7 @@
int *unit, png_charpp width, png_charpp height)
{
if (png_ptr != NULL && info_ptr != NULL &&
- (info_ptr->valid & PNG_INFO_sCAL))
+ (info_ptr->valid & PNG_INFO_sCAL))
{
*unit = info_ptr->scal_unit;
*width = info_ptr->scal_s_width;
@@ -669,16 +692,19 @@
(info_ptr->valid & PNG_INFO_pHYs))
{
png_debug1(1, "in %s retrieval function", "pHYs");
+
if (res_x != NULL)
{
*res_x = info_ptr->x_pixels_per_unit;
retval |= PNG_INFO_pHYs;
}
+
if (res_y != NULL)
{
*res_y = info_ptr->y_pixels_per_unit;
retval |= PNG_INFO_pHYs;
}
+
if (unit_type != NULL)
{
*unit_type = (int)info_ptr->phys_unit_type;
@@ -730,10 +756,13 @@
png_debug1(1, "in %s retrieval function",
(png_ptr->chunk_name[0] == '\0' ? "text"
: (png_const_charp)png_ptr->chunk_name));
+
if (text_ptr != NULL)
*text_ptr = info_ptr->text;
+
if (num_text != NULL)
*num_text = info_ptr->num_text;
+
return ((png_uint_32)info_ptr->num_text);
}
if (num_text != NULL)
@@ -773,6 +802,7 @@
*trans = info_ptr->trans;
retval |= PNG_INFO_tRNS;
}
+
if (trans_color != NULL)
*trans_color = &(info_ptr->trans_color);
}
@@ -783,6 +813,7 @@
*trans_color = &(info_ptr->trans_color);
retval |= PNG_INFO_tRNS;
}
+
if (trans != NULL)
*trans = NULL;
}
diff --git a/pngmem.c b/pngmem.c
index 6c18734..ad53ae0 100644
--- a/pngmem.c
+++ b/pngmem.c
@@ -40,11 +40,11 @@
png_voidp struct_ptr;
if (type == PNG_STRUCT_INFO)
- size = png_sizeof(png_info);
+ size = png_sizeof(png_info);
else if (type == PNG_STRUCT_PNG)
- size = png_sizeof(png_struct);
+ size = png_sizeof(png_struct);
else
- return (png_get_copyright(NULL));
+ return (png_get_copyright(NULL));
#ifdef PNG_USER_MEM_SUPPORTED
if (malloc_fn != NULL)
@@ -56,7 +56,7 @@
}
else
#endif /* PNG_USER_MEM_SUPPORTED */
- struct_ptr = (png_voidp)farmalloc(size);
+ struct_ptr = (png_voidp)farmalloc(size);
if (struct_ptr != NULL)
png_memset(struct_ptr, 0, size);
return (struct_ptr);
@@ -134,9 +134,9 @@
#ifdef PNG_USER_MEM_SUPPORTED
if (png_ptr->malloc_fn != NULL)
- ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
+ ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
else
- ret = (png_malloc_default(png_ptr, size));
+ ret = (png_malloc_default(png_ptr, size));
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
png_error(png_ptr, "Out of memory");
return (ret);
@@ -161,7 +161,7 @@
#endif
if (size != (size_t)size)
- ret = NULL;
+ ret = NULL;
else if (size == (png_uint_32)65536L)
{
if (png_ptr->offset_table == NULL)
@@ -282,9 +282,9 @@
}
/* free a pointer allocated by png_malloc(). In the default
- configuration, png_ptr is not used, but is passed in case it
- is needed. If ptr is NULL, return without taking any action. */
-
+ * configuration, png_ptr is not used, but is passed in case it
+ * is needed. If ptr is NULL, return without taking any action.
+ */
void PNGAPI
png_free(png_structp png_ptr, png_voidp ptr)
{
@@ -297,7 +297,8 @@
(*(png_ptr->free_fn))(png_ptr, ptr);
return;
}
- else png_free_default(png_ptr, ptr);
+ else
+ png_free_default(png_ptr, ptr);
}
void PNGAPI
@@ -305,7 +306,8 @@
{
#endif /* PNG_USER_MEM_SUPPORTED */
- if (png_ptr == NULL || ptr == NULL) return;
+ if (png_ptr == NULL || ptr == NULL)
+ return;
if (png_ptr->offset_table != NULL)
{
@@ -432,10 +434,11 @@
}
/* Allocate memory. For reasonable files, size should never exceed
- 64K. However, zlib may allocate more then 64K if you don't tell
- it not to. See zconf.h and png.h for more information. zlib does
- need to allocate exactly 64K, so whatever you call here must
- have the ability to do that. */
+ * 64K. However, zlib may allocate more then 64K if you don't tell
+ * it not to. See zconf.h and png.h for more information. zlib does
+ * need to allocate exactly 64K, so whatever you call here must
+ * have the ability to do that.
+ */
png_voidp PNGAPI
png_calloc(png_structp png_ptr, png_alloc_size_t size)
@@ -458,9 +461,9 @@
return (NULL);
if (png_ptr->malloc_fn != NULL)
- ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
+ ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
else
- ret = (png_malloc_default(png_ptr, size));
+ ret = (png_malloc_default(png_ptr, size));
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
png_error(png_ptr, "Out of Memory");
return (ret);
@@ -487,23 +490,23 @@
}
#endif
- /* Check for overflow */
+ /* Check for overflow */
#if defined(__TURBOC__) && !defined(__FLAT__)
- if (size != (unsigned long)size)
- ret = NULL;
- else
- ret = farmalloc(size);
+ if (size != (unsigned long)size)
+ ret = NULL;
+ else
+ ret = farmalloc(size);
#else
# if defined(_MSC_VER) && defined(MAXSEG_64K)
- if (size != (unsigned long)size)
- ret = NULL;
- else
- ret = halloc(size, 1);
+ if (size != (unsigned long)size)
+ ret = NULL;
+ else
+ ret = halloc(size, 1);
# else
- if (size != (size_t)size)
- ret = NULL;
- else
- ret = malloc((size_t)size);
+ if (size != (size_t)size)
+ ret = NULL;
+ else
+ ret = malloc((size_t)size);
# endif
#endif
@@ -516,7 +519,8 @@
}
/* Free a pointer allocated by png_malloc(). If ptr is NULL, return
- without taking any action. */
+ * without taking any action.
+ */
void PNGAPI
png_free(png_structp png_ptr, png_voidp ptr)
{
@@ -529,7 +533,8 @@
(*(png_ptr->free_fn))(png_ptr, ptr);
return;
}
- else png_free_default(png_ptr, ptr);
+ else
+ png_free_default(png_ptr, ptr);
}
void PNGAPI
png_free_default(png_structp png_ptr, png_voidp ptr)
@@ -562,7 +567,8 @@
{
png_voidp ptr;
png_uint_32 save_flags;
- if (png_ptr == NULL) return (NULL);
+ if (png_ptr == NULL)
+ return (NULL);
save_flags = png_ptr->flags;
png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
@@ -595,7 +601,8 @@
png_voidp PNGAPI
png_get_mem_ptr(png_structp png_ptr)
{
- if (png_ptr == NULL) return (NULL);
+ if (png_ptr == NULL)
+ return (NULL);
return ((png_voidp)png_ptr->mem_ptr);
}
#endif /* PNG_USER_MEM_SUPPORTED */
diff --git a/pngpread.c b/pngpread.c
index aed0a92..e7af70c 100644
--- a/pngpread.c
+++ b/pngpread.c
@@ -27,7 +27,9 @@
png_process_data(png_structp png_ptr, png_infop info_ptr,
png_bytep buffer, png_size_t buffer_size)
{
- if (png_ptr == NULL || info_ptr == NULL) return;
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
+
png_push_restore_buffer(png_ptr, buffer, buffer_size);
while (png_ptr->buffer_size)
@@ -42,7 +44,9 @@
void /* PRIVATE */
png_process_some_data(png_structp png_ptr, png_infop info_ptr)
{
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
+
switch (png_ptr->process_mode)
{
case PNG_READ_SIG_MODE:
@@ -50,22 +54,26 @@
png_push_read_sig(png_ptr, info_ptr);
break;
}
+
case PNG_READ_CHUNK_MODE:
{
png_push_read_chunk(png_ptr, info_ptr);
break;
}
+
case PNG_READ_IDAT_MODE:
{
png_push_read_IDAT(png_ptr);
break;
}
+
#if defined(PNG_READ_tEXt_SUPPORTED)
case PNG_READ_tEXt_MODE:
{
png_push_read_tEXt(png_ptr, info_ptr);
break;
}
+
#endif
#if defined(PNG_READ_zTXt_SUPPORTED)
case PNG_READ_zTXt_MODE:
@@ -73,6 +81,7 @@
png_push_read_zTXt(png_ptr, info_ptr);
break;
}
+
#endif
#if defined(PNG_READ_iTXt_SUPPORTED)
case PNG_READ_iTXt_MODE:
@@ -80,12 +89,14 @@
png_push_read_iTXt(png_ptr, info_ptr);
break;
}
+
#endif
case PNG_SKIP_MODE:
{
png_push_crc_finish(png_ptr);
break;
}
+
default:
{
png_ptr->buffer_size = 0;
@@ -224,13 +235,16 @@
{
if (png_ptr->push_length != 13)
png_error(png_ptr, "Invalid IHDR length");
+
if (png_ptr->push_length + 4 > png_ptr->buffer_size)
{
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
}
+
else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
{
if (png_ptr->push_length + 4 > png_ptr->buffer_size)
@@ -238,11 +252,13 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
png_ptr->process_mode = PNG_READ_DONE_MODE;
png_push_have_end(png_ptr, info_ptr);
}
+
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
{
@@ -251,20 +267,26 @@
png_push_save_buffer(png_ptr);
return;
}
+
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
png_ptr->mode |= PNG_HAVE_IDAT;
+
png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
+
if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
png_ptr->mode |= PNG_HAVE_PLTE;
+
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
{
if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before IDAT");
+
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE))
png_error(png_ptr, "Missing PLTE before IDAT");
}
}
+
#endif
else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
{
@@ -275,23 +297,26 @@
}
png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
}
+
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
{
/* If we reach an IDAT chunk, this means we have read all of the
* header chunks, and we can start reading the image (or if this
* is called after the image has been read - we have an error).
*/
- if (!(png_ptr->mode & PNG_HAVE_IHDR))
- png_error(png_ptr, "Missing IHDR before IDAT");
- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
- !(png_ptr->mode & PNG_HAVE_PLTE))
- png_error(png_ptr, "Missing PLTE before IDAT");
+
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))
+ png_error(png_ptr, "Missing IHDR before IDAT");
+
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+ !(png_ptr->mode & PNG_HAVE_PLTE))
+ png_error(png_ptr, "Missing PLTE before IDAT");
if (png_ptr->mode & PNG_HAVE_IDAT)
{
if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
- if (png_ptr->push_length == 0)
- return;
+ if (png_ptr->push_length == 0)
+ return;
if (png_ptr->mode & PNG_AFTER_IDAT)
png_benign_error(png_ptr, "Too many IDATs found");
@@ -305,6 +330,7 @@
png_ptr->zstream.next_out = png_ptr->row_buf;
return;
}
+
#if defined(PNG_READ_gAMA_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
{
@@ -313,8 +339,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_sBIT_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
@@ -324,8 +352,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_cHRM_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
@@ -335,8 +365,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_sRGB_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
@@ -346,8 +378,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_iCCP_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
@@ -357,8 +391,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_sPLT_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
@@ -368,8 +404,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_tRNS_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
@@ -379,8 +417,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_bKGD_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
@@ -390,8 +430,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_hIST_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
@@ -401,8 +443,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_pHYs_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
@@ -412,8 +456,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_oFFs_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
@@ -423,9 +469,11 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
}
#endif
+
#if defined(PNG_READ_pCAL_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
{
@@ -434,8 +482,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_sCAL_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
@@ -445,8 +495,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_tIME_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
@@ -456,8 +508,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_tEXt_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
@@ -467,8 +521,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_zTXt_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
@@ -478,8 +534,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
#if defined(PNG_READ_iTXt_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
@@ -489,8 +547,10 @@
png_push_save_buffer(png_ptr);
return;
}
+
png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
}
+
#endif
else
{
@@ -565,7 +625,9 @@
{
png_bytep ptr;
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
+
ptr = buffer;
if (png_ptr->save_buffer_size)
{
@@ -589,6 +651,7 @@
if (length < png_ptr->current_buffer_size)
save_size = length;
+
else
save_size = png_ptr->current_buffer_size;
@@ -629,6 +692,7 @@
{
png_error(png_ptr, "Potential overflow of save_buffer");
}
+
new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
old_buffer = png_ptr->save_buffer;
png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,
@@ -697,6 +761,7 @@
if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)
{
save_size = (png_size_t)png_ptr->idat_size;
+
/* check for overflow */
if ((png_uint_32)save_size != png_ptr->idat_size)
png_error(png_ptr, "save_size overflowed in pngpread");
@@ -705,8 +770,10 @@
save_size = png_ptr->save_buffer_size;
png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
+
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
+
png_ptr->idat_size -= save_size;
png_ptr->buffer_size -= save_size;
png_ptr->save_buffer_size -= save_size;
@@ -719,6 +786,7 @@
if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)
{
save_size = (png_size_t)png_ptr->idat_size;
+
/* check for overflow */
if ((png_uint_32)save_size != png_ptr->idat_size)
png_error(png_ptr, "save_size overflowed in pngpread");
@@ -769,6 +837,7 @@
{
if (png_ptr->zstream.avail_in)
png_benign_error(png_ptr, "Extra compressed data");
+
if (!(png_ptr->zstream.avail_out))
{
png_push_process_row(png_ptr);
@@ -780,6 +849,7 @@
}
else if (ret == Z_BUF_ERROR)
break;
+
else
png_error(png_ptr, "Decompression Error");
}
@@ -801,6 +871,7 @@
png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
png_ptr->zstream.next_out = png_ptr->row_buf;
}
+
else
break;
}
@@ -848,6 +919,7 @@
png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */
}
+
if (png_ptr->pass == 2) /* pass 1 might be empty */
{
for (i = 0; i < 4 && png_ptr->pass == 2; i++)
@@ -856,6 +928,7 @@
png_read_push_finish_row(png_ptr);
}
}
+
if (png_ptr->pass == 4 && png_ptr->height <= 4)
{
for (i = 0; i < 2 && png_ptr->pass == 4; i++)
@@ -864,13 +937,16 @@
png_read_push_finish_row(png_ptr);
}
}
+
if (png_ptr->pass == 6 && png_ptr->height <= 4)
{
png_push_have_row(png_ptr, NULL);
png_read_push_finish_row(png_ptr);
}
+
break;
}
+
case 1:
{
int i;
@@ -879,6 +955,7 @@
png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr);
}
+
if (png_ptr->pass == 2) /* skip top 4 generated rows */
{
for (i = 0; i < 4 && png_ptr->pass == 2; i++)
@@ -887,21 +964,26 @@
png_read_push_finish_row(png_ptr);
}
}
+
break;
}
+
case 2:
{
int i;
+
for (i = 0; i < 4 && png_ptr->pass == 2; i++)
{
png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr);
}
+
for (i = 0; i < 4 && png_ptr->pass == 2; i++)
{
png_push_have_row(png_ptr, NULL);
png_read_push_finish_row(png_ptr);
}
+
if (png_ptr->pass == 4) /* pass 3 might be empty */
{
for (i = 0; i < 2 && png_ptr->pass == 4; i++)
@@ -910,16 +992,20 @@
png_read_push_finish_row(png_ptr);
}
}
+
break;
}
+
case 3:
{
int i;
+
for (i = 0; i < 4 && png_ptr->pass == 3; i++)
{
png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr);
}
+
if (png_ptr->pass == 4) /* skip top two generated rows */
{
for (i = 0; i < 2 && png_ptr->pass == 4; i++)
@@ -928,49 +1014,61 @@
png_read_push_finish_row(png_ptr);
}
}
+
break;
}
+
case 4:
{
int i;
+
for (i = 0; i < 2 && png_ptr->pass == 4; i++)
{
png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr);
}
+
for (i = 0; i < 2 && png_ptr->pass == 4; i++)
{
png_push_have_row(png_ptr, NULL);
png_read_push_finish_row(png_ptr);
}
+
if (png_ptr->pass == 6) /* pass 5 might be empty */
{
png_push_have_row(png_ptr, NULL);
png_read_push_finish_row(png_ptr);
}
+
break;
}
+
case 5:
{
int i;
+
for (i = 0; i < 2 && png_ptr->pass == 5; i++)
{
png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr);
}
+
if (png_ptr->pass == 6) /* skip top generated row */
{
png_push_have_row(png_ptr, NULL);
png_read_push_finish_row(png_ptr);
}
+
break;
}
case 6:
{
png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr);
+
if (png_ptr->pass != 6)
break;
+
png_push_have_row(png_ptr, NULL);
png_read_push_finish_row(png_ptr);
}
@@ -988,18 +1086,18 @@
png_read_push_finish_row(png_structp png_ptr)
{
#ifdef PNG_USE_LOCAL_ARRAYS
- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
- /* start of interlace block */
+ /* Start of interlace block */
PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
- /* offset to next interlace block */
+ /* Offset to next interlace block */
PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
- /* start of interlace block in the y direction */
+ /* Start of interlace block in the y direction */
PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
- /* offset to next interlace block in the y direction */
+ /* Offset to next interlace block in the y direction */
PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
/* Height of interlace block. This is not currently used - if you need
@@ -1016,6 +1114,7 @@
{
png_ptr->row_number = 0;
png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
+
do
{
png_ptr->pass++;
@@ -1026,6 +1125,7 @@
if (png_ptr->pass > 7)
png_ptr->pass--;
+
if (png_ptr->pass >= 7)
break;
@@ -1089,8 +1189,10 @@
if (png_ptr->buffer_size < png_ptr->current_text_left)
text_size = png_ptr->buffer_size;
+
else
text_size = png_ptr->current_text_left;
+
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
png_ptr->current_text_left -= text_size;
png_ptr->current_text_ptr += text_size;
@@ -1187,8 +1289,10 @@
if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
text_size = png_ptr->buffer_size;
+
else
text_size = png_ptr->current_text_left;
+
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
png_ptr->current_text_left -= text_size;
png_ptr->current_text_ptr += text_size;
@@ -1263,11 +1367,15 @@
text = (png_charp)png_malloc(png_ptr,
(png_ptr->zbuf_size
- png_ptr->zstream.avail_out + key_size + 1));
+
png_memcpy(text + key_size, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+
png_memcpy(text, key, key_size);
+
text_size = key_size + png_ptr->zbuf_size -
png_ptr->zstream.avail_out;
+
*(text + text_size) = '\0';
}
else
@@ -1278,10 +1386,13 @@
text = (png_charp)png_malloc(png_ptr, text_size +
(png_ptr->zbuf_size
- png_ptr->zstream.avail_out + 1));
+
png_memcpy(text, tmp, text_size);
png_free(png_ptr, tmp);
+
png_memcpy(text + text_size, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out);
+
text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
*(text + text_size) = '\0';
}
@@ -1378,8 +1489,10 @@
if (png_ptr->buffer_size < png_ptr->current_text_left)
text_size = png_ptr->buffer_size;
+
else
text_size = png_ptr->current_text_left;
+
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
png_ptr->current_text_left -= text_size;
png_ptr->current_text_ptr += text_size;
@@ -1420,9 +1533,11 @@
for (lang_key = lang; *lang_key; lang_key++)
/* empty loop */ ;
+
lang_key++; /* skip NUL separator */
text=lang_key;
+
if (lang_key < key + png_ptr->current_text_size - 1)
{
for (; *text; text++)
@@ -1434,6 +1549,7 @@
text_ptr = (png_textp)png_malloc(png_ptr,
png_sizeof(png_text));
+
text_ptr->compression = comp_flag + 2;
text_ptr->key = key;
text_ptr->lang = lang;
@@ -1496,14 +1612,17 @@
= '\0';
png_ptr->unknown_chunk.size = (png_size_t)length;
+
if (length == 0)
png_ptr->unknown_chunk.data = NULL;
+
else
{
png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,
(png_size_t)length);
png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
}
+
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
if (png_ptr->read_user_chunk_fn != NULL)
{
@@ -1511,8 +1630,10 @@
int ret;
ret = (*(png_ptr->read_user_chunk_fn))
(png_ptr, &png_ptr->unknown_chunk);
+
if (ret < 0)
png_chunk_error(png_ptr, "error in user chunk");
+
if (ret == 0)
{
if (!(png_ptr->chunk_name[0] & 0x20))
@@ -1523,12 +1644,14 @@
&png_ptr->unknown_chunk, 1);
}
}
+
else
#endif
png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
png_free(png_ptr, png_ptr->unknown_chunk.data);
png_ptr->unknown_chunk.data = NULL;
}
+
else
#endif
skip=length;
@@ -1565,7 +1688,9 @@
PNG_CONST int FARDATA png_pass_dsp_mask[7] =
{0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
#endif
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
+
if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */
png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
}
@@ -1575,7 +1700,9 @@
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
png_progressive_end_ptr end_fn)
{
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
+
png_ptr->info_fn = info_fn;
png_ptr->row_fn = row_fn;
png_ptr->end_fn = end_fn;
@@ -1586,7 +1713,9 @@
png_voidp PNGAPI
png_get_progressive_ptr(png_structp png_ptr)
{
- if (png_ptr == NULL) return (NULL);
+ if (png_ptr == NULL)
+ return (NULL);
+
return png_ptr->io_ptr;
}
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
diff --git a/pngread.c b/pngread.c
index bfa5c50..e3d1ad5 100644
--- a/pngread.c
+++ b/pngread.c
@@ -74,7 +74,7 @@
#else
if (setjmp(png_ptr->jmpbuf))
#endif
- PNG_ABORT();
+ PNG_ABORT();
#endif
#ifdef PNG_USER_MEM_SUPPORTED
@@ -85,50 +85,50 @@
if (user_png_ver)
{
- i = 0;
- do
- {
- if (user_png_ver[i] != png_libpng_ver[i])
- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
- } while (png_libpng_ver[i++]);
- }
- else
- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+ i = 0;
+ do
+ {
+ if (user_png_ver[i] != png_libpng_ver[i])
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+ } while (png_libpng_ver[i++]);
+ }
+ else
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
- if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
- {
- /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
- * we must recompile any applications that use any older library version.
- * For versions after libpng 1.0, we will be compatible, so we need
- * only check the first digit.
- */
- if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
- (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
- (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
- {
+ if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
+ {
+ /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
+ * we must recompile any applications that use any older library version.
+ * For versions after libpng 1.0, we will be compatible, so we need
+ * only check the first digit.
+ */
+ if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
+ (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
+ (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
+ {
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
- char msg[80];
- if (user_png_ver)
- {
- png_snprintf(msg, 80,
- "Application was compiled with png.h from libpng-%.20s",
- user_png_ver);
- png_warning(png_ptr, msg);
- }
- png_snprintf(msg, 80,
+ char msg[80];
+ if (user_png_ver)
+ {
+ png_snprintf(msg, 80,
+ "Application was compiled with png.h from libpng-%.20s",
+ user_png_ver);
+ png_warning(png_ptr, msg);
+ }
+ png_snprintf(msg, 80,
"Application is running with png.c from libpng-%.20s",
- png_libpng_ver);
- png_warning(png_ptr, msg);
+ png_libpng_ver);
+ png_warning(png_ptr, msg);
#endif
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
- png_ptr->flags = 0;
+ png_ptr->flags = 0;
#endif
- png_warning(png_ptr,
- "Incompatible libpng version in application and library");
+ png_warning(png_ptr,
+ "Incompatible libpng version in application and library");
- png_cleanup_needed = 1;
- }
+ png_cleanup_needed = 1;
+ }
}
if (!png_cleanup_needed)
@@ -146,17 +146,17 @@
if (!png_cleanup_needed)
{
- switch (inflateInit(&png_ptr->zstream))
- {
- case Z_OK: /* Do nothing */ break;
- case Z_MEM_ERROR:
- case Z_STREAM_ERROR: png_warning(png_ptr, "zlib memory error");
- png_cleanup_needed = 1; break;
- case Z_VERSION_ERROR: png_warning(png_ptr, "zlib version error");
- png_cleanup_needed = 1; break;
- default: png_warning(png_ptr, "Unknown zlib error");
- png_cleanup_needed = 1;
- }
+ switch (inflateInit(&png_ptr->zstream))
+ {
+ case Z_OK: /* Do nothing */ break;
+ case Z_MEM_ERROR:
+ case Z_STREAM_ERROR: png_warning(png_ptr, "zlib memory error");
+ png_cleanup_needed = 1; break;
+ case Z_VERSION_ERROR: png_warning(png_ptr, "zlib version error");
+ png_cleanup_needed = 1; break;
+ default: png_warning(png_ptr, "Unknown zlib error");
+ png_cleanup_needed = 1;
+ }
}
if (png_cleanup_needed)
@@ -195,7 +195,8 @@
void PNGAPI
png_read_info(png_structp png_ptr, png_infop info_ptr)
{
- if (png_ptr == NULL || info_ptr == NULL) return;
+ if (png_ptr == NULL || info_ptr == NULL)
+ return;
png_debug(1, "in png_read_info");
/* If we haven't checked all of the PNG signature bytes, do so now. */
if (png_ptr->sig_bytes < 8)
@@ -407,7 +408,8 @@
png_read_update_info(png_structp png_ptr, png_infop info_ptr)
{
png_debug(1, "in png_read_update_info");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_read_start_row(png_ptr);
else
@@ -426,7 +428,8 @@
png_start_read_image(png_structp png_ptr)
{
png_debug(1, "in png_start_read_image");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_read_start_row(png_ptr);
}
@@ -443,7 +446,8 @@
PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
#endif
int ret;
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_debug2(1, "in png_read_row (row %lu, pass %d)",
(unsigned long) png_ptr->row_number, png_ptr->pass);
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
@@ -633,10 +637,10 @@
(png_ptr->transformations & PNG_INTERLACE))
{
if (png_ptr->pass < 6)
-/* old interface (pre-1.0.9):
- png_do_read_interlace(&(png_ptr->row_info),
- png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
- */
+ /* old interface (pre-1.0.9):
+ * png_do_read_interlace(&(png_ptr->row_info),
+ * png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
+ */
png_do_read_interlace(png_ptr);
if (dsp_row != NULL)
@@ -695,7 +699,8 @@
png_bytepp dp;
png_debug(1, "in png_read_rows");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
rp = row;
dp = display_row;
if (rp != NULL && dp != NULL)
@@ -744,7 +749,8 @@
png_bytepp rp;
png_debug(1, "in png_read_image");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
#ifdef PNG_READ_INTERLACING_SUPPORTED
pass = png_set_interlace_handling(png_ptr);
@@ -780,7 +786,8 @@
png_read_end(png_structp png_ptr, png_infop info_ptr)
{
png_debug(1, "in png_read_end");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
do
@@ -1168,7 +1175,8 @@
void PNGAPI
png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
{
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->read_row_fn = read_row_fn;
}
@@ -1182,7 +1190,8 @@
{
int row;
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
/* invert the alpha channel from opacity to transparency
*/
@@ -1200,10 +1209,10 @@
/* -------------- image transformations start here ------------------- */
#if defined(PNG_READ_16_TO_8_SUPPORTED)
- /* tell libpng to strip 16 bit/color files down to 8 bits per color
+ /* Tell libpng to strip 16 bit/color files down to 8 bits per color.
*/
if (transforms & PNG_TRANSFORM_STRIP_16)
- png_set_strip_16(png_ptr);
+ png_set_strip_16(png_ptr);
#endif
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
@@ -1211,7 +1220,7 @@
* the background (not recommended).
*/
if (transforms & PNG_TRANSFORM_STRIP_ALPHA)
- png_set_strip_alpha(png_ptr);
+ png_set_strip_alpha(png_ptr);
#endif
#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)
@@ -1219,7 +1228,7 @@
* byte into separate bytes (useful for paletted and grayscale images).
*/
if (transforms & PNG_TRANSFORM_PACKING)
- png_set_packing(png_ptr);
+ png_set_packing(png_ptr);
#endif
#if defined(PNG_READ_PACKSWAP_SUPPORTED)
@@ -1227,7 +1236,7 @@
* (not useful if you are using png_set_packing).
*/
if (transforms & PNG_TRANSFORM_PACKSWAP)
- png_set_packswap(png_ptr);
+ png_set_packswap(png_ptr);
#endif
#if defined(PNG_READ_EXPAND_SUPPORTED)
@@ -1237,9 +1246,9 @@
* channels so the data will be available as RGBA quartets.
*/
if (transforms & PNG_TRANSFORM_EXPAND)
- if ((png_ptr->bit_depth < 8) ||
- (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||
- (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
+ if ((png_ptr->bit_depth < 8) ||
+ (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||
+ (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
png_set_expand(png_ptr);
#endif
@@ -1250,7 +1259,7 @@
/* invert monochrome files to have 0 as white and 1 as black
*/
if (transforms & PNG_TRANSFORM_INVERT_MONO)
- png_set_invert_mono(png_ptr);
+ png_set_invert_mono(png_ptr);
#endif
#if defined(PNG_READ_SHIFT_SUPPORTED)
@@ -1272,7 +1281,7 @@
/* flip the RGB pixels to BGR (or RGBA to BGRA)
*/
if (transforms & PNG_TRANSFORM_BGR)
- png_set_bgr(png_ptr);
+ png_set_bgr(png_ptr);
#endif
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
@@ -1286,7 +1295,7 @@
/* swap bytes of 16 bit files to least significant byte first
*/
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
- png_set_swap(png_ptr);
+ png_set_swap(png_ptr);
#endif
/* We don't handle adding filler bytes */
@@ -1324,7 +1333,7 @@
png_read_image(png_ptr, info_ptr->row_pointers);
info_ptr->valid |= PNG_INFO_IDAT;
- /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
+ /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
png_read_end(png_ptr, info_ptr);
transforms = transforms; /* quiet compiler warnings */
diff --git a/pngrio.c b/pngrio.c
index ffae152..61b2aef 100644
--- a/pngrio.c
+++ b/pngrio.c
@@ -20,10 +20,11 @@
#include "pngpriv.h"
/* Read the data from whatever input you are using. The default routine
- reads from a file pointer. Note that this routine sometimes gets called
- with very small lengths, so you should implement some kind of simple
- buffering if you are using unbuffered reads. This should never be asked
- to read more then 64K on a 16 bit machine. */
+ * reads from a file pointer. Note that this routine sometimes gets called
+ * with very small lengths, so you should implement some kind of simple
+ * buffering if you are using unbuffered reads. This should never be asked
+ * to read more then 64K on a 16 bit machine.
+ */
void /* PRIVATE */
png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
@@ -36,16 +37,18 @@
#if !defined(PNG_NO_STDIO)
/* This is the function that does the actual reading of data. If you are
- not reading from a standard C stream, you should create a replacement
- read_data function and use it at run time with png_set_read_fn(), rather
- than changing the library. */
+ * not reading from a standard C stream, you should create a replacement
+ * read_data function and use it at run time with png_set_read_fn(), rather
+ * than changing the library.
+ */
#ifndef USE_FAR_KEYWORD
void PNGAPI
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
png_size_t check;
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
/* fread() returns 0 on error, so it is OK to store this in a png_size_t
* instead of an int, which is what fread() actually returns.
*/
@@ -55,7 +58,7 @@
png_error(png_ptr, "Read Error");
}
#else
-/* this is the model-independent version. Since the standard I/O library
+/* This is the model-independent version. Since the standard I/O library
can't handle far buffers in the medium and small models, we have to copy
the data.
*/
@@ -70,7 +73,8 @@
png_byte *n_data;
png_FILE_p io_ptr;
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
/* Check if data really is near. If so, use usual code. */
n_data = (png_byte *)CVT_PTR_NOCHECK(data);
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
@@ -105,25 +109,27 @@
#endif
/* This function allows the application to supply a new input function
- for libpng if standard C streams aren't being used.
-
- This function takes as its arguments:
- png_ptr - pointer to a png input data structure
- io_ptr - pointer to user supplied structure containing info about
- the input functions. May be NULL.
- read_data_fn - pointer to a new input function that takes as its
- arguments a pointer to a png_struct, a pointer to
- a location where input data can be stored, and a 32-bit
- unsigned int that is the number of bytes to be read.
- To exit and output any fatal error messages the new write
- function should call png_error(png_ptr, "Error msg").
- May be NULL, in which case libpng's default function will
- be used. */
+ * for libpng if standard C streams aren't being used.
+ *
+ * This function takes as its arguments:
+ * png_ptr - pointer to a png input data structure
+ * io_ptr - pointer to user supplied structure containing info about
+ * the input functions. May be NULL.
+ * read_data_fn - pointer to a new input function that takes as its
+ * arguments a pointer to a png_struct, a pointer to
+ * a location where input data can be stored, and a 32-bit
+ * unsigned int that is the number of bytes to be read.
+ * To exit and output any fatal error messages the new write
+ * function should call png_error(png_ptr, "Error msg").
+ * May be NULL, in which case libpng's default function will
+ * be used.
+ */
void PNGAPI
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
png_rw_ptr read_data_fn)
{
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->io_ptr = io_ptr;
#if !defined(PNG_NO_STDIO)
diff --git a/pngrtran.c b/pngrtran.c
index c775af4..ca24629 100644
--- a/pngrtran.c
+++ b/pngrtran.c
@@ -23,24 +23,29 @@
{
png_debug(1, "in png_set_crc_action");
/* Tell libpng how we react to CRC errors in critical chunks */
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
switch (crit_action)
{
case PNG_CRC_NO_CHANGE: /* leave setting as is */
break;
+
case PNG_CRC_WARN_USE: /* warn/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
break;
+
case PNG_CRC_QUIET_USE: /* quiet/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
PNG_FLAG_CRC_CRITICAL_IGNORE;
break;
+
case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */
png_warning(png_ptr,
"Can't discard critical data on CRC error");
case PNG_CRC_ERROR_QUIT: /* error/quit */
+
case PNG_CRC_DEFAULT:
default:
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
@@ -51,20 +56,25 @@
{
case PNG_CRC_NO_CHANGE: /* leave setting as is */
break;
+
case PNG_CRC_WARN_USE: /* warn/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
break;
+
case PNG_CRC_QUIET_USE: /* quiet/use data */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
PNG_FLAG_CRC_ANCILLARY_NOWARN;
break;
+
case PNG_CRC_ERROR_QUIT: /* error/quit */
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
break;
+
case PNG_CRC_WARN_DISCARD: /* warn/discard data */
+
case PNG_CRC_DEFAULT:
default:
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
@@ -81,7 +91,8 @@
int need_expand, double background_gamma)
{
png_debug(1, "in png_set_background");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
{
png_warning(png_ptr, "Application must supply a known background gamma");
@@ -98,12 +109,13 @@
#endif
#if defined(PNG_READ_16_TO_8_SUPPORTED)
-/* strip 16 bit depth files to 8 bit depth */
+/* Strip 16 bit depth files to 8 bit depth */
void PNGAPI
png_set_strip_16(png_structp png_ptr)
{
png_debug(1, "in png_set_strip_16");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= PNG_16_TO_8;
}
#endif
@@ -113,7 +125,8 @@
png_set_strip_alpha(png_structp png_ptr)
{
png_debug(1, "in png_set_strip_alpha");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;
}
#endif
@@ -123,7 +136,8 @@
png_set_premultiply_alpha(png_structp png_ptr)
{
png_debug(1, "in png_set_premultiply_alpha");
- if(png_ptr == NULL) return;
+ if(png_ptr == NULL)
+ return;
png_ptr->transformations |=
(PNG_PREMULTIPLY_ALPHA | PNG_EXPAND_tRNS);
png_ptr->transformations |=
@@ -157,7 +171,8 @@
int full_dither)
{
png_debug(1, "in png_set_dither");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= PNG_DITHER;
if (!full_dither)
@@ -175,7 +190,8 @@
if (histogram != NULL)
{
/* This is easy enough, just throw out the least used colors.
- Perhaps not the best solution, but good enough. */
+ * Perhaps not the best solution, but good enough.
+ */
int i;
@@ -188,10 +204,11 @@
png_ptr->dither_sort[i] = (png_byte)i;
/* Find the least used palette entries by starting a
- bubble sort, and running it until we have sorted
- out enough colors. Note that we don't care about
- sorting all the colors, just finding which are
- least used. */
+ * bubble sort, and running it until we have sorted
+ * out enough colors. Note that we don't care about
+ * sorting all the colors, just finding which are
+ * least used.
+ */
for (i = num_palette - 1; i >= maximum_colors; i--)
{
@@ -216,13 +233,14 @@
break;
}
- /* swap the palette around, and set up a table, if necessary */
+ /* Swap the palette around, and set up a table, if necessary */
if (full_dither)
{
int j = num_palette;
- /* put all the useful colors within the max, but don't
- move the others */
+ /* Put all the useful colors within the max, but don't
+ * move the others.
+ */
for (i = 0; i < maximum_colors; i++)
{
if ((int)png_ptr->dither_sort[i] >= maximum_colors)
@@ -238,11 +256,12 @@
{
int j = num_palette;
- /* move all the used colors inside the max limit, and
- develop a translation table */
+ /* Move all the used colors inside the max limit, and
+ * develop a translation table.
+ */
for (i = 0; i < maximum_colors; i++)
{
- /* only move the colors we need to */
+ /* Only move the colors we need to */
if ((int)png_ptr->dither_sort[i] >= maximum_colors)
{
png_color tmp_color;
@@ -254,20 +273,20 @@
tmp_color = palette[j];
palette[j] = palette[i];
palette[i] = tmp_color;
- /* indicate where the color went */
+ /* Indicate where the color went */
png_ptr->dither_index[j] = (png_byte)i;
png_ptr->dither_index[i] = (png_byte)j;
}
}
- /* find closest color for those colors we are not using */
+ /* Find closest color for those colors we are not using */
for (i = 0; i < num_palette; i++)
{
if ((int)png_ptr->dither_index[i] >= maximum_colors)
{
int min_d, k, min_k, d_index;
- /* find the closest color to one we threw out */
+ /* Find the closest color to one we threw out */
d_index = png_ptr->dither_index[i];
min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
for (k = 1, min_k = 0; k < maximum_colors; k++)
@@ -282,7 +301,7 @@
min_k = k;
}
}
- /* point to closest color */
+ /* Point to closest color */
png_ptr->dither_index[i] = (png_byte)min_k;
}
}
@@ -293,13 +312,13 @@
else
{
/* This is much harder to do simply (and quickly). Perhaps
- we need to go through a median cut routine, but those
- don't always behave themselves with only a few colors
- as input. So we will just find the closest two colors,
- and throw out one of them (chosen somewhat randomly).
- [We don't understand this at all, so if someone wants to
- work on improving it, be our guest - AED, GRP]
- */
+ * we need to go through a median cut routine, but those
+ * don't always behave themselves with only a few colors
+ * as input. So we will just find the closest two colors,
+ * and throw out one of them (chosen somewhat randomly).
+ * [We don't understand this at all, so if someone wants to
+ * work on improving it, be our guest - AED, GRP]
+ */
int i;
int max_d;
int num_new_palette;
@@ -308,13 +327,13 @@
t = NULL;
- /* initialize palette index arrays */
+ /* Initialize palette index arrays */
png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
(png_uint_32)(num_palette * png_sizeof(png_byte)));
png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
(png_uint_32)(num_palette * png_sizeof(png_byte)));
- /* initialize the sort array */
+ /* Initialize the sort array */
for (i = 0; i < num_palette; i++)
{
png_ptr->index_to_palette[i] = (png_byte)i;
@@ -332,14 +351,14 @@
num_new_palette = num_palette;
- /* initial wild guess at how far apart the farthest pixel
- pair we will be eliminating will be. Larger
- numbers mean more areas will be allocated, Smaller
- numbers run the risk of not saving enough data, and
- having to do this all over again.
-
- I have not done extensive checking on this number.
- */
+ /* Initial wild guess at how far apart the farthest pixel
+ * pair we will be eliminating will be. Larger
+ * numbers mean more areas will be allocated, Smaller
+ * numbers run the risk of not saving enough data, and
+ * having to do this all over again.
+ *
+ * I have not done extensive checking on this number.
+ */
max_d = 96;
while (num_new_palette > maximum_colors)
@@ -548,7 +567,8 @@
png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
{
png_debug(1, "in png_set_gamma");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
@@ -567,7 +587,8 @@
png_set_expand(png_structp png_ptr)
{
png_debug(1, "in png_set_expand");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
}
@@ -594,7 +615,8 @@
png_set_palette_to_rgb(png_structp png_ptr)
{
png_debug(1, "in png_set_palette_to_rgb");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
}
@@ -604,7 +626,8 @@
png_set_expand_gray_1_2_4_to_8(png_structp png_ptr)
{
png_debug(1, "in png_set_expand_gray_1_2_4_to_8");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= PNG_EXPAND;
png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
}
@@ -641,10 +664,11 @@
png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
double green)
{
- int red_fixed = (int)((float)red*100000.0 + 0.5);
- int green_fixed = (int)((float)green*100000.0 + 0.5);
- if (png_ptr == NULL) return;
- png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);
+ int red_fixed = (int)((float)red*100000.0 + 0.5);
+ int green_fixed = (int)((float)green*100000.0 + 0.5);
+ if (png_ptr == NULL)
+ return;
+ png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);
}
#endif
@@ -653,13 +677,16 @@
png_fixed_point red, png_fixed_point green)
{
png_debug(1, "in png_set_rgb_to_gray");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
switch(error_action)
{
case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;
break;
+
case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
break;
+
case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
}
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
@@ -681,8 +708,8 @@
}
else if (red + green < 100000L)
{
- red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);
- green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);
+ red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);
+ green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);
}
else
{
@@ -706,7 +733,8 @@
read_user_transform_fn)
{
png_debug(1, "in png_set_read_user_transform_fn");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
png_ptr->transformations |= PNG_USER_TRANSFORM;
png_ptr->read_user_transform_fn = read_user_transform_fn;
@@ -736,8 +764,9 @@
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
/* Detect gray background and attempt to enable optimization
- * for gray --> RGB case */
- /* Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or
+ * for gray --> RGB case
+ *
+ * Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or
* RGB_ALPHA (in which case need_expand is superfluous anyway), the
* background color might actually be gray yet not be flagged as such.
* This is not a problem for the current code, which uses
@@ -764,7 +793,7 @@
{
if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */
{
- /* expand background and tRNS chunks */
+ /* Expand background and tRNS chunks */
switch (png_ptr->bit_depth)
{
case 1:
@@ -778,6 +807,7 @@
= png_ptr->trans_color.blue = png_ptr->trans_color.gray;
}
break;
+
case 2:
png_ptr->background.gray *= (png_uint_16)0x55;
png_ptr->background.red = png_ptr->background.green
@@ -789,6 +819,7 @@
= png_ptr->trans_color.blue = png_ptr->trans_color.gray;
}
break;
+
case 4:
png_ptr->background.gray *= (png_uint_16)0x11;
png_ptr->background.red = png_ptr->background.green
@@ -800,7 +831,9 @@
= png_ptr->trans_color.blue = png_ptr->trans_color.gray;
}
break;
+
case 8:
+
case 16:
png_ptr->background.red = png_ptr->background.green
= png_ptr->background.blue = png_ptr->background.gray;
@@ -823,8 +856,9 @@
if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
#endif
{
- /* invert the alpha channel (in tRNS) unless the pixels are
- going to be expanded, in which case leave it for later */
+ /* Invert the alpha channel (in tRNS) unless the pixels are
+ * going to be expanded, in which case leave it for later
+ */
int i, istop;
istop=(int)png_ptr->num_trans;
for (i=0; i<istop; i++)
@@ -866,8 +900,7 @@
{
if (color_type == PNG_COLOR_TYPE_PALETTE)
{
- /* could skip if no transparency and
- */
+ /* Could skip if no transparency */
png_color back, back_1;
png_colorp palette = png_ptr->palette;
int num_palette = png_ptr->num_palette;
@@ -892,10 +925,12 @@
g = (png_ptr->screen_gamma);
gs = 1.0;
break;
+
case PNG_BACKGROUND_GAMMA_FILE:
g = 1.0 / (png_ptr->gamma);
gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
break;
+
case PNG_BACKGROUND_GAMMA_UNIQUE:
g = 1.0 / (png_ptr->background_gamma);
gs = 1.0 / (png_ptr->background_gamma *
@@ -984,10 +1019,12 @@
g = (png_ptr->screen_gamma);
gs = 1.0;
break;
+
case PNG_BACKGROUND_GAMMA_FILE:
g = 1.0 / (png_ptr->gamma);
gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
break;
+
case PNG_BACKGROUND_GAMMA_UNIQUE:
g = 1.0 / (png_ptr->background_gamma);
gs = 1.0 / (png_ptr->background_gamma *
@@ -1201,8 +1238,8 @@
if (png_ptr->transformations & PNG_DITHER)
{
if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
- (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
- png_ptr->palette_lookup && info_ptr->bit_depth == 8)
+ (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
+ png_ptr->palette_lookup && info_ptr->bit_depth == 8)
{
info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
}
@@ -1236,7 +1273,7 @@
(info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))
{
info_ptr->channels++;
- /* if adding a true alpha channel not just filler */
+ /* If adding a true alpha channel not just filler */
if (png_ptr->transformations & PNG_ADD_ALPHA)
info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
}
@@ -1289,7 +1326,8 @@
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
/* Application has failed to call either png_read_start_image()
* or png_read_update_info() after setting transforms that expand
- * pixels. This check added to libpng-1.2.19 */
+ * pixels. This check added to libpng-1.2.19
+ */
#if (PNG_WARN_UNINITIALIZED_ROW==1)
png_error(png_ptr, "Uninitialized row");
#else
@@ -1342,39 +1380,41 @@
}
#endif
-/*
-From Andreas Dilger e-mail to png-implement, 26 March 1998:
-
- In most cases, the "simple transparency" should be done prior to doing
- gray-to-RGB, or you will have to test 3x as many bytes to check if a
- pixel is transparent. You would also need to make sure that the
- transparency information is upgraded to RGB.
-
- To summarize, the current flow is:
- - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
- with background "in place" if transparent,
- convert to RGB if necessary
- - Gray + alpha -> composite with gray background and remove alpha bytes,
- convert to RGB if necessary
-
- To support RGB backgrounds for gray images we need:
- - Gray + simple transparency -> convert to RGB + simple transparency, compare
- 3 or 6 bytes and composite with background
- "in place" if transparent (3x compare/pixel
- compared to doing composite with gray bkgrnd)
- - Gray + alpha -> convert to RGB + alpha, composite with background and
- remove alpha bytes (3x float operations/pixel
- compared with composite on gray background)
-
- Greg's change will do this. The reason it wasn't done before is for
- performance, as this increases the per-pixel operations. If we would check
- in advance if the background was gray or RGB, and position the gray-to-RGB
- transform appropriately, then it would save a lot of work/time.
+/* From Andreas Dilger e-mail to png-implement, 26 March 1998:
+ *
+ * In most cases, the "simple transparency" should be done prior to doing
+ * gray-to-RGB, or you will have to test 3x as many bytes to check if a
+ * pixel is transparent. You would also need to make sure that the
+ * transparency information is upgraded to RGB.
+ *
+ * To summarize, the current flow is:
+ * - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
+ * with background "in place" if transparent,
+ * convert to RGB if necessary
+ * - Gray + alpha -> composite with gray background and remove alpha bytes,
+ * convert to RGB if necessary
+ *
+ * To support RGB backgrounds for gray images we need:
+ * - Gray + simple transparency -> convert to RGB + simple transparency,
+ * compare 3 or 6 bytes and composite with
+ * background "in place" if transparent
+ * (3x compare/pixel compared to doing
+ * composite with gray bkgrnd)
+ * - Gray + alpha -> convert to RGB + alpha, composite with background and
+ * remove alpha bytes (3x float
+ * operations/pixel compared with composite
+ * on gray background)
+ *
+ * Greg's change will do this. The reason it wasn't done before is for
+ * performance, as this increases the per-pixel operations. If we would check
+ * in advance if the background was gray or RGB, and position the gray-to-RGB
+ * transform appropriately, then it would save a lot of work/time.
*/
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
- /* if gray -> RGB, do so now only if background is non-gray; else do later
- * for performance reasons */
+ /* If gray -> RGB, do so now only if background is non-gray; else do later
+ * for performance reasons
+ */
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
!(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
@@ -1404,14 +1444,14 @@
#if defined(PNG_READ_GAMMA_SUPPORTED)
if ((png_ptr->transformations & PNG_GAMMA) &&
#if defined(PNG_READ_BACKGROUND_SUPPORTED)
- !((png_ptr->transformations & PNG_BACKGROUND) &&
- ((png_ptr->num_trans != 0) ||
- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
+ !((png_ptr->transformations & PNG_BACKGROUND) &&
+ ((png_ptr->num_trans != 0) ||
+ (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
#endif
- (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
+ (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,
- png_ptr->gamma_table, png_ptr->gamma_16_table,
- png_ptr->gamma_shift);
+ png_ptr->gamma_table, png_ptr->gamma_16_table,
+ png_ptr->gamma_shift);
#endif
#if defined(PNG_READ_DITHER_SUPPORTED)
@@ -1451,7 +1491,7 @@
#endif
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
- /* if gray -> RGB, do so now only if we did not do so above */
+ /* If gray -> RGB, do so now only if we did not do so above */
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
@@ -1488,16 +1528,16 @@
if (png_ptr->transformations & PNG_USER_TRANSFORM)
{
if (png_ptr->read_user_transform_fn != NULL)
- (*(png_ptr->read_user_transform_fn)) /* user read transform function */
- (png_ptr, /* png_ptr */
- &(png_ptr->row_info), /* row_info: */
- /* png_uint_32 width; width of row */
- /* png_uint_32 rowbytes; number of bytes in row */
- /* png_byte color_type; color type of pixels */
- /* png_byte bit_depth; bit depth of samples */
- /* png_byte channels; number of channels (1-4) */
- /* png_byte pixel_depth; bits per pixel (depth*channels) */
- png_ptr->row_buf + 1); /* start of pixel data for row */
+ (*(png_ptr->read_user_transform_fn)) /* user read transform function */
+ (png_ptr, /* png_ptr */
+ &(png_ptr->row_info), /* row_info: */
+ /* png_uint_32 width; width of row */
+ /* png_uint_32 rowbytes; number of bytes in row */
+ /* png_byte color_type; color type of pixels */
+ /* png_byte bit_depth; bit depth of samples */
+ /* png_byte channels; number of channels (1-4) */
+ /* png_byte pixel_depth; bits per pixel (depth*channels) */
+ png_ptr->row_buf + 1); /* start of pixel data for row */
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
if (png_ptr->user_transform_depth)
png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;
@@ -1551,6 +1591,7 @@
}
break;
}
+
case 2:
{
@@ -1572,6 +1613,7 @@
}
break;
}
+
case 4:
{
png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);
@@ -1660,6 +1702,7 @@
}
break;
}
+
case 4:
{
png_bytep bp = row;
@@ -1675,6 +1718,7 @@
}
break;
}
+
case 8:
{
png_bytep bp = row;
@@ -1687,6 +1731,7 @@
}
break;
}
+
case 16:
{
png_bytep bp = row;
@@ -1708,7 +1753,7 @@
#endif
#if defined(PNG_READ_16_TO_8_SUPPORTED)
-/* chop rows of bit depth 16 down to 8 */
+/* Chop rows of bit depth 16 down to 8 */
void /* PRIVATE */
png_do_chop(png_row_infop row_info, png_bytep row)
{
@@ -1728,14 +1773,17 @@
*
* What the ideal calculation should be:
* *dp = (((((png_uint_32)(*sp) << 8) |
- * (png_uint_32)(*(sp + 1))) * 255 + 127) / (png_uint_32)65535L;
+ * (png_uint_32)(*(sp + 1))) * 255 + 127)
+ * / (png_uint_32)65535L;
*
* GRR: no, I think this is what it really should be:
* *dp = (((((png_uint_32)(*sp) << 8) |
- * (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L;
+ * (png_uint_32)(*(sp + 1))) + 128L)
+ * / (png_uint_32)257L;
*
* GRR: here's the exact calculation with shifts:
- * temp = (((png_uint_32)(*sp) << 8) | (png_uint_32)(*(sp + 1))) + 128L;
+ * temp = (((png_uint_32)(*sp) << 8) |
+ * (png_uint_32)(*(sp + 1))) + 128L;
* *dp = (temp - (temp >> 8)) >> 8;
*
* Approximate calculation with shift/add instead of multiply/divide:
@@ -2549,18 +2597,22 @@
num_palette = 2;
color_inc = 0xff;
break;
+
case 2:
num_palette = 4;
color_inc = 0x55;
break;
+
case 4:
num_palette = 16;
color_inc = 0x11;
break;
+
case 8:
num_palette = 256;
color_inc = 1;
break;
+
default:
num_palette = 0;
color_inc = 0;
@@ -2630,6 +2682,7 @@
}
break;
}
+
case 2:
{
#if defined(PNG_READ_GAMMA_SUPPORTED)
@@ -2686,6 +2739,7 @@
}
break;
}
+
case 4:
{
#if defined(PNG_READ_GAMMA_SUPPORTED)
@@ -2742,6 +2796,7 @@
}
break;
}
+
case 8:
{
#if defined(PNG_READ_GAMMA_SUPPORTED)
@@ -2774,6 +2829,7 @@
}
break;
}
+
case 16:
{
#if defined(PNG_READ_GAMMA_SUPPORTED)
@@ -2787,7 +2843,7 @@
v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
if (v == trans_color->gray)
{
- /* background is already in screen gamma */
+ /* Background is already in screen gamma */
*sp = (png_byte)((background->gray >> 8) & 0xff);
*(sp + 1) = (png_byte)(background->gray & 0xff);
}
@@ -2820,6 +2876,7 @@
}
break;
}
+
case PNG_COLOR_TYPE_RGB:
{
if (row_info->bit_depth == 8)
@@ -2877,7 +2934,7 @@
if (r == trans_color->red && g == trans_color->green &&
b == trans_color->blue)
{
- /* background is already in screen gamma */
+ /* Background is already in screen gamma */
*sp = (png_byte)((background->red >> 8) & 0xff);
*(sp + 1) = (png_byte)(background->red & 0xff);
*(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
@@ -2924,6 +2981,7 @@
}
break;
}
+
case PNG_COLOR_TYPE_GRAY_ALPHA:
{
if (row_info->bit_depth == 8)
@@ -2944,7 +3002,7 @@
}
else if (a == 0)
{
- /* background is already in screen gamma */
+ /* Background is already in screen gamma */
*dp = (png_byte)background->gray;
}
else
@@ -3011,7 +3069,7 @@
else
#endif
{
- /* background is already in screen gamma */
+ /* Background is already in screen gamma */
*dp = (png_byte)((background->gray >> 8) & 0xff);
*(dp + 1) = (png_byte)(background->gray & 0xff);
}
@@ -3066,6 +3124,7 @@
}
break;
}
+
case PNG_COLOR_TYPE_RGB_ALPHA:
{
if (row_info->bit_depth == 8)
@@ -3088,7 +3147,7 @@
}
else if (a == 0)
{
- /* background is already in screen gamma */
+ /* Background is already in screen gamma */
*dp = (png_byte)background->red;
*(dp + 1) = (png_byte)background->green;
*(dp + 2) = (png_byte)background->blue;
@@ -3169,7 +3228,7 @@
}
else if (a == 0)
{
- /* background is already in screen gamma */
+ /* Background is already in screen gamma */
*dp = (png_byte)((background->red >> 8) & 0xff);
*(dp + 1) = (png_byte)(background->red & 0xff);
*(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
@@ -3321,6 +3380,7 @@
}
break;
}
+
case PNG_COLOR_TYPE_RGB_ALPHA:
{
if (row_info->bit_depth == 8)
@@ -3358,6 +3418,7 @@
}
break;
}
+
case PNG_COLOR_TYPE_GRAY_ALPHA:
{
if (row_info->bit_depth == 8)
@@ -3382,6 +3443,7 @@
}
break;
}
+
case PNG_COLOR_TYPE_GRAY:
{
if (row_info->bit_depth == 2)
@@ -3402,6 +3464,7 @@
sp++;
}
}
+
if (row_info->bit_depth == 4)
{
sp = row;
@@ -3415,6 +3478,7 @@
sp++;
}
}
+
else if (row_info->bit_depth == 8)
{
sp = row;
@@ -3424,6 +3488,7 @@
sp++;
}
}
+
else if (row_info->bit_depth == 16)
{
sp = row;
@@ -3486,6 +3551,7 @@
}
break;
}
+
case 2:
{
sp = row + (png_size_t)((row_width - 1) >> 2);
@@ -3507,6 +3573,7 @@
}
break;
}
+
case 4:
{
sp = row + (png_size_t)((row_width - 1) >> 1);
@@ -3571,6 +3638,7 @@
*dp-- = palette[*sp].red;
sp--;
}
+
row_info->bit_depth = 8;
row_info->pixel_depth = 24;
row_info->rowbytes = row_width * 3;
@@ -3629,6 +3697,7 @@
}
break;
}
+
case 2:
{
gray = (png_uint_16)((gray&0x03)*0x55);
@@ -3652,6 +3721,7 @@
}
break;
}
+
case 4:
{
gray = (png_uint_16)((gray&0x0f)*0x11);
@@ -3675,6 +3745,7 @@
break;
}
}
+
row_info->bit_depth = 8;
row_info->pixel_depth = 8;
row_info->rowbytes = row_width;
@@ -3696,6 +3767,7 @@
*dp-- = *sp--;
}
}
+
else if (row_info->bit_depth == 16)
{
png_byte gray_high = (gray >> 8) & 0xff;
@@ -3718,6 +3790,7 @@
*dp-- = *sp--;
}
}
+
row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
row_info->channels = 2;
row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
@@ -3812,13 +3885,13 @@
g = *sp++;
b = *sp++;
- /* this looks real messy, but the compiler will reduce
- it down to a reasonable formula. For example, with
- 5 bits per color, we get:
- p = (((r >> 3) & 0x1f) << 10) |
- (((g >> 3) & 0x1f) << 5) |
- ((b >> 3) & 0x1f);
- */
+ /* This looks real messy, but the compiler will reduce
+ * it down to a reasonable formula. For example, with
+ * 5 bits per color, we get:
+ * p = (((r >> 3) & 0x1f) << 10) |
+ * (((g >> 3) & 0x1f) << 5) |
+ * ((b >> 3) & 0x1f);
+ */
p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
((1 << PNG_DITHER_RED_BITS) - 1)) <<
(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
@@ -3899,6 +3972,7 @@
if (png_ptr->screen_gamma > .000001)
g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
+
else
g = 1.0;
@@ -3933,6 +4007,7 @@
if (png_ptr->screen_gamma > 0.000001)
g = 1.0 / png_ptr->screen_gamma;
+
else
g = png_ptr->gamma; /* probably doing rgb_to_gray */
@@ -3955,8 +4030,10 @@
if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
{
sig_bit = (int)png_ptr->sig_bit.red;
+
if ((int)png_ptr->sig_bit.green > sig_bit)
sig_bit = png_ptr->sig_bit.green;
+
if ((int)png_ptr->sig_bit.blue > sig_bit)
sig_bit = png_ptr->sig_bit.blue;
}
@@ -3967,6 +4044,7 @@
if (sig_bit > 0)
shift = 16 - sig_bit;
+
else
shift = 0;
@@ -3978,6 +4056,7 @@
if (shift > 8)
shift = 8;
+
if (shift < 0)
shift = 0;
@@ -4040,6 +4119,7 @@
(png_uint_32)(256 * png_sizeof(png_uint_16)));
ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);
+
for (j = 0; j < 256; j++)
{
png_ptr->gamma_16_table[i][j] =
@@ -4082,6 +4162,7 @@
if (png_ptr->screen_gamma > 0.000001)
g = 1.0 / png_ptr->screen_gamma;
+
else
g = png_ptr->gamma; /* probably doing rgb_to_gray */
@@ -4102,6 +4183,7 @@
ig = (((png_uint_32)i *
(png_uint_32)png_gamma_shift[shift]) >> 4);
+
for (j = 0; j < 256; j++)
{
png_ptr->gamma_16_from_1[i][j] =
@@ -4135,8 +4217,10 @@
if (row_info->color_type == PNG_COLOR_TYPE_RGB)
bytes_per_pixel = 3;
+
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
bytes_per_pixel = 4;
+
else
return;
@@ -4153,8 +4237,10 @@
if (row_info->color_type == PNG_COLOR_TYPE_RGB)
bytes_per_pixel = 6;
+
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
bytes_per_pixel = 8;
+
else
return;
diff --git a/pngrutil.c b/pngrutil.c
index 2ec82c0..960b691 100644
--- a/pngrutil.c
+++ b/pngrutil.c
@@ -39,7 +39,8 @@
/* Grab a signed 32-bit integer from a buffer in big-endian format. The
* data is stored in the PNG file in two's complement format, and it is
- * assumed that the machine format for signed integers is the same. */
+ * assumed that the machine format for signed integers is the same.
+ */
png_int_32 PNGAPI
png_get_int_32(png_bytep buf)
{
@@ -78,21 +79,21 @@
png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR;
#endif
- /* read the length and the chunk name */
+ /* Read the length and the chunk name */
png_read_data(png_ptr, buf, 8);
length = png_get_uint_31(png_ptr, buf);
- /* put the chunk name into png_ptr->chunk_name */
+ /* Put the chunk name into png_ptr->chunk_name */
png_memcpy(png_ptr->chunk_name, buf + 4, 4);
png_debug2(0, "Reading %s chunk, length = %lu",
png_ptr->chunk_name, length);
- /* reset the crc and run it over the chunk name */
+ /* Reset the crc and run it over the chunk name */
png_reset_crc(png_ptr);
png_calculate_crc(png_ptr, png_ptr->chunk_name, 4);
- /* check to see if chunk name is valid */
+ /* Check to see if chunk name is valid */
png_check_chunk_name(png_ptr, png_ptr->chunk_name);
#ifdef PNG_IO_STATE_SUPPORTED
@@ -109,15 +110,17 @@
void /* PRIVATE */
png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
{
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_read_data(png_ptr, buf, length);
png_calculate_crc(png_ptr, buf, length);
}
/* Optionally skip data and then check the CRC. Depending on whether we
- are reading a ancillary or critical chunk, and how the program has set
- things up, we may calculate the CRC on the data and print a message.
- Returns '1' if there was a CRC error, '0' otherwise. */
+ * are reading a ancillary or critical chunk, and how the program has set
+ * things up, we may calculate the CRC on the data and print a message.
+ * Returns '1' if there was a CRC error, '0' otherwise.
+ */
int /* PRIVATE */
png_crc_finish(png_structp png_ptr, png_uint_32 skip)
{
@@ -136,7 +139,7 @@
if (png_crc_error(png_ptr))
{
if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */
- !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
+ !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
(!(png_ptr->chunk_name[0] & 0x20) && /* Critical */
(png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))
{
@@ -154,7 +157,8 @@
}
/* Compare the CRC stored in the PNG file with that calculated by libpng from
- the data it has read thus far. */
+ * the data it has read thus far.
+ */
int /* PRIVATE */
png_crc_error(png_structp png_ptr)
{
@@ -315,14 +319,17 @@
png_snprintf(umsg, 52,
"Buffer error in compressed datastream in %s chunk",
png_ptr->chunk_name);
+
else if (ret == Z_DATA_ERROR)
png_snprintf(umsg, 52,
"Data error in compressed datastream in %s chunk",
png_ptr->chunk_name);
+
else
png_snprintf(umsg, 52,
"Incomplete compressed datastream in %s chunk",
png_ptr->chunk_name);
+
png_warning(png_ptr, umsg);
#else
png_warning(png_ptr,
@@ -367,7 +374,7 @@
}
#endif
-/* read and check the IDHR chunk */
+/* Read and check the IDHR chunk */
void /* PRIVATE */
png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
@@ -381,7 +388,7 @@
if (png_ptr->mode & PNG_HAVE_IHDR)
png_error(png_ptr, "Out of place IHDR");
- /* check the length */
+ /* Check the length */
if (length != 13)
png_error(png_ptr, "Invalid IHDR chunk");
@@ -398,7 +405,7 @@
filter_type = buf[11];
interlace_type = buf[12];
- /* set internal variables */
+ /* Set internal variables */
png_ptr->width = width;
png_ptr->height = height;
png_ptr->bit_depth = (png_byte)bit_depth;
@@ -409,25 +416,28 @@
#endif
png_ptr->compression_type = (png_byte)compression_type;
- /* find number of channels */
+ /* Find number of channels */
switch (png_ptr->color_type)
{
case PNG_COLOR_TYPE_GRAY:
case PNG_COLOR_TYPE_PALETTE:
png_ptr->channels = 1;
break;
+
case PNG_COLOR_TYPE_RGB:
png_ptr->channels = 3;
break;
+
case PNG_COLOR_TYPE_GRAY_ALPHA:
png_ptr->channels = 2;
break;
+
case PNG_COLOR_TYPE_RGB_ALPHA:
png_ptr->channels = 4;
break;
}
- /* set up other useful info */
+ /* Set up other useful info */
png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
png_ptr->channels);
png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
@@ -438,7 +448,7 @@
color_type, interlace_type, compression_type, filter_type);
}
-/* read and check the palette */
+/* Read and check the palette */
void /* PRIVATE */
png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
@@ -452,12 +462,14 @@
if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before PLTE");
+
else if (png_ptr->mode & PNG_HAVE_IDAT)
{
png_warning(png_ptr, "Invalid PLTE after IDAT");
png_crc_finish(png_ptr, length);
return;
}
+
else if (png_ptr->mode & PNG_HAVE_PLTE)
png_error(png_ptr, "Duplicate PLTE chunk");
@@ -486,6 +498,7 @@
png_crc_finish(png_ptr, length);
return;
}
+
else
{
png_error(png_ptr, "Invalid palette chunk");
@@ -518,9 +531,10 @@
#endif
/* If we actually NEED the PLTE chunk (ie for a paletted image), we do
- whatever the normal CRC configuration tells us. However, if we
- have an RGB image, the PLTE can be considered ancillary, so
- we will act as though it is. */
+ * whatever the normal CRC configuration tells us. However, if we
+ * have an RGB image, the PLTE can be considered ancillary, so
+ * we will act as though it is.
+ */
#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
#endif
diff --git a/pngset.c b/pngset.c
index 1d93053..ec2e503 100644
--- a/pngset.c
+++ b/pngset.c
@@ -79,25 +79,25 @@
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y))
#endif
{
- info_ptr->int_x_white = white_x;
- info_ptr->int_y_white = white_y;
- info_ptr->int_x_red = red_x;
- info_ptr->int_y_red = red_y;
- info_ptr->int_x_green = green_x;
- info_ptr->int_y_green = green_y;
- info_ptr->int_x_blue = blue_x;
- info_ptr->int_y_blue = blue_y;
-#ifdef PNG_FLOATING_POINT_SUPPORTED
- info_ptr->x_white = (float)(white_x/100000.);
- info_ptr->y_white = (float)(white_y/100000.);
- info_ptr->x_red = (float)( red_x/100000.);
- info_ptr->y_red = (float)( red_y/100000.);
- info_ptr->x_green = (float)(green_x/100000.);
- info_ptr->y_green = (float)(green_y/100000.);
- info_ptr->x_blue = (float)( blue_x/100000.);
- info_ptr->y_blue = (float)( blue_y/100000.);
+ info_ptr->int_x_white = white_x;
+ info_ptr->int_y_white = white_y;
+ info_ptr->int_x_red = red_x;
+ info_ptr->int_y_red = red_y;
+ info_ptr->int_x_green = green_x;
+ info_ptr->int_y_green = green_y;
+ info_ptr->int_x_blue = blue_x;
+ info_ptr->int_y_blue = blue_y;
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+ info_ptr->x_white = (float)(white_x/100000.);
+ info_ptr->y_white = (float)(white_y/100000.);
+ info_ptr->x_red = (float)( red_x/100000.);
+ info_ptr->y_red = (float)( red_y/100000.);
+ info_ptr->x_green = (float)(green_x/100000.);
+ info_ptr->y_green = (float)(green_y/100000.);
+ info_ptr->x_blue = (float)( blue_x/100000.);
+ info_ptr->y_blue = (float)( blue_y/100000.);
#endif
- info_ptr->valid |= PNG_INFO_cHRM;
+ info_ptr->valid |= PNG_INFO_cHRM;
}
}
#endif /* PNG_FIXED_POINT_SUPPORTED */
@@ -140,20 +140,20 @@
if (png_ptr == NULL || info_ptr == NULL)
return;
- if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX)
+ if (int_gamma > (png_fixed_point)PNG_UINT_31_MAX)
{
- png_warning(png_ptr, "Limiting gamma to 21474.83");
- png_gamma=PNG_UINT_31_MAX;
+ png_warning(png_ptr, "Limiting gamma to 21474.83");
+ png_gamma=PNG_UINT_31_MAX;
}
else
{
- if (int_gamma < 0)
- {
- png_warning(png_ptr, "Setting negative gamma to zero");
- png_gamma = 0;
- }
- else
- png_gamma = int_gamma;
+ if (int_gamma < 0)
+ {
+ png_warning(png_ptr, "Setting negative gamma to zero");
+ png_gamma = 0;
+ }
+ else
+ png_gamma = int_gamma;
}
#ifdef PNG_FLOATING_POINT_SUPPORTED
info_ptr->gamma = (float)(png_gamma/100000.);
@@ -179,26 +179,27 @@
if (info_ptr->num_palette == 0 || info_ptr->num_palette
> PNG_MAX_PALETTE_LENGTH)
{
- png_warning(png_ptr,
- "Invalid palette size, hIST allocation skipped");
- return;
+ png_warning(png_ptr,
+ "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 PNG_MAX_PALETTE_LENGTH 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_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16));
if (png_ptr->hist == NULL)
- {
- png_warning(png_ptr, "Insufficient memory for hIST chunk data");
- return;
- }
+ {
+ png_warning(png_ptr, "Insufficient memory for hIST chunk data");
+ return;
+ }
for (i = 0; i < info_ptr->num_palette; i++)
- png_ptr->hist[i] = hist[i];
+ png_ptr->hist[i] = hist[i];
info_ptr->hist = png_ptr->hist;
info_ptr->valid |= PNG_INFO_hIST;
@@ -246,7 +247,7 @@
png_error(png_ptr, "Invalid bit depth in IHDR");
if (color_type < 0 || color_type == 1 ||
- color_type == 5 || color_type > 6)
+ color_type == 5 || color_type > 6)
png_error(png_ptr, "Invalid color type in IHDR");
if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
@@ -276,9 +277,9 @@
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 ||
+ (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)
@@ -496,15 +497,15 @@
return;
if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
- {
- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_error(png_ptr, "Invalid palette length");
- else
- {
+ else
+ {
png_warning(png_ptr, "Invalid palette length");
return;
- }
- }
+ }
+ }
/*
* It may not actually be necessary to set png_ptr->palette here;
@@ -516,8 +517,9 @@
#endif
/* 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. */
+ * of num_palette entries, in case of an invalid PNG file that has
+ * too-large sample values.
+ */
#ifdef PNG_CALLOC_SUPPORTED
png_ptr->palette = (png_colorp)png_calloc(png_ptr,
PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
@@ -625,18 +627,18 @@
#if !defined(PNG_NO_CHECK_cHRM)
if (png_check_cHRM_fixed(png_ptr,
- int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
- int_green_y, int_blue_x, int_blue_y))
+ int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
+ int_green_y, int_blue_x, int_blue_y))
#endif
{
#ifdef PNG_FIXED_POINT_SUPPORTED
- png_set_cHRM_fixed(png_ptr, info_ptr,
- int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
- int_green_y, int_blue_x, int_blue_y);
+ png_set_cHRM_fixed(png_ptr, info_ptr,
+ int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
+ int_green_y, int_blue_x, int_blue_y);
#endif
#ifdef PNG_FLOATING_POINT_SUPPORTED
png_set_cHRM(png_ptr, info_ptr,
- white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
+ white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
#endif
}
#endif /* cHRM */
@@ -694,17 +696,17 @@
#if defined(PNG_TEXT_SUPPORTED)
void PNGAPI
png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
- int num_text)
+ int num_text)
{
int ret;
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
if (ret)
- png_error(png_ptr, "Insufficient memory to store text");
+ png_error(png_ptr, "Insufficient memory to store text");
}
int /* PRIVATE */
png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
- int num_text)
+ int num_text)
{
int i;
@@ -730,10 +732,10 @@
info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
(png_size_t)(info_ptr->max_text * png_sizeof(png_text)));
if (info_ptr->text == NULL)
- {
- png_free(png_ptr, old_text);
- return(1);
- }
+ {
+ png_free(png_ptr, old_text);
+ return(1);
+ }
png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
png_sizeof(png_text)));
png_free(png_ptr, old_text);
@@ -745,7 +747,7 @@
info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
(png_size_t)(info_ptr->max_text * png_sizeof(png_text)));
if (info_ptr->text == NULL)
- return(1);
+ return(1);
#ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_TEXT;
#endif
@@ -766,26 +768,26 @@
if (text_ptr[i].compression <= 0)
{
- lang_len = 0;
- lang_key_len = 0;
+ lang_len = 0;
+ lang_key_len = 0;
}
else
#ifdef PNG_iTXt_SUPPORTED
{
- /* set iTXt data */
- if (text_ptr[i].lang != NULL)
- lang_len = png_strlen(text_ptr[i].lang);
- else
- lang_len = 0;
- if (text_ptr[i].lang_key != NULL)
- lang_key_len = png_strlen(text_ptr[i].lang_key);
- else
- lang_key_len = 0;
+ /* set iTXt data */
+ if (text_ptr[i].lang != NULL)
+ lang_len = png_strlen(text_ptr[i].lang);
+ else
+ lang_len = 0;
+ if (text_ptr[i].lang_key != NULL)
+ lang_key_len = png_strlen(text_ptr[i].lang_key);
+ else
+ lang_key_len = 0;
}
#else
{
- png_warning(png_ptr, "iTXt chunk not supported");
- continue;
+ png_warning(png_ptr, "iTXt chunk not supported");
+ continue;
}
#endif
@@ -809,14 +811,13 @@
(png_size_t)
(key_len + text_length + lang_len + lang_key_len + 4));
if (textp->key == NULL)
- return(1);
+ return(1);
png_debug2(2, "Allocated %lu bytes at %x in png_set_text",
- (unsigned long)(png_uint_32)
- (key_len + lang_len + lang_key_len + text_length + 4),
- (int)textp->key);
+ (unsigned long)(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));
+ png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len));
*(textp->key + key_len) = '\0';
#ifdef PNG_iTXt_SUPPORTED
if (text_ptr[i].compression > 0)
@@ -903,7 +904,7 @@
png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,
(png_size_t)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);
+ png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);
}
if (trans_color != NULL)
@@ -915,12 +916,12 @@
((int)trans_color->red > sample_max ||
(int)trans_color->green > sample_max ||
(int)trans_color->blue > sample_max)))
- png_warning(png_ptr,
- "tRNS chunk has out-of-range samples for bit_depth");
+ png_warning(png_ptr,
+ "tRNS chunk has out-of-range samples for bit_depth");
png_memcpy(&(info_ptr->trans_color), trans_color,
png_sizeof(png_color_16));
if (num_trans == 0)
- num_trans = 1;
+ num_trans = 1;
}
info_ptr->num_trans = (png_uint_16)num_trans;
@@ -948,62 +949,62 @@
* added.
*/
{
- png_sPLT_tp np;
- int i;
+ 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_size_t)png_sizeof(png_sPLT_t));
- if (np == NULL)
- {
- png_warning(png_ptr, "No memory for sPLT palettes");
+ if (png_ptr == NULL || info_ptr == NULL)
return;
- }
- png_memcpy(np, info_ptr->splt_palettes,
- info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
- png_free(png_ptr, info_ptr->splt_palettes);
- info_ptr->splt_palettes=NULL;
+ np = (png_sPLT_tp)png_malloc_warn(png_ptr,
+ (info_ptr->splt_palettes_num + nentries) *
+ (png_size_t)png_sizeof(png_sPLT_t));
+ if (np == NULL)
+ {
+ png_warning(png_ptr, "No memory for sPLT palettes");
+ return;
+ }
- for (i = 0; i < nentries; i++)
- {
- png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
- png_sPLT_tp from = entries + i;
- png_uint_32 length;
+ png_memcpy(np, info_ptr->splt_palettes,
+ info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
+ png_free(png_ptr, info_ptr->splt_palettes);
+ info_ptr->splt_palettes=NULL;
- length = png_strlen(from->name) + 1;
+ for (i = 0; i < nentries; i++)
+ {
+ png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
+ png_sPLT_tp from = entries + i;
+ png_uint_32 length;
+
+ length = png_strlen(from->name) + 1;
to->name = (png_charp)png_malloc_warn(png_ptr, (png_size_t)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,
+ 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,
(png_size_t)(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_entry));
- to->nentries = from->nentries;
- to->depth = from->depth;
- }
+ 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_entry));
+ to->nentries = from->nentries;
+ to->depth = from->depth;
+ }
- info_ptr->splt_palettes = np;
- info_ptr->splt_palettes_num += nentries;
- info_ptr->valid |= PNG_INFO_sPLT;
+ info_ptr->splt_palettes = np;
+ info_ptr->splt_palettes_num += nentries;
+ info_ptr->valid |= PNG_INFO_sPLT;
#ifdef PNG_FREE_ME_SUPPORTED
- info_ptr->free_me |= PNG_FREE_SPLT;
+ info_ptr->free_me |= PNG_FREE_SPLT;
#endif
}
#endif /* PNG_sPLT_SUPPORTED */
@@ -1013,60 +1014,60 @@
png_set_unknown_chunks(png_structp png_ptr,
png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
{
- png_unknown_chunkp np;
- int i;
+ png_unknown_chunkp np;
+ int i;
- if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
- return;
-
- np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
- (png_size_t)((info_ptr->unknown_chunks_num + num_unknowns) *
- png_sizeof(png_unknown_chunk)));
- if (np == NULL)
- {
- png_warning(png_ptr,
- "Out of memory while processing unknown chunk");
+ if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
return;
- }
- png_memcpy(np, info_ptr->unknown_chunks,
- info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
- png_free(png_ptr, info_ptr->unknown_chunks);
+ np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
+ (png_size_t)((info_ptr->unknown_chunks_num + num_unknowns) *
+ png_sizeof(png_unknown_chunk)));
+ if (np == NULL)
+ {
+ 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_memcpy(np, info_ptr->unknown_chunks,
+ info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
+ png_free(png_ptr, info_ptr->unknown_chunks);
- 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);
+ for (i = 0; i < num_unknowns; i++)
+ {
+ png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
+ png_unknown_chunkp from = unknowns + i;
- if (from->size == 0)
- to->data=NULL;
- else
- {
- to->data = (png_bytep)png_malloc_warn(png_ptr,
- (png_size_t)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);
- }
- }
+ 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);
- info_ptr->unknown_chunks = np;
- info_ptr->unknown_chunks_num += num_unknowns;
+ if (from->size == 0)
+ to->data=NULL;
+ else
+ {
+ to->data = (png_bytep)png_malloc_warn(png_ptr,
+ (png_size_t)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;
+ info_ptr->unknown_chunks_num += num_unknowns;
#ifdef PNG_FREE_ME_SUPPORTED
- info_ptr->free_me |= PNG_FREE_UNKN;
+ info_ptr->free_me |= PNG_FREE_UNKN;
#endif
}
void PNGAPI
@@ -1098,44 +1099,44 @@
png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
chunk_list, int num_chunks)
{
- png_bytep new_list, p;
- int i, old_num_chunks;
- if (png_ptr == NULL)
- return;
- if (num_chunks == 0)
- {
+ 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_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
+ png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
else
- png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
+ png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
if (keep == PNG_HANDLE_CHUNK_ALWAYS)
- png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
+ png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
else
- png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
+ png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
return;
- }
- if (chunk_list == NULL)
+ }
+ if (chunk_list == NULL)
return;
- old_num_chunks = png_ptr->num_chunk_list;
- new_list=(png_bytep)png_malloc(png_ptr,
- (png_size_t)
- (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_size_t)(5*num_chunks));
- 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;
+ old_num_chunks = png_ptr->num_chunk_list;
+ new_list=(png_bytep)png_malloc(png_ptr,
+ (png_size_t)
+ (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_size_t)(5*num_chunks));
+ 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;
#ifdef PNG_FREE_ME_SUPPORTED
- png_ptr->free_me |= PNG_FREE_LIST;
+ png_ptr->free_me |= PNG_FREE_LIST;
#endif
}
#endif
@@ -1200,25 +1201,27 @@
png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
png_uint_32 user_height_max)
{
- /* Images with dimensions larger than these limits will be
- * 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;
+ /* Images with dimensions larger than these limits will be
+ * 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;
}
/* this function was added to libpng 1.4.0 */
void PNGAPI
png_set_chunk_cache_max (png_structp png_ptr,
png_uint_32 user_chunk_cache_max)
{
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->user_chunk_cache_max = user_chunk_cache_max;
if (user_chunk_cache_max == 0x7fffffffL) /* Unlimited */
- png_ptr->user_chunk_cache_max = 0;
+ png_ptr->user_chunk_cache_max = 0;
else
- png_ptr->user_chunk_cache_max = user_chunk_cache_max + 1;
+ png_ptr->user_chunk_cache_max = user_chunk_cache_max + 1;
}
#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
@@ -1229,9 +1232,9 @@
{
png_debug(1, "in png_set_benign_errors");
if (allowed)
- png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
+ png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
else
- png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN;
+ png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN;
}
#endif /* PNG_BENIGN_ERRORS_SUPPORTED */
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
diff --git a/pngtest.c b/pngtest.c
index fca5848..03d55f2 100644
--- a/pngtest.c
+++ b/pngtest.c
@@ -99,20 +99,21 @@
void
read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
{
- if (png_ptr == NULL || row_number > PNG_UINT_31_MAX) return;
- if (status_pass != pass)
- {
- fprintf(stdout, "\n Pass %d: ", pass);
- status_pass = pass;
- status_dots = 31;
- }
- status_dots--;
- if (status_dots == 0)
- {
- fprintf(stdout, "\n ");
- status_dots=30;
- }
- fprintf(stdout, "r");
+ if (png_ptr == NULL || row_number > PNG_UINT_31_MAX)
+ return;
+ if (status_pass != pass)
+ {
+ fprintf(stdout, "\n Pass %d: ", pass);
+ status_pass = pass;
+ status_dots = 31;
+ }
+ status_dots--;
+ if (status_dots == 0)
+ {
+ fprintf(stdout, "\n ");
+ status_dots=30;
+ }
+ fprintf(stdout, "r");
}
void
@@ -120,29 +121,32 @@
void
write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
{
- if (png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7) return;
- fprintf(stdout, "w");
+ if (png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7)
+ return;
+ fprintf(stdout, "w");
}
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
/* Example of using user transform callback (we don't transform anything,
- but merely examine the row filters. We set this to 256 rather than
- 5 in case illegal filter values are present.) */
+ * but merely examine the row filters. We set this to 256 rather than
+ * 5 in case illegal filter values are present.)
+ */
static png_uint_32 filters_used[256];
void
count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data);
void
count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data)
{
- if (png_ptr != NULL && row_info != NULL)
+ if (png_ptr != NULL && row_info != NULL)
++filters_used[*(data - 1)];
}
#endif
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
/* example of using user transform callback (we don't transform anything,
- but merely count the zero samples) */
+ * but merely count the zero samples)
+ */
static png_uint_32 zero_samples;
@@ -163,7 +167,6 @@
* png_byte pixel_depth bits per pixel (depth*channels)
*/
-
/* counts the number of zero samples (or zero pixels if color_type is 3 */
if (row_info->color_type == 0 || row_info->color_type == 3)
@@ -174,7 +177,8 @@
{
if (row_info->bit_depth == 1)
{
- if (((*dp << pos++ ) & 0x80) == 0) zero_samples++;
+ if (((*dp << pos++ ) & 0x80) == 0)
+ zero_samples++;
if (pos == 8)
{
pos = 0;
@@ -183,7 +187,8 @@
}
if (row_info->bit_depth == 2)
{
- if (((*dp << (pos+=2)) & 0xc0) == 0) zero_samples++;
+ if (((*dp << (pos+=2)) & 0xc0) == 0)
+ zero_samples++;
if (pos == 8)
{
pos = 0;
@@ -192,7 +197,8 @@
}
if (row_info->bit_depth == 4)
{
- if (((*dp << (pos+=4)) & 0xf0) == 0) zero_samples++;
+ if (((*dp << (pos+=4)) & 0xf0) == 0)
+ zero_samples++;
if (pos == 8)
{
pos = 0;
@@ -200,7 +206,8 @@
}
}
if (row_info->bit_depth == 8)
- if (*dp++ == 0) zero_samples++;
+ if (*dp++ == 0)
+ zero_samples++;
if (row_info->bit_depth == 16)
{
if ((*dp | *(dp+1)) == 0) zero_samples++;
@@ -220,7 +227,8 @@
for (channel = 0; channel < color_channels; channel++)
{
if (row_info->bit_depth == 8)
- if (*dp++ == 0) zero_samples++;
+ if (*dp++ == 0)
+ zero_samples++;
if (row_info->bit_depth == 16)
{
if ((*dp | *(dp+1)) == 0) zero_samples++;
@@ -230,7 +238,8 @@
if (row_info->color_type > 3)
{
dp++;
- if (row_info->bit_depth == 16)dp++;
+ if (row_info->bit_depth == 16)
+ dp++;
}
}
}
@@ -241,12 +250,13 @@
#if defined(PNG_NO_STDIO)
/* START of code to validate stdio-free compilation */
-/* These copies of the default read/write functions come from pngrio.c and */
-/* pngwio.c. They allow "don't include stdio" testing of the library. */
-/* This is the function that does the actual reading of data. If you are
- not reading from a standard C stream, you should create a replacement
- read_data function and use it at run time with png_set_read_fn(), rather
- than changing the library. */
+/* These copies of the default read/write functions come from pngrio.c and
+ * pngwio.c. They allow "don't include stdio" testing of the library.
+ * This is the function that does the actual reading of data. If you are
+ * not reading from a standard C stream, you should create a replacement
+ * read_data function and use it at run time with png_set_read_fn(), rather
+ * than changing the library.
+ */
#ifndef USE_FAR_KEYWORD
static void
@@ -265,7 +275,7 @@
}
}
#else
-/* this is the model-independent version. Since the standard I/O library
+/* This is the model-independent version. Since the standard I/O library
can't handle far buffers in the medium and small models, we have to copy
the data.
*/
@@ -308,9 +318,7 @@
while (remaining != 0);
}
if (check != length)
- {
png_error(png_ptr, "read Error");
- }
}
#endif /* USE_FAR_KEYWORD */
@@ -324,9 +332,10 @@
#endif
/* This is the function that does the actual writing of data. If you are
- not writing to a standard C stream, you should create a replacement
- write_data function and use it at run time with png_set_write_fn(), rather
- than changing the library. */
+ * not writing to a standard C stream, you should create a replacement
+ * write_data function and use it at run time with png_set_write_fn(), rather
+ * than changing the library.
+ */
#ifndef USE_FAR_KEYWORD
static void
pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
@@ -340,7 +349,7 @@
}
}
#else
-/* this is the model-independent version. Since the standard I/O library
+/* This is the model-independent version. Since the standard I/O library
can't handle far buffers in the medium and small models, we have to copy
the data.
*/
@@ -413,7 +422,8 @@
{
pngtest_warning(png_ptr, message);
/* We can return because png_error calls the default handler, which is
- * actually OK in this case. */
+ * actually OK in this case.
+ */
}
#endif /* PNG_NO_STDIO */
/* END of code to validate stdio-free compilation */
@@ -422,13 +432,14 @@
#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
/* Allocate memory. For reasonable files, size should never exceed
- 64K. However, zlib may allocate more then 64K if you don't tell
- it not to. See zconf.h and png.h for more information. zlib does
- need to allocate exactly 64K, so whatever you call here must
- have the ability to do that.
-
- This piece of code can be compiled to validate max 64K allocations
- by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K. */
+ * 64K. However, zlib may allocate more then 64K if you don't tell
+ * it not to. See zconf.h and png.h for more information. zlib does
+ * need to allocate exactly 64K, so whatever you call here must
+ * have the ability to do that.
+ *
+ * This piece of code can be compiled to validate max 64K allocations
+ * by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K.
+ */
typedef struct memory_information
{
png_alloc_size_t size;
@@ -452,7 +463,8 @@
{
/* png_malloc has already tested for NULL; png_create_struct calls
- png_debug_malloc directly, with png_ptr == NULL which is OK */
+ * png_debug_malloc directly, with png_ptr == NULL which is OK
+ */
if (size == 0)
return (NULL);
@@ -548,7 +560,7 @@
/* Demonstration of user chunk support of the sTER and vpAg chunks */
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
-/* (sTER is a public chunk not yet understood by libpng. vpAg is a private
+/* (sTER is a public chunk not yet known by libpng. vpAg is a private
chunk used in ImageMagick to store "virtual page" size). */
static png_uint_32 user_chunk_data[4];
@@ -562,50 +574,51 @@
static int read_user_chunk_callback(png_struct *png_ptr,
png_unknown_chunkp chunk)
{
- png_uint_32
- *my_user_chunk_data;
+ png_uint_32
+ *my_user_chunk_data;
- /* Return one of the following: */
- /* return (-n); chunk had an error */
- /* return (0); did not recognize */
- /* return (n); success */
+ /* Return one of the following:
+ * return (-n); chunk had an error
+ * return (0); did not recognize
+ * return (n); success
+ *
+ * The unknown chunk structure contains the chunk data:
+ * png_byte name[5];
+ * png_byte *data;
+ * png_size_t size;
+ *
+ * Note that libpng has already taken care of the CRC handling.
+ */
- /* The unknown chunk structure contains the chunk data:
- * png_byte name[5];
- * png_byte *data;
- * png_size_t size;
- *
- * Note that libpng has already taken care of the CRC handling.
- */
+ if (chunk->name[0] == 115 && chunk->name[1] == 84 && /* s T */
+ chunk->name[2] == 69 && chunk->name[3] == 82) /* E R */
+ {
+ /* Found sTER chunk */
+ if (chunk->size != 1)
+ return (-1); /* Error return */
+ if (chunk->data[0] != 0 && chunk->data[0] != 1)
+ return (-1); /* Invalid mode */
+ my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);
+ my_user_chunk_data[0]=chunk->data[0]+1;
+ return (1);
+ }
- if (chunk->name[0] == 115 && chunk->name[1] == 84 && /* s T */
- chunk->name[2] == 69 && chunk->name[3] == 82) /* E R */
- {
- /* Found sTER chunk */
- if (chunk->size != 1)
- return (-1); /* Error return */
- if (chunk->data[0] != 0 && chunk->data[0] != 1)
- return (-1); /* Invalid mode */
- my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);
- my_user_chunk_data[0]=chunk->data[0]+1;
- return (1);
- }
- if (chunk->name[0] != 118 || chunk->name[1] != 112 || /* v p */
- chunk->name[2] != 65 || chunk->name[3] != 103) /* A g */
- return (0); /* Did not recognize */
+ if (chunk->name[0] != 118 || chunk->name[1] != 112 || /* v p */
+ chunk->name[2] != 65 || chunk->name[3] != 103) /* A g */
+ return (0); /* Did not recognize */
- /* Found ImageMagick vpAg chunk */
+ /* Found ImageMagick vpAg chunk */
- if (chunk->size != 9)
- return (-1); /* Error return */
+ if (chunk->size != 9)
+ return (-1); /* Error return */
- my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);
+ my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr);
- my_user_chunk_data[1]=png_get_uint_31(png_ptr, chunk->data);
- my_user_chunk_data[2]=png_get_uint_31(png_ptr, chunk->data + 4);
- my_user_chunk_data[3]=(png_uint_32)chunk->data[8];
+ my_user_chunk_data[1]=png_get_uint_31(png_ptr, chunk->data);
+ my_user_chunk_data[2]=png_get_uint_31(png_ptr, chunk->data + 4);
+ my_user_chunk_data[3]=(png_uint_32)chunk->data[8];
- return (1);
+ return (1);
}
#endif
@@ -672,12 +685,12 @@
#endif
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
- user_chunk_data[0] = 0;
- user_chunk_data[1] = 0;
- user_chunk_data[2] = 0;
- user_chunk_data[3] = 0;
- png_set_read_user_chunk_fn(read_ptr, user_chunk_data,
- read_user_chunk_callback);
+ user_chunk_data[0] = 0;
+ user_chunk_data[1] = 0;
+ user_chunk_data[2] = 0;
+ user_chunk_data[3] = 0;
+ png_set_read_user_chunk_fn(read_ptr, user_chunk_data,
+ read_user_chunk_callback);
#endif
#ifdef PNG_WRITE_SUPPORTED
@@ -784,10 +797,10 @@
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
{
- int i;
- for (i = 0; i<256; i++)
- filters_used[i] = 0;
- png_set_read_user_transform_fn(read_ptr, count_filters);
+ int i;
+ for (i = 0; i<256; i++)
+ filters_used[i] = 0;
+ png_set_read_user_transform_fn(read_ptr, count_filters);
}
#endif
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
@@ -846,9 +859,7 @@
png_fixed_point gamma;
if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma))
- {
png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);
- }
}
#endif
#else /* Use floating point versions */
@@ -870,9 +881,7 @@
double gamma;
if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))
- {
png_set_gAMA(write_ptr, write_info_ptr, gamma);
- }
}
#endif
#endif /* floating point */
@@ -897,9 +906,7 @@
int intent;
if (png_get_sRGB(read_ptr, read_info_ptr, &intent))
- {
png_set_sRGB(write_ptr, write_info_ptr, intent);
- }
}
#endif
{
@@ -907,9 +914,7 @@
int num_palette;
if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette))
- {
png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);
- }
}
#if defined(PNG_bKGD_SUPPORTED)
{
@@ -926,9 +931,7 @@
png_uint_16p hist;
if (png_get_hIST(read_ptr, read_info_ptr, &hist))
- {
png_set_hIST(write_ptr, write_info_ptr, hist);
- }
}
#endif
#if defined(PNG_oFFs_SUPPORTED)
@@ -937,7 +940,7 @@
int unit_type;
if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,
- &unit_type))
+ &unit_type))
{
png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);
}
@@ -964,9 +967,7 @@
int unit_type;
if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type))
- {
png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);
- }
}
#endif
#if defined(PNG_sBIT_SUPPORTED)
@@ -974,9 +975,7 @@
png_color_8p sig_bit;
if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))
- {
png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
- }
}
#endif
#if defined(PNG_sCAL_SUPPORTED)
@@ -1027,8 +1026,9 @@
png_set_tIME(write_ptr, write_info_ptr, mod_time);
#if defined(PNG_TIME_RFC1123_SUPPORTED)
/* we have to use png_memcpy instead of "=" because the string
- pointed to by png_convert_to_rfc1123() gets free'ed before
- we use it */
+ * pointed to by png_convert_to_rfc1123() gets free'ed before
+ * we use it.
+ */
png_memcpy(tIME_string,
png_convert_to_rfc1123(read_ptr, mod_time),
png_sizeof(tIME_string));
@@ -1050,13 +1050,13 @@
int sample_max = (1 << read_info_ptr->bit_depth);
/* libpng doesn't reject a tRNS chunk with out-of-range samples */
if (!((read_info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
- (int)trans_color->gray > sample_max) ||
- (read_info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
- ((int)trans_color->red > sample_max ||
- (int)trans_color->green > sample_max ||
- (int)trans_color->blue > sample_max))))
- png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans,
- trans_color);
+ (int)trans_color->gray > sample_max) ||
+ (read_info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
+ ((int)trans_color->red > sample_max ||
+ (int)trans_color->green > sample_max ||
+ (int)trans_color->blue > sample_max))))
+ png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans,
+ trans_color);
}
}
#endif
@@ -1071,8 +1071,9 @@
png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,
num_unknowns);
/* copy the locations from the read_info_ptr. The automatically
- generated locations in write_info_ptr are wrong because we
- haven't written anything yet */
+ * generated locations in write_info_ptr are wrong because we
+ * haven't written anything yet.
+ */
for (i = 0; i < (png_size_t)num_unknowns; i++)
png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,
unknowns[i].location);
@@ -1084,40 +1085,40 @@
png_debug(0, "Writing info struct");
/* If we wanted, we could write info in two steps:
- png_write_info_before_PLTE(write_ptr, write_info_ptr);
+ * png_write_info_before_PLTE(write_ptr, write_info_ptr);
*/
png_write_info(write_ptr, write_info_ptr);
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
if (user_chunk_data[0] != 0)
{
- png_byte png_sTER[5] = {115, 84, 69, 82, '\0'};
+ png_byte png_sTER[5] = {115, 84, 69, 82, '\0'};
- unsigned char
- ster_chunk_data[1];
+ unsigned char
+ ster_chunk_data[1];
- if (verbose)
- fprintf(STDERR, "\n stereo mode = %lu\n",
- (unsigned long)(user_chunk_data[0] - 1));
- ster_chunk_data[0]=(unsigned char)(user_chunk_data[0] - 1);
- png_write_chunk(write_ptr, png_sTER, ster_chunk_data, 1);
+ if (verbose)
+ fprintf(STDERR, "\n stereo mode = %lu\n",
+ (unsigned long)(user_chunk_data[0] - 1));
+ ster_chunk_data[0]=(unsigned char)(user_chunk_data[0] - 1);
+ png_write_chunk(write_ptr, png_sTER, ster_chunk_data, 1);
}
if (user_chunk_data[1] != 0 || user_chunk_data[2] != 0)
{
- png_byte png_vpAg[5] = {118, 112, 65, 103, '\0'};
+ png_byte png_vpAg[5] = {118, 112, 65, 103, '\0'};
- unsigned char
- vpag_chunk_data[9];
+ unsigned char
+ vpag_chunk_data[9];
- if (verbose)
- fprintf(STDERR, " vpAg = %lu x %lu, units = %lu\n",
- (unsigned long)user_chunk_data[1],
- (unsigned long)user_chunk_data[2],
- (unsigned long)user_chunk_data[3]);
- png_save_uint_32(vpag_chunk_data, user_chunk_data[1]);
- png_save_uint_32(vpag_chunk_data + 4, user_chunk_data[2]);
- vpag_chunk_data[8] = (unsigned char)(user_chunk_data[3] & 0xff);
- png_write_chunk(write_ptr, png_vpAg, vpag_chunk_data, 9);
+ if (verbose)
+ fprintf(STDERR, " vpAg = %lu x %lu, units = %lu\n",
+ (unsigned long)user_chunk_data[1],
+ (unsigned long)user_chunk_data[2],
+ (unsigned long)user_chunk_data[3]);
+ png_save_uint_32(vpag_chunk_data, user_chunk_data[1]);
+ png_save_uint_32(vpag_chunk_data + 4, user_chunk_data[2]);
+ vpag_chunk_data[8] = (unsigned char)(user_chunk_data[3] & 0xff);
+ png_write_chunk(write_ptr, png_vpAg, vpag_chunk_data, 9);
}
#endif
@@ -1236,8 +1237,9 @@
png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns,
num_unknowns);
/* copy the locations from the read_info_ptr. The automatically
- generated locations in write_end_info_ptr are wrong because we
- haven't written the end_info yet */
+ * generated locations in write_end_info_ptr are wrong because we
+ * haven't written the end_info yet.
+ */
for (i = 0; i < (png_size_t)num_unknowns; i++)
png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,
unknowns[i].location);
@@ -1379,9 +1381,10 @@
(long)png_sizeof(png_struct), (long)png_sizeof(png_info));
/* Do some consistency checking on the memory allocation settings, I'm
- not sure this matters, but it is nice to know, the first of these
- tests should be impossible because of the way the macros are set
- in pngconf.h */
+ * not sure this matters, but it is nice to know, the first of these
+ * tests should be impossible because of the way the macros are set
+ * in pngconf.h
+ */
#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");
#endif
diff --git a/pngtrans.c b/pngtrans.c
index 0fef0b2..61e78b3 100644
--- a/pngtrans.c
+++ b/pngtrans.c
@@ -13,12 +13,13 @@
#include "pngpriv.h"
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
-/* turn on BGR-to-RGB mapping */
+/* Turn on BGR-to-RGB mapping */
void PNGAPI
png_set_bgr(png_structp png_ptr)
{
png_debug(1, "in png_set_bgr");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= PNG_BGR;
}
#endif
@@ -29,7 +30,8 @@
png_set_swap(png_structp png_ptr)
{
png_debug(1, "in png_set_swap");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
if (png_ptr->bit_depth == 16)
png_ptr->transformations |= PNG_SWAP_BYTES;
}
@@ -41,7 +43,8 @@
png_set_packing(png_structp png_ptr)
{
png_debug(1, "in png_set_packing");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
if (png_ptr->bit_depth < 8)
{
png_ptr->transformations |= PNG_PACK;
@@ -56,7 +59,8 @@
png_set_packswap(png_structp png_ptr)
{
png_debug(1, "in png_set_packswap");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
if (png_ptr->bit_depth < 8)
png_ptr->transformations |= PNG_PACKSWAP;
}
@@ -67,7 +71,8 @@
png_set_shift(png_structp png_ptr, png_color_8p true_bits)
{
png_debug(1, "in png_set_shift");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= PNG_SHIFT;
png_ptr->shift = *true_bits;
}
@@ -99,7 +104,8 @@
png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
{
png_debug(1, "in png_set_filler");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= PNG_FILLER;
png_ptr->filler = (png_byte)filler;
if (filler_loc == PNG_FILLER_AFTER)
@@ -131,7 +137,8 @@
png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
{
png_debug(1, "in png_set_add_alpha");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_set_filler(png_ptr, filler, filler_loc);
png_ptr->transformations |= PNG_ADD_ALPHA;
}
@@ -144,7 +151,8 @@
png_set_swap_alpha(png_structp png_ptr)
{
png_debug(1, "in png_set_swap_alpha");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= PNG_SWAP_ALPHA;
}
#endif
@@ -155,7 +163,8 @@
png_set_invert_alpha(png_structp png_ptr)
{
png_debug(1, "in png_set_invert_alpha");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= PNG_INVERT_ALPHA;
}
#endif
@@ -165,7 +174,8 @@
png_set_invert_mono(png_structp png_ptr)
{
png_debug(1, "in png_set_invert_mono");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
png_ptr->transformations |= PNG_INVERT_MONO;
}
@@ -348,7 +358,7 @@
0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
};
-/* swaps pixel packing order within bytes */
+/* Swaps pixel packing order within bytes */
void /* PRIVATE */
png_do_packswap(png_row_infop row_info, png_bytep row)
{
@@ -377,7 +387,7 @@
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
-/* remove filler or alpha byte(s) */
+/* Remove filler or alpha byte(s) */
void /* PRIVATE */
png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
{
@@ -389,9 +399,9 @@
png_uint_32 i;
if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||
- (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
- (flags & PNG_FLAG_STRIP_ALPHA))) &&
- row_info->channels == 4)
+ (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
+ (flags & PNG_FLAG_STRIP_ALPHA))) &&
+ row_info->channels == 4)
{
if (row_info->bit_depth == 8)
{
@@ -532,7 +542,7 @@
#endif
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
-/* swaps red and blue bytes within a pixel */
+/* Swaps red and blue bytes within a pixel */
void /* PRIVATE */
png_do_bgr(png_row_infop row_info, png_bytep row)
{
@@ -613,7 +623,8 @@
user_transform_ptr, int user_transform_depth, int user_transform_channels)
{
png_debug(1, "in png_set_user_transform_info");
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
png_ptr->user_transform_ptr = user_transform_ptr;
png_ptr->user_transform_depth = (png_byte)user_transform_depth;
@@ -634,7 +645,8 @@
png_voidp PNGAPI
png_get_user_transform_ptr(png_structp png_ptr)
{
- if (png_ptr == NULL) return (NULL);
+ if (png_ptr == NULL)
+ return (NULL);
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
return ((png_voidp)png_ptr->user_transform_ptr);
#else
diff --git a/pngwio.c b/pngwio.c
index d094cff..b76632a 100644
--- a/pngwio.c
+++ b/pngwio.c
@@ -20,10 +20,11 @@
#include "pngpriv.h"
/* Write the data to whatever output you are using. The default routine
- writes to a file pointer. Note that this routine sometimes gets called
- with very small lengths, so you should implement some kind of simple
- buffering if you are using unbuffered writes. This should never be asked
- to write more than 64K on a 16 bit machine. */
+ * writes to a file pointer. Note that this routine sometimes gets called
+ * with very small lengths, so you should implement some kind of simple
+ * buffering if you are using unbuffered writes. This should never be asked
+ * to write more than 64K on a 16 bit machine.
+ */
void /* PRIVATE */
png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
@@ -36,9 +37,10 @@
#if !defined(PNG_NO_STDIO)
/* This is the function that does the actual writing of data. If you are
- not writing to a standard C stream, you should create a replacement
- write_data function and use it at run time with png_set_write_fn(), rather
- than changing the library. */
+ * not writing to a standard C stream, you should create a replacement
+ * write_data function and use it at run time with png_set_write_fn(), rather
+ * than changing the library.
+ */
#ifndef USE_FAR_KEYWORD
void PNGAPI
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
@@ -51,10 +53,10 @@
png_error(png_ptr, "Write Error");
}
#else
-/* this is the model-independent version. Since the standard I/O library
- can't handle far buffers in the medium and small models, we have to copy
- the data.
-*/
+/* This is the model-independent version. Since the standard I/O library
+ * can't handle far buffers in the medium and small models, we have to copy
+ * the data.
+ */
#define NEAR_BUF_SIZE 1024
#define MIN(a,b) (a <= b ? a : b)
@@ -87,8 +89,10 @@
err = fwrite(buf, 1, written, io_ptr);
if (err != written)
break;
+
else
check += err;
+
data += written;
remaining -= written;
}
@@ -102,8 +106,9 @@
#endif
/* This function is called to output any data pending writing (normally
- to disk). After png_flush is called, there should be no data pending
- writing in any buffers. */
+ * to disk). After png_flush is called, there should be no data pending
+ * writing in any buffers.
+ */
#if defined(PNG_WRITE_FLUSH_SUPPORTED)
void /* PRIVATE */
png_flush(png_structp png_ptr)
@@ -117,7 +122,8 @@
png_default_flush(png_structp png_ptr)
{
png_FILE_p io_ptr;
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
fflush(io_ptr);
}
@@ -125,43 +131,47 @@
#endif
/* This function allows the application to supply new output functions for
- libpng if standard C streams aren't being used.
-
- This function takes as its arguments:
- png_ptr - pointer to a png output data structure
- io_ptr - pointer to user supplied structure containing info about
- the output functions. May be NULL.
- write_data_fn - pointer to a new output function that takes as its
- arguments a pointer to a png_struct, a pointer to
- data to be written, and a 32-bit unsigned int that is
- the number of bytes to be written. The new write
- function should call png_error(png_ptr, "Error msg")
- to exit and output any fatal error messages. May be
- NULL, in which case libpng's default function will
- be used.
- flush_data_fn - pointer to a new flush function that takes as its
- arguments a pointer to a png_struct. After a call to
- the flush function, there should be no data in any buffers
- or pending transmission. If the output method doesn't do
- any buffering of ouput, a function prototype must still be
- supplied although it doesn't have to do anything. If
- PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
- time, output_flush_fn will be ignored, although it must be
- supplied for compatibility. May be NULL, in which case
- libpng's default function will be used, if
- PNG_WRITE_FLUSH_SUPPORTED is defined. This is not
- a good idea if io_ptr does not point to a standard
- *FILE structure. */
+ * libpng if standard C streams aren't being used.
+ *
+ * This function takes as its arguments:
+ * png_ptr - pointer to a png output data structure
+ * io_ptr - pointer to user supplied structure containing info about
+ * the output functions. May be NULL.
+ * write_data_fn - pointer to a new output function that takes as its
+ * arguments a pointer to a png_struct, a pointer to
+ * data to be written, and a 32-bit unsigned int that is
+ * the number of bytes to be written. The new write
+ * function should call png_error(png_ptr, "Error msg")
+ * to exit and output any fatal error messages. May be
+ * NULL, in which case libpng's default function will
+ * be used.
+ * flush_data_fn - pointer to a new flush function that takes as its
+ * arguments a pointer to a png_struct. After a call to
+ * the flush function, there should be no data in any buffers
+ * or pending transmission. If the output method doesn't do
+ * any buffering of ouput, a function prototype must still be
+ * supplied although it doesn't have to do anything. If
+ * PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
+ * time, output_flush_fn will be ignored, although it must be
+ * supplied for compatibility. May be NULL, in which case
+ * libpng's default function will be used, if
+ * PNG_WRITE_FLUSH_SUPPORTED is defined. This is not
+ * a good idea if io_ptr does not point to a standard
+ * *FILE structure.
+ */
void PNGAPI
png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
{
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
+
png_ptr->io_ptr = io_ptr;
#if !defined(PNG_NO_STDIO)
if (write_data_fn != NULL)
png_ptr->write_data_fn = write_data_fn;
+
else
png_ptr->write_data_fn = png_default_write_data;
#else
@@ -172,6 +182,7 @@
#if !defined(PNG_NO_STDIO)
if (output_flush_fn != NULL)
png_ptr->output_flush_fn = output_flush_fn;
+
else
png_ptr->output_flush_fn = png_default_flush;
#else
@@ -198,9 +209,11 @@
void FAR *far_ptr;
FP_OFF(near_ptr) = FP_OFF(ptr);
far_ptr = (void FAR *)near_ptr;
+
if (check != 0)
if (FP_SEG(ptr) != FP_SEG(far_ptr))
png_error(png_ptr, "segment lost in conversion");
+
return(near_ptr);
}
# else
@@ -210,9 +223,11 @@
void FAR *far_ptr;
near_ptr = (void FAR *)ptr;
far_ptr = (void FAR *)near_ptr;
+
if (check != 0)
if (far_ptr != ptr)
png_error(png_ptr, "segment lost in conversion");
+
return(near_ptr);
}
# endif
diff --git a/pngwrite.c b/pngwrite.c
index 992a02d..c33e767 100644
--- a/pngwrite.c
+++ b/pngwrite.c
@@ -47,8 +47,9 @@
#else
0);
#endif
- /* the rest of these check to see if the valid field has the appropriate
- flag set, and if it does, writes the chunk. */
+ /* The rest of these check to see if the valid field has the appropriate
+ * flag set, and if it does, writes the chunk.
+ */
#if defined(PNG_WRITE_gAMA_SUPPORTED)
if (info_ptr->valid & PNG_INFO_gAMA)
{
@@ -97,14 +98,14 @@
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
if (info_ptr->unknown_chunks_num)
{
- png_unknown_chunk *up;
+ png_unknown_chunk *up;
- png_debug(5, "writing extra chunks");
+ png_debug(5, "writing extra chunks");
- for (up = info_ptr->unknown_chunks;
- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
- up++)
- {
+ for (up = info_ptr->unknown_chunks;
+ up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+ up++)
+ {
int keep=png_handle_as_unknown(png_ptr, up->name);
if (keep != PNG_HANDLE_CHUNK_NEVER &&
up->location && !(up->location & PNG_HAVE_PLTE) &&
@@ -116,7 +117,7 @@
png_warning(png_ptr, "Writing zero-length unknown chunk");
png_write_chunk(png_ptr, up->name, up->data, up->size);
}
- }
+ }
}
#endif
png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
@@ -145,20 +146,20 @@
#if defined(PNG_WRITE_tRNS_SUPPORTED)
if (info_ptr->valid & PNG_INFO_tRNS)
- {
+ {
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
- /* invert the alpha channel (in tRNS) */
- if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
- info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
- {
- int j;
- for (j=0; j<(int)info_ptr->num_trans; j++)
- info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]);
- }
+ /* invert the alpha channel (in tRNS) */
+ if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
+ info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+ {
+ int j;
+ for (j=0; j<(int)info_ptr->num_trans; j++)
+ info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]);
+ }
#endif
png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_color),
info_ptr->num_trans, info_ptr->color_type);
- }
+ }
#endif
#if defined(PNG_WRITE_bKGD_SUPPORTED)
if (info_ptr->valid & PNG_INFO_bKGD)
@@ -179,8 +180,9 @@
info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
info_ptr->pcal_units, info_ptr->pcal_params);
#endif
-#if defined(PNG_WRITE_sCAL_SUPPORTED)
+#if defined(PNG_sCAL_SUPPORTED)
if (info_ptr->valid & PNG_INFO_sCAL)
+#if defined(PNG_WRITE_sCAL_SUPPORTED)
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,
info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);
@@ -188,29 +190,34 @@
#ifdef PNG_FIXED_POINT_SUPPORTED
png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
info_ptr->scal_s_width, info_ptr->scal_s_height);
-#else
+#endif /* FIXED_POINT */
+#endif /* FLOATING_POINT */
+#else /* WRITE_sCAL */
png_warning(png_ptr,
"png_write_sCAL not supported; sCAL chunk not written");
-#endif
-#endif
-#endif
+#endif /* WRITE_sCAL */
+#endif /* sCAL */
+
#if defined(PNG_WRITE_pHYs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_pHYs)
png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
-#endif
+#endif /* pHYs */
+
#if defined(PNG_WRITE_tIME_SUPPORTED)
if (info_ptr->valid & PNG_INFO_tIME)
{
png_write_tIME(png_ptr, &(info_ptr->mod_time));
png_ptr->mode |= PNG_WROTE_tIME;
}
-#endif
+#endif /* tIME */
+
#if defined(PNG_WRITE_sPLT_SUPPORTED)
if (info_ptr->valid & PNG_INFO_sPLT)
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
-#endif
+#endif /* sPLT */
+
#if defined(PNG_WRITE_TEXT_SUPPORTED)
/* Check to see if we need to write text chunks */
for (i = 0; i < info_ptr->num_text; i++)
@@ -255,25 +262,27 @@
png_write_tEXt(png_ptr, info_ptr->text[i].key,
info_ptr->text[i].text,
0);
-#else
- png_warning(png_ptr, "Unable to write uncompressed text");
-#endif
/* Mark this chunk as written */
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+#else
+ /* Can't get here */
+ png_warning(png_ptr, "Unable to write uncompressed text");
+#endif
}
}
-#endif
+#endif /* tEXt */
+
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
if (info_ptr->unknown_chunks_num)
{
- png_unknown_chunk *up;
+ png_unknown_chunk *up;
- png_debug(5, "writing extra chunks");
+ png_debug(5, "writing extra chunks");
- for (up = info_ptr->unknown_chunks;
- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
- up++)
- {
+ for (up = info_ptr->unknown_chunks;
+ up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+ up++)
+ {
int keep=png_handle_as_unknown(png_ptr, up->name);
if (keep != PNG_HANDLE_CHUNK_NEVER &&
up->location && (up->location & PNG_HAVE_PLTE) &&
@@ -283,7 +292,7 @@
{
png_write_chunk(png_ptr, up->name, up->data, up->size);
}
- }
+ }
}
#endif
}
@@ -324,18 +333,18 @@
if (info_ptr->text[i].compression > 0)
{
#if defined(PNG_WRITE_iTXt_SUPPORTED)
- /* write international chunk */
- png_write_iTXt(png_ptr,
- info_ptr->text[i].compression,
- info_ptr->text[i].key,
- info_ptr->text[i].lang,
- info_ptr->text[i].lang_key,
- info_ptr->text[i].text);
+ /* write international chunk */
+ png_write_iTXt(png_ptr,
+ info_ptr->text[i].compression,
+ info_ptr->text[i].key,
+ info_ptr->text[i].lang,
+ info_ptr->text[i].lang_key,
+ info_ptr->text[i].text);
#else
- png_warning(png_ptr, "Unable to write international text");
+ png_warning(png_ptr, "Unable to write international text");
#endif
- /* Mark this chunk as written */
- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
+ /* Mark this chunk as written */
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
}
else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
{
@@ -368,14 +377,14 @@
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
if (info_ptr->unknown_chunks_num)
{
- png_unknown_chunk *up;
+ png_unknown_chunk *up;
- png_debug(5, "writing extra chunks");
+ png_debug(5, "writing extra chunks");
- for (up = info_ptr->unknown_chunks;
- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
- up++)
- {
+ for (up = info_ptr->unknown_chunks;
+ up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
+ up++)
+ {
int keep=png_handle_as_unknown(png_ptr, up->name);
if (keep != PNG_HANDLE_CHUNK_NEVER &&
up->location && (up->location & PNG_AFTER_IDAT) &&
@@ -384,7 +393,7 @@
{
png_write_chunk(png_ptr, up->name, up->data, up->size);
}
- }
+ }
}
#endif
}
@@ -449,7 +458,7 @@
#endif /* PNG_USER_MEM_SUPPORTED */
int png_cleanup_needed = 0;
#ifdef PNG_SETJMP_SUPPORTED
- volatile
+ volatile
#endif
png_structp png_ptr;
#ifdef PNG_SETJMP_SUPPORTED
@@ -483,7 +492,7 @@
#else
if (setjmp(png_ptr->jmpbuf))
#endif
- PNG_ABORT();
+ PNG_ABORT();
#endif
#ifdef PNG_USER_MEM_SUPPORTED
@@ -493,12 +502,12 @@
if (user_png_ver)
{
- i=0;
- do
- {
- if (user_png_ver[i] != png_libpng_ver[i])
- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
- } while (png_libpng_ver[i++]);
+ i=0;
+ do
+ {
+ if (user_png_ver[i] != png_libpng_ver[i])
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
+ } while (png_libpng_ver[i++]);
}
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
@@ -516,10 +525,10 @@
char msg[80];
if (user_png_ver)
{
- png_snprintf(msg, 80,
- "Application was compiled with png.h from libpng-%.20s",
- user_png_ver);
- png_warning(png_ptr, msg);
+ png_snprintf(msg, 80,
+ "Application was compiled with png.h from libpng-%.20s",
+ user_png_ver);
+ png_warning(png_ptr, msg);
}
png_snprintf(msg, 80,
"Application is running with png.c from libpng-%.20s",
@@ -538,25 +547,25 @@
/* initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE;
if (!png_cleanup_needed)
- {
- png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr,
- png_ptr->zbuf_size);
- if (png_ptr->zbuf == NULL)
- png_cleanup_needed = 1;
- }
+ {
+ png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr,
+ png_ptr->zbuf_size);
+ if (png_ptr->zbuf == NULL)
+ png_cleanup_needed = 1;
+ }
if (png_cleanup_needed)
- {
- /* Clean up PNG structure and deallocate any memory. */
- png_free(png_ptr, png_ptr->zbuf);
- png_ptr->zbuf = NULL;
+ {
+ /* Clean up PNG structure and deallocate any memory. */
+ png_free(png_ptr, png_ptr->zbuf);
+ png_ptr->zbuf = NULL;
#ifdef PNG_USER_MEM_SUPPORTED
- png_destroy_struct_2((png_voidp)png_ptr,
- (png_free_ptr)free_fn, (png_voidp)mem_ptr);
+ png_destroy_struct_2((png_voidp)png_ptr,
+ (png_free_ptr)free_fn, (png_voidp)mem_ptr);
#else
- png_destroy_struct((png_voidp)png_ptr);
+ png_destroy_struct((png_voidp)png_ptr);
#endif
- return (NULL);
- }
+ return (NULL);
+ }
png_set_write_fn(png_ptr, NULL, NULL, NULL);
@@ -609,7 +618,8 @@
png_debug(1, "in png_write_image");
#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
/* intialize interlace handling. If image is not interlaced,
- this will set pass to 1 */
+ * this will set pass to 1
+ */
num_pass = png_set_interlace_handling(png_ptr);
#else
num_pass = 1;
@@ -637,39 +647,39 @@
/* initialize transformations and other stuff if first time */
if (png_ptr->row_number == 0 && png_ptr->pass == 0)
{
- /* make sure we wrote the header info */
- if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
- png_error(png_ptr,
- "png_write_info was never called before png_write_row");
+ /* make sure we wrote the header info */
+ if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
+ png_error(png_ptr,
+ "png_write_info was never called before png_write_row");
- /* check for transforms that have been set but were defined out */
+ /* check for transforms that have been set but were defined out */
#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
- if (png_ptr->transformations & PNG_INVERT_MONO)
- png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined");
+ if (png_ptr->transformations & PNG_INVERT_MONO)
+ png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined");
#endif
#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
- if (png_ptr->transformations & PNG_FILLER)
- png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined");
+ if (png_ptr->transformations & PNG_FILLER)
+ png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined");
#endif
#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED)
- if (png_ptr->transformations & PNG_PACKSWAP)
- png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined");
+ if (png_ptr->transformations & PNG_PACKSWAP)
+ png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined");
#endif
#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
- if (png_ptr->transformations & PNG_PACK)
- png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined");
+ if (png_ptr->transformations & PNG_PACK)
+ png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined");
#endif
#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
- if (png_ptr->transformations & PNG_SHIFT)
- png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined");
+ if (png_ptr->transformations & PNG_SHIFT)
+ png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined");
#endif
#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
- if (png_ptr->transformations & PNG_BGR)
- png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined");
+ if (png_ptr->transformations & PNG_BGR)
+ png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined");
#endif
#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
- if (png_ptr->transformations & PNG_SWAP_BYTES)
- png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined");
+ if (png_ptr->transformations & PNG_SWAP_BYTES)
+ png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined");
#endif
png_write_start_row(png_ptr);
@@ -756,13 +766,13 @@
png_memcpy(png_ptr->row_buf + 1, row, png_ptr->row_info.rowbytes);
#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
- /* handle interlacing */
+ /* Handle interlacing */
if (png_ptr->interlaced && png_ptr->pass < 6 &&
(png_ptr->transformations & PNG_INTERLACE))
{
png_do_write_interlace(&(png_ptr->row_info),
png_ptr->row_buf + 1, png_ptr->pass);
- /* this should always get caught above, but still ... */
+ /* This should always get caught above, but still ... */
if (!(png_ptr->row_info.width))
{
png_write_finish_row(png_ptr);
@@ -771,7 +781,7 @@
}
#endif
- /* handle other transformations */
+ /* Handle other transformations */
if (png_ptr->transformations)
png_do_write_transformations(png_ptr);
@@ -822,7 +832,7 @@
return;
/* We have already written out all of the data */
if (png_ptr->row_number >= png_ptr->num_rows)
- return;
+ return;
do
{
@@ -866,7 +876,7 @@
}
#endif /* PNG_WRITE_FLUSH_SUPPORTED */
-/* free all memory used by the write */
+/* Free all memory used by the write */
void PNGAPI
png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
{
@@ -978,7 +988,7 @@
#endif
#ifdef PNG_SETJMP_SUPPORTED
- /* reset structure */
+ /* Reset structure */
png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
#endif
@@ -1334,9 +1344,9 @@
if (png_ptr == NULL || info_ptr == NULL)
return;
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
- /* invert the alpha channel from opacity to transparency */
+ /* Invert the alpha channel from opacity to transparency */
if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
- png_set_invert_alpha(png_ptr);
+ png_set_invert_alpha(png_ptr);
#endif
/* Write the file header information. */
@@ -1345,9 +1355,9 @@
/* ------ these transformations don't touch the info structure ------- */
#if defined(PNG_WRITE_INVERT_SUPPORTED)
- /* invert monochrome pixels */
+ /* Invert monochrome pixels */
if (transforms & PNG_TRANSFORM_INVERT_MONO)
- png_set_invert_mono(png_ptr);
+ png_set_invert_mono(png_ptr);
#endif
#if defined(PNG_WRITE_SHIFT_SUPPORTED)
@@ -1356,50 +1366,50 @@
*/
if ((transforms & PNG_TRANSFORM_SHIFT)
&& (info_ptr->valid & PNG_INFO_sBIT))
- png_set_shift(png_ptr, &info_ptr->sig_bit);
+ png_set_shift(png_ptr, &info_ptr->sig_bit);
#endif
#if defined(PNG_WRITE_PACK_SUPPORTED)
- /* pack pixels into bytes */
+ /* Pack pixels into bytes */
if (transforms & PNG_TRANSFORM_PACKING)
png_set_packing(png_ptr);
#endif
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
- /* swap location of alpha bytes from ARGB to RGBA */
+ /* Swap location of alpha bytes from ARGB to RGBA */
if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
- png_set_swap_alpha(png_ptr);
+ png_set_swap_alpha(png_ptr);
#endif
#if defined(PNG_WRITE_FILLER_SUPPORTED)
/* Pack XRGB/RGBX/ARGB/RGBA into * RGB (4 channels -> 3 channels) */
- if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER)
+ if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER)
png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
- else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE)
+ else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE)
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
#endif
#if defined(PNG_WRITE_BGR_SUPPORTED)
- /* flip BGR pixels to RGB */
+ /* Flip BGR pixels to RGB */
if (transforms & PNG_TRANSFORM_BGR)
- png_set_bgr(png_ptr);
+ png_set_bgr(png_ptr);
#endif
#if defined(PNG_WRITE_SWAP_SUPPORTED)
- /* swap bytes of 16-bit files to most significant byte first */
+ /* Swap bytes of 16-bit files to most significant byte first */
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
- png_set_swap(png_ptr);
+ png_set_swap(png_ptr);
#endif
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
- /* swap bits of 1, 2, 4 bit packed pixel formats */
+ /* Swap bits of 1, 2, 4 bit packed pixel formats */
if (transforms & PNG_TRANSFORM_PACKSWAP)
- png_set_packswap(png_ptr);
+ png_set_packswap(png_ptr);
#endif
/* ----------------------- end of transformations ------------------- */
- /* write the bits */
+ /* Write the bits */
if (info_ptr->valid & PNG_INFO_IDAT)
png_write_image(png_ptr, info_ptr->row_pointers);
diff --git a/pngwutil.c b/pngwutil.c
index 1b680ec..76f2bda 100644
--- a/pngwutil.c
+++ b/pngwutil.c
@@ -67,7 +67,7 @@
png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;
#endif
- /* write the rest of the 8 byte signature */
+ /* 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)
@@ -87,7 +87,8 @@
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, (png_size_t)length);
png_write_chunk_end(png_ptr);
@@ -112,15 +113,16 @@
png_debug2(0, "Writing %s chunk, length = %lu", chunk_name,
(unsigned long)length);
- if (png_ptr == NULL) return;
+ if (png_ptr == NULL)
+ return;
- /* write the length and the chunk name */
+ /* Write the length and the chunk name */
png_save_uint_32(buf, length);
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 */
+ /* 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 */
+ /* Reset the crc and run it over the chunk name */
png_reset_crc(png_ptr);
png_calculate_crc(png_ptr, chunk_name, 4);
@@ -140,12 +142,13 @@
void PNGAPI
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;
+ /* Write the data, and run the CRC over it */
+ if (png_ptr == NULL)
+ return;
if (data != NULL && length > 0)
{
png_write_data(png_ptr, data, length);
- /* update the CRC after writing the data,
+ /* Update the CRC after writing the data,
* in case that the user I/O routine alters it.
*/
png_calculate_crc(png_ptr, data, length);
@@ -167,15 +170,14 @@
png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;
#endif
- /* write the crc in a single operation */
+ /* 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);
}
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)
-/*
- * This pair of functions encapsulates the operation of (a) compressing a
+/* This pair of functions encapsulates the operation of (a) compressing a
* text string, and (b) issuing it later as a series of chunk data writes.
* The compression_state structure is shared context for these functions
* set up by the caller in order to make the whole mess thread-safe.
@@ -183,11 +185,11 @@
typedef struct
{
- char *input; /* the uncompressed input data */
- int input_len; /* its length */
- int num_output_ptr; /* number of output pointers used */
- int max_output_ptr; /* size of output_ptr */
- png_charpp output_ptr; /* array of pointers to output */
+ char *input; /* the uncompressed input data */
+ int input_len; /* its length */
+ int num_output_ptr; /* number of output pointers used */
+ int max_output_ptr; /* size of output_ptr */
+ png_charpp output_ptr; /* array of pointers to output */
} compression_state;
/* compress given text into storage in the png_ptr structure */
@@ -204,7 +206,7 @@
comp->input = NULL;
comp->input_len = 0;
- /* we may just want to pass the text right through */
+ /* We may just want to pass the text right through */
if (compression == PNG_TEXT_COMPRESSION_NONE)
{
comp->input = text;
@@ -238,13 +240,13 @@
* wouldn't cause a failure, just a slowdown due to swapping).
*/
- /* set up the compression buffers */
+ /* Set up the compression buffers */
png_ptr->zstream.avail_in = (uInt)text_len;
png_ptr->zstream.next_in = (Bytef *)text;
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf;
- /* this is the same compression loop as in png_write_row() */
+ /* This is the same compression loop as in png_write_row() */
do
{
/* compress the data */
@@ -257,10 +259,10 @@
else
png_error(png_ptr, "zlib error");
}
- /* check to see if we need more room */
+ /* Check to see if we need more room */
if (!(png_ptr->zstream.avail_out))
{
- /* make sure the output array has room */
+ /* Make sure the output array has room */
if (comp->num_output_ptr >= comp->max_output_ptr)
{
int old_max;
@@ -285,7 +287,7 @@
(comp->max_output_ptr * png_sizeof(png_charp)));
}
- /* save the data */
+ /* Save the data */
comp->output_ptr[comp->num_output_ptr] =
(png_charp)png_malloc(png_ptr,
(png_alloc_size_t)png_ptr->zbuf_size);
@@ -297,21 +299,21 @@
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
png_ptr->zstream.next_out = png_ptr->zbuf;
}
- /* continue until we don't have any more to compress */
+ /* Continue until we don't have any more to compress */
} while (png_ptr->zstream.avail_in);
- /* finish the compression */
+ /* Finish the compression */
do
{
- /* tell zlib we are finished */
+ /* Tell zlib we are finished */
ret = deflate(&png_ptr->zstream, Z_FINISH);
if (ret == Z_OK)
{
- /* check to see if we need more room */
+ /* Check to see if we need more room */
if (!(png_ptr->zstream.avail_out))
{
- /* check to make sure our output array has room */
+ /* Check to make sure our output array has room */
if (comp->num_output_ptr >= comp->max_output_ptr)
{
int old_max;
@@ -337,7 +339,7 @@
png_sizeof(png_charp)));
}
- /* save off the data */
+ /* Save the data */
comp->output_ptr[comp->num_output_ptr] =
(png_charp)png_malloc(png_ptr,
(png_alloc_size_t)png_ptr->zbuf_size);
@@ -352,7 +354,7 @@
}
else if (ret != Z_STREAM_END)
{
- /* we got an error */
+ /* We got an error */
if (png_ptr->zstream.msg != NULL)
png_error(png_ptr, png_ptr->zstream.msg);
else
@@ -360,7 +362,7 @@
}
} while (ret != Z_STREAM_END);
- /* text length is number of buffers plus last buffer */
+ /* Text length is number of buffers plus last buffer */
text_len = png_ptr->zbuf_size * comp->num_output_ptr;
if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;
@@ -374,15 +376,15 @@
{
int i;
- /* handle the no-compression case */
+ /* Handle the no-compression case */
if (comp->input)
{
- png_write_chunk_data(png_ptr, (png_bytep)comp->input,
+ png_write_chunk_data(png_ptr, (png_bytep)comp->input,
(png_size_t)comp->input_len);
- return;
+ return;
}
- /* write saved output buffers, if any */
+ /* 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],
@@ -391,12 +393,12 @@
}
if (comp->max_output_ptr != 0)
png_free(png_ptr, comp->output_ptr);
- /* write anything left in zbuf */
+ /* 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_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));
- /* reset zlib for another zTXt/iTXt or image data */
+ /* Reset zlib for another zTXt/iTXt or image data */
deflateReset(&png_ptr->zstream);
png_ptr->zstream.data_type = Z_BINARY;
}
@@ -502,7 +504,7 @@
interlace_type=PNG_INTERLACE_NONE;
#endif
- /* save off the relevent information */
+ /* Save the relevent information */
png_ptr->bit_depth = (png_byte)bit_depth;
png_ptr->color_type = (png_byte)color_type;
png_ptr->interlaced = (png_byte)interlace_type;
@@ -520,7 +522,7 @@
png_ptr->usr_bit_depth = png_ptr->bit_depth;
png_ptr->usr_channels = png_ptr->channels;
- /* pack the header information into the buffer */
+ /* Pack the header information into the buffer */
png_save_uint_32(buf, width);
png_save_uint_32(buf + 4, height);
buf[8] = (png_byte)bit_depth;
@@ -529,10 +531,10 @@
buf[11] = (png_byte)filter_type;
buf[12] = (png_byte)interlace_type;
- /* write the chunk */
+ /* Write the chunk */
png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);
- /* initialize zlib with PNG info */
+ /* Initialize zlib with PNG info */
png_ptr->zstream.zalloc = png_zalloc;
png_ptr->zstream.zfree = png_zfree;
png_ptr->zstream.opaque = (voidpf)png_ptr;
@@ -581,7 +583,7 @@
png_ptr->mode = PNG_HAVE_IHDR;
}
-/* write the palette. We are careful not to trust png_color to be in the
+/* Write the palette. We are careful not to trust png_color to be in the
* correct order for PNG, so people can redefine it to any convenient
* structure.
*/
@@ -648,7 +650,7 @@
png_ptr->mode |= PNG_HAVE_PLTE;
}
-/* write an IDAT chunk */
+/* Write an IDAT chunk */
void /* PRIVATE */
png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
{
@@ -665,9 +667,11 @@
unsigned int z_cmf = data[0]; /* zlib compression method and flags */
if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
{
- /* Avoid memory underflows and multiplication overflows. */
- /* The conditions below are practically always satisfied;
- however, they still must be checked. */
+ /* Avoid memory underflows and multiplication overflows.
+ *
+ * The conditions below are practically always satisfied;
+ * however, they still must be checked.
+ */
if (length >= 2 &&
png_ptr->height < 16384 && png_ptr->width < 16384)
{
@@ -700,7 +704,7 @@
png_ptr->mode |= PNG_HAVE_IDAT;
}
-/* write an IEND chunk */
+/* Write an IEND chunk */
void /* PRIVATE */
png_write_IEND(png_structp png_ptr)
{
@@ -714,7 +718,7 @@
}
#if defined(PNG_WRITE_gAMA_SUPPORTED)
-/* write a gAMA chunk */
+/* Write a gAMA chunk */
#ifdef PNG_FLOATING_POINT_SUPPORTED
void /* PRIVATE */
png_write_gAMA(png_structp png_ptr, double file_gamma)
@@ -750,7 +754,7 @@
#endif
#if defined(PNG_WRITE_sRGB_SUPPORTED)
-/* write a sRGB chunk */
+/* Write a sRGB chunk */
void /* PRIVATE */
png_write_sRGB(png_structp png_ptr, int srgb_intent)
{
@@ -769,7 +773,7 @@
#endif
#if defined(PNG_WRITE_iCCP_SUPPORTED)
-/* write an iCCP chunk */
+/* Write an iCCP chunk */
void /* PRIVATE */
png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
png_charp profile, int profile_len)
@@ -842,7 +846,7 @@
#endif
#if defined(PNG_WRITE_sPLT_SUPPORTED)
-/* write a sPLT chunk */
+/* Write a sPLT chunk */
void /* PRIVATE */
png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
{
@@ -860,18 +864,17 @@
#endif
png_debug(1, "in png_write_sPLT");
- if ((name_len = png_check_keyword(png_ptr,
- spalette->name, &new_name))==0)
- return;
+ if ((name_len = png_check_keyword(png_ptr,spalette->name, &new_name))==0)
+ return;
- /* make sure we include the NULL after the name */
+ /* Make sure we include the NULL after the name */
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 */
+ /* Loop through each palette entry, writing appropriately */
#ifndef PNG_NO_POINTER_INDEXING
for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
{
@@ -934,7 +937,7 @@
png_size_t size;
png_debug(1, "in png_write_sBIT");
- /* make sure we don't depend upon the order of PNG_COLOR_8 */
+ /* Make sure we don't depend upon the order of PNG_COLOR_8 */
if (color_type & PNG_COLOR_MASK_COLOR)
{
png_byte maxbits;
@@ -1010,21 +1013,21 @@
int_red_x, int_red_y, int_green_x, int_green_y, int_blue_x, int_blue_y))
#endif
{
- /* each value is saved in 1/100,000ths */
-
- png_save_uint_32(buf, int_white_x);
- png_save_uint_32(buf + 4, int_white_y);
+ /* each value is saved in 1/100,000ths */
+
+ png_save_uint_32(buf, int_white_x);
+ png_save_uint_32(buf + 4, int_white_y);
- png_save_uint_32(buf + 8, int_red_x);
- png_save_uint_32(buf + 12, int_red_y);
+ png_save_uint_32(buf + 8, int_red_x);
+ png_save_uint_32(buf + 12, int_red_y);
- png_save_uint_32(buf + 16, int_green_x);
- png_save_uint_32(buf + 20, int_green_y);
+ png_save_uint_32(buf + 16, int_green_x);
+ png_save_uint_32(buf + 20, int_green_y);
- png_save_uint_32(buf + 24, int_blue_x);
- png_save_uint_32(buf + 28, int_blue_y);
+ png_save_uint_32(buf + 24, int_blue_x);
+ png_save_uint_32(buf + 28, int_blue_y);
- png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
+ png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
}
}
#endif
@@ -1047,26 +1050,26 @@
green_x, green_y, blue_x, blue_y))
#endif
{
- png_save_uint_32(buf, (png_uint_32)white_x);
- png_save_uint_32(buf + 4, (png_uint_32)white_y);
+ png_save_uint_32(buf, (png_uint_32)white_x);
+ png_save_uint_32(buf + 4, (png_uint_32)white_y);
- png_save_uint_32(buf + 8, (png_uint_32)red_x);
- png_save_uint_32(buf + 12, (png_uint_32)red_y);
+ png_save_uint_32(buf + 8, (png_uint_32)red_x);
+ png_save_uint_32(buf + 12, (png_uint_32)red_y);
- png_save_uint_32(buf + 16, (png_uint_32)green_x);
- png_save_uint_32(buf + 20, (png_uint_32)green_y);
+ png_save_uint_32(buf + 16, (png_uint_32)green_x);
+ png_save_uint_32(buf + 20, (png_uint_32)green_y);
- png_save_uint_32(buf + 24, (png_uint_32)blue_x);
- png_save_uint_32(buf + 28, (png_uint_32)blue_y);
+ 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_bytep)png_cHRM, buf, (png_size_t)32);
+ png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
}
}
#endif
#endif
#if defined(PNG_WRITE_tRNS_SUPPORTED)
-/* write the tRNS chunk */
+/* Write the tRNS chunk */
void /* PRIVATE */
png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
int num_trans, int color_type)
@@ -1122,7 +1125,7 @@
#endif
#if defined(PNG_WRITE_bKGD_SUPPORTED)
-/* write the background chunk */
+/* Write the background chunk */
void /* PRIVATE */
png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
{
@@ -1175,7 +1178,7 @@
#endif
#if defined(PNG_WRITE_hIST_SUPPORTED)
-/* write the histogram */
+/* Write the histogram */
void /* PRIVATE */
png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
{
@@ -1275,8 +1278,8 @@
while (*kp == ' ')
{
- *(kp--) = '\0';
- key_len--;
+ *(kp--) = '\0';
+ key_len--;
}
}
@@ -1288,8 +1291,8 @@
while (*kp == ' ')
{
- kp++;
- key_len--;
+ kp++;
+ key_len--;
}
}
@@ -1336,7 +1339,7 @@
#endif
#if defined(PNG_WRITE_tEXt_SUPPORTED)
-/* write a tEXt chunk */
+/* Write a tEXt chunk */
void /* PRIVATE */
png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
png_size_t text_len)
@@ -1376,7 +1379,7 @@
#endif
#if defined(PNG_WRITE_zTXt_SUPPORTED)
-/* write a compressed text chunk */
+/* Write a compressed text chunk */
void /* PRIVATE */
png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
png_size_t text_len, int compression)
@@ -1412,31 +1415,31 @@
text_len = png_strlen(text);
- /* compute the compressed data; do it now for the length */
+ /* Compute the compressed data; do it now for the length */
text_len = png_text_compress(png_ptr, text, text_len, compression,
&comp);
- /* write start of chunk */
+ /* Write start of chunk */
png_write_chunk_start(png_ptr, (png_bytep)png_zTXt,
(png_uint_32)(key_len+text_len + 2));
- /* write key */
+ /* Write key */
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;
- /* write compression */
+ /* Write compression */
png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);
- /* write the compressed data */
+ /* Write the compressed data */
png_write_compressed_data_out(png_ptr, &comp);
- /* close the chunk */
+ /* Close the chunk */
png_write_chunk_end(png_ptr);
}
#endif
#if defined(PNG_WRITE_iTXt_SUPPORTED)
-/* write an iTXt chunk */
+/* Write an iTXt chunk */
void /* PRIVATE */
png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
png_charp lang, png_charp lang_key, png_charp text)
@@ -1468,21 +1471,21 @@
}
if (lang_key == NULL)
- lang_key_len = 0;
+ lang_key_len = 0;
else
- lang_key_len = png_strlen(lang_key);
+ lang_key_len = png_strlen(lang_key);
if (text == NULL)
text_len = 0;
else
- text_len = png_strlen(text);
+ text_len = png_strlen(text);
- /* compute the compressed data; do it now for the length */
+ /* Compute the compressed data; do it now for the length */
text_len = png_text_compress(png_ptr, text, text_len, compression-2,
&comp);
- /* make sure we include the compression flag, the compression byte,
+ /* 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_bytep)png_iTXt,
@@ -1493,8 +1496,7 @@
+ lang_key_len
+ text_len));
- /*
- * We leave it to the application to meet PNG-1.0 requirements on the
+ /* 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.
@@ -1502,13 +1504,13 @@
png_write_chunk_data(png_ptr, (png_bytep)new_key,
(png_size_t)(key_len + 1));
- /* set the compression flag */
+ /* Set the compression flag */
if (compression == PNG_ITXT_COMPRESSION_NONE || \
compression == PNG_TEXT_COMPRESSION_NONE)
cbuf[0] = 0;
else /* compression == PNG_ITXT_COMPRESSION_zTXt */
cbuf[0] = 1;
- /* set the compression method */
+ /* Set the compression method */
cbuf[1] = 0;
png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);
@@ -1526,7 +1528,7 @@
#endif
#if defined(PNG_WRITE_oFFs_SUPPORTED)
-/* write the oFFs chunk */
+/* Write the oFFs chunk */
void /* PRIVATE */
png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
int unit_type)
@@ -1548,7 +1550,7 @@
}
#endif
#if defined(PNG_WRITE_pCAL_SUPPORTED)
-/* write the pCAL chunk (described in the PNG extensions document) */
+/* Write the pCAL chunk (described in the PNG extensions document) */
void /* PRIVATE */
png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
png_int_32 X1, int type, int nparams, png_charp units, png_charpp params)
@@ -1610,7 +1612,7 @@
#endif
#if defined(PNG_WRITE_sCAL_SUPPORTED)
-/* write the sCAL chunk */
+/* Write the sCAL chunk */
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
void /* PRIVATE */
png_write_sCAL(png_structp png_ptr, int unit, double width, double height)
@@ -1667,7 +1669,7 @@
#endif
#if defined(PNG_WRITE_pHYs_SUPPORTED)
-/* write the pHYs chunk */
+/* Write the pHYs chunk */
void /* PRIVATE */
png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
png_uint_32 y_pixels_per_unit,
@@ -1722,24 +1724,24 @@
}
#endif
-/* initializes the row writing capability of libpng */
+/* Initializes the row writing capability of libpng */
void /* PRIVATE */
png_write_start_row(png_structp png_ptr)
{
#ifdef PNG_WRITE_INTERLACING_SUPPORTED
#ifdef PNG_USE_LOCAL_ARRAYS
- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
- /* start of interlace block */
+ /* Start of interlace block */
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
- /* offset to next interlace block */
+ /* Offset to next interlace block */
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
- /* start of interlace block in the y direction */
+ /* Start of interlace block in the y direction */
int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
- /* offset to next interlace block in the y direction */
+ /* Offset to next interlace block in the y direction */
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
#endif
#endif
@@ -1750,13 +1752,13 @@
buf_size = (png_size_t)(PNG_ROWBYTES(
png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);
- /* set up row buffer */
+ /* Set up row buffer */
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr,
(png_alloc_size_t)buf_size);
png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
#ifndef PNG_NO_WRITE_FILTER
- /* set up filtering buffer, if using this 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,
@@ -1801,7 +1803,7 @@
#endif /* PNG_NO_WRITE_FILTER */
#ifdef PNG_WRITE_INTERLACING_SUPPORTED
- /* if interlaced, we need to set up width and height of pass */
+ /* If interlaced, we need to set up width and height of pass */
if (png_ptr->interlaced)
{
if (!(png_ptr->transformations & PNG_INTERLACE))
@@ -1833,18 +1835,18 @@
{
#ifdef PNG_WRITE_INTERLACING_SUPPORTED
#ifdef PNG_USE_LOCAL_ARRAYS
- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
- /* start of interlace block */
+ /* Start of interlace block */
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
- /* offset to next interlace block */
+ /* Offset to next interlace block */
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
- /* start of interlace block in the y direction */
+ /* Start of interlace block in the y direction */
int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
- /* offset to next interlace block in the y direction */
+ /* Offset to next interlace block in the y direction */
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
#endif
#endif
@@ -1855,12 +1857,12 @@
/* next row */
png_ptr->row_number++;
- /* see if we are done */
+ /* See if we are done */
if (png_ptr->row_number < png_ptr->num_rows)
return;
#ifdef PNG_WRITE_INTERLACING_SUPPORTED
- /* if interlaced, go to next pass */
+ /* If interlaced, go to next pass */
if (png_ptr->interlaced)
{
png_ptr->row_number = 0;
@@ -1870,7 +1872,7 @@
}
else
{
- /* loop until we find a non-zero width or height pass */
+ /* Loop until we find a non-zero width or height pass */
do
{
png_ptr->pass++;
@@ -1890,7 +1892,7 @@
}
- /* reset the row above the image for the next pass */
+ /* Reset the row above the image for the next pass */
if (png_ptr->pass < 7)
{
if (png_ptr->prev_row != NULL)
@@ -1902,16 +1904,16 @@
}
#endif
- /* if we get here, we've just written the last row, so we need
+ /* If we get here, we've just written the last row, so we need
to flush the compressor */
do
{
- /* tell the compressor we are done */
+ /* Tell the compressor we are done */
ret = deflate(&png_ptr->zstream, Z_FINISH);
- /* check for an error */
+ /* Check for an error */
if (ret == Z_OK)
{
- /* check to see if we need more room */
+ /* Check to see if we need more room */
if (!(png_ptr->zstream.avail_out))
{
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
@@ -1928,7 +1930,7 @@
}
} while (ret != Z_STREAM_END);
- /* write any extra space */
+ /* Write any extra space */
if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
{
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size -
@@ -1951,20 +1953,20 @@
png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
{
#ifdef PNG_USE_LOCAL_ARRAYS
- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
- /* start of interlace block */
+ /* Start of interlace block */
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
- /* offset to next interlace block */
+ /* Offset to next interlace block */
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
#endif
png_debug(1, "in png_do_write_interlace");
- /* we don't have to do anything on the last pass (6) */
+ /* We don't have to do anything on the last pass (6) */
if (pass < 6)
{
- /* each pixel depth is handled separately */
+ /* Each pixel depth is handled separately */
switch (row_info->pixel_depth)
{
case 1:
@@ -2075,27 +2077,27 @@
png_uint_32 row_width = row_info->width;
png_size_t pixel_bytes;
- /* start at the beginning */
+ /* Start at the beginning */
dp = row;
- /* find out how many bytes each pixel takes up */
+ /* Find out how many bytes each pixel takes up */
pixel_bytes = (row_info->pixel_depth >> 3);
- /* loop through the row, only looking at the pixels that
+ /* Loop through the row, only looking at the pixels that
matter */
for (i = png_pass_start[pass]; i < row_width;
i += png_pass_inc[pass])
{
- /* find out where the original pixel is */
+ /* Find out where the original pixel is */
sp = row + (png_size_t)i * pixel_bytes;
- /* move the pixel */
+ /* Move the pixel */
if (dp != sp)
png_memcpy(dp, sp, pixel_bytes);
- /* next pixel */
+ /* Next pixel */
dp += pixel_bytes;
}
break;
}
}
- /* set new row width */
+ /* Set new row width */
row_info->width = (row_info->width +
png_pass_inc[pass] - 1 -
png_pass_start[pass]) /
@@ -2215,9 +2217,9 @@
mins = sum;
}
- /* sub filter */
+ /* Sub filter */
if (filter_to_do == PNG_FILTER_SUB)
- /* it's the only filter so no testing is needed */
+ /* It's the only filter so no testing is needed */
{
png_bytep rp, lp, dp;
png_uint_32 i;
@@ -2332,7 +2334,7 @@
}
}
- /* up filter */
+ /* Up filter */
if (filter_to_do == PNG_FILTER_UP)
{
png_bytep rp, dp, pp;
@@ -2435,7 +2437,7 @@
}
}
- /* avg filter */
+ /* Avg filter */
if (filter_to_do == PNG_FILTER_AVG)
{
png_bytep rp, dp, pp, lp;
@@ -2738,18 +2740,18 @@
{
png_debug(1, "in png_write_filtered_row");
png_debug1(2, "filter = %d", filtered_row[0]);
- /* set up the zlib input buffer */
+ /* Set up the zlib input buffer */
png_ptr->zstream.next_in = filtered_row;
png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1;
- /* repeat until we have compressed all the data */
+ /* Repeat until we have compressed all the data */
do
{
- int ret; /* return of zlib */
+ int ret; /* Return of zlib */
- /* compress the data */
+ /* Compress the data */
ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
- /* check for compression errors */
+ /* Check for compression errors */
if (ret != Z_OK)
{
if (png_ptr->zstream.msg != NULL)
@@ -2758,18 +2760,18 @@
png_error(png_ptr, "zlib error");
}
- /* see if it is time to write another IDAT */
+ /* See if it is time to write another IDAT */
if (!(png_ptr->zstream.avail_out))
{
- /* write the IDAT and reset the zlib output buffer */
+ /* Write the IDAT and reset the zlib output buffer */
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
png_ptr->zstream.next_out = png_ptr->zbuf;
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
}
- /* repeat until all data has been compressed */
+ /* Repeat until all data has been compressed */
} while (png_ptr->zstream.avail_in);
- /* swap the current and previous rows */
+ /* Swap the current and previous rows */
if (png_ptr->prev_row != NULL)
{
png_bytep tptr;
@@ -2779,7 +2781,7 @@
png_ptr->row_buf = tptr;
}
- /* finish row - updates counters and flushes zlib if last row */
+ /* Finish row - updates counters and flushes zlib if last row */
png_write_finish_row(png_ptr);
#if defined(PNG_WRITE_FLUSH_SUPPORTED)