astyle formatting cleanup to make the sourcecode more accessible

switch used: astyle --style=ansi --min-conditional-indent=0 --pad=oper --unpad=paren
http://astyle.sourceforge.net/

git-svn-id: https://mpc-hc.svn.sourceforge.net/svnroot/mpc-hc/trunk@1783 10f7b99b-c216-0410-bff0-8a66a9350fd8

19 files changed, 17133 insertions, 17058 deletions

diff --git a/src/libpng/png.c b/src/libpng/png.c
index e7bed11c9..747493e0c 100644
--- a/src/libpng/png.c
+++ b/src/libpng/png.c
@@ -33,15 +33,15 @@ typedef version_1_4_1 Your_png_h_is_not_version_1_4_1;
 void PNGAPI

 png_set_sig_bytes(png_structp png_ptr, int num_bytes)

 {

-   png_debug(1, "in png_set_sig_bytes");

+    png_debug(1, "in png_set_sig_bytes");

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

-   if (num_bytes > 8)

-      png_error(png_ptr, "Too many bytes for PNG signature");

+    if(num_bytes > 8)

+        png_error(png_ptr, "Too many bytes for PNG signature");

 

-   png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);

+    png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);

 }

 

 /* Checks whether the supplied bytes match the PNG signature.  We allow

@@ -55,19 +55,19 @@ png_set_sig_bytes(png_structp png_ptr, int num_bytes)
 int PNGAPI

 png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)

 {

-   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

-   if (num_to_check > 8)

-      num_to_check = 8;

-   else if (num_to_check < 1)

-      return (-1);

+    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

+    if(num_to_check > 8)

+        num_to_check = 8;

+    else if(num_to_check < 1)

+        return (-1);

 

-   if (start > 7)

-      return (-1);

+    if(start > 7)

+        return (-1);

 

-   if (start + num_to_check > 8)

-      num_to_check = 8 - start;

+    if(start + num_to_check > 8)

+        num_to_check = 8 - start;

 

-   return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));

+    return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));

 }

 

 #endif /* PNG_READ_SUPPORTED */

@@ -77,32 +77,32 @@ png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
 voidpf /* PRIVATE */

 png_zalloc(voidpf png_ptr, uInt items, uInt size)

 {

-   png_voidp ptr;

-   png_structp p=(png_structp)png_ptr;

-   png_uint_32 save_flags=p->flags;

-   png_alloc_size_t num_bytes;

-

-   if (png_ptr == NULL)

-      return (NULL);

-   if (items > PNG_UINT_32_MAX/size)

-   {

-     png_warning (p, "Potential overflow in png_zalloc()");

-     return (NULL);

-   }

-   num_bytes = (png_alloc_size_t)items * size;

-

-   p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;

-   ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);

-   p->flags=save_flags;

-

-   return ((voidpf)ptr);

+    png_voidp ptr;

+    png_structp p = (png_structp)png_ptr;

+    png_uint_32 save_flags = p->flags;

+    png_alloc_size_t num_bytes;

+

+    if(png_ptr == NULL)

+        return (NULL);

+    if(items > PNG_UINT_32_MAX / size)

+    {

+        png_warning(p, "Potential overflow in png_zalloc()");

+        return (NULL);

+    }

+    num_bytes = (png_alloc_size_t)items * size;

+

+    p->flags |= PNG_FLAG_MALLOC_NULL_MEM_OK;

+    ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);

+    p->flags = save_flags;

+

+    return ((voidpf)ptr);

 }

 

 /* Function to free memory for zlib */

 void /* PRIVATE */

 png_zfree(voidpf png_ptr, voidpf ptr)

 {

-   png_free((png_structp)png_ptr, (png_voidp)ptr);

+    png_free((png_structp)png_ptr, (png_voidp)ptr);

 }

 

 /* Reset the CRC variable to 32 bits of 1's.  Care must be taken

@@ -111,7 +111,7 @@ png_zfree(voidpf png_ptr, voidpf ptr)
 void /* PRIVATE */

 png_reset_crc(png_structp png_ptr)

 {

-   png_ptr->crc = crc32(0, Z_NULL, 0);

+    png_ptr->crc = crc32(0, Z_NULL, 0);

 }

 

 /* Calculate the CRC over a section of data.  We can only pass as

@@ -122,22 +122,22 @@ png_reset_crc(png_structp png_ptr)
 void /* PRIVATE */

 png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)

 {

-   int need_crc = 1;

-

-   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */

-   {

-      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==

-          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))

-         need_crc = 0;

-   }

-   else                                                    /* critical */

-   {

-      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)

-         need_crc = 0;

-   }

-

-   if (need_crc)

-      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);

+    int need_crc = 1;

+

+    if(png_ptr->chunk_name[0] & 0x20)                      /* ancillary */

+    {

+        if((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==

+           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))

+            need_crc = 0;

+    }

+    else                                                    /* critical */

+    {

+        if(png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)

+            need_crc = 0;

+    }

+

+    if(need_crc)

+        png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);

 }

 

 /* Allocate the memory for an info_struct for the application.  We don't

@@ -149,23 +149,23 @@ png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
 png_infop PNGAPI

 png_create_info_struct(png_structp png_ptr)

 {

-   png_infop info_ptr;

+    png_infop info_ptr;

 

-   png_debug(1, "in png_create_info_struct");

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

+    info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,

+               png_ptr->malloc_fn, png_ptr->mem_ptr);

 #else

-   info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);

+    info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);

 #endif

-   if (info_ptr != NULL)

-      png_info_init_3(&info_ptr, png_sizeof(png_info));

+    if(info_ptr != NULL)

+        png_info_init_3(&info_ptr, png_sizeof(png_info));

 

-   return (info_ptr);

+    return (info_ptr);

 }

 

 /* This function frees the memory associated with a single info struct.

@@ -176,28 +176,28 @@ png_create_info_struct(png_structp png_ptr)
 void PNGAPI

 png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)

 {

-   png_infop info_ptr = NULL;

+    png_infop info_ptr = NULL;

 

-   png_debug(1, "in png_destroy_info_struct");

+    png_debug(1, "in png_destroy_info_struct");

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

-   if (info_ptr_ptr != NULL)

-      info_ptr = *info_ptr_ptr;

+    if(info_ptr_ptr != NULL)

+        info_ptr = *info_ptr_ptr;

 

-   if (info_ptr != NULL)

-   {

-      png_info_destroy(png_ptr, info_ptr);

+    if(info_ptr != NULL)

+    {

+        png_info_destroy(png_ptr, info_ptr);

 

 #ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,

-          png_ptr->mem_ptr);

+        png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,

+                             png_ptr->mem_ptr);

 #else

-      png_destroy_struct((png_voidp)info_ptr);

+        png_destroy_struct((png_voidp)info_ptr);

 #endif

-      *info_ptr_ptr = NULL;

-   }

+        *info_ptr_ptr = NULL;

+    }

 }

 

 /* Initialize the info structure.  This is now an internal function (0.89)

@@ -208,241 +208,241 @@ png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
 void PNGAPI

 png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)

 {

-   png_infop info_ptr = *ptr_ptr;

+    png_infop info_ptr = *ptr_ptr;

 

-   png_debug(1, "in png_info_init_3");

+    png_debug(1, "in png_info_init_3");

 

-   if (info_ptr == NULL)

-      return;

+    if(info_ptr == NULL)

+        return;

 

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

-   }

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

+    }

 

-   /* Set everything to 0 */

-   png_memset(info_ptr, 0, png_sizeof(png_info));

+    /* Set everything to 0 */

+    png_memset(info_ptr, 0, png_sizeof(png_info));

 }

 

 void PNGAPI

 png_data_freer(png_structp png_ptr, png_infop info_ptr,

-   int freer, png_uint_32 mask)

+               int freer, png_uint_32 mask)

 {

-   png_debug(1, "in png_data_freer");

-

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

-      return;

-

-   if (freer == PNG_DESTROY_WILL_FREE_DATA)

-      info_ptr->free_me |= mask;

-   else if (freer == PNG_USER_WILL_FREE_DATA)

-      info_ptr->free_me &= ~mask;

-   else

-      png_warning(png_ptr,

-         "Unknown freer parameter in png_data_freer");

+    png_debug(1, "in png_data_freer");

+

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

+        return;

+

+    if(freer == PNG_DESTROY_WILL_FREE_DATA)

+        info_ptr->free_me |= mask;

+    else if(freer == PNG_USER_WILL_FREE_DATA)

+        info_ptr->free_me &= ~mask;

+    else

+        png_warning(png_ptr,

+                    "Unknown freer parameter in png_data_freer");

 }

 

 void PNGAPI

 png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,

-   int num)

+              int num)

 {

-   png_debug(1, "in png_free_data");

+    png_debug(1, "in png_free_data");

 

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

-      return;

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

+        return;

 

 #ifdef PNG_TEXT_SUPPORTED

-   /* Free text item num or (if num == -1) all text items */

-   if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)

-   {

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

-      }

-   }

+    /* Free text item num or (if num == -1) all text items */

+    if((mask & PNG_FREE_TEXT) & info_ptr->free_me)

+    {

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

+        }

+    }

 #endif

 

 #ifdef PNG_tRNS_SUPPORTED

-   /* Free any tRNS entry */

-   if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)

-   {

-      png_free(png_ptr, info_ptr->trans_alpha);

-      info_ptr->trans_alpha = NULL;

-      info_ptr->valid &= ~PNG_INFO_tRNS;

-   }

+    /* Free any tRNS entry */

+    if((mask & PNG_FREE_TRNS) & info_ptr->free_me)

+    {

+        png_free(png_ptr, info_ptr->trans_alpha);

+        info_ptr->trans_alpha = NULL;

+        info_ptr->valid &= ~PNG_INFO_tRNS;

+    }

 #endif

 

 #ifdef PNG_sCAL_SUPPORTED

-   /* Free any sCAL entry */

-   if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)

-   {

+    /* Free any sCAL entry */

+    if((mask & PNG_FREE_SCAL) & info_ptr->free_me)

+    {

 #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

 

 #ifdef PNG_pCAL_SUPPORTED

-   /* Free any pCAL entry */

-   if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)

-   {

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

-         {

+    /* Free any pCAL entry */

+    if((mask & PNG_FREE_PCAL) & info_ptr->free_me)

+    {

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

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

-   }

+        }

+        info_ptr->valid &= ~PNG_INFO_pCAL;

+    }

 #endif

 

 #ifdef PNG_iCCP_SUPPORTED

-   /* Free any iCCP entry */

-   if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)

-   {

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

-   }

+    /* Free any iCCP entry */

+    if((mask & PNG_FREE_ICCP) & info_ptr->free_me)

+    {

+        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

 

 #ifdef PNG_sPLT_SUPPORTED

-   /* Free a given sPLT entry, or (if num == -1) all sPLT entries */

-   if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)

-   {

-      if (num != -1)

-      {

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

-      }

-   }

+    /* Free a given sPLT entry, or (if num == -1) all sPLT entries */

+    if((mask & PNG_FREE_SPLT) & info_ptr->free_me)

+    {

+        if(num != -1)

+        {

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

+        }

+    }

 #endif

 

 #ifdef 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 ((mask & PNG_FREE_UNKN) & info_ptr->free_me)

-   {

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

-

-            png_free(png_ptr, info_ptr->unknown_chunks);

-            info_ptr->unknown_chunks = NULL;

-            info_ptr->unknown_chunks_num = 0;

-         }

-      }

-   }

+    if(png_ptr->unknown_chunk.data)

+    {

+        png_free(png_ptr, png_ptr->unknown_chunk.data);

+        png_ptr->unknown_chunk.data = NULL;

+    }

+

+    if((mask & PNG_FREE_UNKN) & info_ptr->free_me)

+    {

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

+

+                png_free(png_ptr, info_ptr->unknown_chunks);

+                info_ptr->unknown_chunks = NULL;

+                info_ptr->unknown_chunks_num = 0;

+            }

+        }

+    }

 #endif

 

 #ifdef PNG_hIST_SUPPORTED

-   /* Free any hIST entry */

-   if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)

-   {

-      png_free(png_ptr, info_ptr->hist);

-      info_ptr->hist = NULL;

-      info_ptr->valid &= ~PNG_INFO_hIST;

-   }

+    /* Free any hIST entry */

+    if((mask & PNG_FREE_HIST)  & info_ptr->free_me)

+    {

+        png_free(png_ptr, info_ptr->hist);

+        info_ptr->hist = NULL;

+        info_ptr->valid &= ~PNG_INFO_hIST;

+    }

 #endif

 

-   /* Free any PLTE entry that was internally allocated */

-   if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)

-   {

-      png_zfree(png_ptr, info_ptr->palette);

-      info_ptr->palette = NULL;

-      info_ptr->valid &= ~PNG_INFO_PLTE;

-      info_ptr->num_palette = 0;

-   }

+    /* Free any PLTE entry that was internally allocated */

+    if((mask & PNG_FREE_PLTE) & info_ptr->free_me)

+    {

+        png_zfree(png_ptr, info_ptr->palette);

+        info_ptr->palette = NULL;

+        info_ptr->valid &= ~PNG_INFO_PLTE;

+        info_ptr->num_palette = 0;

+    }

 

 #ifdef PNG_INFO_IMAGE_SUPPORTED

-   /* Free any image bits attached to the info structure */

-   if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)

-   {

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

-            info_ptr->row_pointers[row] = NULL;

-         }

-         png_free(png_ptr, info_ptr->row_pointers);

-         info_ptr->row_pointers = NULL;

-      }

-      info_ptr->valid &= ~PNG_INFO_IDAT;

-   }

+    /* Free any image bits attached to the info structure */

+    if((mask & PNG_FREE_ROWS) & info_ptr->free_me)

+    {

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

+                info_ptr->row_pointers[row] = NULL;

+            }

+            png_free(png_ptr, info_ptr->row_pointers);

+            info_ptr->row_pointers = NULL;

+        }

+        info_ptr->valid &= ~PNG_INFO_IDAT;

+    }

 #endif

 

-   if (num == -1)

-      info_ptr->free_me &= ~mask;

-   else

-      info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);

+    if(num == -1)

+        info_ptr->free_me &= ~mask;

+    else

+        info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);

 }

 

 /* This is an internal routine to free any memory that the info struct is

@@ -452,20 +452,20 @@ png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
 void /* PRIVATE */

 png_info_destroy(png_structp png_ptr, png_infop info_ptr)

 {

-   png_debug(1, "in png_info_destroy");

+    png_debug(1, "in png_info_destroy");

 

-   png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

+    png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

 

 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-   if (png_ptr->num_chunk_list)

-   {

-      png_free(png_ptr, png_ptr->chunk_list);

-      png_ptr->chunk_list = NULL;

-      png_ptr->num_chunk_list = 0;

-   }

+    if(png_ptr->num_chunk_list)

+    {

+        png_free(png_ptr, png_ptr->chunk_list);

+        png_ptr->chunk_list = NULL;

+        png_ptr->num_chunk_list = 0;

+    }

 #endif

 

-   png_info_init_3(&info_ptr, png_sizeof(png_info));

+    png_info_init_3(&info_ptr, png_sizeof(png_info));

 }

 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */

 

@@ -476,9 +476,9 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
 png_voidp PNGAPI

 png_get_io_ptr(png_structp png_ptr)

 {

-   if (png_ptr == NULL)

-      return (NULL);

-   return (png_ptr->io_ptr);

+    if(png_ptr == NULL)

+        return (NULL);

+    return (png_ptr->io_ptr);

 }

 

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

@@ -492,12 +492,12 @@ png_get_io_ptr(png_structp png_ptr)
 void PNGAPI

 png_init_io(png_structp png_ptr, png_FILE_p fp)

 {

-   png_debug(1, "in png_init_io");

+    png_debug(1, "in png_init_io");

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

-   png_ptr->io_ptr = (png_voidp)fp;

+    png_ptr->io_ptr = (png_voidp)fp;

 }

 #endif

 

@@ -508,35 +508,37 @@ png_init_io(png_structp png_ptr, png_FILE_p fp)
 png_charp PNGAPI

 png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)

 {

-   static PNG_CONST char short_months[12][4] =

-        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",

-         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

-

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

-         png_sizeof(char)));

-   }

+    static PNG_CONST char short_months[12][4] =

+    {

+        "Jan", "Feb", "Mar", "Apr", "May", "Jun",

+        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"

+    };

+

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

+                               png_sizeof(char)));

+    }

 

 #ifdef USE_FAR_KEYWORD

-   {

-      char near_time_buf[29];

-      png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000",

-          ptime->day % 32, short_months[(ptime->month - 1) % 12],

-          ptime->year, ptime->hour % 24, ptime->minute % 60,

-          ptime->second % 61);

-      png_memcpy(png_ptr->time_buffer, near_time_buf,

-          29*png_sizeof(char));

-   }

+    {

+        char near_time_buf[29];

+        png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000",

+                      ptime->day % 32, short_months[(ptime->month - 1) % 12],

+                      ptime->year, ptime->hour % 24, ptime->minute % 60,

+                      ptime->second % 61);

+        png_memcpy(png_ptr->time_buffer, near_time_buf,

+                   29 * png_sizeof(char));

+    }

 #else

-   png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000",

-       ptime->day % 32, short_months[(ptime->month - 1) % 12],

-       ptime->year, ptime->hour % 24, ptime->minute % 60,

-       ptime->second % 61);

+    png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000",

+                  ptime->day % 32, short_months[(ptime->month - 1) % 12],

+                  ptime->year, ptime->hour % 24, ptime->minute % 60,

+                  ptime->second % 61);

 #endif

-   return ((png_charp)png_ptr->time_buffer);

+    return ((png_charp)png_ptr->time_buffer);

 }

 #endif /* PNG_TIME_RFC1123_SUPPORTED */

 

@@ -545,63 +547,63 @@ png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
 png_charp PNGAPI

 png_get_copyright(png_structp png_ptr)

 {

-   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

+    png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

 #ifdef PNG_STRING_COPYRIGHT

-      return PNG_STRING_COPYRIGHT

+    return PNG_STRING_COPYRIGHT

 #else

 #ifdef __STDC__

-   return ((png_charp) PNG_STRING_NEWLINE \

-     "libpng version 1.4.1 - February 25, 2010" PNG_STRING_NEWLINE \

-     "Copyright (c) 1998-2010 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);

+    return ((png_charp) PNG_STRING_NEWLINE \

+            "libpng version 1.4.1 - February 25, 2010" PNG_STRING_NEWLINE \

+            "Copyright (c) 1998-2010 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.1 - February 25, 2010\

+           return ((png_charp) "libpng version 1.4.1 - February 25, 2010\

       Copyright (c) 1998-2010 Glenn Randers-Pehrson\

       Copyright (c) 1996-1997 Andreas Dilger\

       Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.");

 #endif

 #endif

-}

-

-/* The following return the library version as a short string in the

- * format 1.0.0 through 99.99.99zz.  To get the version of *.h files

- * used with your application, print out PNG_LIBPNG_VER_STRING, which

- * is defined in png.h.

- * Note: now there is no difference between png_get_libpng_ver() and

- * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,

- * it is guaranteed that png.c uses the correct version of png.h.

- */

-png_charp PNGAPI

-png_get_libpng_ver(png_structp png_ptr)

+       }

+

+       /* The following return the library version as a short string in the

+        * format 1.0.0 through 99.99.99zz.  To get the version of *.h files

+        * used with your application, print out PNG_LIBPNG_VER_STRING, which

+        * is defined in png.h.

+        * Note: now there is no difference between png_get_libpng_ver() and

+        * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,

+        * it is guaranteed that png.c uses the correct version of png.h.

+        */

+       png_charp PNGAPI

+       png_get_libpng_ver(png_structp png_ptr)

 {

-   /* Version of *.c files used when building libpng */

-   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

-   return ((png_charp) PNG_LIBPNG_VER_STRING);

+    /* Version of *.c files used when building libpng */

+    png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

+    return ((png_charp) PNG_LIBPNG_VER_STRING);

 }

 

 png_charp PNGAPI

 png_get_header_ver(png_structp png_ptr)

 {

-   /* Version of *.h files used when building libpng */

-   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

-   return ((png_charp) PNG_LIBPNG_VER_STRING);

+    /* Version of *.h files used when building libpng */

+    png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

+    return ((png_charp) PNG_LIBPNG_VER_STRING);

 }

 

 png_charp PNGAPI

 png_get_header_version(png_structp png_ptr)

 {

-   /* Returns longer string containing both version and date */

-   png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

+    /* Returns longer string containing both version and date */

+    png_ptr = png_ptr;  /* Silence compiler warning about unused png_ptr */

 #ifdef __STDC__

-   return ((png_charp) PNG_HEADER_VERSION_STRING

+    return ((png_charp) PNG_HEADER_VERSION_STRING

 #ifndef PNG_READ_SUPPORTED

-   "     (NO READ SUPPORT)"

+            "     (NO READ SUPPORT)"

 #endif

-   PNG_STRING_NEWLINE);

+            PNG_STRING_NEWLINE);

 #else

-   return ((png_charp) PNG_HEADER_VERSION_STRING);

+    return ((png_charp) PNG_HEADER_VERSION_STRING);

 #endif

 }

 

@@ -610,16 +612,16 @@ png_get_header_version(png_structp png_ptr)
 int PNGAPI

 png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)

 {

-   /* Check chunk_name and return "keep" value if it's on the list, else 0 */

-   int i;

-   png_bytep p;

-   if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)

-      return 0;

-   p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5;

-   for (i = png_ptr->num_chunk_list; i; i--, p -= 5)

-      if (!png_memcmp(chunk_name, p, 4))

-        return ((int)*(p + 4));

-   return 0;

+    /* Check chunk_name and return "keep" value if it's on the list, else 0 */

+    int i;

+    png_bytep p;

+    if(png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list <= 0)

+        return 0;

+    p = png_ptr->chunk_list + png_ptr->num_chunk_list * 5 - 5;

+    for(i = png_ptr->num_chunk_list; i; i--, p -= 5)

+        if(!png_memcmp(chunk_name, p, 4))

+            return ((int) * (p + 4));

+    return 0;

 }

 #endif

 

@@ -627,9 +629,9 @@ png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
 int PNGAPI

 png_reset_zstream(png_structp png_ptr)

 {

-   if (png_ptr == NULL)

-      return Z_STREAM_ERROR;

-   return (inflateReset(&png_ptr->zstream));

+    if(png_ptr == NULL)

+        return Z_STREAM_ERROR;

+    return (inflateReset(&png_ptr->zstream));

 }

 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */

 

@@ -637,8 +639,8 @@ png_reset_zstream(png_structp png_ptr)
 png_uint_32 PNGAPI

 png_access_version_number(void)

 {

-   /* Version of *.c files used when building libpng */

-   return((png_uint_32) PNG_LIBPNG_VER);

+    /* Version of *.c files used when building libpng */

+    return((png_uint_32) PNG_LIBPNG_VER);

 }

 

 

@@ -646,13 +648,13 @@ png_access_version_number(void)
 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

 #ifdef PNG_SIZE_T

 /* Added at libpng version 1.2.6 */

-   PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));

+PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));

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

 

@@ -676,241 +678,241 @@ png_convert_size(size_t size)
 */

 

 void /* PRIVATE */

-png_64bit_product (long v1, long v2, unsigned long *hi_product,

-   unsigned long *lo_product)

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

-   png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,

-   png_fixed_point blue_x, png_fixed_point blue_y)

+                     png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,

+                     png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,

+                     png_fixed_point blue_x, png_fixed_point blue_y)

 {

-   int ret = 1;

-   unsigned long xy_hi,xy_lo,yx_hi,yx_lo;

+    int ret = 1;

+    unsigned long xy_hi, xy_lo, yx_hi, yx_lo;

 

-   png_debug(1, "in function png_check_cHRM_fixed");

+    png_debug(1, "in function png_check_cHRM_fixed");

 

-   if (png_ptr == NULL)

-      return 0;

+    if(png_ptr == NULL)

+        return 0;

 

-   if (white_x < 0 || white_y <= 0 ||

-         red_x < 0 ||   red_y <  0 ||

+    if(white_x < 0 || white_y <= 0 ||

+       red_x < 0 ||   red_y <  0 ||

        green_x < 0 || green_y <  0 ||

-        blue_x < 0 ||  blue_y <  0)

-   {

-      png_warning(png_ptr,

-        "Ignoring attempt to set negative chromaticity value");

-      ret = 0;

-   }

-   if (white_x > (png_fixed_point) PNG_UINT_31_MAX ||

+       blue_x < 0 ||  blue_y <  0)

+    {

+        png_warning(png_ptr,

+                    "Ignoring attempt to set negative chromaticity value");

+        ret = 0;

+    }

+    if(white_x > (png_fixed_point) PNG_UINT_31_MAX ||

        white_y > (png_fixed_point) PNG_UINT_31_MAX ||

-         red_x > (png_fixed_point) PNG_UINT_31_MAX ||

-         red_y > (png_fixed_point) PNG_UINT_31_MAX ||

+       red_x > (png_fixed_point) PNG_UINT_31_MAX ||

+       red_y > (png_fixed_point) PNG_UINT_31_MAX ||

        green_x > (png_fixed_point) PNG_UINT_31_MAX ||

        green_y > (png_fixed_point) PNG_UINT_31_MAX ||

-        blue_x > (png_fixed_point) PNG_UINT_31_MAX ||

-        blue_y > (png_fixed_point) PNG_UINT_31_MAX )

-   {

-      png_warning(png_ptr,

-        "Ignoring attempt to set chromaticity value exceeding 21474.83");

-      ret = 0;

-   }

-   if (white_x > 100000L - white_y)

-   {

-      png_warning(png_ptr, "Invalid cHRM white point");

-      ret = 0;

-   }

-   if (red_x > 100000L - red_y)

-   {

-      png_warning(png_ptr, "Invalid cHRM red point");

-      ret = 0;

-   }

-   if (green_x > 100000L - green_y)

-   {

-      png_warning(png_ptr, "Invalid cHRM green point");

-      ret = 0;

-   }

-   if (blue_x > 100000L - blue_y)

-   {

-      png_warning(png_ptr, "Invalid cHRM blue point");

-      ret = 0;

-   }

-

-   png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo);

-   png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo);

-

-   if (xy_hi == yx_hi && xy_lo == yx_lo)

-   {

-      png_warning(png_ptr,

-         "Ignoring attempt to set cHRM RGB triangle with zero area");

-      ret = 0;

-   }

-

-   return ret;

+       blue_x > (png_fixed_point) PNG_UINT_31_MAX ||

+       blue_y > (png_fixed_point) PNG_UINT_31_MAX)

+    {

+        png_warning(png_ptr,

+                    "Ignoring attempt to set chromaticity value exceeding 21474.83");

+        ret = 0;

+    }

+    if(white_x > 100000L - white_y)

+    {

+        png_warning(png_ptr, "Invalid cHRM white point");

+        ret = 0;

+    }

+    if(red_x > 100000L - red_y)

+    {

+        png_warning(png_ptr, "Invalid cHRM red point");

+        ret = 0;

+    }

+    if(green_x > 100000L - green_y)

+    {

+        png_warning(png_ptr, "Invalid cHRM green point");

+        ret = 0;

+    }

+    if(blue_x > 100000L - blue_y)

+    {

+        png_warning(png_ptr, "Invalid cHRM blue point");

+        ret = 0;

+    }

+

+    png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo);

+    png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo);

+

+    if(xy_hi == yx_hi && xy_lo == yx_lo)

+    {

+        png_warning(png_ptr,

+                    "Ignoring attempt to set cHRM RGB triangle with zero area");

+        ret = 0;

+    }

+

+    return ret;

 }

 #endif /* PNG_CHECK_cHRM_SUPPORTED */

 #endif /* PNG_cHRM_SUPPORTED */

 

 void /* PRIVATE */

 png_check_IHDR(png_structp png_ptr,

-   png_uint_32 width, png_uint_32 height, int bit_depth,

-   int color_type, int interlace_type, int compression_type,

-   int filter_type)

+               png_uint_32 width, png_uint_32 height, int bit_depth,

+               int color_type, int interlace_type, int compression_type,

+               int filter_type)

 {

-   int error = 0;

+    int error = 0;

 

-   /* Check for width and height valid values */

-   if (width == 0)

-   {

-      png_warning(png_ptr, "Image width is zero in IHDR");

-      error = 1;

-   }

+    /* Check for width and height valid values */

+    if(width == 0)

+    {

+        png_warning(png_ptr, "Image width is zero in IHDR");

+        error = 1;

+    }

 

-   if (height == 0)

-   {

-      png_warning(png_ptr, "Image height is zero in IHDR");

-      error = 1;

-   }

+    if(height == 0)

+    {

+        png_warning(png_ptr, "Image height is zero in IHDR");

+        error = 1;

+    }

 

 #ifdef PNG_SET_USER_LIMITS_SUPPORTED

-   if (width > png_ptr->user_width_max || width > PNG_USER_WIDTH_MAX)

+    if(width > png_ptr->user_width_max || width > PNG_USER_WIDTH_MAX)

 #else

-   if (width > PNG_USER_WIDTH_MAX)

+    if(width > PNG_USER_WIDTH_MAX)

 #endif

-   {

-      png_warning(png_ptr, "Image width exceeds user limit in IHDR");

-      error = 1;

-   }

+    {

+        png_warning(png_ptr, "Image width exceeds user limit in IHDR");

+        error = 1;

+    }

 

 #ifdef PNG_SET_USER_LIMITS_SUPPORTED

-   if (height > png_ptr->user_height_max || height > PNG_USER_HEIGHT_MAX)

+    if(height > png_ptr->user_height_max || height > PNG_USER_HEIGHT_MAX)

 #else

-   if (height > PNG_USER_HEIGHT_MAX)

+    if(height > PNG_USER_HEIGHT_MAX)

 #endif

-   {

-      png_warning(png_ptr, "Image height exceeds user limit in IHDR");

-      error = 1;

-   }

-

-   if (width > PNG_UINT_31_MAX)

-   {

-      png_warning(png_ptr, "Invalid image width in IHDR");

-      error = 1;

-   }

-

-   if ( height > PNG_UINT_31_MAX)

-   {

-      png_warning(png_ptr, "Invalid image height in IHDR");

-      error = 1;

-   }

-

-   if ( width > (PNG_UINT_32_MAX

-                 >> 3)      /* 8-byte RGBA pixels */

-                 - 64       /* bigrowbuf hack */

-                 - 1        /* filter byte */

-                 - 7*8      /* rounding of width to multiple of 8 pixels */

-                 - 8)       /* extra max_pixel_depth pad */

-      png_warning(png_ptr, "Width is too large for libpng to process pixels");

-

-   /* Check other values */

-   if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&

+    {

+        png_warning(png_ptr, "Image height exceeds user limit in IHDR");

+        error = 1;

+    }

+

+    if(width > PNG_UINT_31_MAX)

+    {

+        png_warning(png_ptr, "Invalid image width in IHDR");

+        error = 1;

+    }

+

+    if(height > PNG_UINT_31_MAX)

+    {

+        png_warning(png_ptr, "Invalid image height in IHDR");

+        error = 1;

+    }

+

+    if(width > (PNG_UINT_32_MAX

+                >> 3)      /* 8-byte RGBA pixels */

+       - 64       /* bigrowbuf hack */

+       - 1        /* filter byte */

+       - 7 * 8    /* rounding of width to multiple of 8 pixels */

+       - 8)       /* extra max_pixel_depth pad */

+        png_warning(png_ptr, "Width is too large for libpng to process pixels");

+

+    /* Check other values */

+    if(bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&

        bit_depth != 8 && bit_depth != 16)

-   {

-      png_warning(png_ptr, "Invalid bit depth in IHDR");

-      error = 1;

-   }

+    {

+        png_warning(png_ptr, "Invalid bit depth in IHDR");

+        error = 1;

+    }

 

-   if (color_type < 0 || color_type == 1 ||

+    if(color_type < 0 || color_type == 1 ||

        color_type == 5 || color_type > 6)

-   {

-      png_warning(png_ptr, "Invalid color type in IHDR");

-      error = 1;

-   }

+    {

+        png_warning(png_ptr, "Invalid color type in IHDR");

+        error = 1;

+    }

 

-   if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||

+    if(((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||

        ((color_type == PNG_COLOR_TYPE_RGB ||

          color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||

          color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))

-   {

-      png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");

-      error = 1;

-   }

-

-   if (interlace_type >= PNG_INTERLACE_LAST)

-   {

-      png_warning(png_ptr, "Unknown interlace method in IHDR");

-      error = 1;

-   }

-

-   if (compression_type != PNG_COMPRESSION_TYPE_BASE)

-   {

-      png_warning(png_ptr, "Unknown compression method in IHDR");

-      error = 1;

-   }

+    {

+        png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");

+        error = 1;

+    }

+

+    if(interlace_type >= PNG_INTERLACE_LAST)

+    {

+        png_warning(png_ptr, "Unknown interlace method in IHDR");

+        error = 1;

+    }

+

+    if(compression_type != PNG_COMPRESSION_TYPE_BASE)

+    {

+        png_warning(png_ptr, "Unknown compression method in IHDR");

+        error = 1;

+    }

 

 #ifdef PNG_MNG_FEATURES_SUPPORTED

-   /* Accept filter_method 64 (intrapixel differencing) only if

-    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

-    * 2. Libpng did not read a PNG signature (this filter_method is only

-    *    used in PNG datastreams that are embedded in MNG datastreams) and

-    * 3. The application called png_permit_mng_features with a mask that

-    *    included PNG_FLAG_MNG_FILTER_64 and

-    * 4. The filter_method is 64 and

-    * 5. The color_type is RGB or RGBA

-    */

-   if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&

+    /* Accept filter_method 64 (intrapixel differencing) only if

+     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

+     * 2. Libpng did not read a PNG signature (this filter_method is only

+     *    used in PNG datastreams that are embedded in MNG datastreams) and

+     * 3. The application called png_permit_mng_features with a mask that

+     *    included PNG_FLAG_MNG_FILTER_64 and

+     * 4. The filter_method is 64 and

+     * 5. The color_type is RGB or RGBA

+     */

+    if((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&

        png_ptr->mng_features_permitted)

-      png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");

-

-   if (filter_type != PNG_FILTER_TYPE_BASE)

-   {

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

-         (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&

-         ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&

-         (color_type == PNG_COLOR_TYPE_RGB ||

-         color_type == PNG_COLOR_TYPE_RGB_ALPHA)))

-      {

-         png_warning(png_ptr, "Unknown filter method in IHDR");

-         error = 1;

-      }

-

-      if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)

-      {

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

-         error = 1;

-      }

-   }

+        png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");

+

+    if(filter_type != PNG_FILTER_TYPE_BASE)

+    {

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

+             (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&

+             ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&

+             (color_type == PNG_COLOR_TYPE_RGB ||

+              color_type == PNG_COLOR_TYPE_RGB_ALPHA)))

+        {

+            png_warning(png_ptr, "Unknown filter method in IHDR");

+            error = 1;

+        }

+

+        if(png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)

+        {

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

+            error = 1;

+        }

+    }

 

 #else

-   if (filter_type != PNG_FILTER_TYPE_BASE)

-   {

-      png_warning(png_ptr, "Unknown filter method in IHDR");

-      error = 1;

-   }

+    if(filter_type != PNG_FILTER_TYPE_BASE)

+    {

+        png_warning(png_ptr, "Unknown filter method in IHDR");

+        error = 1;

+    }

 #endif

 

-   if (error == 1)

-      png_error(png_ptr, "Invalid IHDR data");

+    if(error == 1)

+        png_error(png_ptr, "Invalid IHDR data");

 }

 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */

diff --git a/src/libpng/png.h b/src/libpng/png.h
index f871562f9..a2796cc7c 100644
--- a/src/libpng/png.h
+++ b/src/libpng/png.h
@@ -370,11 +370,11 @@
 

 /* Release-Specific Flags */

 #define PNG_LIBPNG_BUILD_PATCH    8 /* Can be OR'ed with

-                                       PNG_LIBPNG_BUILD_STABLE only */

+PNG_LIBPNG_BUILD_STABLE only */

 #define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with

-                                       PNG_LIBPNG_BUILD_SPECIAL */

+PNG_LIBPNG_BUILD_SPECIAL */

 #define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with

-                                       PNG_LIBPNG_BUILD_PRIVATE */

+PNG_LIBPNG_BUILD_PRIVATE */

 

 #define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_BETA

 

@@ -427,120 +427,120 @@
 extern "C" {

 #endif /* __cplusplus */

 

-/* This file is arranged in several sections.  The first section contains

- * structure and type definitions.  The second section contains the external

- * library functions, while the third has the internal library functions,

- * which applications aren't expected to use directly.

- */

+    /* This file is arranged in several sections.  The first section contains

+     * structure and type definitions.  The second section contains the external

+     * library functions, while the third has the internal library functions,

+     * which applications aren't expected to use directly.

+     */

 

-/* Variables declared in png.c - only it needs to define PNG_NO_EXTERN */

+    /* Variables declared in png.c - only it needs to define PNG_NO_EXTERN */

 #if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)

-/* Version information for C files, stored in png.c.  This had better match

- * the version above.

- */

+    /* Version information for C files, stored in png.c.  This had better match

+     * the version above.

+     */

 #define png_libpng_ver png_get_header_ver(NULL)

 

 #endif /* PNG_NO_EXTERN */

 

-/* Three color definitions.  The order of the red, green, and blue, (and the

- * exact size) is not important, although the size of the fields need to

- * be png_byte or png_uint_16 (as defined below).

- */

-typedef struct png_color_struct

-{

-   png_byte red;

-   png_byte green;

-   png_byte blue;

-} png_color;

-typedef png_color FAR * png_colorp;

-typedef png_color FAR * FAR * png_colorpp;

-

-typedef struct png_color_16_struct

-{

-   png_byte index;    /* used for palette files */

-   png_uint_16 red;   /* for use in red green blue files */

-   png_uint_16 green;

-   png_uint_16 blue;

-   png_uint_16 gray;  /* for use in grayscale files */

-} png_color_16;

-typedef png_color_16 FAR * png_color_16p;

-typedef png_color_16 FAR * FAR * png_color_16pp;

-

-typedef struct png_color_8_struct

-{

-   png_byte red;   /* for use in red green blue files */

-   png_byte green;

-   png_byte blue;

-   png_byte gray;  /* for use in grayscale files */

-   png_byte alpha; /* for alpha channel files */

-} png_color_8;

-typedef png_color_8 FAR * png_color_8p;

-typedef png_color_8 FAR * FAR * png_color_8pp;

-

-/*

- * The following two structures are used for the in-core representation

- * of sPLT chunks.

- */

-typedef struct png_sPLT_entry_struct

-{

-   png_uint_16 red;

-   png_uint_16 green;

-   png_uint_16 blue;

-   png_uint_16 alpha;

-   png_uint_16 frequency;

-} png_sPLT_entry;

-typedef png_sPLT_entry FAR * png_sPLT_entryp;

-typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp;

-

-/*  When the depth of the sPLT palette is 8 bits, the color and alpha samples

- *  occupy the LSB of their respective members, and the MSB of each member

- *  is zero-filled.  The frequency member always occupies the full 16 bits.

- */

-

-typedef struct png_sPLT_struct

-{

-   png_charp name;           /* palette name */

-   png_byte depth;           /* depth of palette samples */

-   png_sPLT_entryp entries;  /* palette entries */

-   png_int_32 nentries;      /* number of palette entries */

-} png_sPLT_t;

-typedef png_sPLT_t FAR * png_sPLT_tp;

-typedef png_sPLT_t FAR * FAR * png_sPLT_tpp;

+    /* Three color definitions.  The order of the red, green, and blue, (and the

+     * exact size) is not important, although the size of the fields need to

+     * be png_byte or png_uint_16 (as defined below).

+     */

+    typedef struct png_color_struct

+    {

+        png_byte red;

+        png_byte green;

+        png_byte blue;

+    } png_color;

+    typedef png_color FAR * png_colorp;

+    typedef png_color FAR * FAR * png_colorpp;

+

+    typedef struct png_color_16_struct

+    {

+        png_byte index;    /* used for palette files */

+        png_uint_16 red;   /* for use in red green blue files */

+        png_uint_16 green;

+        png_uint_16 blue;

+        png_uint_16 gray;  /* for use in grayscale files */

+    } png_color_16;

+    typedef png_color_16 FAR * png_color_16p;

+    typedef png_color_16 FAR * FAR * png_color_16pp;

+

+    typedef struct png_color_8_struct

+    {

+        png_byte red;   /* for use in red green blue files */

+        png_byte green;

+        png_byte blue;

+        png_byte gray;  /* for use in grayscale files */

+        png_byte alpha; /* for alpha channel files */

+    } png_color_8;

+    typedef png_color_8 FAR * png_color_8p;

+    typedef png_color_8 FAR * FAR * png_color_8pp;

+

+    /*

+     * The following two structures are used for the in-core representation

+     * of sPLT chunks.

+     */

+    typedef struct png_sPLT_entry_struct

+    {

+        png_uint_16 red;

+        png_uint_16 green;

+        png_uint_16 blue;

+        png_uint_16 alpha;

+        png_uint_16 frequency;

+    } png_sPLT_entry;

+    typedef png_sPLT_entry FAR * png_sPLT_entryp;

+    typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp;

+

+    /*  When the depth of the sPLT palette is 8 bits, the color and alpha samples

+     *  occupy the LSB of their respective members, and the MSB of each member

+     *  is zero-filled.  The frequency member always occupies the full 16 bits.

+     */

+

+    typedef struct png_sPLT_struct

+    {

+        png_charp name;           /* palette name */

+        png_byte depth;           /* depth of palette samples */

+        png_sPLT_entryp entries;  /* palette entries */

+        png_int_32 nentries;      /* number of palette entries */

+    } png_sPLT_t;

+    typedef png_sPLT_t FAR * png_sPLT_tp;

+    typedef png_sPLT_t FAR * FAR * png_sPLT_tpp;

 

 #ifdef PNG_TEXT_SUPPORTED

-/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,

- * and whether that contents is compressed or not.  The "key" field

- * points to a regular zero-terminated C string.  The "text", "lang", and

- * "lang_key" fields can be regular C strings, empty strings, or NULL pointers.

- * However, the * structure returned by png_get_text() will always contain

- * regular zero-terminated C strings (possibly empty), never NULL pointers,

- * so they can be safely used in printf() and other string-handling functions.

- */

-typedef struct png_text_struct

-{

-   int  compression;       /* compression value:

+    /* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,

+     * and whether that contents is compressed or not.  The "key" field

+     * points to a regular zero-terminated C string.  The "text", "lang", and

+     * "lang_key" fields can be regular C strings, empty strings, or NULL pointers.

+     * However, the * structure returned by png_get_text() will always contain

+     * regular zero-terminated C strings (possibly empty), never NULL pointers,

+     * so they can be safely used in printf() and other string-handling functions.

+     */

+    typedef struct png_text_struct

+    {

+        int  compression;       /* compression value:

                              -1: tEXt, none

                               0: zTXt, deflate

                               1: iTXt, none

                               2: iTXt, deflate  */

-   png_charp key;          /* keyword, 1-79 character description of "text" */

-   png_charp text;         /* comment, may be an empty string (ie "")

+        png_charp key;          /* keyword, 1-79 character description of "text" */

+        png_charp text;         /* comment, may be an empty string (ie "")

                               or a NULL pointer */

-   png_size_t text_length; /* length of the text string */

+        png_size_t text_length; /* length of the text string */

 #ifdef PNG_iTXt_SUPPORTED

-   png_size_t itxt_length; /* length of the itxt string */

-   png_charp lang;         /* language code, 0-79 characters

+        png_size_t itxt_length; /* length of the itxt string */

+        png_charp lang;         /* language code, 0-79 characters

                               or a NULL pointer */

-   png_charp lang_key;     /* keyword translated UTF-8 string, 0 or more

+        png_charp lang_key;     /* keyword translated UTF-8 string, 0 or more

                               chars or a NULL pointer */

 #endif

-} png_text;

-typedef png_text FAR * png_textp;

-typedef png_text FAR * FAR * png_textpp;

+    } png_text;

+    typedef png_text FAR * png_textp;

+    typedef png_text FAR * FAR * png_textpp;

 #endif

 

-/* Supported compression types for text in PNG files (tEXt, and zTXt).

- * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */

+    /* Supported compression types for text in PNG files (tEXt, and zTXt).

+     * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */

 #define PNG_TEXT_COMPRESSION_NONE_WR -3

 #define PNG_TEXT_COMPRESSION_zTXt_WR -2

 #define PNG_TEXT_COMPRESSION_NONE    -1

@@ -549,426 +549,426 @@ typedef png_text FAR * FAR * png_textpp;
 #define PNG_ITXT_COMPRESSION_zTXt     2

 #define PNG_TEXT_COMPRESSION_LAST     3  /* Not a valid value */

 

-/* png_time is a way to hold the time in an machine independent way.

- * Two conversions are provided, both from time_t and struct tm.  There

- * is no portable way to convert to either of these structures, as far

- * as I know.  If you know of a portable way, send it to me.  As a side

- * note - PNG has always been Year 2000 compliant!

- */

-typedef struct png_time_struct

-{

-   png_uint_16 year; /* full year, as in, 1995 */

-   png_byte month;   /* month of year, 1 - 12 */

-   png_byte day;     /* day of month, 1 - 31 */

-   png_byte hour;    /* hour of day, 0 - 23 */

-   png_byte minute;  /* minute of hour, 0 - 59 */

-   png_byte second;  /* second of minute, 0 - 60 (for leap seconds) */

-} png_time;

-typedef png_time FAR * png_timep;

-typedef png_time FAR * FAR * png_timepp;

+    /* png_time is a way to hold the time in an machine independent way.

+     * Two conversions are provided, both from time_t and struct tm.  There

+     * is no portable way to convert to either of these structures, as far

+     * as I know.  If you know of a portable way, send it to me.  As a side

+     * note - PNG has always been Year 2000 compliant!

+     */

+    typedef struct png_time_struct

+    {

+        png_uint_16 year; /* full year, as in, 1995 */

+        png_byte month;   /* month of year, 1 - 12 */

+        png_byte day;     /* day of month, 1 - 31 */

+        png_byte hour;    /* hour of day, 0 - 23 */

+        png_byte minute;  /* minute of hour, 0 - 59 */

+        png_byte second;  /* second of minute, 0 - 60 (for leap seconds) */

+    } png_time;

+    typedef png_time FAR * png_timep;

+    typedef png_time FAR * FAR * png_timepp;

 

 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \

  defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)

-/* png_unknown_chunk is a structure to hold queued chunks for which there is

- * no specific support.  The idea is that we can use this to queue

- * up private chunks for output even though the library doesn't actually

- * know about their semantics.

- */

-typedef struct png_unknown_chunk_t

-{

-    png_byte name[5];

-    png_byte *data;

-    png_size_t size;

-

-    /* libpng-using applications should NOT directly modify this byte. */

-    png_byte location; /* mode of operation at read time */

-}

-png_unknown_chunk;

-typedef png_unknown_chunk FAR * png_unknown_chunkp;

-typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp;

-#endif

-

-/* png_info is a structure that holds the information in a PNG file so

- * that the application can find out the characteristics of the image.

- * If you are reading the file, this structure will tell you what is

- * in the PNG file.  If you are writing the file, fill in the information

- * you want to put into the PNG file, then call png_write_info().

- * The names chosen should be very close to the PNG specification, so

- * consult that document for information about the meaning of each field.

- *

- * With libpng < 0.95, it was only possible to directly set and read the

- * the values in the png_info_struct, which meant that the contents and

- * order of the values had to remain fixed.  With libpng 0.95 and later,

- * however, there are now functions that abstract the contents of

- * png_info_struct from the application, so this makes it easier to use

- * libpng with dynamic libraries, and even makes it possible to use

- * libraries that don't have all of the libpng ancillary chunk-handing

- * functionality.

- *

- * In any case, the order of the parameters in png_info_struct should NOT

- * be changed for as long as possible to keep compatibility with applications

- * that use the old direct-access method with png_info_struct.

- *

- * The following members may have allocated storage attached that should be

- * cleaned up before the structure is discarded: palette, trans, text,

- * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile,

- * splt_palettes, scal_unit, row_pointers, and unknowns.   By default, these

- * are automatically freed when the info structure is deallocated, if they were

- * allocated internally by libpng.  This behavior can be changed by means

- * of the png_data_freer() function.

- *

- * More allocation details: all the chunk-reading functions that

- * change these members go through the corresponding png_set_*

- * functions.  A function to clear these members is available: see

- * png_free_data().  The png_set_* functions do not depend on being

- * able to point info structure members to any of the storage they are

- * passed (they make their own copies), EXCEPT that the png_set_text

- * functions use the same storage passed to them in the text_ptr or

- * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns

- * functions do not make their own copies.

- */

-typedef struct png_info_struct

-{

-   /* the following are necessary for every PNG file */

-   png_uint_32 width PNG_DEPSTRUCT;  /* width of image in pixels (from IHDR) */

-   png_uint_32 height PNG_DEPSTRUCT; /* height of image in pixels (from IHDR) */

-   png_uint_32 valid PNG_DEPSTRUCT;  /* valid chunk data (see PNG_INFO_

+    /* png_unknown_chunk is a structure to hold queued chunks for which there is

+     * no specific support.  The idea is that we can use this to queue

+     * up private chunks for output even though the library doesn't actually

+     * know about their semantics.

+     */

+    typedef struct png_unknown_chunk_t

+    {

+        png_byte name[5];

+        png_byte *data;

+        png_size_t size;

+

+        /* libpng-using applications should NOT directly modify this byte. */

+        png_byte location; /* mode of operation at read time */

+    }

+    png_unknown_chunk;

+    typedef png_unknown_chunk FAR * png_unknown_chunkp;

+    typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp;

+#endif

+

+    /* png_info is a structure that holds the information in a PNG file so

+     * that the application can find out the characteristics of the image.

+     * If you are reading the file, this structure will tell you what is

+     * in the PNG file.  If you are writing the file, fill in the information

+     * you want to put into the PNG file, then call png_write_info().

+     * The names chosen should be very close to the PNG specification, so

+     * consult that document for information about the meaning of each field.

+     *

+     * With libpng < 0.95, it was only possible to directly set and read the

+     * the values in the png_info_struct, which meant that the contents and

+     * order of the values had to remain fixed.  With libpng 0.95 and later,

+     * however, there are now functions that abstract the contents of

+     * png_info_struct from the application, so this makes it easier to use

+     * libpng with dynamic libraries, and even makes it possible to use

+     * libraries that don't have all of the libpng ancillary chunk-handing

+     * functionality.

+     *

+     * In any case, the order of the parameters in png_info_struct should NOT

+     * be changed for as long as possible to keep compatibility with applications

+     * that use the old direct-access method with png_info_struct.

+     *

+     * The following members may have allocated storage attached that should be

+     * cleaned up before the structure is discarded: palette, trans, text,

+     * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile,

+     * splt_palettes, scal_unit, row_pointers, and unknowns.   By default, these

+     * are automatically freed when the info structure is deallocated, if they were

+     * allocated internally by libpng.  This behavior can be changed by means

+     * of the png_data_freer() function.

+     *

+     * More allocation details: all the chunk-reading functions that

+     * change these members go through the corresponding png_set_*

+     * functions.  A function to clear these members is available: see

+     * png_free_data().  The png_set_* functions do not depend on being

+     * able to point info structure members to any of the storage they are

+     * passed (they make their own copies), EXCEPT that the png_set_text

+     * functions use the same storage passed to them in the text_ptr or

+     * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns

+     * functions do not make their own copies.

+     */

+    typedef struct png_info_struct

+    {

+        /* the following are necessary for every PNG file */

+        png_uint_32 width PNG_DEPSTRUCT;  /* width of image in pixels (from IHDR) */

+        png_uint_32 height PNG_DEPSTRUCT; /* height of image in pixels (from IHDR) */

+        png_uint_32 valid PNG_DEPSTRUCT;  /* valid chunk data (see PNG_INFO_

                                         below) */

-   png_size_t rowbytes PNG_DEPSTRUCT; /* bytes needed to hold an untransformed

+        png_size_t rowbytes PNG_DEPSTRUCT; /* bytes needed to hold an untransformed

                                          row */

-   png_colorp palette PNG_DEPSTRUCT;      /* array of color values

+        png_colorp palette PNG_DEPSTRUCT;      /* array of color values

                                              (valid & PNG_INFO_PLTE) */

-   png_uint_16 num_palette PNG_DEPSTRUCT; /* number of color entries in

+        png_uint_16 num_palette PNG_DEPSTRUCT; /* number of color entries in

                                              "palette" (PLTE) */

-   png_uint_16 num_trans PNG_DEPSTRUCT;   /* number of transparent palette

+        png_uint_16 num_trans PNG_DEPSTRUCT;   /* number of transparent palette

                                              color (tRNS) */

-   png_byte bit_depth PNG_DEPSTRUCT;      /* 1, 2, 4, 8, or 16 bits/channel

+        png_byte bit_depth PNG_DEPSTRUCT;      /* 1, 2, 4, 8, or 16 bits/channel

                                              (from IHDR) */

-   png_byte color_type PNG_DEPSTRUCT;     /* see PNG_COLOR_TYPE_ below

+        png_byte color_type PNG_DEPSTRUCT;     /* see PNG_COLOR_TYPE_ below

                                              (from IHDR) */

-   /* The following three should have been named *_method not *_type */

-   png_byte compression_type PNG_DEPSTRUCT; /* must be

+        /* The following three should have been named *_method not *_type */

+        png_byte compression_type PNG_DEPSTRUCT; /* must be

                                              PNG_COMPRESSION_TYPE_BASE (IHDR) */

-   png_byte filter_type PNG_DEPSTRUCT;    /* must be PNG_FILTER_TYPE_BASE

+        png_byte filter_type PNG_DEPSTRUCT;    /* must be PNG_FILTER_TYPE_BASE

                                              (from IHDR) */

-   png_byte interlace_type PNG_DEPSTRUCT; /* One of PNG_INTERLACE_NONE,

+        png_byte interlace_type PNG_DEPSTRUCT; /* One of PNG_INTERLACE_NONE,

                                              PNG_INTERLACE_ADAM7 */

 

-   /* The following is informational only on read, and not used on writes. */

-   png_byte channels PNG_DEPSTRUCT;       /* number of data channels per

+        /* The following is informational only on read, and not used on writes. */

+        png_byte channels PNG_DEPSTRUCT;       /* number of data channels per

                                              pixel (1, 2, 3, 4) */

-   png_byte pixel_depth PNG_DEPSTRUCT;    /* number of bits per pixel */

-   png_byte spare_byte PNG_DEPSTRUCT;     /* to align the data, and for

+        png_byte pixel_depth PNG_DEPSTRUCT;    /* number of bits per pixel */

+        png_byte spare_byte PNG_DEPSTRUCT;     /* to align the data, and for

                                              future use */

-   png_byte signature[8] PNG_DEPSTRUCT;   /* magic bytes read by libpng

+        png_byte signature[8] PNG_DEPSTRUCT;   /* magic bytes read by libpng

                                              from start of file */

 

-   /* The rest of the data is optional.  If you are reading, check the

-    * valid field to see if the information in these are valid.  If you

-    * are writing, set the valid field to those chunks you want written,

-    * and initialize the appropriate fields below.

-    */

+        /* The rest of the data is optional.  If you are reading, check the

+         * valid field to see if the information in these are valid.  If you

+         * are writing, set the valid field to those chunks you want written,

+         * and initialize the appropriate fields below.

+         */

 

 #if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)

-   /* The gAMA chunk describes the gamma characteristics of the system

-    * on which the image was created, normally in the range [1.0, 2.5].

-    * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.

-    */

-   float gamma PNG_DEPSTRUCT; /* gamma value of image,

+        /* The gAMA chunk describes the gamma characteristics of the system

+         * on which the image was created, normally in the range [1.0, 2.5].

+         * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.

+         */

+        float gamma PNG_DEPSTRUCT; /* gamma value of image,

                                  if (valid & PNG_INFO_gAMA) */

 #endif

 

 #ifdef PNG_sRGB_SUPPORTED

-    /* GR-P, 0.96a */

-    /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */

-   png_byte srgb_intent PNG_DEPSTRUCT; /* sRGB rendering intent

+        /* GR-P, 0.96a */

+        /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */

+        png_byte srgb_intent PNG_DEPSTRUCT; /* sRGB rendering intent

                                           [0, 1, 2, or 3] */

 #endif

 

 #ifdef PNG_TEXT_SUPPORTED

-   /* The tEXt, and zTXt chunks contain human-readable textual data in

-    * uncompressed, compressed, and optionally compressed forms, respectively.

-    * The data in "text" is an array of pointers to uncompressed,

-    * null-terminated C strings. Each chunk has a keyword that describes the

-    * textual data contained in that chunk.  Keywords are not required to be

-    * unique, and the text string may be empty.  Any number of text chunks may

-    * be in an image.

-    */

-   int num_text PNG_DEPSTRUCT; /* number of comments read/to write */

-   int max_text PNG_DEPSTRUCT; /* current size of text array */

-   png_textp text PNG_DEPSTRUCT; /* array of comments read/to write */

+        /* The tEXt, and zTXt chunks contain human-readable textual data in

+         * uncompressed, compressed, and optionally compressed forms, respectively.

+         * The data in "text" is an array of pointers to uncompressed,

+         * null-terminated C strings. Each chunk has a keyword that describes the

+         * textual data contained in that chunk.  Keywords are not required to be

+         * unique, and the text string may be empty.  Any number of text chunks may

+         * be in an image.

+         */

+        int num_text PNG_DEPSTRUCT; /* number of comments read/to write */

+        int max_text PNG_DEPSTRUCT; /* current size of text array */

+        png_textp text PNG_DEPSTRUCT; /* array of comments read/to write */

 #endif /* PNG_TEXT_SUPPORTED */

 

 #ifdef PNG_tIME_SUPPORTED

-   /* The tIME chunk holds the last time the displayed image data was

-    * modified.  See the png_time struct for the contents of this struct.

-    */

-   png_time mod_time PNG_DEPSTRUCT;

+        /* The tIME chunk holds the last time the displayed image data was

+         * modified.  See the png_time struct for the contents of this struct.

+         */

+        png_time mod_time PNG_DEPSTRUCT;

 #endif

 

 #ifdef PNG_sBIT_SUPPORTED

-   /* The sBIT chunk specifies the number of significant high-order bits

-    * in the pixel data.  Values are in the range [1, bit_depth], and are

-    * only specified for the channels in the pixel data.  The contents of

-    * the low-order bits is not specified.  Data is valid if

-    * (valid & PNG_INFO_sBIT) is non-zero.

-    */

-   png_color_8 sig_bit PNG_DEPSTRUCT; /* significant bits in color channels */

+        /* The sBIT chunk specifies the number of significant high-order bits

+         * in the pixel data.  Values are in the range [1, bit_depth], and are

+         * only specified for the channels in the pixel data.  The contents of

+         * the low-order bits is not specified.  Data is valid if

+         * (valid & PNG_INFO_sBIT) is non-zero.

+         */

+        png_color_8 sig_bit PNG_DEPSTRUCT; /* significant bits in color channels */

 #endif

 

 #if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \

 defined(PNG_READ_BACKGROUND_SUPPORTED)

-   /* The tRNS chunk supplies transparency data for paletted images and

-    * other image types that don't need a full alpha channel.  There are

-    * "num_trans" transparency values for a paletted image, stored in the

-    * same order as the palette colors, starting from index 0.  Values

-    * for the data are in the range [0, 255], ranging from fully transparent

-    * to fully opaque, respectively.  For non-paletted images, there is a

-    * single color specified that should be treated as fully transparent.

-    * Data is valid if (valid & PNG_INFO_tRNS) is non-zero.

-    */

-   png_bytep trans_alpha PNG_DEPSTRUCT;    /* alpha values for paletted

+        /* The tRNS chunk supplies transparency data for paletted images and

+         * other image types that don't need a full alpha channel.  There are

+         * "num_trans" transparency values for a paletted image, stored in the

+         * same order as the palette colors, starting from index 0.  Values

+         * for the data are in the range [0, 255], ranging from fully transparent

+         * to fully opaque, respectively.  For non-paletted images, there is a

+         * single color specified that should be treated as fully transparent.

+         * Data is valid if (valid & PNG_INFO_tRNS) is non-zero.

+         */

+        png_bytep trans_alpha PNG_DEPSTRUCT;    /* alpha values for paletted

                                               image */

-   png_color_16 trans_color PNG_DEPSTRUCT; /* transparent color for

+        png_color_16 trans_color PNG_DEPSTRUCT; /* transparent color for

                                               non-palette image */

 #endif

 

 #if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   /* The bKGD chunk gives the suggested image background color if the

-    * display program does not have its own background color and the image

-    * is needs to composited onto a background before display.  The colors

-    * in "background" are normally in the same color space/depth as the

-    * pixel data.  Data is valid if (valid & PNG_INFO_bKGD) is non-zero.

-    */

-   png_color_16 background PNG_DEPSTRUCT;

+        /* The bKGD chunk gives the suggested image background color if the

+         * display program does not have its own background color and the image

+         * is needs to composited onto a background before display.  The colors

+         * in "background" are normally in the same color space/depth as the

+         * pixel data.  Data is valid if (valid & PNG_INFO_bKGD) is non-zero.

+         */

+        png_color_16 background PNG_DEPSTRUCT;

 #endif

 

 #ifdef PNG_oFFs_SUPPORTED

-   /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards

-    * and downwards from the top-left corner of the display, page, or other

-    * application-specific co-ordinate space.  See the PNG_OFFSET_ defines

-    * below for the unit types.  Valid if (valid & PNG_INFO_oFFs) non-zero.

-    */

-   png_int_32 x_offset PNG_DEPSTRUCT; /* x offset on page */

-   png_int_32 y_offset PNG_DEPSTRUCT; /* y offset on page */

-   png_byte offset_unit_type PNG_DEPSTRUCT; /* offset units type */

+        /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards

+         * and downwards from the top-left corner of the display, page, or other

+         * application-specific co-ordinate space.  See the PNG_OFFSET_ defines

+         * below for the unit types.  Valid if (valid & PNG_INFO_oFFs) non-zero.

+         */

+        png_int_32 x_offset PNG_DEPSTRUCT; /* x offset on page */

+        png_int_32 y_offset PNG_DEPSTRUCT; /* y offset on page */

+        png_byte offset_unit_type PNG_DEPSTRUCT; /* offset units type */

 #endif

 

 #ifdef PNG_pHYs_SUPPORTED

-   /* The pHYs chunk gives the physical pixel density of the image for

-    * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_

-    * defines below).  Data is valid if (valid & PNG_INFO_pHYs) is non-zero.

-    */

-   png_uint_32 x_pixels_per_unit PNG_DEPSTRUCT; /* horizontal pixel density */

-   png_uint_32 y_pixels_per_unit PNG_DEPSTRUCT; /* vertical pixel density */

-   png_byte phys_unit_type PNG_DEPSTRUCT; /* resolution type (see

+        /* The pHYs chunk gives the physical pixel density of the image for

+         * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_

+         * defines below).  Data is valid if (valid & PNG_INFO_pHYs) is non-zero.

+         */

+        png_uint_32 x_pixels_per_unit PNG_DEPSTRUCT; /* horizontal pixel density */

+        png_uint_32 y_pixels_per_unit PNG_DEPSTRUCT; /* vertical pixel density */

+        png_byte phys_unit_type PNG_DEPSTRUCT; /* resolution type (see

                                              PNG_RESOLUTION_ below) */

 #endif

 

 #ifdef PNG_hIST_SUPPORTED

-   /* The hIST chunk contains the relative frequency or importance of the

-    * various palette entries, so that a viewer can intelligently select a

-    * reduced-color palette, if required.  Data is an array of "num_palette"

-    * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST)

-    * is non-zero.

-    */

-   png_uint_16p hist PNG_DEPSTRUCT;

+        /* The hIST chunk contains the relative frequency or importance of the

+         * various palette entries, so that a viewer can intelligently select a

+         * reduced-color palette, if required.  Data is an array of "num_palette"

+         * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST)

+         * is non-zero.

+         */

+        png_uint_16p hist PNG_DEPSTRUCT;

 #endif

 

 #ifdef PNG_cHRM_SUPPORTED

-   /* The cHRM chunk describes the CIE color characteristics of the monitor

-    * on which the PNG was created.  This data allows the viewer to do gamut

-    * mapping of the input image to ensure that the viewer sees the same

-    * colors in the image as the creator.  Values are in the range

-    * [0.0, 0.8].  Data valid if (valid & PNG_INFO_cHRM) non-zero.

-    */

+        /* The cHRM chunk describes the CIE color characteristics of the monitor

+         * on which the PNG was created.  This data allows the viewer to do gamut

+         * mapping of the input image to ensure that the viewer sees the same

+         * colors in the image as the creator.  Values are in the range

+         * [0.0, 0.8].  Data valid if (valid & PNG_INFO_cHRM) non-zero.

+         */

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   float x_white PNG_DEPSTRUCT;

-   float y_white PNG_DEPSTRUCT;

-   float x_red PNG_DEPSTRUCT;

-   float y_red PNG_DEPSTRUCT;

-   float x_green PNG_DEPSTRUCT;

-   float y_green PNG_DEPSTRUCT;

-   float x_blue PNG_DEPSTRUCT;

-   float y_blue PNG_DEPSTRUCT;

+        float x_white PNG_DEPSTRUCT;

+        float y_white PNG_DEPSTRUCT;

+        float x_red PNG_DEPSTRUCT;

+        float y_red PNG_DEPSTRUCT;

+        float x_green PNG_DEPSTRUCT;

+        float y_green PNG_DEPSTRUCT;

+        float x_blue PNG_DEPSTRUCT;

+        float y_blue PNG_DEPSTRUCT;

 #endif

 #endif

 

 #ifdef PNG_pCAL_SUPPORTED

-   /* The pCAL chunk describes a transformation between the stored pixel

-    * values and original physical data values used to create the image.

-    * The integer range [0, 2^bit_depth - 1] maps to the floating-point

-    * range given by [pcal_X0, pcal_X1], and are further transformed by a

-    * (possibly non-linear) transformation function given by "pcal_type"

-    * and "pcal_params" into "pcal_units".  Please see the PNG_EQUATION_

-    * defines below, and the PNG-Group's PNG extensions document for a

-    * complete description of the transformations and how they should be

-    * implemented, and for a description of the ASCII parameter strings.

-    * Data values are valid if (valid & PNG_INFO_pCAL) non-zero.

-    */

-   png_charp pcal_purpose PNG_DEPSTRUCT;  /* pCAL chunk description string */

-   png_int_32 pcal_X0 PNG_DEPSTRUCT;      /* minimum value */

-   png_int_32 pcal_X1 PNG_DEPSTRUCT;      /* maximum value */

-   png_charp pcal_units PNG_DEPSTRUCT;    /* Latin-1 string giving physical

+        /* The pCAL chunk describes a transformation between the stored pixel

+         * values and original physical data values used to create the image.

+         * The integer range [0, 2^bit_depth - 1] maps to the floating-point

+         * range given by [pcal_X0, pcal_X1], and are further transformed by a

+         * (possibly non-linear) transformation function given by "pcal_type"

+         * and "pcal_params" into "pcal_units".  Please see the PNG_EQUATION_

+         * defines below, and the PNG-Group's PNG extensions document for a

+         * complete description of the transformations and how they should be

+         * implemented, and for a description of the ASCII parameter strings.

+         * Data values are valid if (valid & PNG_INFO_pCAL) non-zero.

+         */

+        png_charp pcal_purpose PNG_DEPSTRUCT;  /* pCAL chunk description string */

+        png_int_32 pcal_X0 PNG_DEPSTRUCT;      /* minimum value */

+        png_int_32 pcal_X1 PNG_DEPSTRUCT;      /* maximum value */

+        png_charp pcal_units PNG_DEPSTRUCT;    /* Latin-1 string giving physical

                                              units */

-   png_charpp pcal_params PNG_DEPSTRUCT;  /* ASCII strings containing

+        png_charpp pcal_params PNG_DEPSTRUCT;  /* ASCII strings containing

                                              parameter values */

-   png_byte pcal_type PNG_DEPSTRUCT;      /* equation type

+        png_byte pcal_type PNG_DEPSTRUCT;      /* equation type

                                              (see PNG_EQUATION_ below) */

-   png_byte pcal_nparams PNG_DEPSTRUCT;   /* number of parameters given

+        png_byte pcal_nparams PNG_DEPSTRUCT;   /* number of parameters given

                                              in pcal_params */

 #endif

 

-/* New members added in libpng-1.0.6 */

-   png_uint_32 free_me PNG_DEPSTRUCT;     /* flags items libpng is

+        /* New members added in libpng-1.0.6 */

+        png_uint_32 free_me PNG_DEPSTRUCT;     /* flags items libpng is

                                              responsible for freeing */

 

 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \

  defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)

-   /* Storage for unknown chunks that the library doesn't recognize. */

-   png_unknown_chunkp unknown_chunks PNG_DEPSTRUCT;

-   png_size_t unknown_chunks_num PNG_DEPSTRUCT;

+        /* Storage for unknown chunks that the library doesn't recognize. */

+        png_unknown_chunkp unknown_chunks PNG_DEPSTRUCT;

+        png_size_t unknown_chunks_num PNG_DEPSTRUCT;

 #endif

 

 #ifdef PNG_iCCP_SUPPORTED

-   /* iCCP chunk data. */

-   png_charp iccp_name PNG_DEPSTRUCT;     /* profile name */

-   png_charp iccp_profile PNG_DEPSTRUCT;  /* International Color Consortium

+        /* iCCP chunk data. */

+        png_charp iccp_name PNG_DEPSTRUCT;     /* profile name */

+        png_charp iccp_profile PNG_DEPSTRUCT;  /* International Color Consortium

                                              profile data */

-                            /* Note to maintainer: should be png_bytep */

-   png_uint_32 iccp_proflen PNG_DEPSTRUCT;  /* ICC profile data length */

-   png_byte iccp_compression PNG_DEPSTRUCT; /* Always zero */

+        /* Note to maintainer: should be png_bytep */

+        png_uint_32 iccp_proflen PNG_DEPSTRUCT;  /* ICC profile data length */

+        png_byte iccp_compression PNG_DEPSTRUCT; /* Always zero */

 #endif

 

 #ifdef PNG_sPLT_SUPPORTED

-   /* Data on sPLT chunks (there may be more than one). */

-   png_sPLT_tp splt_palettes PNG_DEPSTRUCT;

-   png_uint_32 splt_palettes_num PNG_DEPSTRUCT;

+        /* Data on sPLT chunks (there may be more than one). */

+        png_sPLT_tp splt_palettes PNG_DEPSTRUCT;

+        png_uint_32 splt_palettes_num PNG_DEPSTRUCT;

 #endif

 

 #ifdef PNG_sCAL_SUPPORTED

-   /* The sCAL chunk describes the actual physical dimensions of the

-    * subject matter of the graphic.  The chunk contains a unit specification

-    * a byte value, and two ASCII strings representing floating-point

-    * values.  The values are width and height corresponsing to one pixel

-    * in the image.  This external representation is converted to double

-    * here.  Data values are valid if (valid & PNG_INFO_sCAL) is non-zero.

-    */

-   png_byte scal_unit PNG_DEPSTRUCT;         /* unit of physical scale */

+        /* The sCAL chunk describes the actual physical dimensions of the

+         * subject matter of the graphic.  The chunk contains a unit specification

+         * a byte value, and two ASCII strings representing floating-point

+         * values.  The values are width and height corresponsing to one pixel

+         * in the image.  This external representation is converted to double

+         * here.  Data values are valid if (valid & PNG_INFO_sCAL) is non-zero.

+         */

+        png_byte scal_unit PNG_DEPSTRUCT;         /* unit of physical scale */

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   double scal_pixel_width PNG_DEPSTRUCT;    /* width of one pixel */

-   double scal_pixel_height PNG_DEPSTRUCT;   /* height of one pixel */

+        double scal_pixel_width PNG_DEPSTRUCT;    /* width of one pixel */

+        double scal_pixel_height PNG_DEPSTRUCT;   /* height of one pixel */

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   png_charp scal_s_width PNG_DEPSTRUCT;     /* string containing height */

-   png_charp scal_s_height PNG_DEPSTRUCT;    /* string containing width */

+        png_charp scal_s_width PNG_DEPSTRUCT;     /* string containing height */

+        png_charp scal_s_height PNG_DEPSTRUCT;    /* string containing width */

 #endif

 #endif

 

 #ifdef PNG_INFO_IMAGE_SUPPORTED

-   /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS)

-      non-zero */

-   /* Data valid if (valid & PNG_INFO_IDAT) non-zero */

-   png_bytepp row_pointers PNG_DEPSTRUCT;        /* the image bits */

+        /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS)

+           non-zero */

+        /* Data valid if (valid & PNG_INFO_IDAT) non-zero */

+        png_bytepp row_pointers PNG_DEPSTRUCT;        /* the image bits */

 #endif

 

 #if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED)

-   png_fixed_point int_gamma PNG_DEPSTRUCT; /* gamma of image,

+        png_fixed_point int_gamma PNG_DEPSTRUCT; /* gamma of image,

                                                if (valid & PNG_INFO_gAMA) */

 #endif

 

 #if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED)

-   png_fixed_point int_x_white PNG_DEPSTRUCT;

-   png_fixed_point int_y_white PNG_DEPSTRUCT;

-   png_fixed_point int_x_red PNG_DEPSTRUCT;

-   png_fixed_point int_y_red PNG_DEPSTRUCT;

-   png_fixed_point int_x_green PNG_DEPSTRUCT;

-   png_fixed_point int_y_green PNG_DEPSTRUCT;

-   png_fixed_point int_x_blue PNG_DEPSTRUCT;

-   png_fixed_point int_y_blue PNG_DEPSTRUCT;

+        png_fixed_point int_x_white PNG_DEPSTRUCT;

+        png_fixed_point int_y_white PNG_DEPSTRUCT;

+        png_fixed_point int_x_red PNG_DEPSTRUCT;

+        png_fixed_point int_y_red PNG_DEPSTRUCT;

+        png_fixed_point int_x_green PNG_DEPSTRUCT;

+        png_fixed_point int_y_green PNG_DEPSTRUCT;

+        png_fixed_point int_x_blue PNG_DEPSTRUCT;

+        png_fixed_point int_y_blue PNG_DEPSTRUCT;

 #endif

 

-} png_info;

+    } png_info;

 

-typedef png_info FAR * png_infop;

-typedef png_info FAR * FAR * png_infopp;

+    typedef png_info FAR * png_infop;

+    typedef png_info FAR * FAR * png_infopp;

 

-/* Maximum positive integer used in PNG is (2^31)-1 */

+    /* Maximum positive integer used in PNG is (2^31)-1 */

 #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)

 #define PNG_UINT_32_MAX ((png_uint_32)(-1))

 #define PNG_SIZE_MAX ((png_size_t)(-1))

 

-/* These describe the color_type field in png_info. */

-/* color type masks */

+    /* These describe the color_type field in png_info. */

+    /* color type masks */

 #define PNG_COLOR_MASK_PALETTE    1

 #define PNG_COLOR_MASK_COLOR      2

 #define PNG_COLOR_MASK_ALPHA      4

 

-/* color types.  Note that not all combinations are legal */

+    /* color types.  Note that not all combinations are legal */

 #define PNG_COLOR_TYPE_GRAY 0

 #define PNG_COLOR_TYPE_PALETTE  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)

 #define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)

 #define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)

 #define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)

-/* aliases */

+    /* aliases */

 #define PNG_COLOR_TYPE_RGBA  PNG_COLOR_TYPE_RGB_ALPHA

 #define PNG_COLOR_TYPE_GA  PNG_COLOR_TYPE_GRAY_ALPHA

 

-/* This is for compression type. PNG 1.0-1.2 only define the single type. */

+    /* This is for compression type. PNG 1.0-1.2 only define the single type. */

 #define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */

 #define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE

 

-/* This is for filter type. PNG 1.0-1.2 only define the single type. */

+    /* This is for filter type. PNG 1.0-1.2 only define the single type. */

 #define PNG_FILTER_TYPE_BASE      0 /* Single row per-byte filtering */

 #define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */

 #define PNG_FILTER_TYPE_DEFAULT   PNG_FILTER_TYPE_BASE

 

-/* These are for the interlacing type.  These values should NOT be changed. */

+    /* These are for the interlacing type.  These values should NOT be changed. */

 #define PNG_INTERLACE_NONE        0 /* Non-interlaced image */

 #define PNG_INTERLACE_ADAM7       1 /* Adam7 interlacing */

 #define PNG_INTERLACE_LAST        2 /* Not a valid value */

 

-/* These are for the oFFs chunk.  These values should NOT be changed. */

+    /* These are for the oFFs chunk.  These values should NOT be changed. */

 #define PNG_OFFSET_PIXEL          0 /* Offset in pixels */

 #define PNG_OFFSET_MICROMETER     1 /* Offset in micrometers (1/10^6 meter) */

 #define PNG_OFFSET_LAST           2 /* Not a valid value */

 

-/* These are for the pCAL chunk.  These values should NOT be changed. */

+    /* These are for the pCAL chunk.  These values should NOT be changed. */

 #define PNG_EQUATION_LINEAR       0 /* Linear transformation */

 #define PNG_EQUATION_BASE_E       1 /* Exponential base e transform */

 #define PNG_EQUATION_ARBITRARY    2 /* Arbitrary base exponential transform */

 #define PNG_EQUATION_HYPERBOLIC   3 /* Hyperbolic sine transformation */

 #define PNG_EQUATION_LAST         4 /* Not a valid value */

 

-/* These are for the sCAL chunk.  These values should NOT be changed. */

+    /* These are for the sCAL chunk.  These values should NOT be changed. */

 #define PNG_SCALE_UNKNOWN         0 /* unknown unit (image scale) */

 #define PNG_SCALE_METER           1 /* meters per pixel */

 #define PNG_SCALE_RADIAN          2 /* radians per pixel */

 #define PNG_SCALE_LAST            3 /* Not a valid value */

 

-/* These are for the pHYs chunk.  These values should NOT be changed. */

+    /* These are for the pHYs chunk.  These values should NOT be changed. */

 #define PNG_RESOLUTION_UNKNOWN    0 /* pixels/unknown unit (aspect ratio) */

 #define PNG_RESOLUTION_METER      1 /* pixels/meter */

 #define PNG_RESOLUTION_LAST       2 /* Not a valid value */

 

-/* These are for the sRGB chunk.  These values should NOT be changed. */

+    /* These are for the sRGB chunk.  These values should NOT be changed. */

 #define PNG_sRGB_INTENT_PERCEPTUAL 0

 #define PNG_sRGB_INTENT_RELATIVE   1

 #define PNG_sRGB_INTENT_SATURATION 2

 #define PNG_sRGB_INTENT_ABSOLUTE   3

 #define PNG_sRGB_INTENT_LAST       4 /* Not a valid value */

 

-/* This is for text chunks */

+    /* This is for text chunks */

 #define PNG_KEYWORD_MAX_LENGTH     79

 

-/* Maximum number of entries in PLTE/sPLT/tRNS arrays */

+    /* Maximum number of entries in PLTE/sPLT/tRNS arrays */

 #define PNG_MAX_PALETTE_LENGTH    256

 

-/* These determine if an ancillary chunk's data has been successfully read

- * from the PNG header, or if the application has filled in the corresponding

- * data in the info_struct to be written into the output file.  The values

- * of the PNG_INFO_<chunk> defines should NOT be changed.

- */

+    /* These determine if an ancillary chunk's data has been successfully read

+     * from the PNG header, or if the application has filled in the corresponding

+     * data in the info_struct to be written into the output file.  The values

+     * of the PNG_INFO_<chunk> defines should NOT be changed.

+     */

 #define PNG_INFO_gAMA 0x0001

 #define PNG_INFO_sBIT 0x0002

 #define PNG_INFO_cHRM 0x0004

@@ -986,70 +986,70 @@ typedef png_info FAR * FAR * png_infopp;
 #define PNG_INFO_sCAL 0x4000   /* ESR, 1.0.6 */

 #define PNG_INFO_IDAT 0x8000L  /* ESR, 1.0.6 */

 

-/* This is used for the transformation routines, as some of them

- * change these values for the row.  It also should enable using

- * the routines for other purposes.

- */

-typedef struct png_row_info_struct

-{

-   png_uint_32 width; /* width of row */

-   png_size_t rowbytes; /* number of bytes in row */

-   png_byte color_type; /* color type of row */

-   png_byte bit_depth; /* bit depth of row */

-   png_byte channels; /* number of channels (1, 2, 3, or 4) */

-   png_byte pixel_depth; /* bits per pixel (depth * channels) */

-} png_row_info;

-

-typedef png_row_info FAR * png_row_infop;

-typedef png_row_info FAR * FAR * png_row_infopp;

-

-/* These are the function types for the I/O functions and for the functions

- * that allow the user to override the default I/O functions with his or her

- * own.  The png_error_ptr type should match that of user-supplied warning

- * and error functions, while the png_rw_ptr type should match that of the

- * user read/write data functions.

- */

-typedef struct png_struct_def png_struct;

-typedef png_struct FAR * png_structp;

-

-typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp));

-typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));

-typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp));

-typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32,

-   int));

-typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32,

-   int));

+    /* This is used for the transformation routines, as some of them

+     * change these values for the row.  It also should enable using

+     * the routines for other purposes.

+     */

+    typedef struct png_row_info_struct

+    {

+        png_uint_32 width; /* width of row */

+        png_size_t rowbytes; /* number of bytes in row */

+        png_byte color_type; /* color type of row */

+        png_byte bit_depth; /* bit depth of row */

+        png_byte channels; /* number of channels (1, 2, 3, or 4) */

+        png_byte pixel_depth; /* bits per pixel (depth * channels) */

+    } png_row_info;

+

+    typedef png_row_info FAR * png_row_infop;

+    typedef png_row_info FAR * FAR * png_row_infopp;

+

+    /* These are the function types for the I/O functions and for the functions

+     * that allow the user to override the default I/O functions with his or her

+     * own.  The png_error_ptr type should match that of user-supplied warning

+     * and error functions, while the png_rw_ptr type should match that of the

+     * user read/write data functions.

+     */

+    typedef struct png_struct_def png_struct;

+    typedef png_struct FAR * png_structp;

+

+    typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp));

+    typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));

+    typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp));

+    typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32,

+            int));

+    typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32,

+            int));

 

 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp,

-   png_infop));

-typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop));

-typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep,

-   png_uint_32, int));

+    typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp,

+            png_infop));

+    typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop));

+    typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep,

+            png_uint_32, int));

 #endif

 

 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

-typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp,

-    png_row_infop, png_bytep));

+    typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp,

+            png_row_infop, png_bytep));

 #endif

 

 #ifdef PNG_USER_CHUNKS_SUPPORTED

-typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp,

-   png_unknown_chunkp));

+    typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp,

+            png_unknown_chunkp));

 #endif

 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp));

+    typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp));

 #endif

 #ifdef PNG_SETJMP_SUPPORTED

-/* This must match the function definition in <setjmp.h>, and the

- * application must include this before png.h to obtain the definition

- * of jmp_buf.

- */

-typedef void (PNGAPI *png_longjmp_ptr) PNGARG((jmp_buf, int));

+    /* This must match the function definition in <setjmp.h>, and the

+     * application must include this before png.h to obtain the definition

+     * of jmp_buf.

+     */

+    typedef void (PNGAPI *png_longjmp_ptr) PNGARG((jmp_buf, int));

 #endif

 

-/* Transform masks for the high-level interface */

+    /* Transform masks for the high-level interface */

 #define PNG_TRANSFORM_IDENTITY       0x0000    /* read and write */

 #define PNG_TRANSFORM_STRIP_16       0x0001    /* read only */

 #define PNG_TRANSFORM_STRIP_ALPHA    0x0002    /* read only */

@@ -1063,468 +1063,468 @@ typedef void (PNGAPI *png_longjmp_ptr) PNGARG((jmp_buf, int));
 #define PNG_TRANSFORM_SWAP_ENDIAN    0x0200    /* read and write */

 #define PNG_TRANSFORM_INVERT_ALPHA   0x0400    /* read and write */

 #define PNG_TRANSFORM_STRIP_FILLER   0x0800    /* write only */

-/* Added to libpng-1.2.34 */

+    /* Added to libpng-1.2.34 */

 #define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER

 #define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */

-/* Added to libpng-1.4.0 */

+    /* Added to libpng-1.4.0 */

 #define PNG_TRANSFORM_GRAY_TO_RGB   0x2000      /* read only */

 

-/* Flags for MNG supported features */

+    /* Flags for MNG supported features */

 #define PNG_FLAG_MNG_EMPTY_PLTE     0x01

 #define PNG_FLAG_MNG_FILTER_64      0x04

 #define PNG_ALL_MNG_FEATURES        0x05

 

-typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_alloc_size_t));

-typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp));

+    typedef png_voidp(*png_malloc_ptr) PNGARG((png_structp, png_alloc_size_t));

+    typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp));

 

-/* The structure that holds the information to read and write PNG files.

- * The only people who need to care about what is inside of this are the

- * people who will be modifying the library for their own special needs.

- * It should NOT be accessed directly by an application, except to store

- * the jmp_buf.

- */

+    /* The structure that holds the information to read and write PNG files.

+     * The only people who need to care about what is inside of this are the

+     * people who will be modifying the library for their own special needs.

+     * It should NOT be accessed directly by an application, except to store

+     * the jmp_buf.

+     */

 

-struct png_struct_def

-{

+    struct png_struct_def

+    {

 #ifdef PNG_SETJMP_SUPPORTED

-   jmp_buf jmpbuf PNG_DEPSTRUCT;            /* used in png_error */

-   png_longjmp_ptr longjmp_fn PNG_DEPSTRUCT;/* setjmp non-local goto

+        jmp_buf jmpbuf PNG_DEPSTRUCT;            /* used in png_error */

+        png_longjmp_ptr longjmp_fn PNG_DEPSTRUCT;/* setjmp non-local goto

                                                function. */

 #endif

-   png_error_ptr error_fn PNG_DEPSTRUCT;    /* function for printing

+        png_error_ptr error_fn PNG_DEPSTRUCT;    /* function for printing

                                                errors and aborting */

-   png_error_ptr warning_fn PNG_DEPSTRUCT;  /* function for printing

+        png_error_ptr warning_fn PNG_DEPSTRUCT;  /* function for printing

                                                warnings */

-   png_voidp error_ptr PNG_DEPSTRUCT;       /* user supplied struct for

+        png_voidp error_ptr PNG_DEPSTRUCT;       /* user supplied struct for

                                                error functions */

-   png_rw_ptr write_data_fn PNG_DEPSTRUCT;  /* function for writing

+        png_rw_ptr write_data_fn PNG_DEPSTRUCT;  /* function for writing

                                                output data */

-   png_rw_ptr read_data_fn PNG_DEPSTRUCT;   /* function for reading

+        png_rw_ptr read_data_fn PNG_DEPSTRUCT;   /* function for reading

                                                input data */

-   png_voidp io_ptr PNG_DEPSTRUCT;          /* ptr to application struct

+        png_voidp io_ptr PNG_DEPSTRUCT;          /* ptr to application struct

                                                for I/O functions */

 

 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-   png_user_transform_ptr read_user_transform_fn PNG_DEPSTRUCT; /* user read

+        png_user_transform_ptr read_user_transform_fn PNG_DEPSTRUCT; /* user read

                                                                  transform */

 #endif

 

 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-   png_user_transform_ptr write_user_transform_fn PNG_DEPSTRUCT; /* user write

+        png_user_transform_ptr write_user_transform_fn PNG_DEPSTRUCT; /* user write

                                                                   transform */

 #endif

 

-/* These were added in libpng-1.0.2 */

+        /* These were added in libpng-1.0.2 */

 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED

 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

-   png_voidp user_transform_ptr PNG_DEPSTRUCT; /* user supplied struct

+        png_voidp user_transform_ptr PNG_DEPSTRUCT; /* user supplied struct

                                                   for user transform */

-   png_byte user_transform_depth PNG_DEPSTRUCT;    /* bit depth of user

+        png_byte user_transform_depth PNG_DEPSTRUCT;    /* bit depth of user

                                                       transformed pixels */

-   png_byte user_transform_channels PNG_DEPSTRUCT; /* channels in user

+        png_byte user_transform_channels PNG_DEPSTRUCT; /* channels in user

                                                       transformed pixels */

 #endif

 #endif

 

-   png_uint_32 mode PNG_DEPSTRUCT;          /* tells us where we are in

+        png_uint_32 mode PNG_DEPSTRUCT;          /* tells us where we are in

                                                the PNG file */

-   png_uint_32 flags PNG_DEPSTRUCT;         /* flags indicating various

+        png_uint_32 flags PNG_DEPSTRUCT;         /* flags indicating various

                                                things to libpng */

-   png_uint_32 transformations PNG_DEPSTRUCT; /* which transformations

+        png_uint_32 transformations PNG_DEPSTRUCT; /* which transformations

                                                  to perform */

 

-   z_stream zstream PNG_DEPSTRUCT;          /* pointer to decompression

+        z_stream zstream PNG_DEPSTRUCT;          /* pointer to decompression

                                                structure (below) */

-   png_bytep zbuf PNG_DEPSTRUCT;            /* buffer for zlib */

-   png_size_t zbuf_size PNG_DEPSTRUCT;      /* size of zbuf */

-   int zlib_level PNG_DEPSTRUCT;            /* holds zlib compression level */

-   int zlib_method PNG_DEPSTRUCT;           /* holds zlib compression method */

-   int zlib_window_bits PNG_DEPSTRUCT;      /* holds zlib compression window

+        png_bytep zbuf PNG_DEPSTRUCT;            /* buffer for zlib */

+        png_size_t zbuf_size PNG_DEPSTRUCT;      /* size of zbuf */

+        int zlib_level PNG_DEPSTRUCT;            /* holds zlib compression level */

+        int zlib_method PNG_DEPSTRUCT;           /* holds zlib compression method */

+        int zlib_window_bits PNG_DEPSTRUCT;      /* holds zlib compression window

                                                bits */

-   int zlib_mem_level PNG_DEPSTRUCT;        /* holds zlib compression memory

+        int zlib_mem_level PNG_DEPSTRUCT;        /* holds zlib compression memory

                                                level */

-   int zlib_strategy PNG_DEPSTRUCT;         /* holds zlib compression

+        int zlib_strategy PNG_DEPSTRUCT;         /* holds zlib compression

                                                strategy */

 

-   png_uint_32 width PNG_DEPSTRUCT;         /* width of image in pixels */

-   png_uint_32 height PNG_DEPSTRUCT;        /* height of image in pixels */

-   png_uint_32 num_rows PNG_DEPSTRUCT;      /* number of rows in current pass */

-   png_uint_32 usr_width PNG_DEPSTRUCT;     /* width of row at start of write */

-   png_size_t rowbytes PNG_DEPSTRUCT;       /* size of row in bytes */

+        png_uint_32 width PNG_DEPSTRUCT;         /* width of image in pixels */

+        png_uint_32 height PNG_DEPSTRUCT;        /* height of image in pixels */

+        png_uint_32 num_rows PNG_DEPSTRUCT;      /* number of rows in current pass */

+        png_uint_32 usr_width PNG_DEPSTRUCT;     /* width of row at start of write */

+        png_size_t rowbytes PNG_DEPSTRUCT;       /* size of row in bytes */

 #if 0 /* Replaced with the following in libpng-1.4.1 */

-   png_size_t irowbytes PNG_DEPSTRUCT;

+        png_size_t irowbytes PNG_DEPSTRUCT;

 #endif

-/* Added in libpng-1.4.1 */

+        /* Added in libpng-1.4.1 */

 #ifdef PNG_USER_LIMITS_SUPPORTED

-   /* Total memory that a zTXt, sPLT, iTXt, iCCP, or unknown chunk

-    * can occupy when decompressed.  0 means unlimited.

-    * We will change the typedef from png_size_t to png_alloc_size_t

-    * in libpng-1.6.0

-    */

-   png_alloc_size_t user_chunk_malloc_max PNG_DEPSTRUCT;

-#endif

-   png_uint_32 iwidth PNG_DEPSTRUCT;        /* width of current interlaced

+        /* Total memory that a zTXt, sPLT, iTXt, iCCP, or unknown chunk

+         * can occupy when decompressed.  0 means unlimited.

+         * We will change the typedef from png_size_t to png_alloc_size_t

+         * in libpng-1.6.0

+         */

+        png_alloc_size_t user_chunk_malloc_max PNG_DEPSTRUCT;

+#endif

+        png_uint_32 iwidth PNG_DEPSTRUCT;        /* width of current interlaced

                                                row in pixels */

-   png_uint_32 row_number PNG_DEPSTRUCT;    /* current row in interlace pass */

-   png_bytep prev_row PNG_DEPSTRUCT;        /* buffer to save previous

+        png_uint_32 row_number PNG_DEPSTRUCT;    /* current row in interlace pass */

+        png_bytep prev_row PNG_DEPSTRUCT;        /* buffer to save previous

                                                (unfiltered) row */

-   png_bytep row_buf PNG_DEPSTRUCT;         /* buffer to save current

+        png_bytep row_buf PNG_DEPSTRUCT;         /* buffer to save current

                                                (unfiltered) row */

-   png_bytep sub_row PNG_DEPSTRUCT;         /* buffer to save "sub" row

+        png_bytep sub_row PNG_DEPSTRUCT;         /* buffer to save "sub" row

                                                when filtering */

-   png_bytep up_row PNG_DEPSTRUCT;          /* buffer to save "up" row

+        png_bytep up_row PNG_DEPSTRUCT;          /* buffer to save "up" row

                                                when filtering */

-   png_bytep avg_row PNG_DEPSTRUCT;         /* buffer to save "avg" row

+        png_bytep avg_row PNG_DEPSTRUCT;         /* buffer to save "avg" row

                                                when filtering */

-   png_bytep paeth_row PNG_DEPSTRUCT;       /* buffer to save "Paeth" row

+        png_bytep paeth_row PNG_DEPSTRUCT;       /* buffer to save "Paeth" row

                                                when filtering */

-   png_row_info row_info PNG_DEPSTRUCT;     /* used for transformation

+        png_row_info row_info PNG_DEPSTRUCT;     /* used for transformation

                                                routines */

 

-   png_uint_32 idat_size PNG_DEPSTRUCT;     /* current IDAT size for read */

-   png_uint_32 crc PNG_DEPSTRUCT;           /* current chunk CRC value */

-   png_colorp palette PNG_DEPSTRUCT;        /* palette from the input file */

-   png_uint_16 num_palette PNG_DEPSTRUCT;   /* number of color entries in

+        png_uint_32 idat_size PNG_DEPSTRUCT;     /* current IDAT size for read */

+        png_uint_32 crc PNG_DEPSTRUCT;           /* current chunk CRC value */

+        png_colorp palette PNG_DEPSTRUCT;        /* palette from the input file */

+        png_uint_16 num_palette PNG_DEPSTRUCT;   /* number of color entries in

                                                palette */

-   png_uint_16 num_trans PNG_DEPSTRUCT;     /* number of transparency values */

-   png_byte chunk_name[5] PNG_DEPSTRUCT;    /* null-terminated name of current

+        png_uint_16 num_trans PNG_DEPSTRUCT;     /* number of transparency values */

+        png_byte chunk_name[5] PNG_DEPSTRUCT;    /* null-terminated name of current

                                                chunk */

-   png_byte compression PNG_DEPSTRUCT;      /* file compression type

+        png_byte compression PNG_DEPSTRUCT;      /* file compression type

                                                (always 0) */

-   png_byte filter PNG_DEPSTRUCT;           /* file filter type (always 0) */

-   png_byte interlaced PNG_DEPSTRUCT;       /* PNG_INTERLACE_NONE,

+        png_byte filter PNG_DEPSTRUCT;           /* file filter type (always 0) */

+        png_byte interlaced PNG_DEPSTRUCT;       /* PNG_INTERLACE_NONE,

                                                PNG_INTERLACE_ADAM7 */

-   png_byte pass PNG_DEPSTRUCT;             /* current interlace pass (0 - 6) */

-   png_byte do_filter PNG_DEPSTRUCT;        /* row filter flags (see

+        png_byte pass PNG_DEPSTRUCT;             /* current interlace pass (0 - 6) */

+        png_byte do_filter PNG_DEPSTRUCT;        /* row filter flags (see

                                                PNG_FILTER_ below ) */

-   png_byte color_type PNG_DEPSTRUCT;       /* color type of file */

-   png_byte bit_depth PNG_DEPSTRUCT;        /* bit depth of file */

-   png_byte usr_bit_depth PNG_DEPSTRUCT;    /* bit depth of users row */

-   png_byte pixel_depth PNG_DEPSTRUCT;      /* number of bits per pixel */

-   png_byte channels PNG_DEPSTRUCT;         /* number of channels in file */

-   png_byte usr_channels PNG_DEPSTRUCT;     /* channels at start of write */

-   png_byte sig_bytes PNG_DEPSTRUCT;        /* magic bytes read/written from

+        png_byte color_type PNG_DEPSTRUCT;       /* color type of file */

+        png_byte bit_depth PNG_DEPSTRUCT;        /* bit depth of file */

+        png_byte usr_bit_depth PNG_DEPSTRUCT;    /* bit depth of users row */

+        png_byte pixel_depth PNG_DEPSTRUCT;      /* number of bits per pixel */

+        png_byte channels PNG_DEPSTRUCT;         /* number of channels in file */

+        png_byte usr_channels PNG_DEPSTRUCT;     /* channels at start of write */

+        png_byte sig_bytes PNG_DEPSTRUCT;        /* magic bytes read/written from

                                                start of file */

 

 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)

-   png_uint_16 filler PNG_DEPSTRUCT;           /* filler bytes for pixel

+        png_uint_16 filler PNG_DEPSTRUCT;           /* filler bytes for pixel

                                                   expansion */

 #endif

 

 #ifdef PNG_bKGD_SUPPORTED

-   png_byte background_gamma_type PNG_DEPSTRUCT;

+        png_byte background_gamma_type PNG_DEPSTRUCT;

 #  ifdef PNG_FLOATING_POINT_SUPPORTED

-   float background_gamma PNG_DEPSTRUCT;

+        float background_gamma PNG_DEPSTRUCT;

 #  endif

-   png_color_16 background PNG_DEPSTRUCT;   /* background color in

+        png_color_16 background PNG_DEPSTRUCT;   /* background color in

                                                screen gamma space */

 #ifdef PNG_READ_GAMMA_SUPPORTED

-   png_color_16 background_1 PNG_DEPSTRUCT; /* background normalized

+        png_color_16 background_1 PNG_DEPSTRUCT; /* background normalized

                                                to gamma 1.0 */

 #endif

 #endif /* PNG_bKGD_SUPPORTED */

 

 #ifdef PNG_WRITE_FLUSH_SUPPORTED

-   png_flush_ptr output_flush_fn PNG_DEPSTRUCT; /* Function for flushing

+        png_flush_ptr output_flush_fn PNG_DEPSTRUCT; /* Function for flushing

                                                output */

-   png_uint_32 flush_dist PNG_DEPSTRUCT;    /* how many rows apart to flush,

+        png_uint_32 flush_dist PNG_DEPSTRUCT;    /* how many rows apart to flush,

                                                0 - no flush */

-   png_uint_32 flush_rows PNG_DEPSTRUCT;    /* number of rows written since

+        png_uint_32 flush_rows PNG_DEPSTRUCT;    /* number of rows written since

                                                last flush */

 #endif

 

 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   int gamma_shift PNG_DEPSTRUCT;      /* number of "insignificant" bits

+        int gamma_shift PNG_DEPSTRUCT;      /* number of "insignificant" bits

                                           16-bit gamma */

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   float gamma PNG_DEPSTRUCT;          /* file gamma value */

-   float screen_gamma PNG_DEPSTRUCT;   /* screen gamma value

+        float gamma PNG_DEPSTRUCT;          /* file gamma value */

+        float screen_gamma PNG_DEPSTRUCT;   /* screen gamma value

                                           (display_exponent) */

 #endif

 #endif

 

 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   png_bytep gamma_table PNG_DEPSTRUCT;     /* gamma table for 8-bit

+        png_bytep gamma_table PNG_DEPSTRUCT;     /* gamma table for 8-bit

                                                depth files */

-   png_bytep gamma_from_1 PNG_DEPSTRUCT;    /* converts from 1.0 to screen */

-   png_bytep gamma_to_1 PNG_DEPSTRUCT;      /* converts from file to 1.0 */

-   png_uint_16pp gamma_16_table PNG_DEPSTRUCT; /* gamma table for 16-bit

+        png_bytep gamma_from_1 PNG_DEPSTRUCT;    /* converts from 1.0 to screen */

+        png_bytep gamma_to_1 PNG_DEPSTRUCT;      /* converts from file to 1.0 */

+        png_uint_16pp gamma_16_table PNG_DEPSTRUCT; /* gamma table for 16-bit

                                                   depth files */

-   png_uint_16pp gamma_16_from_1 PNG_DEPSTRUCT; /* converts from 1.0 to

+        png_uint_16pp gamma_16_from_1 PNG_DEPSTRUCT; /* converts from 1.0 to

                                                    screen */

-   png_uint_16pp gamma_16_to_1 PNG_DEPSTRUCT; /* converts from file to 1.0 */

+        png_uint_16pp gamma_16_to_1 PNG_DEPSTRUCT; /* converts from file to 1.0 */

 #endif

 

 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)

-   png_color_8 sig_bit PNG_DEPSTRUCT;       /* significant bits in each

+        png_color_8 sig_bit PNG_DEPSTRUCT;       /* significant bits in each

                                                available channel */

 #endif

 

 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)

-   png_color_8 shift PNG_DEPSTRUCT;         /* shift for significant bit

+        png_color_8 shift PNG_DEPSTRUCT;         /* shift for significant bit

                                                tranformation */

 #endif

 

 #if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \

  || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   png_bytep trans_alpha PNG_DEPSTRUCT;           /* alpha values for

+        png_bytep trans_alpha PNG_DEPSTRUCT;           /* alpha values for

                                                      paletted files */

-   png_color_16 trans_color PNG_DEPSTRUCT;  /* transparent color for

+        png_color_16 trans_color PNG_DEPSTRUCT;  /* transparent color for

                                                non-paletted files */

 #endif

 

-   png_read_status_ptr read_row_fn PNG_DEPSTRUCT;   /* called after each

+        png_read_status_ptr read_row_fn PNG_DEPSTRUCT;   /* called after each

                                                        row is decoded */

-   png_write_status_ptr write_row_fn PNG_DEPSTRUCT; /* called after each

+        png_write_status_ptr write_row_fn PNG_DEPSTRUCT; /* called after each

                                                        row is encoded */

 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-   png_progressive_info_ptr info_fn PNG_DEPSTRUCT; /* called after header

+        png_progressive_info_ptr info_fn PNG_DEPSTRUCT; /* called after header

                                                       data fully read */

-   png_progressive_row_ptr row_fn PNG_DEPSTRUCT;   /* called after each

+        png_progressive_row_ptr row_fn PNG_DEPSTRUCT;   /* called after each

                                                       prog. row is decoded */

-   png_progressive_end_ptr end_fn PNG_DEPSTRUCT;   /* called after image

+        png_progressive_end_ptr end_fn PNG_DEPSTRUCT;   /* called after image

                                                       is complete */

-   png_bytep save_buffer_ptr PNG_DEPSTRUCT;        /* current location in

+        png_bytep save_buffer_ptr PNG_DEPSTRUCT;        /* current location in

                                                       save_buffer */

-   png_bytep save_buffer PNG_DEPSTRUCT;            /* buffer for previously

+        png_bytep save_buffer PNG_DEPSTRUCT;            /* buffer for previously

                                                       read data */

-   png_bytep current_buffer_ptr PNG_DEPSTRUCT;     /* current location in

+        png_bytep current_buffer_ptr PNG_DEPSTRUCT;     /* current location in

                                                       current_buffer */

-   png_bytep current_buffer PNG_DEPSTRUCT;         /* buffer for recently

+        png_bytep current_buffer PNG_DEPSTRUCT;         /* buffer for recently

                                                       used data */

-   png_uint_32 push_length PNG_DEPSTRUCT;          /* size of current input

+        png_uint_32 push_length PNG_DEPSTRUCT;          /* size of current input

                                                       chunk */

-   png_uint_32 skip_length PNG_DEPSTRUCT;          /* bytes to skip in

+        png_uint_32 skip_length PNG_DEPSTRUCT;          /* bytes to skip in

                                                       input data */

-   png_size_t save_buffer_size PNG_DEPSTRUCT;      /* amount of data now

+        png_size_t save_buffer_size PNG_DEPSTRUCT;      /* amount of data now

                                                       in save_buffer */

-   png_size_t save_buffer_max PNG_DEPSTRUCT;       /* total size of

+        png_size_t save_buffer_max PNG_DEPSTRUCT;       /* total size of

                                                       save_buffer */

-   png_size_t buffer_size PNG_DEPSTRUCT;           /* total amount of

+        png_size_t buffer_size PNG_DEPSTRUCT;           /* total amount of

                                                       available input data */

-   png_size_t current_buffer_size PNG_DEPSTRUCT;   /* amount of data now

+        png_size_t current_buffer_size PNG_DEPSTRUCT;   /* amount of data now

                                                       in current_buffer */

-   int process_mode PNG_DEPSTRUCT;                 /* what push library

+        int process_mode PNG_DEPSTRUCT;                 /* what push library

                                                       is currently doing */

-   int cur_palette PNG_DEPSTRUCT;                  /* current push library

+        int cur_palette PNG_DEPSTRUCT;                  /* current push library

                                                       palette index */

 

 #  ifdef PNG_TEXT_SUPPORTED

-     png_size_t current_text_size PNG_DEPSTRUCT;   /* current size of

+        png_size_t current_text_size PNG_DEPSTRUCT;   /* current size of

                                                       text input data */

-     png_size_t current_text_left PNG_DEPSTRUCT;   /* how much text left

+        png_size_t current_text_left PNG_DEPSTRUCT;   /* how much text left

                                                       to read in input */

-     png_charp current_text PNG_DEPSTRUCT;         /* current text chunk

+        png_charp current_text PNG_DEPSTRUCT;         /* current text chunk

                                                       buffer */

-     png_charp current_text_ptr PNG_DEPSTRUCT;     /* current location

+        png_charp current_text_ptr PNG_DEPSTRUCT;     /* current location

                                                       in current_text */

 #  endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */

 

 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

 

 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)

-/* For the Borland special 64K segment handler */

-   png_bytepp offset_table_ptr PNG_DEPSTRUCT;

-   png_bytep offset_table PNG_DEPSTRUCT;

-   png_uint_16 offset_table_number PNG_DEPSTRUCT;

-   png_uint_16 offset_table_count PNG_DEPSTRUCT;

-   png_uint_16 offset_table_count_free PNG_DEPSTRUCT;

+        /* For the Borland special 64K segment handler */

+        png_bytepp offset_table_ptr PNG_DEPSTRUCT;

+        png_bytep offset_table PNG_DEPSTRUCT;

+        png_uint_16 offset_table_number PNG_DEPSTRUCT;

+        png_uint_16 offset_table_count PNG_DEPSTRUCT;

+        png_uint_16 offset_table_count_free PNG_DEPSTRUCT;

 #endif

 

 #ifdef PNG_READ_DITHER_SUPPORTED

-   png_bytep palette_lookup PNG_DEPSTRUCT; /* lookup table for dithering */

-   png_bytep dither_index PNG_DEPSTRUCT;   /* index translation for palette

+        png_bytep palette_lookup PNG_DEPSTRUCT; /* lookup table for dithering */

+        png_bytep dither_index PNG_DEPSTRUCT;   /* index translation for palette

                                               files */

 #endif

 

 #if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED)

-   png_uint_16p hist PNG_DEPSTRUCT;                /* histogram */

+        png_uint_16p hist PNG_DEPSTRUCT;                /* histogram */

 #endif

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   png_byte heuristic_method PNG_DEPSTRUCT;        /* heuristic for row

+        png_byte heuristic_method PNG_DEPSTRUCT;        /* heuristic for row

                                                       filter selection */

-   png_byte num_prev_filters PNG_DEPSTRUCT;        /* number of weights

+        png_byte num_prev_filters PNG_DEPSTRUCT;        /* number of weights

                                                       for previous rows */

-   png_bytep prev_filters PNG_DEPSTRUCT;           /* filter type(s) of

+        png_bytep prev_filters PNG_DEPSTRUCT;           /* filter type(s) of

                                                       previous row(s) */

-   png_uint_16p filter_weights PNG_DEPSTRUCT;      /* weight(s) for previous

+        png_uint_16p filter_weights PNG_DEPSTRUCT;      /* weight(s) for previous

                                                       line(s) */

-   png_uint_16p inv_filter_weights PNG_DEPSTRUCT;  /* 1/weight(s) for

+        png_uint_16p inv_filter_weights PNG_DEPSTRUCT;  /* 1/weight(s) for

                                                       previous line(s) */

-   png_uint_16p filter_costs PNG_DEPSTRUCT;        /* relative filter

+        png_uint_16p filter_costs PNG_DEPSTRUCT;        /* relative filter

                                                       calculation cost */

-   png_uint_16p inv_filter_costs PNG_DEPSTRUCT;    /* 1/relative filter

+        png_uint_16p inv_filter_costs PNG_DEPSTRUCT;    /* 1/relative filter

                                                       calculation cost */

 #endif

 

 #ifdef PNG_TIME_RFC1123_SUPPORTED

-   png_charp time_buffer PNG_DEPSTRUCT; /* String to hold RFC 1123 time text */

+        png_charp time_buffer PNG_DEPSTRUCT; /* String to hold RFC 1123 time text */

 #endif

 

-/* New members added in libpng-1.0.6 */

+        /* New members added in libpng-1.0.6 */

 

-   png_uint_32 free_me PNG_DEPSTRUCT;    /* flags items libpng is

+        png_uint_32 free_me PNG_DEPSTRUCT;    /* flags items libpng is

                                             responsible for freeing */

 

 #ifdef PNG_USER_CHUNKS_SUPPORTED

-   png_voidp user_chunk_ptr PNG_DEPSTRUCT;

-   png_user_chunk_ptr read_user_chunk_fn PNG_DEPSTRUCT; /* user read

+        png_voidp user_chunk_ptr PNG_DEPSTRUCT;

+        png_user_chunk_ptr read_user_chunk_fn PNG_DEPSTRUCT; /* user read

                                                            chunk handler */

 #endif

 

 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-   int num_chunk_list PNG_DEPSTRUCT;

-   png_bytep chunk_list PNG_DEPSTRUCT;

+        int num_chunk_list PNG_DEPSTRUCT;

+        png_bytep chunk_list PNG_DEPSTRUCT;

 #endif

 

-/* New members added in libpng-1.0.3 */

+        /* New members added in libpng-1.0.3 */

 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-   png_byte rgb_to_gray_status PNG_DEPSTRUCT;

-   /* These were changed from png_byte in libpng-1.0.6 */

-   png_uint_16 rgb_to_gray_red_coeff PNG_DEPSTRUCT;

-   png_uint_16 rgb_to_gray_green_coeff PNG_DEPSTRUCT;

-   png_uint_16 rgb_to_gray_blue_coeff PNG_DEPSTRUCT;

+        png_byte rgb_to_gray_status PNG_DEPSTRUCT;

+        /* These were changed from png_byte in libpng-1.0.6 */

+        png_uint_16 rgb_to_gray_red_coeff PNG_DEPSTRUCT;

+        png_uint_16 rgb_to_gray_green_coeff PNG_DEPSTRUCT;

+        png_uint_16 rgb_to_gray_blue_coeff PNG_DEPSTRUCT;

 #endif

 

-/* New member added in libpng-1.0.4 (renamed in 1.0.9) */

+        /* New member added in libpng-1.0.4 (renamed in 1.0.9) */

 #if defined(PNG_MNG_FEATURES_SUPPORTED) || \

     defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \

     defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)

-/* Changed from png_byte to png_uint_32 at version 1.2.0 */

-   png_uint_32 mng_features_permitted PNG_DEPSTRUCT;

+        /* Changed from png_byte to png_uint_32 at version 1.2.0 */

+        png_uint_32 mng_features_permitted PNG_DEPSTRUCT;

 #endif

 

-/* New member added in libpng-1.0.7 */

+        /* New member added in libpng-1.0.7 */

 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   png_fixed_point int_gamma PNG_DEPSTRUCT;

+        png_fixed_point int_gamma PNG_DEPSTRUCT;

 #endif

 

-/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */

+        /* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */

 #ifdef PNG_MNG_FEATURES_SUPPORTED

-   png_byte filter_type PNG_DEPSTRUCT;

+        png_byte filter_type PNG_DEPSTRUCT;

 #endif

 

-/* New members added in libpng-1.2.0 */

+        /* New members added in libpng-1.2.0 */

 

-/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */

+        /* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_voidp mem_ptr PNG_DEPSTRUCT;             /* user supplied struct for

+        png_voidp mem_ptr PNG_DEPSTRUCT;             /* user supplied struct for

                                                    mem functions */

-   png_malloc_ptr malloc_fn PNG_DEPSTRUCT;      /* function for

+        png_malloc_ptr malloc_fn PNG_DEPSTRUCT;      /* function for

                                                    allocating memory */

-   png_free_ptr free_fn PNG_DEPSTRUCT;          /* function for

+        png_free_ptr free_fn PNG_DEPSTRUCT;          /* function for

                                                    freeing memory */

 #endif

 

-/* New member added in libpng-1.0.13 and 1.2.0 */

-   png_bytep big_row_buf PNG_DEPSTRUCT;         /* buffer to save current

+        /* New member added in libpng-1.0.13 and 1.2.0 */

+        png_bytep big_row_buf PNG_DEPSTRUCT;         /* buffer to save current

                                                    (unfiltered) row */

 

 #ifdef PNG_READ_DITHER_SUPPORTED

-/* The following three members were added at version 1.0.14 and 1.2.4 */

-   png_bytep dither_sort PNG_DEPSTRUCT;            /* working sort array */

-   png_bytep index_to_palette PNG_DEPSTRUCT;       /* where the original

+        /* The following three members were added at version 1.0.14 and 1.2.4 */

+        png_bytep dither_sort PNG_DEPSTRUCT;            /* working sort array */

+        png_bytep index_to_palette PNG_DEPSTRUCT;       /* where the original

                                                      index currently is

                                                      in the palette */

-   png_bytep palette_to_index PNG_DEPSTRUCT;       /* which original index

+        png_bytep palette_to_index PNG_DEPSTRUCT;       /* which original index

                                                       points to this

                                                       palette color */

 #endif

 

-/* New members added in libpng-1.0.16 and 1.2.6 */

-   png_byte compression_type PNG_DEPSTRUCT;

+        /* New members added in libpng-1.0.16 and 1.2.6 */

+        png_byte compression_type PNG_DEPSTRUCT;

 

 #ifdef PNG_USER_LIMITS_SUPPORTED

-   png_uint_32 user_width_max PNG_DEPSTRUCT;

-   png_uint_32 user_height_max PNG_DEPSTRUCT;

-   /* Added in libpng-1.4.0: Total number of sPLT, text, and unknown

-    * chunks that can be stored (0 means unlimited).

-    */

-   png_uint_32 user_chunk_cache_max PNG_DEPSTRUCT;

+        png_uint_32 user_width_max PNG_DEPSTRUCT;

+        png_uint_32 user_height_max PNG_DEPSTRUCT;

+        /* Added in libpng-1.4.0: Total number of sPLT, text, and unknown

+         * chunks that can be stored (0 means unlimited).

+         */

+        png_uint_32 user_chunk_cache_max PNG_DEPSTRUCT;

 #endif

 

-/* New member added in libpng-1.0.25 and 1.2.17 */

+        /* New member added in libpng-1.0.25 and 1.2.17 */

 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-   /* Storage for unknown chunk that the library doesn't recognize. */

-   png_unknown_chunk unknown_chunk PNG_DEPSTRUCT;

+        /* Storage for unknown chunk that the library doesn't recognize. */

+        png_unknown_chunk unknown_chunk PNG_DEPSTRUCT;

 #endif

 

-/* New members added in libpng-1.2.26 */

-  png_uint_32 old_big_row_buf_size PNG_DEPSTRUCT;

-  png_uint_32 old_prev_row_size PNG_DEPSTRUCT;

+        /* New members added in libpng-1.2.26 */

+        png_uint_32 old_big_row_buf_size PNG_DEPSTRUCT;

+        png_uint_32 old_prev_row_size PNG_DEPSTRUCT;

 

-/* New member added in libpng-1.2.30 */

-  png_charp chunkdata PNG_DEPSTRUCT;  /* buffer for reading chunk data */

+        /* New member added in libpng-1.2.30 */

+        png_charp chunkdata PNG_DEPSTRUCT;  /* buffer for reading chunk data */

 

 #ifdef PNG_IO_STATE_SUPPORTED

-/* New member added in libpng-1.4.0 */

-   png_uint_32 io_state PNG_DEPSTRUCT;

+        /* New member added in libpng-1.4.0 */

+        png_uint_32 io_state PNG_DEPSTRUCT;

 #endif

-};

+    };

 

 

-/* This triggers a compiler error in png.c, if png.c and png.h

- * do not agree upon the version number.

- */

-typedef png_structp version_1_4_1;

+    /* This triggers a compiler error in png.c, if png.c and png.h

+     * do not agree upon the version number.

+     */

+    typedef png_structp version_1_4_1;

 

-typedef png_struct FAR * FAR * png_structpp;

+    typedef png_struct FAR * FAR * png_structpp;

 

-/* Here are the function definitions most commonly used.  This is not

- * the place to find out how to use libpng.  See libpng.txt for the

- * full explanation, see example.c for the summary.  This just provides

- * a simple one line description of the use of each function.

- */

+    /* Here are the function definitions most commonly used.  This is not

+     * the place to find out how to use libpng.  See libpng.txt for the

+     * full explanation, see example.c for the summary.  This just provides

+     * a simple one line description of the use of each function.

+     */

 

-/* Returns the version number of the library */

-extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void));

+    /* Returns the version number of the library */

+    extern PNG_EXPORT(png_uint_32, png_access_version_number) PNGARG((void));

 

-/* Tell lib we have already handled the first <num_bytes> magic bytes.

- * Handling more than 8 bytes from the beginning of the file is an error.

- */

-extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr,

-   int num_bytes));

+    /* Tell lib we have already handled the first <num_bytes> magic bytes.

+     * Handling more than 8 bytes from the beginning of the file is an error.

+     */

+    extern PNG_EXPORT(void, png_set_sig_bytes) PNGARG((png_structp png_ptr,

+            int num_bytes));

 

-/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a

- * PNG file.  Returns zero if the supplied bytes match the 8-byte PNG

- * signature, and non-zero otherwise.  Having num_to_check == 0 or

- * start > 7 will always fail (ie return non-zero).

- */

-extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start,

-   png_size_t num_to_check));

+    /* Check sig[start] through sig[start + num_to_check - 1] to see if it's a

+     * PNG file.  Returns zero if the supplied bytes match the 8-byte PNG

+     * signature, and non-zero otherwise.  Having num_to_check == 0 or

+     * start > 7 will always fail (ie return non-zero).

+     */

+    extern PNG_EXPORT(int, png_sig_cmp) PNGARG((png_bytep sig, png_size_t start,

+            png_size_t num_to_check));

 

-/* Allocate and initialize png_ptr struct for reading, and any other memory. */

-extern PNG_EXPORT(png_structp,png_create_read_struct)

-   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;

+    /* Allocate and initialize png_ptr struct for reading, and any other memory. */

+    extern PNG_EXPORT(png_structp, png_create_read_struct)

+    PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

+            png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;

 

-/* Allocate and initialize png_ptr struct for writing, and any other memory */

-extern PNG_EXPORT(png_structp,png_create_write_struct)

-   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;

+    /* Allocate and initialize png_ptr struct for writing, and any other memory */

+    extern PNG_EXPORT(png_structp, png_create_write_struct)

+    PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

+            png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED;

 

-extern PNG_EXPORT(png_size_t,png_get_compression_buffer_size)

-   PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(png_size_t, png_get_compression_buffer_size)

+    PNGARG((png_structp png_ptr));

 

-extern PNG_EXPORT(void,png_set_compression_buffer_size)

-   PNGARG((png_structp png_ptr, png_size_t size));

+    extern PNG_EXPORT(void, png_set_compression_buffer_size)

+    PNGARG((png_structp png_ptr, png_size_t size));

 

-/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp

- * match up.

- */

+    /* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp

+     * match up.

+     */

 #ifdef PNG_SETJMP_SUPPORTED

-/* This function returns the jmp_buf built in to *png_ptr.  It must be

- * supplied with an appropriate 'longjmp' function to use on that jmp_buf

- * unless the default error function is overridden in which case NULL is

- * acceptable.  The size of the jmp_buf is checked against the actual size

- * allocated by the library - the call will return NULL on a mismatch

- * indicating an ABI mismatch.

- */

-extern PNG_EXPORT(jmp_buf*, png_set_longjmp_fn)

-   PNGARG((png_structp png_ptr, png_longjmp_ptr longjmp_fn, size_t

-       jmp_buf_size));

+    /* This function returns the jmp_buf built in to *png_ptr.  It must be

+     * supplied with an appropriate 'longjmp' function to use on that jmp_buf

+     * unless the default error function is overridden in which case NULL is

+     * acceptable.  The size of the jmp_buf is checked against the actual size

+     * allocated by the library - the call will return NULL on a mismatch

+     * indicating an ABI mismatch.

+     */

+    extern PNG_EXPORT(jmp_buf*, png_set_longjmp_fn)

+    PNGARG((png_structp png_ptr, png_longjmp_ptr longjmp_fn, size_t

+            jmp_buf_size));

 #  define png_jmpbuf(png_ptr) \

    (*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf)))

 #else

@@ -1532,172 +1532,172 @@ extern PNG_EXPORT(jmp_buf*, png_set_longjmp_fn)
    (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP)

 #endif

 

-/* Reset the compression stream */

-extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr));

+    /* Reset the compression stream */

+    extern PNG_EXPORT(int, png_reset_zstream) PNGARG((png_structp png_ptr));

 

-/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */

+    /* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */

 #ifdef PNG_USER_MEM_SUPPORTED

-extern PNG_EXPORT(png_structp,png_create_read_struct_2)

-   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

-   png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;

-extern PNG_EXPORT(png_structp,png_create_write_struct_2)

-   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

-   png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;

+    extern PNG_EXPORT(png_structp, png_create_read_struct_2)

+    PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

+            png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

+            png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;

+    extern PNG_EXPORT(png_structp, png_create_write_struct_2)

+    PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

+            png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

+            png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED;

 #endif

 

-/* Write the PNG file signature. */

-extern PNG_EXPORT(void,png_write_sig) PNGARG((png_structp png_ptr));

+    /* Write the PNG file signature. */

+    extern PNG_EXPORT(void, png_write_sig) PNGARG((png_structp png_ptr));

 

-/* Write a PNG chunk - size, type, (optional) data, CRC. */

-extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr,

-   png_bytep chunk_name, png_bytep data, png_size_t length));

+    /* Write a PNG chunk - size, type, (optional) data, CRC. */

+    extern PNG_EXPORT(void, png_write_chunk) PNGARG((png_structp png_ptr,

+            png_bytep chunk_name, png_bytep data, png_size_t length));

 

-/* Write the start of a PNG chunk - length and chunk name. */

-extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr,

-   png_bytep chunk_name, png_uint_32 length));

+    /* Write the start of a PNG chunk - length and chunk name. */

+    extern PNG_EXPORT(void, png_write_chunk_start) PNGARG((png_structp png_ptr,

+            png_bytep chunk_name, png_uint_32 length));

 

-/* Write the data of a PNG chunk started with png_write_chunk_start(). */

-extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr,

-   png_bytep data, png_size_t length));

+    /* Write the data of a PNG chunk started with png_write_chunk_start(). */

+    extern PNG_EXPORT(void, png_write_chunk_data) PNGARG((png_structp png_ptr,

+            png_bytep data, png_size_t length));

 

-/* Finish a chunk started with png_write_chunk_start() (includes CRC). */

-extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr));

+    /* Finish a chunk started with png_write_chunk_start() (includes CRC). */

+    extern PNG_EXPORT(void, png_write_chunk_end) PNGARG((png_structp png_ptr));

 

-/* Allocate and initialize the info structure */

-extern PNG_EXPORT(png_infop,png_create_info_struct)

-   PNGARG((png_structp png_ptr)) PNG_ALLOCATED;

+    /* Allocate and initialize the info structure */

+    extern PNG_EXPORT(png_infop, png_create_info_struct)

+    PNGARG((png_structp png_ptr)) PNG_ALLOCATED;

 

-extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr,

-    png_size_t png_info_struct_size));

+    extern PNG_EXPORT(void, png_info_init_3) PNGARG((png_infopp info_ptr,

+            png_size_t png_info_struct_size));

 

-/* Writes all the PNG information before the image. */

-extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

+    /* Writes all the PNG information before the image. */

+    extern PNG_EXPORT(void, png_write_info_before_PLTE) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

+    extern PNG_EXPORT(void, png_write_info) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Read the information before the actual image data. */

-extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

+    /* Read the information before the actual image data. */

+    extern PNG_EXPORT(void, png_read_info) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 #endif

 

 #ifdef PNG_TIME_RFC1123_SUPPORTED

-extern PNG_EXPORT(png_charp,png_convert_to_rfc1123)

-   PNGARG((png_structp png_ptr, png_timep ptime));

+    extern PNG_EXPORT(png_charp, png_convert_to_rfc1123)

+    PNGARG((png_structp png_ptr, png_timep ptime));

 #endif

 

 #ifdef PNG_CONVERT_tIME_SUPPORTED

-/* Convert from a struct tm to png_time */

-extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime,

-   struct tm FAR * ttime));

+    /* Convert from a struct tm to png_time */

+    extern PNG_EXPORT(void, png_convert_from_struct_tm) PNGARG((png_timep ptime,

+            struct tm FAR * ttime));

 

-/* Convert from time_t to png_time.  Uses gmtime() */

-extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime,

-   time_t ttime));

+    /* Convert from time_t to png_time.  Uses gmtime() */

+    extern PNG_EXPORT(void, png_convert_from_time_t) PNGARG((png_timep ptime,

+            time_t ttime));

 #endif /* PNG_CONVERT_tIME_SUPPORTED */

 

 #ifdef PNG_READ_EXPAND_SUPPORTED

-/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */

-extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr));

-extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp

-  png_ptr));

-extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr));

-extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr));

+    /* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */

+    extern PNG_EXPORT(void, png_set_expand) PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(void, png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp

+            png_ptr));

+    extern PNG_EXPORT(void, png_set_palette_to_rgb) PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(void, png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr));

 #endif

 

 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)

-/* Use blue, green, red order for pixels. */

-extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr));

+    /* Use blue, green, red order for pixels. */

+    extern PNG_EXPORT(void, png_set_bgr) PNGARG((png_structp png_ptr));

 #endif

 

 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-/* Expand the grayscale to 24-bit RGB if necessary. */

-extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr));

+    /* Expand the grayscale to 24-bit RGB if necessary. */

+    extern PNG_EXPORT(void, png_set_gray_to_rgb) PNGARG((png_structp png_ptr));

 #endif

 

 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-/* Reduce RGB to grayscale. */

+    /* Reduce RGB to grayscale. */

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr,

-   int error_action, double red, double green ));

+    extern PNG_EXPORT(void, png_set_rgb_to_gray) PNGARG((png_structp png_ptr,

+            int error_action, double red, double green));

 #endif

-extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr,

-   int error_action, png_fixed_point red, png_fixed_point green ));

-extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp

-   png_ptr));

+    extern PNG_EXPORT(void, png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr,

+            int error_action, png_fixed_point red, png_fixed_point green));

+    extern PNG_EXPORT(png_byte, png_get_rgb_to_gray_status) PNGARG((png_structp

+            png_ptr));

 #endif

 

-extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth,

-   png_colorp palette));

+    extern PNG_EXPORT(void, png_build_grayscale_palette) PNGARG((int bit_depth,

+            png_colorp palette));

 

 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED

-extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(void, png_set_strip_alpha) PNGARG((png_structp png_ptr));

 #endif

 

 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \

     defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

-extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(void, png_set_swap_alpha) PNGARG((png_structp png_ptr));

 #endif

 

 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \

     defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

-extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(void, png_set_invert_alpha) PNGARG((png_structp png_ptr));

 #endif

 

 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)

-/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */

-extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr,

-   png_uint_32 filler, int flags));

-/* The values of the PNG_FILLER_ defines should NOT be changed */

+    /* Add a filler byte to 8-bit Gray or 24-bit RGB images. */

+    extern PNG_EXPORT(void, png_set_filler) PNGARG((png_structp png_ptr,

+            png_uint_32 filler, int flags));

+    /* The values of the PNG_FILLER_ defines should NOT be changed */

 #define PNG_FILLER_BEFORE 0

 #define PNG_FILLER_AFTER 1

-/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */

-extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr,

-   png_uint_32 filler, int flags));

+    /* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */

+    extern PNG_EXPORT(void, png_set_add_alpha) PNGARG((png_structp png_ptr,

+            png_uint_32 filler, int flags));

 #endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */

 

 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

-/* Swap bytes in 16-bit depth files. */

-extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr));

+    /* Swap bytes in 16-bit depth files. */

+    extern PNG_EXPORT(void, png_set_swap) PNGARG((png_structp png_ptr));

 #endif

 

 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)

-/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */

-extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr));

+    /* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */

+    extern PNG_EXPORT(void, png_set_packing) PNGARG((png_structp png_ptr));

 #endif

 

 #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \

     defined(PNG_WRITE_PACKSWAP_SUPPORTED)

-/* Swap packing order of pixels in bytes. */

-extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr));

+    /* Swap packing order of pixels in bytes. */

+    extern PNG_EXPORT(void, png_set_packswap) PNGARG((png_structp png_ptr));

 #endif

 

 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)

-/* Converts files to legal bit depths. */

-extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr,

-   png_color_8p true_bits));

+    /* Converts files to legal bit depths. */

+    extern PNG_EXPORT(void, png_set_shift) PNGARG((png_structp png_ptr,

+            png_color_8p true_bits));

 #endif

 

 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \

     defined(PNG_WRITE_INTERLACING_SUPPORTED)

-/* Have the code handle the interlacing.  Returns the number of passes. */

-extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr));

+    /* Have the code handle the interlacing.  Returns the number of passes. */

+    extern PNG_EXPORT(int, png_set_interlace_handling) PNGARG((png_structp png_ptr));

 #endif

 

 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)

-/* Invert monochrome files */

-extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr));

+    /* Invert monochrome files */

+    extern PNG_EXPORT(void, png_set_invert_mono) PNGARG((png_structp png_ptr));

 #endif

 

 #ifdef PNG_READ_BACKGROUND_SUPPORTED

-/* Handle alpha and tRNS by replacing with a background color. */

+    /* Handle alpha and tRNS by replacing with a background color. */

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr,

-   png_color_16p background_color, int background_gamma_code,

-   int need_expand, double background_gamma));

+    extern PNG_EXPORT(void, png_set_background) PNGARG((png_structp png_ptr,

+            png_color_16p background_color, int background_gamma_code,

+            int need_expand, double background_gamma));

 #endif

 #define PNG_BACKGROUND_GAMMA_UNKNOWN 0

 #define PNG_BACKGROUND_GAMMA_SCREEN  1

@@ -1706,108 +1706,108 @@ extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr,
 #endif

 

 #ifdef PNG_READ_16_TO_8_SUPPORTED

-/* Strip the second byte of information from a 16-bit depth file. */

-extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr));

+    /* Strip the second byte of information from a 16-bit depth file. */

+    extern PNG_EXPORT(void, png_set_strip_16) PNGARG((png_structp png_ptr));

 #endif

 

 #ifdef PNG_READ_DITHER_SUPPORTED

-/* Turn on dithering, and reduce the palette to the number of colors

- * available.

- */

-extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr,

-   png_colorp palette, int num_palette, int maximum_colors,

-   png_uint_16p histogram, int full_dither));

+    /* Turn on dithering, and reduce the palette to the number of colors

+     * available.

+     */

+    extern PNG_EXPORT(void, png_set_dither) PNGARG((png_structp png_ptr,

+            png_colorp palette, int num_palette, int maximum_colors,

+            png_uint_16p histogram, int full_dither));

 #endif

 

 #ifdef PNG_READ_GAMMA_SUPPORTED

-/* Handle gamma correction. Screen_gamma=(display_exponent) */

+    /* Handle gamma correction. Screen_gamma=(display_exponent) */

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr,

-   double screen_gamma, double default_file_gamma));

+    extern PNG_EXPORT(void, png_set_gamma) PNGARG((png_structp png_ptr,

+            double screen_gamma, double default_file_gamma));

 #endif

 #endif

 

 

 #ifdef PNG_WRITE_FLUSH_SUPPORTED

-/* Set how many lines between output flushes - 0 for no flushing */

-extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows));

-/* Flush the current PNG output buffer */

-extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr));

+    /* Set how many lines between output flushes - 0 for no flushing */

+    extern PNG_EXPORT(void, png_set_flush) PNGARG((png_structp png_ptr, int nrows));

+    /* Flush the current PNG output buffer */

+    extern PNG_EXPORT(void, png_write_flush) PNGARG((png_structp png_ptr));

 #endif

 

-/* Optional update palette with requested transformations */

-extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr));

+    /* Optional update palette with requested transformations */

+    extern PNG_EXPORT(void, png_start_read_image) PNGARG((png_structp png_ptr));

 

-/* Optional call to update the users info structure */

-extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

+    /* Optional call to update the users info structure */

+    extern PNG_EXPORT(void, png_read_update_info) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Read one or more rows of image data. */

-extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr,

-   png_bytepp row, png_bytepp display_row, png_uint_32 num_rows));

+    /* Read one or more rows of image data. */

+    extern PNG_EXPORT(void, png_read_rows) PNGARG((png_structp png_ptr,

+            png_bytepp row, png_bytepp display_row, png_uint_32 num_rows));

 #endif

 

 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Read a row of data. */

-extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr,

-   png_bytep row,

-   png_bytep display_row));

+    /* Read a row of data. */

+    extern PNG_EXPORT(void, png_read_row) PNGARG((png_structp png_ptr,

+            png_bytep row,

+            png_bytep display_row));

 #endif

 

 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Read the whole image into memory at once. */

-extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr,

-   png_bytepp image));

+    /* Read the whole image into memory at once. */

+    extern PNG_EXPORT(void, png_read_image) PNGARG((png_structp png_ptr,

+            png_bytepp image));

 #endif

 

-/* Write a row of image data */

-extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr,

-   png_bytep row));

+    /* Write a row of image data */

+    extern PNG_EXPORT(void, png_write_row) PNGARG((png_structp png_ptr,

+            png_bytep row));

 

-/* Write a few rows of image data */

-extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr,

-   png_bytepp row, png_uint_32 num_rows));

+    /* Write a few rows of image data */

+    extern PNG_EXPORT(void, png_write_rows) PNGARG((png_structp png_ptr,

+            png_bytepp row, png_uint_32 num_rows));

 

-/* Write the image data */

-extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr,

-   png_bytepp image));

+    /* Write the image data */

+    extern PNG_EXPORT(void, png_write_image) PNGARG((png_structp png_ptr,

+            png_bytepp image));

 

-/* Write the end of the PNG file. */

-extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

+    /* Write the end of the PNG file. */

+    extern PNG_EXPORT(void, png_write_end) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED

-/* Read the end of the PNG file. */

-extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-#endif

-

-/* Free any memory associated with the png_info_struct */

-extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr,

-   png_infopp info_ptr_ptr));

-

-/* Free any memory associated with the png_struct and the png_info_structs */

-extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp

-   png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));

-

-/* Free any memory associated with the png_struct and the png_info_structs */

-extern PNG_EXPORT(void,png_destroy_write_struct)

-   PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr));

-

-/* Set the libpng method of handling chunk CRC errors */

-extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr,

-   int crit_action, int ancil_action));

-

-/* Values for png_set_crc_action() to say how to handle CRC errors in

- * ancillary and critical chunks, and whether to use the data contained

- * therein.  Note that it is impossible to "discard" data in a critical

- * chunk.  For versions prior to 0.90, the action was always error/quit,

- * whereas in version 0.90 and later, the action for CRC errors in ancillary

- * chunks is warn/discard.  These values should NOT be changed.

- *

- *      value                       action:critical     action:ancillary

- */

+    /* Read the end of the PNG file. */

+    extern PNG_EXPORT(void, png_read_end) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

+#endif

+

+    /* Free any memory associated with the png_info_struct */

+    extern PNG_EXPORT(void, png_destroy_info_struct) PNGARG((png_structp png_ptr,

+            png_infopp info_ptr_ptr));

+

+    /* Free any memory associated with the png_struct and the png_info_structs */

+    extern PNG_EXPORT(void, png_destroy_read_struct) PNGARG((png_structpp

+            png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));

+

+    /* Free any memory associated with the png_struct and the png_info_structs */

+    extern PNG_EXPORT(void, png_destroy_write_struct)

+    PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr));

+

+    /* Set the libpng method of handling chunk CRC errors */

+    extern PNG_EXPORT(void, png_set_crc_action) PNGARG((png_structp png_ptr,

+            int crit_action, int ancil_action));

+

+    /* Values for png_set_crc_action() to say how to handle CRC errors in

+     * ancillary and critical chunks, and whether to use the data contained

+     * therein.  Note that it is impossible to "discard" data in a critical

+     * chunk.  For versions prior to 0.90, the action was always error/quit,

+     * whereas in version 0.90 and later, the action for CRC errors in ancillary

+     * chunks is warn/discard.  These values should NOT be changed.

+     *

+     *      value                       action:critical     action:ancillary

+     */

 #define PNG_CRC_DEFAULT       0  /* error/quit          warn/discard data */

 #define PNG_CRC_ERROR_QUIT    1  /* error/quit          error/quit        */

 #define PNG_CRC_WARN_DISCARD  2  /* (INVALID)           warn/discard data */

@@ -1815,25 +1815,25 @@ extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr,
 #define PNG_CRC_QUIET_USE     4  /* quiet/use data      quiet/use data    */

 #define PNG_CRC_NO_CHANGE     5  /* use current value   use current value */

 

-/* These functions give the user control over the scan-line filtering in

- * libpng and the compression methods used by zlib.  These functions are

- * mainly useful for testing, as the defaults should work with most users.

- * Those users who are tight on memory or want faster performance at the

- * expense of compression can modify them.  See the compression library

- * header file (zlib.h) for an explination of the compression functions.

- */

-

-/* Set the filtering method(s) used by libpng.  Currently, the only valid

- * value for "method" is 0.

- */

-extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,

-   int filters));

-

-/* Flags for png_set_filter() to say which filters to use.  The flags

- * are chosen so that they don't conflict with real filter types

- * below, in case they are supplied instead of the #defined constants.

- * These values should NOT be changed.

- */

+    /* These functions give the user control over the scan-line filtering in

+     * libpng and the compression methods used by zlib.  These functions are

+     * mainly useful for testing, as the defaults should work with most users.

+     * Those users who are tight on memory or want faster performance at the

+     * expense of compression can modify them.  See the compression library

+     * header file (zlib.h) for an explination of the compression functions.

+     */

+

+    /* Set the filtering method(s) used by libpng.  Currently, the only valid

+     * value for "method" is 0.

+     */

+    extern PNG_EXPORT(void, png_set_filter) PNGARG((png_structp png_ptr, int method,

+            int filters));

+

+    /* Flags for png_set_filter() to say which filters to use.  The flags

+     * are chosen so that they don't conflict with real filter types

+     * below, in case they are supplied instead of the #defined constants.

+     * These values should NOT be changed.

+     */

 #define PNG_NO_FILTERS     0x00

 #define PNG_FILTER_NONE    0x08

 #define PNG_FILTER_SUB     0x10

@@ -1843,9 +1843,9 @@ extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,
 #define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \

                          PNG_FILTER_AVG | PNG_FILTER_PAETH)

 

-/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.

- * These defines should NOT be changed.

- */

+    /* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.

+     * These defines should NOT be changed.

+     */

 #define PNG_FILTER_VALUE_NONE  0

 #define PNG_FILTER_VALUE_SUB   1

 #define PNG_FILTER_VALUE_UP    2

@@ -1854,210 +1854,210 @@ extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,
 #define PNG_FILTER_VALUE_LAST  5

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* EXPERIMENTAL */

-/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_

- * defines, either the default (minimum-sum-of-absolute-differences), or

- * the experimental method (weighted-minimum-sum-of-absolute-differences).

- *

- * Weights are factors >= 1.0, indicating how important it is to keep the

- * filter type consistent between rows.  Larger numbers mean the current

- * filter is that many times as likely to be the same as the "num_weights"

- * previous filters.  This is cumulative for each previous row with a weight.

- * There needs to be "num_weights" values in "filter_weights", or it can be

- * NULL if the weights aren't being specified.  Weights have no influence on

- * the selection of the first row filter.  Well chosen weights can (in theory)

- * improve the compression for a given image.

- *

- * Costs are factors >= 1.0 indicating the relative decoding costs of a

- * filter type.  Higher costs indicate more decoding expense, and are

- * therefore less likely to be selected over a filter with lower computational

- * costs.  There needs to be a value in "filter_costs" for each valid filter

- * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't

- * setting the costs.  Costs try to improve the speed of decompression without

- * unduly increasing the compressed image size.

- *

- * A negative weight or cost indicates the default value is to be used, and

- * values in the range [0.0, 1.0) indicate the value is to remain unchanged.

- * The default values for both weights and costs are currently 1.0, but may

- * change if good general weighting/cost heuristics can be found.  If both

- * the weights and costs are set to 1.0, this degenerates the WEIGHTED method

- * to the UNWEIGHTED method, but with added encoding time/computation.

- */

+    /* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_

+     * defines, either the default (minimum-sum-of-absolute-differences), or

+     * the experimental method (weighted-minimum-sum-of-absolute-differences).

+     *

+     * Weights are factors >= 1.0, indicating how important it is to keep the

+     * filter type consistent between rows.  Larger numbers mean the current

+     * filter is that many times as likely to be the same as the "num_weights"

+     * previous filters.  This is cumulative for each previous row with a weight.

+     * There needs to be "num_weights" values in "filter_weights", or it can be

+     * NULL if the weights aren't being specified.  Weights have no influence on

+     * the selection of the first row filter.  Well chosen weights can (in theory)

+     * improve the compression for a given image.

+     *

+     * Costs are factors >= 1.0 indicating the relative decoding costs of a

+     * filter type.  Higher costs indicate more decoding expense, and are

+     * therefore less likely to be selected over a filter with lower computational

+     * costs.  There needs to be a value in "filter_costs" for each valid filter

+     * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't

+     * setting the costs.  Costs try to improve the speed of decompression without

+     * unduly increasing the compressed image size.

+     *

+     * A negative weight or cost indicates the default value is to be used, and

+     * values in the range [0.0, 1.0) indicate the value is to remain unchanged.

+     * The default values for both weights and costs are currently 1.0, but may

+     * change if good general weighting/cost heuristics can be found.  If both

+     * the weights and costs are set to 1.0, this degenerates the WEIGHTED method

+     * to the UNWEIGHTED method, but with added encoding time/computation.

+     */

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr,

-   int heuristic_method, int num_weights, png_doublep filter_weights,

-   png_doublep filter_costs));

+    extern PNG_EXPORT(void, png_set_filter_heuristics) PNGARG((png_structp png_ptr,

+            int heuristic_method, int num_weights, png_doublep filter_weights,

+            png_doublep filter_costs));

 #endif

 #endif /*  PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */

 

-/* Heuristic used for row filter selection.  These defines should NOT be

- * changed.

- */

+    /* Heuristic used for row filter selection.  These defines should NOT be

+     * changed.

+     */

 #define PNG_FILTER_HEURISTIC_DEFAULT    0  /* Currently "UNWEIGHTED" */

 #define PNG_FILTER_HEURISTIC_UNWEIGHTED 1  /* Used by libpng < 0.95 */

 #define PNG_FILTER_HEURISTIC_WEIGHTED   2  /* Experimental feature */

 #define PNG_FILTER_HEURISTIC_LAST       3  /* Not a valid value */

 

-/* Set the library compression level.  Currently, valid values range from

- * 0 - 9, corresponding directly to the zlib compression levels 0 - 9

- * (0 - no compression, 9 - "maximal" compression).  Note that tests have

- * shown that zlib compression levels 3-6 usually perform as well as level 9

- * for PNG images, and do considerably fewer caclulations.  In the future,

- * these values may not correspond directly to the zlib compression levels.

- */

-extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr,

-   int level));

-

-extern PNG_EXPORT(void,png_set_compression_mem_level)

-   PNGARG((png_structp png_ptr, int mem_level));

-

-extern PNG_EXPORT(void,png_set_compression_strategy)

-   PNGARG((png_structp png_ptr, int strategy));

-

-extern PNG_EXPORT(void,png_set_compression_window_bits)

-   PNGARG((png_structp png_ptr, int window_bits));

-

-extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr,

-   int method));

-

-/* These next functions are called for input/output, memory, and error

- * handling.  They are in the file pngrio.c, pngwio.c, and pngerror.c,

- * and call standard C I/O routines such as fread(), fwrite(), and

- * fprintf().  These functions can be made to use other I/O routines

- * at run time for those applications that need to handle I/O in a

- * different manner by calling png_set_???_fn().  See libpng.txt for

- * more information.

- */

+    /* Set the library compression level.  Currently, valid values range from

+     * 0 - 9, corresponding directly to the zlib compression levels 0 - 9

+     * (0 - no compression, 9 - "maximal" compression).  Note that tests have

+     * shown that zlib compression levels 3-6 usually perform as well as level 9

+     * for PNG images, and do considerably fewer caclulations.  In the future,

+     * these values may not correspond directly to the zlib compression levels.

+     */

+    extern PNG_EXPORT(void, png_set_compression_level) PNGARG((png_structp png_ptr,

+            int level));

+

+    extern PNG_EXPORT(void, png_set_compression_mem_level)

+    PNGARG((png_structp png_ptr, int mem_level));

+

+    extern PNG_EXPORT(void, png_set_compression_strategy)

+    PNGARG((png_structp png_ptr, int strategy));

+

+    extern PNG_EXPORT(void, png_set_compression_window_bits)

+    PNGARG((png_structp png_ptr, int window_bits));

+

+    extern PNG_EXPORT(void, png_set_compression_method) PNGARG((png_structp png_ptr,

+            int method));

+

+    /* These next functions are called for input/output, memory, and error

+     * handling.  They are in the file pngrio.c, pngwio.c, and pngerror.c,

+     * and call standard C I/O routines such as fread(), fwrite(), and

+     * fprintf().  These functions can be made to use other I/O routines

+     * at run time for those applications that need to handle I/O in a

+     * different manner by calling png_set_???_fn().  See libpng.txt for

+     * more information.

+     */

 

 #ifdef PNG_STDIO_SUPPORTED

-/* Initialize the input/output for the PNG file to the default functions. */

-extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr,

-    png_FILE_p fp));

-#endif

-

-/* Replace the (error and abort), and warning functions with user

- * supplied functions.  If no messages are to be printed you must still

- * write and use replacement functions. The replacement error_fn should

- * still do a longjmp to the last setjmp location if you are using this

- * method of error handling.  If error_fn or warning_fn is NULL, the

- * default function will be used.

- */

-

-extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr,

-   png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));

-

-/* Return the user pointer associated with the error functions */

-extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr));

-

-/* Replace the default data output functions with a user supplied one(s).

- * If buffered output is not used, then output_flush_fn can be set to NULL.

- * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time

- * output_flush_fn will be ignored (and thus can be NULL).

- * It is probably a mistake to use NULL for output_flush_fn if

- * write_data_fn is not also NULL unless you have built libpng with

- * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's

- * default flush function, which uses the standard *FILE structure, will

- * be used.

- */

-extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr,

-   png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));

-

-/* Replace the default data input function with a user supplied one. */

-extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr,

-   png_voidp io_ptr, png_rw_ptr read_data_fn));

-

-/* Return the user pointer associated with the I/O functions */

-extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr));

-

-extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr,

-   png_read_status_ptr read_row_fn));

-

-extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr,

-   png_write_status_ptr write_row_fn));

+    /* Initialize the input/output for the PNG file to the default functions. */

+    extern PNG_EXPORT(void, png_init_io) PNGARG((png_structp png_ptr,

+            png_FILE_p fp));

+#endif

+

+    /* Replace the (error and abort), and warning functions with user

+     * supplied functions.  If no messages are to be printed you must still

+     * write and use replacement functions. The replacement error_fn should

+     * still do a longjmp to the last setjmp location if you are using this

+     * method of error handling.  If error_fn or warning_fn is NULL, the

+     * default function will be used.

+     */

+

+    extern PNG_EXPORT(void, png_set_error_fn) PNGARG((png_structp png_ptr,

+            png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));

+

+    /* Return the user pointer associated with the error functions */

+    extern PNG_EXPORT(png_voidp, png_get_error_ptr) PNGARG((png_structp png_ptr));

+

+    /* Replace the default data output functions with a user supplied one(s).

+     * If buffered output is not used, then output_flush_fn can be set to NULL.

+     * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time

+     * output_flush_fn will be ignored (and thus can be NULL).

+     * It is probably a mistake to use NULL for output_flush_fn if

+     * write_data_fn is not also NULL unless you have built libpng with

+     * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's

+     * default flush function, which uses the standard *FILE structure, will

+     * be used.

+     */

+    extern PNG_EXPORT(void, png_set_write_fn) PNGARG((png_structp png_ptr,

+            png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));

+

+    /* Replace the default data input function with a user supplied one. */

+    extern PNG_EXPORT(void, png_set_read_fn) PNGARG((png_structp png_ptr,

+            png_voidp io_ptr, png_rw_ptr read_data_fn));

+

+    /* Return the user pointer associated with the I/O functions */

+    extern PNG_EXPORT(png_voidp, png_get_io_ptr) PNGARG((png_structp png_ptr));

+

+    extern PNG_EXPORT(void, png_set_read_status_fn) PNGARG((png_structp png_ptr,

+            png_read_status_ptr read_row_fn));

+

+    extern PNG_EXPORT(void, png_set_write_status_fn) PNGARG((png_structp png_ptr,

+            png_write_status_ptr write_row_fn));

 

 #ifdef PNG_USER_MEM_SUPPORTED

-/* Replace the default memory allocation functions with user supplied one(s). */

-extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr,

-   png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn));

-/* Return the user pointer associated with the memory functions */

-extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr));

+    /* Replace the default memory allocation functions with user supplied one(s). */

+    extern PNG_EXPORT(void, png_set_mem_fn) PNGARG((png_structp png_ptr,

+            png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn));

+    /* Return the user pointer associated with the memory functions */

+    extern PNG_EXPORT(png_voidp, png_get_mem_ptr) PNGARG((png_structp png_ptr));

 #endif

 

 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp

-   png_ptr, png_user_transform_ptr read_user_transform_fn));

+    extern PNG_EXPORT(void, png_set_read_user_transform_fn) PNGARG((png_structp

+            png_ptr, png_user_transform_ptr read_user_transform_fn));

 #endif

 

 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp

-   png_ptr, png_user_transform_ptr write_user_transform_fn));

+    extern PNG_EXPORT(void, png_set_write_user_transform_fn) PNGARG((png_structp

+            png_ptr, png_user_transform_ptr write_user_transform_fn));

 #endif

 

 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

-extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp

-   png_ptr, png_voidp user_transform_ptr, int user_transform_depth,

-   int user_transform_channels));

-/* Return the user pointer associated with the user transform functions */

-extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr)

-   PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(void, png_set_user_transform_info) PNGARG((png_structp

+            png_ptr, png_voidp user_transform_ptr, int user_transform_depth,

+            int user_transform_channels));

+    /* Return the user pointer associated with the user transform functions */

+    extern PNG_EXPORT(png_voidp, png_get_user_transform_ptr)

+    PNGARG((png_structp png_ptr));

 #endif

 

 #ifdef PNG_USER_CHUNKS_SUPPORTED

-extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr,

-   png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));

-extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp

-   png_ptr));

+    extern PNG_EXPORT(void, png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr,

+            png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));

+    extern PNG_EXPORT(png_voidp, png_get_user_chunk_ptr) PNGARG((png_structp

+            png_ptr));

 #endif

 

 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-/* Sets the function callbacks for the push reader, and a pointer to a

- * user-defined structure available to the callback functions.

- */

-extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr,

-   png_voidp progressive_ptr,

-   png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,

-   png_progressive_end_ptr end_fn));

-

-/* Returns the user pointer associated with the push read functions */

-extern PNG_EXPORT(png_voidp,png_get_progressive_ptr)

-   PNGARG((png_structp png_ptr));

-

-/* Function to be called when data becomes available */

-extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_bytep buffer, png_size_t buffer_size));

-

-/* Function that combines rows.  Not very much different than the

- * png_combine_row() call.  Is this even used?????

- */

-extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr,

-   png_bytep old_row, png_bytep new_row));

+    /* Sets the function callbacks for the push reader, and a pointer to a

+     * user-defined structure available to the callback functions.

+     */

+    extern PNG_EXPORT(void, png_set_progressive_read_fn) PNGARG((png_structp png_ptr,

+            png_voidp progressive_ptr,

+            png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,

+            png_progressive_end_ptr end_fn));

+

+    /* Returns the user pointer associated with the push read functions */

+    extern PNG_EXPORT(png_voidp, png_get_progressive_ptr)

+    PNGARG((png_structp png_ptr));

+

+    /* Function to be called when data becomes available */

+    extern PNG_EXPORT(void, png_process_data) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_bytep buffer, png_size_t buffer_size));

+

+    /* Function that combines rows.  Not very much different than the

+     * png_combine_row() call.  Is this even used?????

+     */

+    extern PNG_EXPORT(void, png_progressive_combine_row) PNGARG((png_structp png_ptr,

+            png_bytep old_row, png_bytep new_row));

 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

 

-extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr,

-   png_alloc_size_t size)) PNG_ALLOCATED;

-/* Added at libpng version 1.4.0 */

-extern PNG_EXPORT(png_voidp,png_calloc) PNGARG((png_structp png_ptr,

-   png_alloc_size_t size)) PNG_ALLOCATED;

-

-/* Added at libpng version 1.2.4 */

-extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr,

-   png_alloc_size_t size)) PNG_ALLOCATED;

-

-/* Frees a pointer allocated by png_malloc() */

-extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));

-

-/* Free data that was allocated internally */

-extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 free_me, int num));

-/* Reassign responsibility for freeing existing data, whether allocated

- * by libpng or by the application */

-extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int freer, png_uint_32 mask));

-/* Assignments for png_data_freer */

+    extern PNG_EXPORT(png_voidp, png_malloc) PNGARG((png_structp png_ptr,

+            png_alloc_size_t size)) PNG_ALLOCATED;

+    /* Added at libpng version 1.4.0 */

+    extern PNG_EXPORT(png_voidp, png_calloc) PNGARG((png_structp png_ptr,

+            png_alloc_size_t size)) PNG_ALLOCATED;

+

+    /* Added at libpng version 1.2.4 */

+    extern PNG_EXPORT(png_voidp, png_malloc_warn) PNGARG((png_structp png_ptr,

+            png_alloc_size_t size)) PNG_ALLOCATED;

+

+    /* Frees a pointer allocated by png_malloc() */

+    extern PNG_EXPORT(void, png_free) PNGARG((png_structp png_ptr, png_voidp ptr));

+

+    /* Free data that was allocated internally */

+    extern PNG_EXPORT(void, png_free_data) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 free_me, int num));

+    /* Reassign responsibility for freeing existing data, whether allocated

+     * by libpng or by the application */

+    extern PNG_EXPORT(void, png_data_freer) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, int freer, png_uint_32 mask));

+    /* Assignments for png_data_freer */

 #define PNG_DESTROY_WILL_FREE_DATA 1

 #define PNG_SET_WILL_FREE_DATA 1

 #define PNG_USER_WILL_FREE_DATA 2

-/* Flags for png_ptr->free_me and info_ptr->free_me */

+    /* Flags for png_ptr->free_me and info_ptr->free_me */

 #define PNG_FREE_HIST 0x0008

 #define PNG_FREE_ICCP 0x0010

 #define PNG_FREE_SPLT 0x0020

@@ -2073,347 +2073,347 @@ extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr,
 #define PNG_FREE_MUL  0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */

 

 #ifdef PNG_USER_MEM_SUPPORTED

-extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr,

-   png_alloc_size_t size)) PNG_ALLOCATED;

-extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr,

-   png_voidp ptr));

+    extern PNG_EXPORT(png_voidp, png_malloc_default) PNGARG((png_structp png_ptr,

+            png_alloc_size_t size)) PNG_ALLOCATED;

+    extern PNG_EXPORT(void, png_free_default) PNGARG((png_structp png_ptr,

+            png_voidp ptr));

 #endif

 

 #ifndef PNG_NO_ERROR_TEXT

-/* Fatal error in PNG image of libpng - can't continue */

-extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr,

-   png_const_charp error_message)) PNG_NORETURN;

+    /* Fatal error in PNG image of libpng - can't continue */

+    extern PNG_EXPORT(void, png_error) PNGARG((png_structp png_ptr,

+            png_const_charp error_message)) PNG_NORETURN;

 

-/* The same, but the chunk name is prepended to the error string. */

-extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr,

-   png_const_charp error_message)) PNG_NORETURN;

+    /* The same, but the chunk name is prepended to the error string. */

+    extern PNG_EXPORT(void, png_chunk_error) PNGARG((png_structp png_ptr,

+            png_const_charp error_message)) PNG_NORETURN;

 

 #else

-/* Fatal error in PNG image of libpng - can't continue */

-extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr)) PNG_NORETURN;

+    /* Fatal error in PNG image of libpng - can't continue */

+    extern PNG_EXPORT(void, png_err) PNGARG((png_structp png_ptr)) PNG_NORETURN;

 #endif

 

-/* Non-fatal error in libpng.  Can continue, but may have a problem. */

-extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr,

-   png_const_charp warning_message));

+    /* Non-fatal error in libpng.  Can continue, but may have a problem. */

+    extern PNG_EXPORT(void, png_warning) PNGARG((png_structp png_ptr,

+            png_const_charp warning_message));

 

-/* Non-fatal error in libpng, chunk name is prepended to message. */

-extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr,

-   png_const_charp warning_message));

+    /* Non-fatal error in libpng, chunk name is prepended to message. */

+    extern PNG_EXPORT(void, png_chunk_warning) PNGARG((png_structp png_ptr,

+            png_const_charp warning_message));

 

 #ifdef PNG_BENIGN_ERRORS_SUPPORTED

-/* Benign error in libpng.  Can continue, but may have a problem.

- * User can choose whether to handle as a fatal error or as a warning. */

-extern PNG_EXPORT(void,png_benign_error) PNGARG((png_structp png_ptr,

-   png_const_charp warning_message));

-

-/* Same, chunk name is prepended to message. */

-extern PNG_EXPORT(void,png_chunk_benign_error) PNGARG((png_structp png_ptr,

-   png_const_charp warning_message));

-

-extern PNG_EXPORT(void,png_set_benign_errors) PNGARG((png_structp

-   png_ptr, int allowed));

-#endif

-

-/* The png_set_<chunk> functions are for storing values in the png_info_struct.

- * Similarly, the png_get_<chunk> calls are used to read values from the

- * png_info_struct, either storing the parameters in the passed variables, or

- * setting pointers into the png_info_struct where the data is stored.  The

- * png_get_<chunk> functions return a non-zero value if the data was available

- * in info_ptr, or return zero and do not change any of the parameters if the

- * data was not available.

- *

- * These functions should be used instead of directly accessing png_info

- * to avoid problems with future changes in the size and internal layout of

- * png_info_struct.

- */

-/* Returns "flag" if chunk data is valid in info_ptr. */

-extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr,

-png_infop info_ptr, png_uint_32 flag));

-

-/* Returns number of bytes needed to hold a transformed row. */

-extern PNG_EXPORT(png_size_t,png_get_rowbytes) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

+    /* Benign error in libpng.  Can continue, but may have a problem.

+     * User can choose whether to handle as a fatal error or as a warning. */

+    extern PNG_EXPORT(void, png_benign_error) PNGARG((png_structp png_ptr,

+            png_const_charp warning_message));

+

+    /* Same, chunk name is prepended to message. */

+    extern PNG_EXPORT(void, png_chunk_benign_error) PNGARG((png_structp png_ptr,

+            png_const_charp warning_message));

+

+    extern PNG_EXPORT(void, png_set_benign_errors) PNGARG((png_structp

+            png_ptr, int allowed));

+#endif

+

+    /* The png_set_<chunk> functions are for storing values in the png_info_struct.

+     * Similarly, the png_get_<chunk> calls are used to read values from the

+     * png_info_struct, either storing the parameters in the passed variables, or

+     * setting pointers into the png_info_struct where the data is stored.  The

+     * png_get_<chunk> functions return a non-zero value if the data was available

+     * in info_ptr, or return zero and do not change any of the parameters if the

+     * data was not available.

+     *

+     * These functions should be used instead of directly accessing png_info

+     * to avoid problems with future changes in the size and internal layout of

+     * png_info_struct.

+     */

+    /* Returns "flag" if chunk data is valid in info_ptr. */

+    extern PNG_EXPORT(png_uint_32, png_get_valid) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 flag));

+

+    /* Returns number of bytes needed to hold a transformed row. */

+    extern PNG_EXPORT(png_size_t, png_get_rowbytes) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

 #ifdef PNG_INFO_IMAGE_SUPPORTED

-/* Returns row_pointers, which is an array of pointers to scanlines that was

- * returned from png_read_png().

- */

-extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

-/* Set row_pointers, which is an array of pointers to scanlines for use

- * by png_write_png().

- */

-extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_bytepp row_pointers));

-#endif

-

-/* Returns number of color channels in image. */

-extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

+    /* Returns row_pointers, which is an array of pointers to scanlines that was

+     * returned from png_read_png().

+     */

+    extern PNG_EXPORT(png_bytepp, png_get_rows) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

+    /* Set row_pointers, which is an array of pointers to scanlines for use

+     * by png_write_png().

+     */

+    extern PNG_EXPORT(void, png_set_rows) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_bytepp row_pointers));

+#endif

+

+    /* Returns number of color channels in image. */

+    extern PNG_EXPORT(png_byte, png_get_channels) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

 #ifdef PNG_EASY_ACCESS_SUPPORTED

-/* Returns image width in pixels. */

-extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image height in pixels. */

-extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image bit_depth. */

-extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image color_type. */

-extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image filter_type. */

-extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image interlace_type. */

-extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image compression_type. */

-extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns image resolution in pixels per meter, from pHYs chunk data. */

-extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-

-/* Returns pixel aspect ratio, computed from pHYs chunk data.  */

+    /* Returns image width in pixels. */

+    extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+

+    /* Returns image height in pixels. */

+    extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+

+    /* Returns image bit_depth. */

+    extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+

+    /* Returns image color_type. */

+    extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+

+    /* Returns image filter_type. */

+    extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+

+    /* Returns image interlace_type. */

+    extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+

+    /* Returns image compression_type. */

+    extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+

+    /* Returns image resolution in pixels per meter, from pHYs chunk data. */

+    extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+    extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+    extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+

+    /* Returns pixel aspect ratio, computed from pHYs chunk data.  */

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

+    extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

 #endif

 

-/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */

-extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

-extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp

-png_ptr, png_infop info_ptr));

+    /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */

+    extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+    extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+    extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

+    extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp

+            png_ptr, png_infop info_ptr));

 

 #endif /* PNG_EASY_ACCESS_SUPPORTED */

 

-/* Returns pointer to signature string read from PNG header */

-extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

+    /* Returns pointer to signature string read from PNG header */

+    extern PNG_EXPORT(png_bytep, png_get_signature) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

 #ifdef PNG_bKGD_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_color_16p *background));

+    extern PNG_EXPORT(png_uint_32, png_get_bKGD) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_color_16p *background));

 #endif

 

 #ifdef PNG_bKGD_SUPPORTED

-extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_color_16p background));

+    extern PNG_EXPORT(void, png_set_bKGD) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_color_16p background));

 #endif

 

 #ifdef PNG_cHRM_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, double *white_x, double *white_y, double *red_x,

-   double *red_y, double *green_x, double *green_y, double *blue_x,

-   double *blue_y));

+    extern PNG_EXPORT(png_uint_32, png_get_cHRM) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, double *white_x, double *white_y, double *red_x,

+            double *red_y, double *green_x, double *green_y, double *blue_x,

+            double *blue_y));

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point

-   *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y,

-   png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point

-   *int_blue_x, png_fixed_point *int_blue_y));

+    extern PNG_EXPORT(png_uint_32, png_get_cHRM_fixed) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point

+            *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y,

+            png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point

+            *int_blue_x, png_fixed_point *int_blue_y));

 #endif

 #endif

 

 #ifdef PNG_cHRM_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, double white_x, double white_y, double red_x,

-   double red_y, double green_x, double green_y, double blue_x, double blue_y));

+    extern PNG_EXPORT(void, png_set_cHRM) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, double white_x, double white_y, double red_x,

+            double red_y, double green_x, double green_y, double blue_x, double blue_y));

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y,

-   png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

-   int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

-   png_fixed_point int_blue_y));

+    extern PNG_EXPORT(void, png_set_cHRM_fixed) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y,

+            png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

+            int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

+            png_fixed_point int_blue_y));

 #endif

 #endif

 

 #ifdef PNG_gAMA_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, double *file_gamma));

+    extern PNG_EXPORT(png_uint_32, png_get_gAMA) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, double *file_gamma));

 #endif

-extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_fixed_point *int_file_gamma));

+    extern PNG_EXPORT(png_uint_32, png_get_gAMA_fixed) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_fixed_point *int_file_gamma));

 #endif

 

 #ifdef PNG_gAMA_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, double file_gamma));

+    extern PNG_EXPORT(void, png_set_gAMA) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, double file_gamma));

 #endif

-extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_fixed_point int_file_gamma));

+    extern PNG_EXPORT(void, png_set_gAMA_fixed) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_fixed_point int_file_gamma));

 #endif

 

 #ifdef PNG_hIST_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_16p *hist));

+    extern PNG_EXPORT(png_uint_32, png_get_hIST) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_16p *hist));

 #endif

 

 #ifdef PNG_hIST_SUPPORTED

-extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_16p hist));

+    extern PNG_EXPORT(void, png_set_hIST) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_16p hist));

 #endif

 

-extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 *width, png_uint_32 *height,

-   int *bit_depth, int *color_type, int *interlace_method,

-   int *compression_method, int *filter_method));

+    extern PNG_EXPORT(png_uint_32, png_get_IHDR) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 *width, png_uint_32 *height,

+            int *bit_depth, int *color_type, int *interlace_method,

+            int *compression_method, int *filter_method));

 

-extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,

-   int color_type, int interlace_method, int compression_method,

-   int filter_method));

+    extern PNG_EXPORT(void, png_set_IHDR) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,

+            int color_type, int interlace_method, int compression_method,

+            int filter_method));

 

 #ifdef PNG_oFFs_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,

-   int *unit_type));

+    extern PNG_EXPORT(png_uint_32, png_get_oFFs) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,

+            int *unit_type));

 #endif

 

 #ifdef PNG_oFFs_SUPPORTED

-extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y,

-   int unit_type));

+    extern PNG_EXPORT(void, png_set_oFFs) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y,

+            int unit_type));

 #endif

 

 #ifdef PNG_pCAL_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1,

-   int *type, int *nparams, png_charp *units, png_charpp *params));

+    extern PNG_EXPORT(png_uint_32, png_get_pCAL) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1,

+            int *type, int *nparams, png_charp *units, png_charpp *params));

 #endif

 

 #ifdef PNG_pCAL_SUPPORTED

-extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1,

-   int type, int nparams, png_charp units, png_charpp params));

+    extern PNG_EXPORT(void, png_set_pCAL) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1,

+            int type, int nparams, png_charp units, png_charpp params));

 #endif

 

 #ifdef PNG_pHYs_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));

+    extern PNG_EXPORT(png_uint_32, png_get_pHYs) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));

 #endif

 

 #ifdef PNG_pHYs_SUPPORTED

-extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));

+    extern PNG_EXPORT(void, png_set_pHYs) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));

 #endif

 

-extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_colorp *palette, int *num_palette));

+    extern PNG_EXPORT(png_uint_32, png_get_PLTE) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_colorp *palette, int *num_palette));

 

-extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_colorp palette, int num_palette));

+    extern PNG_EXPORT(void, png_set_PLTE) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_colorp palette, int num_palette));

 

 #ifdef PNG_sBIT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_color_8p *sig_bit));

+    extern PNG_EXPORT(png_uint_32, png_get_sBIT) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_color_8p *sig_bit));

 #endif

 

 #ifdef PNG_sBIT_SUPPORTED

-extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_color_8p sig_bit));

+    extern PNG_EXPORT(void, png_set_sBIT) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_color_8p sig_bit));

 #endif

 

 #ifdef PNG_sRGB_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int *intent));

+    extern PNG_EXPORT(png_uint_32, png_get_sRGB) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, int *intent));

 #endif

 

 #ifdef PNG_sRGB_SUPPORTED

-extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int intent));

-extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int intent));

+    extern PNG_EXPORT(void, png_set_sRGB) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, int intent));

+    extern PNG_EXPORT(void, png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, int intent));

 #endif

 

 #ifdef PNG_iCCP_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_charpp name, int *compression_type,

-   png_charpp profile, png_uint_32 *proflen));

-   /* Note to maintainer: profile should be png_bytepp */

+    extern PNG_EXPORT(png_uint_32, png_get_iCCP) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_charpp name, int *compression_type,

+            png_charpp profile, png_uint_32 *proflen));

+    /* Note to maintainer: profile should be png_bytepp */

 #endif

 

 #ifdef PNG_iCCP_SUPPORTED

-extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_charp name, int compression_type,

-   png_charp profile, png_uint_32 proflen));

-   /* Note to maintainer: profile should be png_bytep */

+    extern PNG_EXPORT(void, png_set_iCCP) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_charp name, int compression_type,

+            png_charp profile, png_uint_32 proflen));

+    /* Note to maintainer: profile should be png_bytep */

 #endif

 

 #ifdef PNG_sPLT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_sPLT_tpp entries));

+    extern PNG_EXPORT(png_uint_32, png_get_sPLT) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_sPLT_tpp entries));

 #endif

 

 #ifdef PNG_sPLT_SUPPORTED

-extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_sPLT_tp entries, int nentries));

+    extern PNG_EXPORT(void, png_set_sPLT) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_sPLT_tp entries, int nentries));

 #endif

 

 #ifdef PNG_TEXT_SUPPORTED

-/* png_get_text also returns the number of text chunks in *num_text */

-extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_textp *text_ptr, int *num_text));

+    /* png_get_text also returns the number of text chunks in *num_text */

+    extern PNG_EXPORT(png_uint_32, png_get_text) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_textp *text_ptr, int *num_text));

 #endif

 

-/* Note while png_set_text() will accept a structure whose text,

- * language, and  translated keywords are NULL pointers, the structure

- * returned by png_get_text will always contain regular

- * zero-terminated C strings.  They might be empty strings but

- * they will never be NULL pointers.

- */

+    /* Note while png_set_text() will accept a structure whose text,

+     * language, and  translated keywords are NULL pointers, the structure

+     * returned by png_get_text will always contain regular

+     * zero-terminated C strings.  They might be empty strings but

+     * they will never be NULL pointers.

+     */

 

 #ifdef PNG_TEXT_SUPPORTED

-extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_textp text_ptr, int num_text));

+    extern PNG_EXPORT(void, png_set_text) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_textp text_ptr, int num_text));

 #endif

 

 #ifdef PNG_tIME_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_timep *mod_time));

+    extern PNG_EXPORT(png_uint_32, png_get_tIME) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_timep *mod_time));

 #endif

 

 #ifdef PNG_tIME_SUPPORTED

-extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_timep mod_time));

+    extern PNG_EXPORT(void, png_set_tIME) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_timep mod_time));

 #endif

 

 #ifdef PNG_tRNS_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_bytep *trans_alpha, int *num_trans,

-   png_color_16p *trans_color));

+    extern PNG_EXPORT(png_uint_32, png_get_tRNS) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_bytep *trans_alpha, int *num_trans,

+            png_color_16p *trans_color));

 #endif

 

 #ifdef PNG_tRNS_SUPPORTED

-extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_bytep trans_alpha, int num_trans,

-   png_color_16p trans_color));

+    extern PNG_EXPORT(void, png_set_tRNS) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_bytep trans_alpha, int num_trans,

+            png_color_16p trans_color));

 #endif

 

 #ifdef PNG_tRNS_SUPPORTED

@@ -2421,146 +2421,146 @@ extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
 

 #ifdef PNG_sCAL_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int *unit, double *width, double *height));

+    extern PNG_EXPORT(png_uint_32, png_get_sCAL) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, int *unit, double *width, double *height));

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight));

+    extern PNG_EXPORT(png_uint_32, png_get_sCAL_s) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight));

 #endif

 #endif

 #endif /* PNG_sCAL_SUPPORTED */

 

 #ifdef PNG_sCAL_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int unit, double width, double height));

+    extern PNG_EXPORT(void, png_set_sCAL) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, int unit, double width, double height));

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

-extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int unit, png_charp swidth, png_charp sheight));

+    extern PNG_EXPORT(void, png_set_sCAL_s) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, int unit, png_charp swidth, png_charp sheight));

 #endif

 #endif

 #endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */

 

 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-/* Provide a list of chunks and how they are to be handled, if the built-in

-   handling or default unknown chunk handling is not desired.  Any chunks not

-   listed will be handled in the default manner.  The IHDR and IEND chunks

-   must not be listed.

-      keep = 0: follow default behaviour

-           = 1: do not keep

-           = 2: keep only if safe-to-copy

-           = 3: keep even if unsafe-to-copy

-*/

-extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp

-   png_ptr, int keep, png_bytep chunk_list, int num_chunks));

-PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep

-   chunk_name));

+    /* Provide a list of chunks and how they are to be handled, if the built-in

+       handling or default unknown chunk handling is not desired.  Any chunks not

+       listed will be handled in the default manner.  The IHDR and IEND chunks

+       must not be listed.

+          keep = 0: follow default behaviour

+               = 1: do not keep

+               = 2: keep only if safe-to-copy

+               = 3: keep even if unsafe-to-copy

+    */

+    extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp

+            png_ptr, int keep, png_bytep chunk_list, int num_chunks));

+    PNG_EXPORT(int, png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep

+            chunk_name));

 #endif

 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns));

-extern PNG_EXPORT(void, png_set_unknown_chunk_location)

-   PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location));

-extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp

-   png_ptr, png_infop info_ptr, png_unknown_chunkpp entries));

+    extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns));

+    extern PNG_EXPORT(void, png_set_unknown_chunk_location)

+    PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location));

+    extern PNG_EXPORT(png_uint_32, png_get_unknown_chunks) PNGARG((png_structp

+            png_ptr, png_infop info_ptr, png_unknown_chunkpp entries));

 #endif

 

-/* Png_free_data() will turn off the "valid" flag for anything it frees.

- * If you need to turn it off for a chunk that your application has freed,

- * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK);

- */

-extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr,

-   png_infop info_ptr, int mask));

+    /* Png_free_data() will turn off the "valid" flag for anything it frees.

+     * If you need to turn it off for a chunk that your application has freed,

+     * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK);

+     */

+    extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, int mask));

 

 #ifdef PNG_INFO_IMAGE_SUPPORTED

-/* The "params" pointer is currently not used and is for future expansion. */

-extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr,

-                        png_infop info_ptr,

-                        int transforms,

-                        png_voidp params));

-extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,

-                        png_infop info_ptr,

-                        int transforms,

-                        png_voidp params));

-#endif

-

-extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr));

-extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr));

-extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp

-    png_ptr));

-extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr));

+    /* The "params" pointer is currently not used and is for future expansion. */

+    extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr,

+            png_infop info_ptr,

+            int transforms,

+            png_voidp params));

+    extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,

+            png_infop info_ptr,

+            int transforms,

+            png_voidp params));

+#endif

+

+    extern PNG_EXPORT(png_charp, png_get_copyright) PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(png_charp, png_get_header_ver) PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(png_charp, png_get_header_version) PNGARG((png_structp

+            png_ptr));

+    extern PNG_EXPORT(png_charp, png_get_libpng_ver) PNGARG((png_structp png_ptr));

 

 #ifdef PNG_MNG_FEATURES_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp

-   png_ptr, png_uint_32 mng_features_permitted));

+    extern PNG_EXPORT(png_uint_32, png_permit_mng_features) PNGARG((png_structp

+            png_ptr, png_uint_32 mng_features_permitted));

 #endif

 

-/* For use in png_set_keep_unknown, added to version 1.2.6 */

+    /* For use in png_set_keep_unknown, added to version 1.2.6 */

 #define PNG_HANDLE_CHUNK_AS_DEFAULT   0

 #define PNG_HANDLE_CHUNK_NEVER        1

 #define PNG_HANDLE_CHUNK_IF_SAFE      2

 #define PNG_HANDLE_CHUNK_ALWAYS       3

 

-/* Strip the prepended error numbers ("#nnn ") from error and warning

- * messages before passing them to the error or warning handler.

- */

+    /* Strip the prepended error numbers ("#nnn ") from error and warning

+     * messages before passing them to the error or warning handler.

+     */

 #ifdef PNG_ERROR_NUMBERS_SUPPORTED

-extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp

-   png_ptr, png_uint_32 strip_mode));

+    extern PNG_EXPORT(void, png_set_strip_error_numbers) PNGARG((png_structp

+            png_ptr, png_uint_32 strip_mode));

 #endif

 

-/* Added in libpng-1.2.6 */

+    /* Added in libpng-1.2.6 */

 #ifdef PNG_SET_USER_LIMITS_SUPPORTED

-extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp

-   png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max));

-extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp

-   png_ptr));

-extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp

-   png_ptr));

-/* Added in libpng-1.4.0 */

-extern PNG_EXPORT(void,png_set_chunk_cache_max) PNGARG((png_structp

-   png_ptr, png_uint_32 user_chunk_cache_max));

-extern PNG_EXPORT(png_uint_32,png_get_chunk_cache_max)

-   PNGARG((png_structp png_ptr));

-/* Added in libpng-1.4.1 */

-extern PNG_EXPORT(void,png_set_chunk_malloc_max) PNGARG((png_structp

-   png_ptr, png_alloc_size_t user_chunk_cache_max));

-extern PNG_EXPORT(png_alloc_size_t,png_get_chunk_malloc_max)

-   PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(void, png_set_user_limits) PNGARG((png_structp

+            png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max));

+    extern PNG_EXPORT(png_uint_32, png_get_user_width_max) PNGARG((png_structp

+            png_ptr));

+    extern PNG_EXPORT(png_uint_32, png_get_user_height_max) PNGARG((png_structp

+            png_ptr));

+    /* Added in libpng-1.4.0 */

+    extern PNG_EXPORT(void, png_set_chunk_cache_max) PNGARG((png_structp

+            png_ptr, png_uint_32 user_chunk_cache_max));

+    extern PNG_EXPORT(png_uint_32, png_get_chunk_cache_max)

+    PNGARG((png_structp png_ptr));

+    /* Added in libpng-1.4.1 */

+    extern PNG_EXPORT(void, png_set_chunk_malloc_max) PNGARG((png_structp

+            png_ptr, png_alloc_size_t user_chunk_cache_max));

+    extern PNG_EXPORT(png_alloc_size_t, png_get_chunk_malloc_max)

+    PNGARG((png_structp png_ptr));

 #endif

 

 #if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)

-PNG_EXPORT(png_uint_32,png_get_pixels_per_inch) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

+    PNG_EXPORT(png_uint_32, png_get_pixels_per_inch) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

-PNG_EXPORT(png_uint_32,png_get_x_pixels_per_inch) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

+    PNG_EXPORT(png_uint_32, png_get_x_pixels_per_inch) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

-PNG_EXPORT(png_uint_32,png_get_y_pixels_per_inch) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

+    PNG_EXPORT(png_uint_32, png_get_y_pixels_per_inch) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

-PNG_EXPORT(float,png_get_x_offset_inches) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

+    PNG_EXPORT(float, png_get_x_offset_inches) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

-PNG_EXPORT(float,png_get_y_offset_inches) PNGARG((png_structp png_ptr,

-png_infop info_ptr));

+    PNG_EXPORT(float, png_get_y_offset_inches) PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

 #ifdef PNG_pHYs_SUPPORTED

-PNG_EXPORT(png_uint_32,png_get_pHYs_dpi) PNGARG((png_structp png_ptr,

-png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));

+    PNG_EXPORT(png_uint_32, png_get_pHYs_dpi) PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));

 #endif /* PNG_pHYs_SUPPORTED */

 #endif  /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */

 

-/* Added in libpng-1.4.0 */

+    /* Added in libpng-1.4.0 */

 #ifdef PNG_IO_STATE_SUPPORTED

-extern PNG_EXPORT(png_uint_32,png_get_io_state) PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(png_uint_32, png_get_io_state) PNGARG((png_structp png_ptr));

 

-extern PNG_EXPORT(png_bytep,png_get_io_chunk_name)

-   PNGARG((png_structp png_ptr));

+    extern PNG_EXPORT(png_bytep, png_get_io_chunk_name)

+    PNGARG((png_structp png_ptr));

 

-/* The flags returned by png_get_io_state() are the following: */

+    /* The flags returned by png_get_io_state() are the following: */

 #define PNG_IO_NONE        0x0000   /* no I/O at this moment */

 #define PNG_IO_READING     0x0001   /* currently reading */

 #define PNG_IO_WRITING     0x0002   /* currently writing */

@@ -2572,24 +2572,24 @@ extern PNG_EXPORT(png_bytep,png_get_io_chunk_name)
 #define PNG_IO_MASK_LOC    0x00f0   /* current location: sig/hdr/data/crc */

 #endif /* ?PNG_IO_STATE_SUPPORTED */

 

-/* Maintainer: Put new public prototypes here ^, in libpng.3, and project

- * defs

- */

+    /* Maintainer: Put new public prototypes here ^, in libpng.3, and project

+     * defs

+     */

 

 #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED

-/* With these routines we avoid an integer divide, which will be slower on

- * most machines.  However, it does take more operations than the corresponding

- * divide method, so it may be slower on a few RISC systems.  There are two

- * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.

- *

- * Note that the rounding factors are NOT supposed to be the same!  128 and

- * 32768 are correct for the NODIV code; 127 and 32767 are correct for the

- * standard method.

- *

- * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]

- */

-

- /* fg and bg should be in `gamma 1.0' space; alpha is the opacity          */

+    /* With these routines we avoid an integer divide, which will be slower on

+     * most machines.  However, it does take more operations than the corresponding

+     * divide method, so it may be slower on a few RISC systems.  There are two

+     * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.

+     *

+     * Note that the rounding factors are NOT supposed to be the same!  128 and

+     * 32768 are correct for the NODIV code; 127 and 32767 are correct for the

+     * standard method.

+     *

+     * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]

+     */

+

+    /* fg and bg should be in `gamma 1.0' space; alpha is the opacity          */

 

 #  define png_composite(composite, fg, alpha, bg)         \

      { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \

@@ -2619,11 +2619,11 @@ extern PNG_EXPORT(png_bytep,png_get_io_chunk_name)
 #endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */

 

 #ifdef PNG_USE_READ_MACROS

-/* Inline macros to do direct reads of bytes from the input buffer.

- * The png_get_int_32() routine assumes we are using two's complement

- * format for negative values, which is almost certainly true.

- */

-/* We could make special-case BIG_ENDIAN macros that do direct reads here */

+    /* Inline macros to do direct reads of bytes from the input buffer.

+     * The png_get_int_32() routine assumes we are using two's complement

+     * format for negative values, which is almost certainly true.

+     */

+    /* We could make special-case BIG_ENDIAN macros that do direct reads here */

 #  define png_get_uint_32(buf) \

      (((png_uint_32)(*(buf)) << 24) + \

       ((png_uint_32)(*((buf) + 1)) << 16) + \

@@ -2640,35 +2640,35 @@ extern PNG_EXPORT(png_bytep,png_get_io_chunk_name)
       ((png_int_32)(*((buf) + 3))))

 #endif

 #else

-extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf));

-extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf));

+    extern PNG_EXPORT(png_uint_32, png_get_uint_32) PNGARG((png_bytep buf));

+    extern PNG_EXPORT(png_uint_16, png_get_uint_16) PNGARG((png_bytep buf));

 #ifdef PNG_GET_INT_32_SUPPORTED

-extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf));

+    extern PNG_EXPORT(png_int_32, png_get_int_32) PNGARG((png_bytep buf));

 #endif

 #endif

-extern PNG_EXPORT(png_uint_32,png_get_uint_31)

-  PNGARG((png_structp png_ptr, png_bytep buf));

-/* No png_get_int_16 -- may be added if there's a real need for it. */

+    extern PNG_EXPORT(png_uint_32, png_get_uint_31)

+    PNGARG((png_structp png_ptr, png_bytep buf));

+    /* No png_get_int_16 -- may be added if there's a real need for it. */

 

-/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */

-extern PNG_EXPORT(void,png_save_uint_32)

-   PNGARG((png_bytep buf, png_uint_32 i));

-extern PNG_EXPORT(void,png_save_int_32)

-   PNGARG((png_bytep buf, png_int_32 i));

+    /* Place a 32-bit number into a buffer in PNG byte order (big-endian). */

+    extern PNG_EXPORT(void, png_save_uint_32)

+    PNGARG((png_bytep buf, png_uint_32 i));

+    extern PNG_EXPORT(void, png_save_int_32)

+    PNGARG((png_bytep buf, png_int_32 i));

 

-/* Place a 16-bit number into a buffer in PNG byte order.

- * The parameter is declared unsigned int, not png_uint_16,

- * just to avoid potential problems on pre-ANSI C compilers.

- */

-extern PNG_EXPORT(void,png_save_uint_16)

-   PNGARG((png_bytep buf, unsigned int i));

-/* No png_save_int_16 -- may be added if there's a real need for it. */

+    /* Place a 16-bit number into a buffer in PNG byte order.

+     * The parameter is declared unsigned int, not png_uint_16,

+     * just to avoid potential problems on pre-ANSI C compilers.

+     */

+    extern PNG_EXPORT(void, png_save_uint_16)

+    PNGARG((png_bytep buf, unsigned int i));

+    /* No png_save_int_16 -- may be added if there's a real need for it. */

 

-/* ************************************************************************* */

+    /* ************************************************************************* */

 

-/* Various modes of operation.  Note that after an init, mode is set to

- * zero automatically when the structure is created.

- */

+    /* Various modes of operation.  Note that after an init, mode is set to

+     * zero automatically when the structure is created.

+     */

 #define PNG_HAVE_IHDR               0x01

 #define PNG_HAVE_PLTE               0x02

 #define PNG_HAVE_IDAT               0x04

diff --git a/src/libpng/pngconf.h b/src/libpng/pngconf.h
index 9ec58d7ea..c5a7446bf 100644
--- a/src/libpng/pngconf.h
+++ b/src/libpng/pngconf.h
@@ -360,16 +360,16 @@
 #        undef _BSD_SOURCE

 #      endif

 #      ifdef _SETJMP_H

-       /* If you encounter a compiler error here, see the explanation

-        * near the end of INSTALL.

-        */

-           __pngconf.h__ in libpng already includes setjmp.h;

-           __dont__ include it again.;

+/* If you encounter a compiler error here, see the explanation

+ * near the end of INSTALL.

+ */

+__pngconf.h__ in libpng already includes setjmp.h;

+__dont__ include it again.;

 #      endif

 #    endif /* __linux__ */

 #  endif /* PNG_SKIP_SETJMP_CHECK */

 

-   /* Include setjmp.h for error handling */

+/* Include setjmp.h for error handling */

 #  include <setjmp.h>

 

 #  ifdef __linux__

@@ -541,7 +541,7 @@
  !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED)  /* if you don't do progressive */

 #  define PNG_PROGRESSIVE_READ_SUPPORTED     /* reading.  This is not talking */

 #endif                               /* about interlacing capability!  You'll */

-            /* still have interlacing unless you change the following define: */

+/* still have interlacing unless you change the following define: */

 

 #define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */

 

@@ -610,9 +610,9 @@
 

 #if !defined(PNG_NO_WRITE_INTERLACING_SUPPORTED) && \

     !defined(PNG_WRITE_INTERLACING_SUPPORTED)

-    /* This is not required for PNG-compliant encoders, but can cause

-     * trouble if left undefined

-    */

+/* This is not required for PNG-compliant encoders, but can cause

+ * trouble if left undefined

+*/

 #  define PNG_WRITE_INTERLACING_SUPPORTED

 #endif

 

@@ -678,11 +678,11 @@
 #  ifndef PNG_SET_USER_LIMITS_SUPPORTED

 #    define PNG_SET_USER_LIMITS_SUPPORTED

 #  endif

-  /* Feature added at libpng-1.4.0, this flag added at 1.4.1 */

+/* Feature added at libpng-1.4.0, this flag added at 1.4.1 */

 #  ifndef PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED

 #    define PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED

 #  endif

-  /* Feature added at libpng-1.4.1, this flag added at 1.4.1 */

+/* Feature added at libpng-1.4.1, this flag added at 1.4.1 */

 #  ifndef PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED

 #    define PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED

 #  endif

@@ -1071,7 +1071,7 @@
 

 /* Need the time information for converting tIME chunks */

 #ifdef PNG_CONVERT_tIME_SUPPORTED

-     /* "time.h" functions are not supported on WindowsCE */

+/* "time.h" functions are not supported on WindowsCE */

 #    include <time.h>

 #endif

 

@@ -1095,9 +1095,9 @@ typedef short png_int_16;
 typedef unsigned char png_byte;

 

 #ifdef PNG_NO_SIZE_T

-   typedef unsigned int png_size_t;

+typedef unsigned int png_size_t;

 #else

-   typedef size_t png_size_t;

+typedef size_t png_size_t;

 #endif

 #define png_sizeof(x) sizeof(x)

 

@@ -1119,7 +1119,7 @@ typedef unsigned char png_byte;
 #  else

 #    define LDATA 0

 #  endif

-   /* GRR:  why is Cygwin in here?  Cygwin is not Borland C... */

+/* GRR:  why is Cygwin in here?  Cygwin is not Borland C... */

 #  if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__)

 #    define PNG_MAX_MALLOC_64K

 #    if (LDATA != 1)

@@ -1128,11 +1128,11 @@ typedef unsigned char png_byte;
 #      endif

 #      define USE_FAR_KEYWORD

 #    endif   /* LDATA != 1 */

-     /* Possibly useful for moving data out of default segment.

-      * Uncomment it if you want. Could also define FARDATA as

-      * const if your compiler supports it. (SJT)

+/* Possibly useful for moving data out of default segment.

+ * Uncomment it if you want. Could also define FARDATA as

+ * const if your compiler supports it. (SJT)

 #    define FARDATA FAR

-      */

+ */

 #  endif  /* __WIN32__, __FLAT__, __CYGWIN__ */

 #endif   /* __BORLANDC__ */

 

@@ -1269,7 +1269,7 @@ typedef char            FAR * FAR * FAR * png_charppp;
 #    define PNG_EXPORT_TYPE1(type,symbol)  PNG_IMPEXP type PNGAPI symbol

 #    define PNG_EXPORT_TYPE2(type,symbol)  type PNG_IMPEXP PNGAPI symbol

 

-     /* Borland/Microsoft */

+/* Borland/Microsoft */

 #    if defined(_MSC_VER) || defined(__BORLANDC__)

 #      if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500)

 #         define PNG_EXPORT PNG_EXPORT_TYPE1

@@ -1280,7 +1280,7 @@ typedef char            FAR * FAR * FAR * png_charppp;
 #         else

 #            define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in VC++ */

 #         endif                              /* Exists in Borland C++ for

-                                                C++ classes (== huge) */

+C++ classes (== huge) */

 #      endif

 #    endif

 

@@ -1350,10 +1350,10 @@ typedef char            FAR * FAR * FAR * png_charppp;
 #      define PNG_ALLOCATED  __attribute__((__malloc__))

 #    endif

 

-    /* This specifically protects structure members that should only be

-     * accessed from within the library, therefore should be empty during

-     * a library build.

-     */

+/* This specifically protects structure members that should only be

+ * accessed from within the library, therefore should be empty during

+ * a library build.

+ */

 #    ifndef PNG_DEPRECATED

 #      define PNG_DEPRECATED __attribute__((__deprecated__))

 #    endif

@@ -1449,12 +1449,12 @@ typedef char            FAR * FAR * FAR * png_charppp;
 #        define png_snprintf6 snprintf

 #      endif

 #    else

-       /* You don't have or don't want to use snprintf().  Caution: Using

-        * sprintf instead of snprintf exposes your application to accidental

-        * or malevolent buffer overflows.  If you don't have snprintf()

-        * as a general rule you should provide one (you can get one from

-        * Portable OpenSSH).

-        */

+/* You don't have or don't want to use snprintf().  Caution: Using

+ * sprintf instead of snprintf exposes your application to accidental

+ * or malevolent buffer overflows.  If you don't have snprintf()

+ * as a general rule you should provide one (you can get one from

+ * Portable OpenSSH).

+ */

 #      define png_snprintf(s1,n,fmt,x1) sprintf(s1,fmt,x1)

 #      define png_snprintf2(s1,n,fmt,x1,x2) sprintf(s1,fmt,x1,x2)

 #      define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \

@@ -1475,21 +1475,21 @@ typedef char            FAR * FAR * FAR * png_charppp;
 #if defined(__TURBOC__) && !defined(__FLAT__)

 #  define  png_mem_alloc farmalloc

 #  define  png_mem_free  farfree

-   typedef unsigned long png_alloc_size_t;

+typedef unsigned long png_alloc_size_t;

 #else

 #  if defined(_MSC_VER) && defined(MAXSEG_64K)

 #    define  png_mem_alloc(s) halloc(s, 1)

 #    define  png_mem_free     hfree

-     typedef unsigned long    png_alloc_size_t;

+typedef unsigned long    png_alloc_size_t;

 #  else

 #    if defined(_WINDOWS_) && (!defined(INT_MAX) || INT_MAX <= 0x7ffffffeL)

 #      define  png_mem_alloc(s) HeapAlloc(GetProcessHeap(), 0, s)

 #      define  png_mem_free(p)  HeapFree(GetProcessHeap(), 0, p)

-       typedef DWORD            png_alloc_size_t;

+typedef DWORD            png_alloc_size_t;

 #    else

 #      define  png_mem_alloc malloc

 #      define  png_mem_free  free

-       typedef png_size_t    png_alloc_size_t;

+typedef png_size_t    png_alloc_size_t;

 #    endif

 #  endif

 #endif

diff --git a/src/libpng/pngerror.c b/src/libpng/pngerror.c
index bb02b2763..5b386d548 100644
--- a/src/libpng/pngerror.c
+++ b/src/libpng/pngerror.c
@@ -23,11 +23,11 @@
 

 static void /* PRIVATE */

 png_default_error PNGARG((png_structp png_ptr,

-  png_const_charp error_message)) PNG_NORETURN;

+                          png_const_charp error_message)) PNG_NORETURN;

 #ifdef PNG_WARNINGS_SUPPORTED

 static void /* PRIVATE */

 png_default_warning PNGARG((png_structp png_ptr,

-  png_const_charp warning_message));

+                            png_const_charp warning_message));

 #endif /* PNG_WARNINGS_SUPPORTED */

 

 /* This function is called whenever there is a fatal error.  This function

@@ -40,59 +40,59 @@ void PNGAPI
 png_error(png_structp png_ptr, png_const_charp error_message)

 {

 #ifdef PNG_ERROR_NUMBERS_SUPPORTED

-   char msg[16];

-   if (png_ptr != NULL)

-   {

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

-           }

-       }

-     }

-   }

+    char msg[16];

+    if(png_ptr != NULL)

+    {

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

+                }

+            }

+        }

+    }

 #endif

-   if (png_ptr != NULL && png_ptr->error_fn != NULL)

-      (*(png_ptr->error_fn))(png_ptr, error_message);

+    if(png_ptr != NULL && png_ptr->error_fn != NULL)

+        (*(png_ptr->error_fn))(png_ptr, error_message);

 

-   /* If the custom handler doesn't exist, or if it returns,

-      use the default handler, which will not return. */

-   png_default_error(png_ptr, error_message);

+    /* If the custom handler doesn't exist, or if it returns,

+       use the default handler, which will not return. */

+    png_default_error(png_ptr, error_message);

 }

 #else

 void PNGAPI

 png_err(png_structp png_ptr)

 {

-   if (png_ptr != NULL && png_ptr->error_fn != NULL)

-      (*(png_ptr->error_fn))(png_ptr, '\0');

+    if(png_ptr != NULL && png_ptr->error_fn != NULL)

+        (*(png_ptr->error_fn))(png_ptr, '\0');

 

-   /* If the custom handler doesn't exist, or if it returns,

-      use the default handler, which will not return. */

-   png_default_error(png_ptr, '\0');

+    /* If the custom handler doesn't exist, or if it returns,

+       use the default handler, which will not return. */

+    png_default_error(png_ptr, '\0');

 }

 #endif /* PNG_ERROR_TEXT_SUPPORTED */

 

@@ -105,26 +105,26 @@ png_err(png_structp png_ptr)
 void PNGAPI

 png_warning(png_structp png_ptr, png_const_charp warning_message)

 {

-   int offset = 0;

-   if (png_ptr != NULL)

-   {

+    int offset = 0;

+    if(png_ptr != NULL)

+    {

 #ifdef PNG_ERROR_NUMBERS_SUPPORTED

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

 #endif

-     {

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

-   else

-      png_default_warning(png_ptr, warning_message + offset);

+        {

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

+    else

+        png_default_warning(png_ptr, warning_message + offset);

 }

 #endif /* PNG_WARNINGS_SUPPORTED */

 

@@ -132,10 +132,10 @@ png_warning(png_structp png_ptr, png_const_charp warning_message)
 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

 

@@ -146,58 +146,59 @@ png_benign_error(png_structp png_ptr, png_const_charp error_message)
  * if the character is invalid.

  */

 #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))

-static PNG_CONST char png_digit[16] = {

-   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',

-   'A', 'B', 'C', 'D', 'E', 'F'

+static PNG_CONST char png_digit[16] =

+{

+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',

+    'A', 'B', 'C', 'D', 'E', 'F'

 };

 

 #define PNG_MAX_ERROR_TEXT 64

 #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)

 static void /* PRIVATE */

 png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp

-   error_message)

+                  error_message)

 {

-   int iout = 0, iin = 0;

+    int iout = 0, iin = 0;

 

-   while (iin < 4)

-   {

-      int c = png_ptr->chunk_name[iin++];

-      if (isnonalpha(c))

-      {

-         buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;

-         buffer[iout++] = png_digit[(c & 0xf0) >> 4];

-         buffer[iout++] = png_digit[c & 0x0f];

-         buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;

-      }

-      else

-      {

-         buffer[iout++] = (png_byte)c;

-      }

-   }

+    while(iin < 4)

+    {

+        int c = png_ptr->chunk_name[iin++];

+        if(isnonalpha(c))

+        {

+            buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;

+            buffer[iout++] = png_digit[(c & 0xf0) >> 4];

+            buffer[iout++] = png_digit[c & 0x0f];

+            buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;

+        }

+        else

+        {

+            buffer[iout++] = (png_byte)c;

+        }

+    }

 

-   if (error_message == NULL)

-      buffer[iout] = '\0';

-   else

-   {

-      buffer[iout++] = ':';

-      buffer[iout++] = ' ';

-      png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT);

-      buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';

-   }

+    if(error_message == NULL)

+        buffer[iout] = '\0';

+    else

+    {

+        buffer[iout++] = ':';

+        buffer[iout++] = ' ';

+        png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT);

+        buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';

+    }

 }

 

 #ifdef PNG_READ_SUPPORTED

 void PNGAPI

 png_chunk_error(png_structp png_ptr, png_const_charp error_message)

 {

-   char msg[18+PNG_MAX_ERROR_TEXT];

-   if (png_ptr == NULL)

-     png_error(png_ptr, error_message);

-   else

-   {

-     png_format_buffer(png_ptr, msg, error_message);

-     png_error(png_ptr, msg);

-   }

+    char msg[18+PNG_MAX_ERROR_TEXT];

+    if(png_ptr == NULL)

+        png_error(png_ptr, error_message);

+    else

+    {

+        png_format_buffer(png_ptr, msg, error_message);

+        png_error(png_ptr, msg);

+    }

 }

 #endif /* PNG_READ_SUPPORTED */

 #endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */

@@ -206,14 +207,14 @@ png_chunk_error(png_structp png_ptr, png_const_charp error_message)
 void PNGAPI

 png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)

 {

-   char msg[18+PNG_MAX_ERROR_TEXT];

-   if (png_ptr == NULL)

-     png_warning(png_ptr, warning_message);

-   else

-   {

-     png_format_buffer(png_ptr, msg, warning_message);

-     png_warning(png_ptr, msg);

-   }

+    char msg[18+PNG_MAX_ERROR_TEXT];

+    if(png_ptr == NULL)

+        png_warning(png_ptr, warning_message);

+    else

+    {

+        png_format_buffer(png_ptr, msg, warning_message);

+        png_warning(png_ptr, msg);

+    }

 }

 #endif /* PNG_WARNINGS_SUPPORTED */

 

@@ -222,10 +223,10 @@ png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
 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 */

@@ -236,13 +237,13 @@ png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
  */

 jmp_buf* PNGAPI

 png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn,

-    size_t jmp_buf_size)

+                   size_t jmp_buf_size)

 {

-   if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf))

-      return NULL;

+    if(png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf))

+        return NULL;

 

-   png_ptr->longjmp_fn = longjmp_fn;

-   return &png_ptr->jmpbuf;

+    png_ptr->longjmp_fn = longjmp_fn;

+    return &png_ptr->jmpbuf;

 }

 #endif

 

@@ -256,57 +257,57 @@ png_default_error(png_structp png_ptr, png_const_charp error_message)
 {

 #ifdef PNG_CONSOLE_IO_SUPPORTED

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

-     {

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

-     }

-   }

-   else

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

+        {

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

+        }

+    }

+    else

 #endif

-   {

-      fprintf(stderr, "libpng error: %s", error_message);

-      fprintf(stderr, PNG_STRING_NEWLINE);

-   }

+    {

+        fprintf(stderr, "libpng error: %s", error_message);

+        fprintf(stderr, PNG_STRING_NEWLINE);

+    }

 #endif

 

 #ifdef PNG_SETJMP_SUPPORTED

-   if (png_ptr && png_ptr->longjmp_fn)

-   {

+    if(png_ptr && png_ptr->longjmp_fn)

+    {

 #  ifdef USE_FAR_KEYWORD

-   {

-      jmp_buf jmpbuf;

-      png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));

-     png_ptr->longjmp_fn(jmpbuf, 1);

-   }

+        {

+            jmp_buf jmpbuf;

+            png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));

+            png_ptr->longjmp_fn(jmpbuf, 1);

+        }

 #  else

-   png_ptr->longjmp_fn(png_ptr->jmpbuf, 1);

+        png_ptr->longjmp_fn(png_ptr->jmpbuf, 1);

 #  endif

-   }

+    }

 #endif

-   /* Here if not setjmp support or if png_ptr is null. */

-   PNG_ABORT();

+    /* Here if not setjmp support or if png_ptr is null. */

+    PNG_ABORT();

 #ifndef PNG_CONSOLE_IO_SUPPORTED

-   error_message = error_message; /* Make compiler happy */

+    error_message = error_message; /* Make compiler happy */

 #endif

 }

 

@@ -321,40 +322,40 @@ png_default_warning(png_structp png_ptr, png_const_charp warning_message)
 {

 #ifdef PNG_CONSOLE_IO_SUPPORTED

 #  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] == ' ')

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

-     }

-   }

-   else

+    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] == ' ')

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

+        }

+    }

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

+    warning_message = warning_message; /* Make compiler happy */

 #endif

-   png_ptr = png_ptr; /* Make compiler happy */

+    png_ptr = png_ptr; /* Make compiler happy */

 }

 #endif /* PNG_WARNINGS_SUPPORTED */

 

@@ -365,13 +366,13 @@ png_default_warning(png_structp png_ptr, png_const_charp warning_message)
  */

 void PNGAPI

 png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warning_fn)

+                 png_error_ptr error_fn, png_error_ptr warning_fn)

 {

-   if (png_ptr == NULL)

-      return;

-   png_ptr->error_ptr = error_ptr;

-   png_ptr->error_fn = error_fn;

-   png_ptr->warning_fn = warning_fn;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->error_ptr = error_ptr;

+    png_ptr->error_fn = error_fn;

+    png_ptr->warning_fn = warning_fn;

 }

 

 

@@ -382,9 +383,9 @@ png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
 png_voidp PNGAPI

 png_get_error_ptr(png_structp png_ptr)

 {

-   if (png_ptr == NULL)

-      return NULL;

-   return ((png_voidp)png_ptr->error_ptr);

+    if(png_ptr == NULL)

+        return NULL;

+    return ((png_voidp)png_ptr->error_ptr);

 }

 

 

@@ -392,11 +393,11 @@ png_get_error_ptr(png_structp png_ptr)
 void PNGAPI

 png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)

 {

-   if (png_ptr != NULL)

-   {

-     png_ptr->flags &=

-       ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);

-   }

+    if(png_ptr != NULL)

+    {

+        png_ptr->flags &=

+            ((~(PNG_FLAG_STRIP_ERROR_NUMBERS | PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);

+    }

 }

 #endif

 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

diff --git a/src/libpng/pngget.c b/src/libpng/pngget.c
index e2e8bf841..5b3795246 100644
--- a/src/libpng/pngget.c
+++ b/src/libpng/pngget.c
@@ -20,32 +20,32 @@
 png_uint_32 PNGAPI

 png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return(info_ptr->valid & flag);

+    if(png_ptr != NULL && info_ptr != NULL)

+        return(info_ptr->valid & flag);

 

-   else

-      return(0);

+    else

+        return(0);

 }

 

 png_size_t PNGAPI

 png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return(info_ptr->rowbytes);

+    if(png_ptr != NULL && info_ptr != NULL)

+        return(info_ptr->rowbytes);

 

-   else

-      return(0);

+    else

+        return(0);

 }

 

 #ifdef PNG_INFO_IMAGE_SUPPORTED

 png_bytepp PNGAPI

 png_get_rows(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return(info_ptr->row_pointers);

+    if(png_ptr != NULL && info_ptr != NULL)

+        return(info_ptr->row_pointers);

 

-   else

-      return(0);

+    else

+        return(0);

 }

 #endif

 

@@ -54,312 +54,312 @@ png_get_rows(png_structp png_ptr, png_infop info_ptr)
 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;

+    if(png_ptr != NULL && info_ptr != NULL)

+        return info_ptr->width;

 

-   return (0);

+    return (0);

 }

 

 png_uint_32 PNGAPI

 png_get_image_height(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->height;

+    if(png_ptr != NULL && info_ptr != NULL)

+        return info_ptr->height;

 

-   return (0);

+    return (0);

 }

 

 png_byte PNGAPI

 png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->bit_depth;

+    if(png_ptr != NULL && info_ptr != NULL)

+        return info_ptr->bit_depth;

 

-   return (0);

+    return (0);

 }

 

 png_byte PNGAPI

 png_get_color_type(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->color_type;

+    if(png_ptr != NULL && info_ptr != NULL)

+        return info_ptr->color_type;

 

-   return (0);

+    return (0);

 }

 

 png_byte PNGAPI

 png_get_filter_type(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->filter_type;

+    if(png_ptr != NULL && info_ptr != NULL)

+        return info_ptr->filter_type;

 

-   return (0);

+    return (0);

 }

 

 png_byte PNGAPI

 png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->interlace_type;

+    if(png_ptr != NULL && info_ptr != NULL)

+        return info_ptr->interlace_type;

 

-   return (0);

+    return (0);

 }

 

 png_byte PNGAPI

 png_get_compression_type(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return info_ptr->compression_type;

+    if(png_ptr != NULL && info_ptr != NULL)

+        return info_ptr->compression_type;

 

-   return (0);

+    return (0);

 }

 

 png_uint_32 PNGAPI

 png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

+    if(png_ptr != NULL && info_ptr != NULL)

 #ifdef PNG_pHYs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_pHYs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter");

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

+            if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)

+                return (0);

 

-      else

-          return (info_ptr->x_pixels_per_unit);

-   }

+            else

+                return (info_ptr->x_pixels_per_unit);

+        }

 #else

-   return (0);

+        return (0);

 #endif

-   return (0);

+    return (0);

 }

 

 png_uint_32 PNGAPI

 png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

+    if(png_ptr != NULL && info_ptr != NULL)

 #ifdef PNG_pHYs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_pHYs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_y_pixels_per_meter");

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

+            if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)

+                return (0);

 

-      else

-          return (info_ptr->y_pixels_per_unit);

-   }

+            else

+                return (info_ptr->y_pixels_per_unit);

+        }

 #else

-   return (0);

+        return (0);

 #endif

-   return (0);

+    return (0);

 }

 

 png_uint_32 PNGAPI

 png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

+    if(png_ptr != NULL && info_ptr != NULL)

 #ifdef PNG_pHYs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_pHYs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");

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

+            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

+                return (info_ptr->x_pixels_per_unit);

+        }

 #else

-   return (0);

+        return (0);

 #endif

-   return (0);

+    return (0);

 }

 

 #ifdef PNG_FLOATING_POINT_SUPPORTED

 float PNGAPI

 png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)

-   {

-   if (png_ptr != NULL && info_ptr != NULL)

+{

+    if(png_ptr != NULL && info_ptr != NULL)

 #ifdef PNG_pHYs_SUPPORTED

 

-   if (info_ptr->valid & PNG_INFO_pHYs)

-   {

-      png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");

+        if(info_ptr->valid & PNG_INFO_pHYs)

+        {

+            png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");

 

-      if (info_ptr->x_pixels_per_unit == 0)

-         return ((float)0.0);

+            if(info_ptr->x_pixels_per_unit == 0)

+                return ((float)0.0);

 

-      else

-         return ((float)((float)info_ptr->y_pixels_per_unit

-            /(float)info_ptr->x_pixels_per_unit));

-   }

+            else

+                return ((float)((float)info_ptr->y_pixels_per_unit

+                                / (float)info_ptr->x_pixels_per_unit));

+        }

 #else

-      return (0.0);

+        return (0.0);

 #endif

-   return ((float)0.0);

+    return ((float)0.0);

 }

 #endif

 

 png_int_32 PNGAPI

 png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

+    if(png_ptr != NULL && info_ptr != NULL)

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

+            if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)

+                return (0);

 

-      else

-          return (info_ptr->x_offset);

-   }

+            else

+                return (info_ptr->x_offset);

+        }

 #else

-      return (0);

+        return (0);

 #endif

-   return (0);

+    return (0);

 }

 

 png_int_32 PNGAPI

 png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

+    if(png_ptr != NULL && info_ptr != NULL)

 

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

+            if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)

+                return (0);

 

-      else

-          return (info_ptr->y_offset);

-   }

+            else

+                return (info_ptr->y_offset);

+        }

 #else

-   return (0);

+        return (0);

 #endif

-   return (0);

+    return (0);

 }

 

 png_int_32 PNGAPI

 png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

+    if(png_ptr != NULL && info_ptr != NULL)

 

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

+            if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)

+                return (0);

 

-      else

-          return (info_ptr->x_offset);

-   }

+            else

+                return (info_ptr->x_offset);

+        }

 #else

-   return (0);

+        return (0);

 #endif

-   return (0);

+    return (0);

 }

 

 png_int_32 PNGAPI

 png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

+    if(png_ptr != NULL && info_ptr != NULL)

 

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

+            if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)

+                return (0);

 

-      else

-          return (info_ptr->y_offset);

-   }

+            else

+                return (info_ptr->y_offset);

+        }

 #else

-   return (0);

+        return (0);

 #endif

-   return (0);

+    return (0);

 }

 

 #if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)

 png_uint_32 PNGAPI

 png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)

 {

-   return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)

-     *.0254 +.5));

+    return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)

+                          * .0254 + .5));

 }

 

 png_uint_32 PNGAPI

 png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)

 {

-   return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)

-     *.0254 +.5));

+    return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)

+                          * .0254 + .5));

 }

 

 png_uint_32 PNGAPI

 png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)

 {

-   return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)

-     *.0254 +.5));

+    return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)

+                          * .0254 + .5));

 }

 

 float PNGAPI

 png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)

 {

-   return ((float)png_get_x_offset_microns(png_ptr, info_ptr)

-     *.00003937);

+    return ((float)png_get_x_offset_microns(png_ptr, info_ptr)

+            * .00003937);

 }

 

 float PNGAPI

 png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)

 {

-   return ((float)png_get_y_offset_microns(png_ptr, info_ptr)

-     *.00003937);

+    return ((float)png_get_y_offset_microns(png_ptr, info_ptr)

+            * .00003937);

 }

 

 #ifdef PNG_pHYs_SUPPORTED

 png_uint_32 PNGAPI

 png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)

-{

-   png_uint_32 retval = 0;

-

-   if (png_ptr != NULL && info_ptr != NULL && (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;

-         retval |= PNG_INFO_pHYs;

-         if (*unit_type == 1)

-         {

-            if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);

-            if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);

-         }

-      }

-   }

-   return (retval);

+                 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)

+{

+    png_uint_32 retval = 0;

+

+    if(png_ptr != NULL && info_ptr != NULL && (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;

+            retval |= PNG_INFO_pHYs;

+            if(*unit_type == 1)

+            {

+                if(res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);

+                if(res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);

+            }

+        }

+    }

+    return (retval);

 }

 #endif /* PNG_pHYs_SUPPORTED */

 #endif  /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */

@@ -371,35 +371,35 @@ png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
 png_byte PNGAPI

 png_get_channels(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return(info_ptr->channels);

-   else

-      return (0);

+    if(png_ptr != NULL && info_ptr != NULL)

+        return(info_ptr->channels);

+    else

+        return (0);

 }

 

 png_bytep PNGAPI

 png_get_signature(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr != NULL && info_ptr != NULL)

-      return(info_ptr->signature);

-   else

-      return (NULL);

+    if(png_ptr != NULL && info_ptr != NULL)

+        return(info_ptr->signature);

+    else

+        return (NULL);

 }

 

 #ifdef PNG_bKGD_SUPPORTED

 png_uint_32 PNGAPI

 png_get_bKGD(png_structp png_ptr, png_infop info_ptr,

-   png_color_16p *background)

+             png_color_16p *background)

 {

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)

-      && background != NULL)

-   {

-      png_debug1(1, "in %s retrieval function", "bKGD");

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)

+       && background != NULL)

+    {

+        png_debug1(1, "in %s retrieval function", "bKGD");

 

-      *background = &(info_ptr->background);

-      return (PNG_INFO_bKGD);

-   }

-   return (0);

+        *background = &(info_ptr->background);

+        return (PNG_INFO_bKGD);

+    }

+    return (0);

 }

 #endif

 

@@ -407,64 +407,64 @@ png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
 #ifdef PNG_FLOATING_POINT_SUPPORTED

 png_uint_32 PNGAPI

 png_get_cHRM(png_structp png_ptr, png_infop info_ptr,

-   double *white_x, double *white_y, double *red_x, double *red_y,

-   double *green_x, double *green_y, double *blue_x, double *blue_y)

-{

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

-   {

-      png_debug1(1, "in %s retrieval function", "cHRM");

-

-      if (white_x != NULL)

-         *white_x = (double)info_ptr->x_white;

-      if (white_y != NULL)

-         *white_y = (double)info_ptr->y_white;

-      if (red_x != NULL)

-         *red_x = (double)info_ptr->x_red;

-      if (red_y != NULL)

-         *red_y = (double)info_ptr->y_red;

-      if (green_x != NULL)

-         *green_x = (double)info_ptr->x_green;

-      if (green_y != NULL)

-         *green_y = (double)info_ptr->y_green;

-      if (blue_x != NULL)

-         *blue_x = (double)info_ptr->x_blue;

-      if (blue_y != NULL)

-         *blue_y = (double)info_ptr->y_blue;

-      return (PNG_INFO_cHRM);

-   }

-   return (0);

+             double *white_x, double *white_y, double *red_x, double *red_y,

+             double *green_x, double *green_y, double *blue_x, double *blue_y)

+{

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

+    {

+        png_debug1(1, "in %s retrieval function", "cHRM");

+

+        if(white_x != NULL)

+            *white_x = (double)info_ptr->x_white;

+        if(white_y != NULL)

+            *white_y = (double)info_ptr->y_white;

+        if(red_x != NULL)

+            *red_x = (double)info_ptr->x_red;

+        if(red_y != NULL)

+            *red_y = (double)info_ptr->y_red;

+        if(green_x != NULL)

+            *green_x = (double)info_ptr->x_green;

+        if(green_y != NULL)

+            *green_y = (double)info_ptr->y_green;

+        if(blue_x != NULL)

+            *blue_x = (double)info_ptr->x_blue;

+        if(blue_y != NULL)

+            *blue_y = (double)info_ptr->y_blue;

+        return (PNG_INFO_cHRM);

+    }

+    return (0);

 }

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

 png_uint_32 PNGAPI

 png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,

-   png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,

-   png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,

-   png_fixed_point *blue_x, png_fixed_point *blue_y)

-{

-   png_debug1(1, "in %s retrieval function", "cHRM");

-

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

-   {

-      if (white_x != NULL)

-         *white_x = info_ptr->int_x_white;

-      if (white_y != NULL)

-         *white_y = info_ptr->int_y_white;

-      if (red_x != NULL)

-         *red_x = info_ptr->int_x_red;

-      if (red_y != NULL)

-         *red_y = info_ptr->int_y_red;

-      if (green_x != NULL)

-         *green_x = info_ptr->int_x_green;

-      if (green_y != NULL)

-         *green_y = info_ptr->int_y_green;

-      if (blue_x != NULL)

-         *blue_x = info_ptr->int_x_blue;

-      if (blue_y != NULL)

-         *blue_y = info_ptr->int_y_blue;

-      return (PNG_INFO_cHRM);

-   }

-   return (0);

+                   png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,

+                   png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,

+                   png_fixed_point *blue_x, png_fixed_point *blue_y)

+{

+    png_debug1(1, "in %s retrieval function", "cHRM");

+

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

+    {

+        if(white_x != NULL)

+            *white_x = info_ptr->int_x_white;

+        if(white_y != NULL)

+            *white_y = info_ptr->int_y_white;

+        if(red_x != NULL)

+            *red_x = info_ptr->int_x_red;

+        if(red_y != NULL)

+            *red_y = info_ptr->int_y_red;

+        if(green_x != NULL)

+            *green_x = info_ptr->int_x_green;

+        if(green_y != NULL)

+            *green_y = info_ptr->int_y_green;

+        if(blue_x != NULL)

+            *blue_x = info_ptr->int_x_blue;

+        if(blue_y != NULL)

+            *blue_y = info_ptr->int_y_blue;

+        return (PNG_INFO_cHRM);

+    }

+    return (0);

 }

 #endif

 #endif

@@ -474,31 +474,31 @@ png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
 png_uint_32 PNGAPI

 png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)

 {

-   png_debug1(1, "in %s retrieval function", "gAMA");

+    png_debug1(1, "in %s retrieval function", "gAMA");

 

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

-      && file_gamma != NULL)

-   {

-      *file_gamma = (double)info_ptr->gamma;

-      return (PNG_INFO_gAMA);

-   }

-   return (0);

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

+       && file_gamma != NULL)

+    {

+        *file_gamma = (double)info_ptr->gamma;

+        return (PNG_INFO_gAMA);

+    }

+    return (0);

 }

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

 png_uint_32 PNGAPI

 png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,

-    png_fixed_point *int_file_gamma)

+                   png_fixed_point *int_file_gamma)

 {

-   png_debug1(1, "in %s retrieval function", "gAMA");

+    png_debug1(1, "in %s retrieval function", "gAMA");

 

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

-      && int_file_gamma != NULL)

-   {

-      *int_file_gamma = info_ptr->int_gamma;

-      return (PNG_INFO_gAMA);

-   }

-   return (0);

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

+       && int_file_gamma != NULL)

+    {

+        *int_file_gamma = info_ptr->int_gamma;

+        return (PNG_INFO_gAMA);

+    }

+    return (0);

 }

 #endif

 #endif

@@ -507,15 +507,15 @@ png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,
 png_uint_32 PNGAPI

 png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)

 {

-   png_debug1(1, "in %s retrieval function", "sRGB");

+    png_debug1(1, "in %s retrieval function", "sRGB");

 

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)

-      && file_srgb_intent != NULL)

-   {

-      *file_srgb_intent = (int)info_ptr->srgb_intent;

-      return (PNG_INFO_sRGB);

-   }

-   return (0);

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)

+       && file_srgb_intent != NULL)

+    {

+        *file_srgb_intent = (int)info_ptr->srgb_intent;

+        return (PNG_INFO_sRGB);

+    }

+    return (0);

 }

 #endif

 

@@ -525,21 +525,21 @@ png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
              png_charpp name, int *compression_type,

              png_charpp profile, png_uint_32 *proflen)

 {

-   png_debug1(1, "in %s retrieval function", "iCCP");

+    png_debug1(1, "in %s retrieval function", "iCCP");

 

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)

-      && name != NULL && profile != NULL && proflen != NULL)

-   {

-      *name = info_ptr->iccp_name;

-      *profile = info_ptr->iccp_profile;

-      /* Compression_type is a dummy so the API won't have to change

-       * if we introduce multiple compression types later.

-       */

-      *proflen = (int)info_ptr->iccp_proflen;

-      *compression_type = (int)info_ptr->iccp_compression;

-      return (PNG_INFO_iCCP);

-   }

-   return (0);

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)

+       && name != NULL && profile != NULL && proflen != NULL)

+    {

+        *name = info_ptr->iccp_name;

+        *profile = info_ptr->iccp_profile;

+        /* Compression_type is a dummy so the API won't have to change

+         * if we introduce multiple compression types later.

+         */

+        *proflen = (int)info_ptr->iccp_proflen;

+        *compression_type = (int)info_ptr->iccp_compression;

+        return (PNG_INFO_iCCP);

+    }

+    return (0);

 }

 #endif

 

@@ -548,12 +548,12 @@ png_uint_32 PNGAPI
 png_get_sPLT(png_structp png_ptr, png_infop info_ptr,

              png_sPLT_tpp spalettes)

 {

-   if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)

-   {

-     *spalettes = info_ptr->splt_palettes;

-     return ((png_uint_32)info_ptr->splt_palettes_num);

-   }

-   return (0);

+    if(png_ptr != NULL && info_ptr != NULL && spalettes != NULL)

+    {

+        *spalettes = info_ptr->splt_palettes;

+        return ((png_uint_32)info_ptr->splt_palettes_num);

+    }

+    return (0);

 }

 #endif

 

@@ -561,98 +561,98 @@ png_get_sPLT(png_structp png_ptr, png_infop info_ptr,
 png_uint_32 PNGAPI

 png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)

 {

-   png_debug1(1, "in %s retrieval function", "hIST");

+    png_debug1(1, "in %s retrieval function", "hIST");

 

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)

-      && hist != NULL)

-   {

-      *hist = info_ptr->hist;

-      return (PNG_INFO_hIST);

-   }

-   return (0);

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)

+       && hist != NULL)

+    {

+        *hist = info_ptr->hist;

+        return (PNG_INFO_hIST);

+    }

+    return (0);

 }

 #endif

 

 png_uint_32 PNGAPI

 png_get_IHDR(png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 *width, png_uint_32 *height, int *bit_depth,

-   int *color_type, int *interlace_type, int *compression_type,

-   int *filter_type)

+             png_uint_32 *width, png_uint_32 *height, int *bit_depth,

+             int *color_type, int *interlace_type, int *compression_type,

+             int *filter_type)

 

 {

-   png_debug1(1, "in %s retrieval function", "IHDR");

+    png_debug1(1, "in %s retrieval function", "IHDR");

 

-   if (png_ptr == NULL || info_ptr == NULL || width == NULL ||

+    if(png_ptr == NULL || info_ptr == NULL || width == NULL ||

        height == NULL || bit_depth == NULL || color_type == NULL)

-      return (0);

+        return (0);

 

-   *width = info_ptr->width;

-   *height = info_ptr->height;

-   *bit_depth = info_ptr->bit_depth;

-   *color_type = info_ptr->color_type;

+    *width = info_ptr->width;

+    *height = info_ptr->height;

+    *bit_depth = info_ptr->bit_depth;

+    *color_type = info_ptr->color_type;

 

-   if (compression_type != NULL)

-      *compression_type = info_ptr->compression_type;

+    if(compression_type != NULL)

+        *compression_type = info_ptr->compression_type;

 

-   if (filter_type != NULL)

-      *filter_type = info_ptr->filter_type;

+    if(filter_type != NULL)

+        *filter_type = info_ptr->filter_type;

 

-   if (interlace_type != NULL)

-      *interlace_type = info_ptr->interlace_type;

+    if(interlace_type != NULL)

+        *interlace_type = info_ptr->interlace_type;

 

-   /* This is redundant if we can be sure that the info_ptr values were all

-    * assigned in png_set_IHDR().  We do the check anyhow in case an

-    * application has ignored our advice not to mess with the members

-    * of info_ptr directly.

-    */

-   png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,

-       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,

-       info_ptr->compression_type, info_ptr->filter_type);

+    /* This is redundant if we can be sure that the info_ptr values were all

+     * assigned in png_set_IHDR().  We do the check anyhow in case an

+     * application has ignored our advice not to mess with the members

+     * of info_ptr directly.

+     */

+    png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height,

+                   info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,

+                   info_ptr->compression_type, info_ptr->filter_type);

 

-   return (1);

+    return (1);

 }

 

 #ifdef PNG_oFFs_SUPPORTED

 png_uint_32 PNGAPI

 png_get_oFFs(png_structp png_ptr, png_infop info_ptr,

-   png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)

+             png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)

 {

-   png_debug1(1, "in %s retrieval function", "oFFs");

+    png_debug1(1, "in %s retrieval function", "oFFs");

 

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)

-      && offset_x != NULL && offset_y != NULL && unit_type != NULL)

-   {

-      *offset_x = info_ptr->x_offset;

-      *offset_y = info_ptr->y_offset;

-      *unit_type = (int)info_ptr->offset_unit_type;

-      return (PNG_INFO_oFFs);

-   }

-   return (0);

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)

+       && offset_x != NULL && offset_y != NULL && unit_type != NULL)

+    {

+        *offset_x = info_ptr->x_offset;

+        *offset_y = info_ptr->y_offset;

+        *unit_type = (int)info_ptr->offset_unit_type;

+        return (PNG_INFO_oFFs);

+    }

+    return (0);

 }

 #endif

 

 #ifdef PNG_pCAL_SUPPORTED

 png_uint_32 PNGAPI

 png_get_pCAL(png_structp png_ptr, png_infop info_ptr,

-   png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,

-   png_charp *units, png_charpp *params)

+             png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,

+             png_charp *units, png_charpp *params)

 {

-   png_debug1(1, "in %s retrieval function", "pCAL");

+    png_debug1(1, "in %s retrieval function", "pCAL");

 

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)

+    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 = info_ptr->pcal_purpose;

-      *X0 = info_ptr->pcal_X0;

-      *X1 = info_ptr->pcal_X1;

-      *type = (int)info_ptr->pcal_type;

-      *nparams = (int)info_ptr->pcal_nparams;

-      *units = info_ptr->pcal_units;

-      *params = info_ptr->pcal_params;

-      return (PNG_INFO_pCAL);

-   }

-   return (0);

+    {

+        *purpose = info_ptr->pcal_purpose;

+        *X0 = info_ptr->pcal_X0;

+        *X1 = info_ptr->pcal_X1;

+        *type = (int)info_ptr->pcal_type;

+        *nparams = (int)info_ptr->pcal_nparams;

+        *units = info_ptr->pcal_units;

+        *params = info_ptr->pcal_params;

+        return (PNG_INFO_pCAL);

+    }

+    return (0);

 }

 #endif

 

@@ -662,8 +662,8 @@ png_uint_32 PNGAPI
 png_get_sCAL(png_structp png_ptr, png_infop info_ptr,

              int *unit, double *width, double *height)

 {

-    if (png_ptr != NULL && info_ptr != NULL &&

-        (info_ptr->valid & PNG_INFO_sCAL))

+    if(png_ptr != NULL && info_ptr != NULL &&

+       (info_ptr->valid & PNG_INFO_sCAL))

     {

         *unit = info_ptr->scal_unit;

         *width = info_ptr->scal_pixel_width;

@@ -676,10 +676,10 @@ png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
 #ifdef PNG_FIXED_POINT_SUPPORTED

 png_uint_32 PNGAPI

 png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,

-             int *unit, png_charpp width, png_charpp height)

+               int *unit, png_charpp width, png_charpp height)

 {

-    if (png_ptr != NULL && info_ptr != NULL &&

-        (info_ptr->valid & PNG_INFO_sCAL))

+    if(png_ptr != NULL && info_ptr != NULL &&

+       (info_ptr->valid & PNG_INFO_sCAL))

     {

         *unit = info_ptr->scal_unit;

         *width = info_ptr->scal_s_width;

@@ -695,92 +695,92 @@ png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
 #ifdef PNG_pHYs_SUPPORTED

 png_uint_32 PNGAPI

 png_get_pHYs(png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)

+             png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)

 {

-   png_uint_32 retval = 0;

+    png_uint_32 retval = 0;

 

-   png_debug1(1, "in %s retrieval function", "pHYs");

+    png_debug1(1, "in %s retrieval function", "pHYs");

 

-   if (png_ptr != NULL && info_ptr != NULL &&

-      (info_ptr->valid & PNG_INFO_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;

-         retval |= PNG_INFO_pHYs;

-      }

-   }

-   return (retval);

+    if(png_ptr != NULL && info_ptr != NULL &&

+       (info_ptr->valid & PNG_INFO_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;

+            retval |= PNG_INFO_pHYs;

+        }

+    }

+    return (retval);

 }

 #endif

 

 png_uint_32 PNGAPI

 png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,

-   int *num_palette)

+             int *num_palette)

 {

-   png_debug1(1, "in %s retrieval function", "PLTE");

+    png_debug1(1, "in %s retrieval function", "PLTE");

 

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)

        && palette != NULL)

-   {

-      *palette = info_ptr->palette;

-      *num_palette = info_ptr->num_palette;

-      png_debug1(3, "num_palette = %d", *num_palette);

-      return (PNG_INFO_PLTE);

-   }

-   return (0);

+    {

+        *palette = info_ptr->palette;

+        *num_palette = info_ptr->num_palette;

+        png_debug1(3, "num_palette = %d", *num_palette);

+        return (PNG_INFO_PLTE);

+    }

+    return (0);

 }

 

 #ifdef PNG_sBIT_SUPPORTED

 png_uint_32 PNGAPI

 png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)

 {

-   png_debug1(1, "in %s retrieval function", "sBIT");

+    png_debug1(1, "in %s retrieval function", "sBIT");

 

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)

-      && sig_bit != NULL)

-   {

-      *sig_bit = &(info_ptr->sig_bit);

-      return (PNG_INFO_sBIT);

-   }

-   return (0);

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)

+       && sig_bit != NULL)

+    {

+        *sig_bit = &(info_ptr->sig_bit);

+        return (PNG_INFO_sBIT);

+    }

+    return (0);

 }

 #endif

 

 #ifdef PNG_TEXT_SUPPORTED

 png_uint_32 PNGAPI

 png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,

-   int *num_text)

+             int *num_text)

 {

-   if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)

-   {

-      png_debug1(1, "in %s retrieval function",

-         (png_ptr->chunk_name[0] == '\0' ? "text"

-             : (png_const_charp)png_ptr->chunk_name));

+    if(png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)

+    {

+        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(text_ptr != NULL)

+            *text_ptr = info_ptr->text;

 

-      if (num_text != NULL)

-         *num_text = info_ptr->num_text;

+        if(num_text != NULL)

+            *num_text = info_ptr->num_text;

 

-      return ((png_uint_32)info_ptr->num_text);

-   }

-   if (num_text != NULL)

-     *num_text = 0;

-   return(0);

+        return ((png_uint_32)info_ptr->num_text);

+    }

+    if(num_text != NULL)

+        *num_text = 0;

+    return(0);

 }

 #endif

 

@@ -788,79 +788,79 @@ png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
 png_uint_32 PNGAPI

 png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)

 {

-   png_debug1(1, "in %s retrieval function", "tIME");

+    png_debug1(1, "in %s retrieval function", "tIME");

 

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)

        && mod_time != NULL)

-   {

-      *mod_time = &(info_ptr->mod_time);

-      return (PNG_INFO_tIME);

-   }

-   return (0);

+    {

+        *mod_time = &(info_ptr->mod_time);

+        return (PNG_INFO_tIME);

+    }

+    return (0);

 }

 #endif

 

 #ifdef PNG_tRNS_SUPPORTED

 png_uint_32 PNGAPI

 png_get_tRNS(png_structp png_ptr, png_infop info_ptr,

-   png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)

-{

-   png_uint_32 retval = 0;

-   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

-   {

-      png_debug1(1, "in %s retrieval function", "tRNS");

-

-      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-          if (trans_alpha != NULL)

-          {

-             *trans_alpha = info_ptr->trans_alpha;

-             retval |= PNG_INFO_tRNS;

-          }

-

-          if (trans_color != NULL)

-             *trans_color = &(info_ptr->trans_color);

-      }

-      else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */

-      {

-          if (trans_color != NULL)

-          {

-             *trans_color = &(info_ptr->trans_color);

-             retval |= PNG_INFO_tRNS;

-          }

-

-          if (trans_alpha != NULL)

-             *trans_alpha = NULL;

-      }

-      if (num_trans != NULL)

-      {

-         *num_trans = info_ptr->num_trans;

-         retval |= PNG_INFO_tRNS;

-      }

-   }

-   return (retval);

+             png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)

+{

+    png_uint_32 retval = 0;

+    if(png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

+    {

+        png_debug1(1, "in %s retrieval function", "tRNS");

+

+        if(info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+        {

+            if(trans_alpha != NULL)

+            {

+                *trans_alpha = info_ptr->trans_alpha;

+                retval |= PNG_INFO_tRNS;

+            }

+

+            if(trans_color != NULL)

+                *trans_color = &(info_ptr->trans_color);

+        }

+        else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */

+        {

+            if(trans_color != NULL)

+            {

+                *trans_color = &(info_ptr->trans_color);

+                retval |= PNG_INFO_tRNS;

+            }

+

+            if(trans_alpha != NULL)

+                *trans_alpha = NULL;

+        }

+        if(num_trans != NULL)

+        {

+            *num_trans = info_ptr->num_trans;

+            retval |= PNG_INFO_tRNS;

+        }

+    }

+    return (retval);

 }

 #endif

 

 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

 png_uint_32 PNGAPI

 png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,

-             png_unknown_chunkpp unknowns)

+                       png_unknown_chunkpp unknowns)

 {

-   if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)

-   {

-     *unknowns = info_ptr->unknown_chunks;

-     return ((png_uint_32)info_ptr->unknown_chunks_num);

-   }

-   return (0);

+    if(png_ptr != NULL && info_ptr != NULL && unknowns != NULL)

+    {

+        *unknowns = info_ptr->unknown_chunks;

+        return ((png_uint_32)info_ptr->unknown_chunks_num);

+    }

+    return (0);

 }

 #endif

 

 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

 png_byte PNGAPI

-png_get_rgb_to_gray_status (png_structp png_ptr)

+png_get_rgb_to_gray_status(png_structp png_ptr)

 {

-   return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);

+    return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);

 }

 #endif

 

@@ -868,14 +868,14 @@ png_get_rgb_to_gray_status (png_structp png_ptr)
 png_voidp PNGAPI

 png_get_user_chunk_ptr(png_structp png_ptr)

 {

-   return (png_ptr? png_ptr->user_chunk_ptr : NULL);

+    return (png_ptr ? png_ptr->user_chunk_ptr : NULL);

 }

 #endif

 

 png_size_t PNGAPI

 png_get_compression_buffer_size(png_structp png_ptr)

 {

-   return (png_ptr ? png_ptr->zbuf_size : 0L);

+    return (png_ptr ? png_ptr->zbuf_size : 0L);

 }

 

 

@@ -883,42 +883,42 @@ png_get_compression_buffer_size(png_structp png_ptr)
 /* These functions were added to libpng 1.2.6 and were enabled

  * by default in libpng-1.4.0 */

 png_uint_32 PNGAPI

-png_get_user_width_max (png_structp png_ptr)

+png_get_user_width_max(png_structp png_ptr)

 {

-    return (png_ptr? png_ptr->user_width_max : 0);

+    return (png_ptr ? png_ptr->user_width_max : 0);

 }

 png_uint_32 PNGAPI

-png_get_user_height_max (png_structp png_ptr)

+png_get_user_height_max(png_structp png_ptr)

 {

-    return (png_ptr? png_ptr->user_height_max : 0);

+    return (png_ptr ? png_ptr->user_height_max : 0);

 }

 /* This function was added to libpng 1.4.0 */

 png_uint_32 PNGAPI

-png_get_chunk_cache_max (png_structp png_ptr)

+png_get_chunk_cache_max(png_structp png_ptr)

 {

-    return (png_ptr? png_ptr->user_chunk_cache_max : 0);

+    return (png_ptr ? png_ptr->user_chunk_cache_max : 0);

 }

 /* This function was added to libpng 1.4.1 */

 png_alloc_size_t PNGAPI

-png_get_chunk_malloc_max (png_structp png_ptr)

+png_get_chunk_malloc_max(png_structp png_ptr)

 {

-    return (png_ptr?

-       png_ptr->user_chunk_malloc_max : 0);

+    return (png_ptr ?

+            png_ptr->user_chunk_malloc_max : 0);

 }

 #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */

 

 /* These functions were added to libpng 1.4.0 */

 #ifdef PNG_IO_STATE_SUPPORTED

 png_uint_32 PNGAPI

-png_get_io_state (png_structp png_ptr)

+png_get_io_state(png_structp png_ptr)

 {

     return png_ptr->io_state;

 }

 

 png_bytep PNGAPI

-png_get_io_chunk_name (png_structp png_ptr)

+png_get_io_chunk_name(png_structp png_ptr)

 {

-   return png_ptr->chunk_name;

+    return png_ptr->chunk_name;

 }

 #endif /* ?PNG_IO_STATE_SUPPORTED */

 

diff --git a/src/libpng/pngmem.c b/src/libpng/pngmem.c
index 671dba4cc..746ac5f5d 100644
--- a/src/libpng/pngmem.c
+++ b/src/libpng/pngmem.c
@@ -32,7 +32,7 @@ png_voidp /* PRIVATE */
 png_create_struct(int type)

 {

 #ifdef PNG_USER_MEM_SUPPORTED

-   return (png_create_struct_2(type, NULL, NULL));

+    return (png_create_struct_2(type, NULL, NULL));

 }

 

 /* Alternate version of png_create_struct, for use with user-defined malloc. */

@@ -40,30 +40,30 @@ png_voidp /* PRIVATE */
 png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)

 {

 #endif /* PNG_USER_MEM_SUPPORTED */

-   png_size_t size;

-   png_voidp struct_ptr;

+    png_size_t size;

+    png_voidp struct_ptr;

 

-   if (type == PNG_STRUCT_INFO)

-      size = png_sizeof(png_info);

-   else if (type == PNG_STRUCT_PNG)

-      size = png_sizeof(png_struct);

-   else

-      return (png_get_copyright(NULL));

+    if(type == PNG_STRUCT_INFO)

+        size = png_sizeof(png_info);

+    else if(type == PNG_STRUCT_PNG)

+        size = png_sizeof(png_struct);

+    else

+        return (png_get_copyright(NULL));

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   if (malloc_fn != NULL)

-   {

-      png_struct dummy_struct;

-      png_structp png_ptr = &dummy_struct;

-      png_ptr->mem_ptr=mem_ptr;

-      struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);

-   }

-   else

+    if(malloc_fn != NULL)

+    {

+        png_struct dummy_struct;

+        png_structp png_ptr = &dummy_struct;

+        png_ptr->mem_ptr = mem_ptr;

+        struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);

+    }

+    else

 #endif /* PNG_USER_MEM_SUPPORTED */

-   struct_ptr = (png_voidp)farmalloc(size);

-   if (struct_ptr != NULL)

-      png_memset(struct_ptr, 0, size);

-   return (struct_ptr);

+        struct_ptr = (png_voidp)farmalloc(size);

+    if(struct_ptr != NULL)

+        png_memset(struct_ptr, 0, size);

+    return (struct_ptr);

 }

 

 /* Free memory allocated by a png_create_struct() call */

@@ -71,29 +71,29 @@ void /* PRIVATE */
 png_destroy_struct(png_voidp struct_ptr)

 {

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_destroy_struct_2(struct_ptr, NULL, NULL);

+    png_destroy_struct_2(struct_ptr, NULL, NULL);

 }

 

 /* Free memory allocated by a png_create_struct() call */

 void /* PRIVATE */

 png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,

-    png_voidp mem_ptr)

+                     png_voidp mem_ptr)

 {

 #endif

-   if (struct_ptr != NULL)

-   {

+    if(struct_ptr != NULL)

+    {

 #ifdef PNG_USER_MEM_SUPPORTED

-      if (free_fn != NULL)

-      {

-         png_struct dummy_struct;

-         png_structp png_ptr = &dummy_struct;

-         png_ptr->mem_ptr=mem_ptr;

-         (*(free_fn))(png_ptr, struct_ptr);

-         return;

-      }

+        if(free_fn != NULL)

+        {

+            png_struct dummy_struct;

+            png_structp png_ptr = &dummy_struct;

+            png_ptr->mem_ptr = mem_ptr;

+            (*(free_fn))(png_ptr, struct_ptr);

+            return;

+        }

 #endif /* PNG_USER_MEM_SUPPORTED */

-      farfree (struct_ptr);

-   }

+        farfree(struct_ptr);

+    }

 }

 

 /* Allocate memory.  For reasonable files, size should never exceed

@@ -118,169 +118,169 @@ png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
 png_voidp PNGAPI

 png_calloc(png_structp png_ptr, png_alloc_size_t size)

 {

-   png_voidp ret;

+    png_voidp ret;

 

-   ret = (png_malloc(png_ptr, size));

-   if (ret != NULL)

-      png_memset(ret,0,(png_size_t)size);

-   return (ret);

+    ret = (png_malloc(png_ptr, size));

+    if(ret != NULL)

+        png_memset(ret, 0, (png_size_t)size);

+    return (ret);

 }

 

 png_voidp PNGAPI

 png_malloc(png_structp png_ptr, png_alloc_size_t size)

 {

-   png_voidp ret;

+    png_voidp ret;

 

-   if (png_ptr == NULL || size == 0)

-      return (NULL);

+    if(png_ptr == NULL || size == 0)

+        return (NULL);

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   if (png_ptr->malloc_fn != NULL)

-      ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));

-   else

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

+    if(png_ptr->malloc_fn != NULL)

+        ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));

+    else

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

 }

 

 png_voidp PNGAPI

 png_malloc_default(png_structp png_ptr, png_alloc_size_t size)

 {

-   png_voidp ret;

+    png_voidp ret;

 #endif /* PNG_USER_MEM_SUPPORTED */

 

-   if (png_ptr == NULL || size == 0)

-      return (NULL);

+    if(png_ptr == NULL || size == 0)

+        return (NULL);

 

 #ifdef PNG_MAX_MALLOC_64K

-   if (size > (png_uint_32)65536L)

-   {

-      png_warning(png_ptr, "Cannot Allocate > 64K");

-      ret = NULL;

-   }

-   else

+    if(size > (png_uint_32)65536L)

+    {

+        png_warning(png_ptr, "Cannot Allocate > 64K");

+        ret = NULL;

+    }

+    else

 #endif

 

-   if (size != (size_t)size)

-      ret = NULL;

-   else if (size == (png_uint_32)65536L)

-   {

-      if (png_ptr->offset_table == NULL)

-      {

-         /* Try to see if we need to do any of this fancy stuff */

-         ret = farmalloc(size);

-         if (ret == NULL || ((png_size_t)ret & 0xffff))

-         {

-            int num_blocks;

-            png_uint_32 total_size;

-            png_bytep table;

-            int i;

-            png_byte huge * hptr;

-

-            if (ret != NULL)

-            {

-               farfree(ret);

-               ret = NULL;

-            }

-

-            if (png_ptr->zlib_window_bits > 14)

-               num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));

-            else

-               num_blocks = 1;

-            if (png_ptr->zlib_mem_level >= 7)

-               num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));

-            else

-               num_blocks++;

-

-            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;

-

-            table = farmalloc(total_size);

-

-            if (table == NULL)

+        if(size != (size_t)size)

+            ret = NULL;

+        else if(size == (png_uint_32)65536L)

+        {

+            if(png_ptr->offset_table == NULL)

             {

+                /* Try to see if we need to do any of this fancy stuff */

+                ret = farmalloc(size);

+                if(ret == NULL || ((png_size_t)ret & 0xffff))

+                {

+                    int num_blocks;

+                    png_uint_32 total_size;

+                    png_bytep table;

+                    int i;

+                    png_byte huge * hptr;

+

+                    if(ret != NULL)

+                    {

+                        farfree(ret);

+                        ret = NULL;

+                    }

+

+                    if(png_ptr->zlib_window_bits > 14)

+                        num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));

+                    else

+                        num_blocks = 1;

+                    if(png_ptr->zlib_mem_level >= 7)

+                        num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));

+                    else

+                        num_blocks++;

+

+                    total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks + 16;

+

+                    table = farmalloc(total_size);

+

+                    if(table == NULL)

+                    {

 #ifndef PNG_USER_MEM_SUPPORTED

-               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-                  png_error(png_ptr, "Out Of Memory"); /* Note "O", "M" */

-               else

-                  png_warning(png_ptr, "Out Of Memory");

+                        if((png_ptr->flags & PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+                            png_error(png_ptr, "Out Of Memory"); /* Note "O", "M" */

+                        else

+                            png_warning(png_ptr, "Out Of Memory");

 #endif

-               return (NULL);

-            }

+                        return (NULL);

+                    }

 

-            if ((png_size_t)table & 0xfff0)

-            {

+                    if((png_size_t)table & 0xfff0)

+                    {

 #ifndef PNG_USER_MEM_SUPPORTED

-               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-                  png_error(png_ptr,

-                    "Farmalloc didn't return normalized pointer");

-               else

-                  png_warning(png_ptr,

-                    "Farmalloc didn't return normalized pointer");

+                        if((png_ptr->flags & PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+                            png_error(png_ptr,

+                                      "Farmalloc didn't return normalized pointer");

+                        else

+                            png_warning(png_ptr,

+                                        "Farmalloc didn't return normalized pointer");

 #endif

-               return (NULL);

-            }

+                        return (NULL);

+                    }

 

-            png_ptr->offset_table = table;

-            png_ptr->offset_table_ptr = farmalloc(num_blocks *

-               png_sizeof(png_bytep));

+                    png_ptr->offset_table = table;

+                    png_ptr->offset_table_ptr = farmalloc(num_blocks *

+                                                          png_sizeof(png_bytep));

 

-            if (png_ptr->offset_table_ptr == NULL)

-            {

+                    if(png_ptr->offset_table_ptr == NULL)

+                    {

 #ifndef PNG_USER_MEM_SUPPORTED

-               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-                  png_error(png_ptr, "Out Of memory"); /* Note "O", "m" */

-               else

-                  png_warning(png_ptr, "Out Of memory");

+                        if((png_ptr->flags & PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+                            png_error(png_ptr, "Out Of memory"); /* Note "O", "m" */

+                        else

+                            png_warning(png_ptr, "Out Of memory");

 #endif

-               return (NULL);

+                        return (NULL);

+                    }

+

+                    hptr = (png_byte huge *)table;

+                    if((png_size_t)hptr & 0xf)

+                    {

+                        hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);

+                        hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */

+                    }

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

+                    {

+                        png_ptr->offset_table_ptr[i] = (png_bytep)hptr;

+                        hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */

+                    }

+

+                    png_ptr->offset_table_number = num_blocks;

+                    png_ptr->offset_table_count = 0;

+                    png_ptr->offset_table_count_free = 0;

+                }

             }

 

-            hptr = (png_byte huge *)table;

-            if ((png_size_t)hptr & 0xf)

+            if(png_ptr->offset_table_count >= png_ptr->offset_table_number)

             {

-               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);

-               hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */

-            }

-            for (i = 0; i < num_blocks; i++)

-            {

-               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;

-               hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */

-            }

-

-            png_ptr->offset_table_number = num_blocks;

-            png_ptr->offset_table_count = 0;

-            png_ptr->offset_table_count_free = 0;

-         }

-      }

-

-      if (png_ptr->offset_table_count >= png_ptr->offset_table_number)

-      {

 #ifndef PNG_USER_MEM_SUPPORTED

-         if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-            png_error(png_ptr, "Out of Memory"); /* Note "o" and "M" */

-         else

-            png_warning(png_ptr, "Out of Memory");

+                if((png_ptr->flags & PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+                    png_error(png_ptr, "Out of Memory"); /* Note "o" and "M" */

+                else

+                    png_warning(png_ptr, "Out of Memory");

 #endif

-         return (NULL);

-      }

+                return (NULL);

+            }

 

-      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];

-   }

-   else

-      ret = farmalloc(size);

+            ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];

+        }

+        else

+            ret = farmalloc(size);

 

 #ifndef PNG_USER_MEM_SUPPORTED

-   if (ret == NULL)

-   {

-      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-         png_error(png_ptr, "Out of memory"); /* Note "o" and "m" */

-      else

-         png_warning(png_ptr, "Out of memory"); /* Note "o" and "m" */

-   }

+    if(ret == NULL)

+    {

+        if((png_ptr->flags & PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+            png_error(png_ptr, "Out of memory"); /* Note "o" and "m" */

+        else

+            png_warning(png_ptr, "Out of memory"); /* Note "o" and "m" */

+    }

 #endif

 

-   return (ret);

+    return (ret);

 }

 

 /* Free a pointer allocated by png_malloc().  In the default

@@ -290,17 +290,17 @@ png_malloc_default(png_structp png_ptr, png_alloc_size_t size)
 void PNGAPI

 png_free(png_structp png_ptr, png_voidp ptr)

 {

-   if (png_ptr == NULL || ptr == NULL)

-      return;

+    if(png_ptr == NULL || ptr == NULL)

+        return;

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   if (png_ptr->free_fn != NULL)

-   {

-      (*(png_ptr->free_fn))(png_ptr, ptr);

-      return;

-   }

-   else

-      png_free_default(png_ptr, ptr);

+    if(png_ptr->free_fn != NULL)

+    {

+        (*(png_ptr->free_fn))(png_ptr, ptr);

+        return;

+    }

+    else

+        png_free_default(png_ptr, ptr);

 }

 

 void PNGAPI

@@ -308,35 +308,35 @@ png_free_default(png_structp png_ptr, png_voidp ptr)
 {

 #endif /* PNG_USER_MEM_SUPPORTED */

 

-   if (png_ptr == NULL || ptr == NULL)

-      return;

-

-   if (png_ptr->offset_table != NULL)

-   {

-      int i;

-

-      for (i = 0; i < png_ptr->offset_table_count; i++)

-      {

-         if (ptr == png_ptr->offset_table_ptr[i])

-         {

-            ptr = NULL;

-            png_ptr->offset_table_count_free++;

-            break;

-         }

-      }

-      if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)

-      {

-         farfree(png_ptr->offset_table);

-         farfree(png_ptr->offset_table_ptr);

-         png_ptr->offset_table = NULL;

-         png_ptr->offset_table_ptr = NULL;

-      }

-   }

-

-   if (ptr != NULL)

-   {

-      farfree(ptr);

-   }

+    if(png_ptr == NULL || ptr == NULL)

+        return;

+

+    if(png_ptr->offset_table != NULL)

+    {

+        int i;

+

+        for(i = 0; i < png_ptr->offset_table_count; i++)

+        {

+            if(ptr == png_ptr->offset_table_ptr[i])

+            {

+                ptr = NULL;

+                png_ptr->offset_table_count_free++;

+                break;

+            }

+        }

+        if(png_ptr->offset_table_count_free == png_ptr->offset_table_count)

+        {

+            farfree(png_ptr->offset_table);

+            farfree(png_ptr->offset_table_ptr);

+            png_ptr->offset_table = NULL;

+            png_ptr->offset_table_ptr = NULL;

+        }

+    }

+

+    if(ptr != NULL)

+    {

+        farfree(ptr);

+    }

 }

 

 #else /* Not the Borland DOS special memory handler */

@@ -348,7 +348,7 @@ png_voidp /* PRIVATE */
 png_create_struct(int type)

 {

 #ifdef PNG_USER_MEM_SUPPORTED

-   return (png_create_struct_2(type, NULL, NULL));

+    return (png_create_struct_2(type, NULL, NULL));

 }

 

 /* Allocate memory for a png_struct or a png_info.  The malloc and

@@ -358,42 +358,42 @@ png_voidp /* PRIVATE */
 png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)

 {

 #endif /* PNG_USER_MEM_SUPPORTED */

-   png_size_t size;

-   png_voidp struct_ptr;

+    png_size_t size;

+    png_voidp struct_ptr;

 

-   if (type == PNG_STRUCT_INFO)

-      size = png_sizeof(png_info);

-   else if (type == PNG_STRUCT_PNG)

-      size = png_sizeof(png_struct);

-   else

-      return (NULL);

+    if(type == PNG_STRUCT_INFO)

+        size = png_sizeof(png_info);

+    else if(type == PNG_STRUCT_PNG)

+        size = png_sizeof(png_struct);

+    else

+        return (NULL);

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   if (malloc_fn != NULL)

-   {

-      png_struct dummy_struct;

-      png_structp png_ptr = &dummy_struct;

-      png_ptr->mem_ptr=mem_ptr;

-      struct_ptr = (*(malloc_fn))(png_ptr, size);

-      if (struct_ptr != NULL)

-         png_memset(struct_ptr, 0, size);

-      return (struct_ptr);

-   }

+    if(malloc_fn != NULL)

+    {

+        png_struct dummy_struct;

+        png_structp png_ptr = &dummy_struct;

+        png_ptr->mem_ptr = mem_ptr;

+        struct_ptr = (*(malloc_fn))(png_ptr, size);

+        if(struct_ptr != NULL)

+            png_memset(struct_ptr, 0, size);

+        return (struct_ptr);

+    }

 #endif /* PNG_USER_MEM_SUPPORTED */

 

 #if defined(__TURBOC__) && !defined(__FLAT__)

-   struct_ptr = (png_voidp)farmalloc(size);

+    struct_ptr = (png_voidp)farmalloc(size);

 #else

 # if defined(_MSC_VER) && defined(MAXSEG_64K)

-   struct_ptr = (png_voidp)halloc(size, 1);

+struct_ptr = (png_voidp)halloc(size, 1);

 # else

-   struct_ptr = (png_voidp)malloc(size);

+struct_ptr = (png_voidp)malloc(size);

 # endif

 #endif

-   if (struct_ptr != NULL)

-      png_memset(struct_ptr, 0, size);

+    if(struct_ptr != NULL)

+        png_memset(struct_ptr, 0, size);

 

-   return (struct_ptr);

+    return (struct_ptr);

 }

 

 

@@ -402,37 +402,37 @@ void /* PRIVATE */
 png_destroy_struct(png_voidp struct_ptr)

 {

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_destroy_struct_2(struct_ptr, NULL, NULL);

+    png_destroy_struct_2(struct_ptr, NULL, NULL);

 }

 

 /* Free memory allocated by a png_create_struct() call */

 void /* PRIVATE */

 png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,

-    png_voidp mem_ptr)

+                     png_voidp mem_ptr)

 {

 #endif /* PNG_USER_MEM_SUPPORTED */

-   if (struct_ptr != NULL)

-   {

+    if(struct_ptr != NULL)

+    {

 #ifdef PNG_USER_MEM_SUPPORTED

-      if (free_fn != NULL)

-      {

-         png_struct dummy_struct;

-         png_structp png_ptr = &dummy_struct;

-         png_ptr->mem_ptr=mem_ptr;

-         (*(free_fn))(png_ptr, struct_ptr);

-         return;

-      }

+        if(free_fn != NULL)

+        {

+            png_struct dummy_struct;

+            png_structp png_ptr = &dummy_struct;

+            png_ptr->mem_ptr = mem_ptr;

+            (*(free_fn))(png_ptr, struct_ptr);

+            return;

+        }

 #endif /* PNG_USER_MEM_SUPPORTED */

 #if defined(__TURBOC__) && !defined(__FLAT__)

-      farfree(struct_ptr);

+        farfree(struct_ptr);

 #else

 # if defined(_MSC_VER) && defined(MAXSEG_64K)

-      hfree(struct_ptr);

+hfree(struct_ptr);

 # else

-      free(struct_ptr);

+free(struct_ptr);

 # endif

 #endif

-   }

+    }

 }

 

 /* Allocate memory.  For reasonable files, size should never exceed

@@ -445,79 +445,79 @@ png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
 png_voidp PNGAPI

 png_calloc(png_structp png_ptr, png_alloc_size_t size)

 {

-   png_voidp ret;

+    png_voidp ret;

 

-   ret = (png_malloc(png_ptr, size));

-   if (ret != NULL)

-      png_memset(ret,0,(png_size_t)size);

-   return (ret);

+    ret = (png_malloc(png_ptr, size));

+    if(ret != NULL)

+        png_memset(ret, 0, (png_size_t)size);

+    return (ret);

 }

 

 png_voidp PNGAPI

 png_malloc(png_structp png_ptr, png_alloc_size_t size)

 {

-   png_voidp ret;

+    png_voidp ret;

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   if (png_ptr == NULL || size == 0)

-      return (NULL);

-

-   if (png_ptr->malloc_fn != NULL)

-      ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));

-   else

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

+    if(png_ptr == NULL || size == 0)

+        return (NULL);

+

+    if(png_ptr->malloc_fn != NULL)

+        ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));

+    else

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

 }

 

 png_voidp PNGAPI

 png_malloc_default(png_structp png_ptr, png_alloc_size_t size)

 {

-   png_voidp ret;

+    png_voidp ret;

 #endif /* PNG_USER_MEM_SUPPORTED */

 

-   if (png_ptr == NULL || size == 0)

-      return (NULL);

+    if(png_ptr == NULL || size == 0)

+        return (NULL);

 

 #ifdef PNG_MAX_MALLOC_64K

-   if (size > (png_uint_32)65536L)

-   {

+    if(size > (png_uint_32)65536L)

+    {

 #ifndef PNG_USER_MEM_SUPPORTED

-      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-         png_error(png_ptr, "Cannot Allocate > 64K");

-      else

+        if((png_ptr->flags & PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+            png_error(png_ptr, "Cannot Allocate > 64K");

+        else

 #endif

-         return NULL;

-   }

+            return NULL;

+    }

 #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

 

 #ifndef PNG_USER_MEM_SUPPORTED

-   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

-      png_error(png_ptr, "Out of Memory");

+    if(ret == NULL && (png_ptr->flags & PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+        png_error(png_ptr, "Out of Memory");

 #endif

 

-   return (ret);

+    return (ret);

 }

 

 /* Free a pointer allocated by png_malloc().  If ptr is NULL, return

@@ -526,33 +526,33 @@ png_malloc_default(png_structp png_ptr, png_alloc_size_t size)
 void PNGAPI

 png_free(png_structp png_ptr, png_voidp ptr)

 {

-   if (png_ptr == NULL || ptr == NULL)

-      return;

+    if(png_ptr == NULL || ptr == NULL)

+        return;

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   if (png_ptr->free_fn != NULL)

-   {

-      (*(png_ptr->free_fn))(png_ptr, ptr);

-      return;

-   }

-   else

-      png_free_default(png_ptr, ptr);

+    if(png_ptr->free_fn != NULL)

+    {

+        (*(png_ptr->free_fn))(png_ptr, ptr);

+        return;

+    }

+    else

+        png_free_default(png_ptr, ptr);

 }

 void PNGAPI

 png_free_default(png_structp png_ptr, png_voidp ptr)

 {

-   if (png_ptr == NULL || ptr == NULL)

-      return;

+    if(png_ptr == NULL || ptr == NULL)

+        return;

 

 #endif /* PNG_USER_MEM_SUPPORTED */

 

 #if defined(__TURBOC__) && !defined(__FLAT__)

-   farfree(ptr);

+    farfree(ptr);

 #else

 # if defined(_MSC_VER) && defined(MAXSEG_64K)

-   hfree(ptr);

+hfree(ptr);

 # else

-   free(ptr);

+free(ptr);

 # endif

 #endif

 }

@@ -567,16 +567,16 @@ png_free_default(png_structp png_ptr, png_voidp ptr)
 png_voidp PNGAPI

 png_malloc_warn(png_structp png_ptr, png_alloc_size_t size)

 {

-   png_voidp ptr;

-   png_uint_32 save_flags;

-   if (png_ptr == NULL)

-      return (NULL);

-

-   save_flags = png_ptr->flags;

-   png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;

-   ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);

-   png_ptr->flags=save_flags;

-   return(ptr);

+    png_voidp ptr;

+    png_uint_32 save_flags;

+    if(png_ptr == NULL)

+        return (NULL);

+

+    save_flags = png_ptr->flags;

+    png_ptr->flags |= PNG_FLAG_MALLOC_NULL_MEM_OK;

+    ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);

+    png_ptr->flags = save_flags;

+    return(ptr);

 }

 

 

@@ -586,14 +586,14 @@ png_malloc_warn(png_structp png_ptr, png_alloc_size_t size)
  */

 void PNGAPI

 png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr

-  malloc_fn, png_free_ptr free_fn)

+               malloc_fn, png_free_ptr free_fn)

 {

-   if (png_ptr != NULL)

-   {

-      png_ptr->mem_ptr = mem_ptr;

-      png_ptr->malloc_fn = malloc_fn;

-      png_ptr->free_fn = free_fn;

-   }

+    if(png_ptr != NULL)

+    {

+        png_ptr->mem_ptr = mem_ptr;

+        png_ptr->malloc_fn = malloc_fn;

+        png_ptr->free_fn = free_fn;

+    }

 }

 

 /* This function returns a pointer to the mem_ptr associated with the user

@@ -603,9 +603,9 @@ png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
 png_voidp PNGAPI

 png_get_mem_ptr(png_structp png_ptr)

 {

-   if (png_ptr == NULL)

-      return (NULL);

-   return ((png_voidp)png_ptr->mem_ptr);

+    if(png_ptr == NULL)

+        return (NULL);

+    return ((png_voidp)png_ptr->mem_ptr);

 }

 #endif /* PNG_USER_MEM_SUPPORTED */

 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

diff --git a/src/libpng/pngpread.c b/src/libpng/pngpread.c
index 6a8ad93d9..97b222dcd 100644
--- a/src/libpng/pngpread.c
+++ b/src/libpng/pngpread.c
@@ -29,17 +29,17 @@
 

 void PNGAPI

 png_process_data(png_structp png_ptr, png_infop info_ptr,

-   png_bytep buffer, png_size_t buffer_size)

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

+    png_push_restore_buffer(png_ptr, buffer, buffer_size);

 

-   while (png_ptr->buffer_size)

-   {

-      png_process_some_data(png_ptr, info_ptr);

-   }

+    while(png_ptr->buffer_size)

+    {

+        png_process_some_data(png_ptr, info_ptr);

+    }

 }

 

 /* What we do with the incoming data depends on what we were previously

@@ -48,65 +48,65 @@ png_process_data(png_structp png_ptr, png_infop info_ptr,
 void /* PRIVATE */

 png_process_some_data(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr == NULL)

-      return;

-

-   switch (png_ptr->process_mode)

-   {

-      case PNG_READ_SIG_MODE:

-      {

-         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(png_ptr == NULL)

+        return;

+

+    switch(png_ptr->process_mode)

+    {

+    case PNG_READ_SIG_MODE:

+    {

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

+    }

 

 #ifdef PNG_READ_tEXt_SUPPORTED

-      case PNG_READ_tEXt_MODE:

-      {

-         png_push_read_tEXt(png_ptr, info_ptr);

-         break;

-      }

+    case PNG_READ_tEXt_MODE:

+    {

+        png_push_read_tEXt(png_ptr, info_ptr);

+        break;

+    }

 

 #endif

 #ifdef PNG_READ_zTXt_SUPPORTED

-      case PNG_READ_zTXt_MODE:

-      {

-         png_push_read_zTXt(png_ptr, info_ptr);

-         break;

-      }

+    case PNG_READ_zTXt_MODE:

+    {

+        png_push_read_zTXt(png_ptr, info_ptr);

+        break;

+    }

 

 #endif

 #ifdef PNG_READ_iTXt_SUPPORTED

-      case PNG_READ_iTXt_MODE:

-      {

-         png_push_read_iTXt(png_ptr, info_ptr);

-         break;

-      }

+    case PNG_READ_iTXt_MODE:

+    {

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

-         break;

-      }

-   }

+    case PNG_SKIP_MODE:

+    {

+        png_push_crc_finish(png_ptr);

+        break;

+    }

+

+    default:

+    {

+        png_ptr->buffer_size = 0;

+        break;

+    }

+    }

 }

 

 /* Read any remaining signature bytes from the stream and compare them with

@@ -118,1461 +118,1462 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr)
 void /* PRIVATE */

 png_push_read_sig(png_structp png_ptr, png_infop info_ptr)

 {

-   png_size_t num_checked = png_ptr->sig_bytes,

-             num_to_check = 8 - num_checked;

-

-   if (png_ptr->buffer_size < num_to_check)

-   {

-      num_to_check = png_ptr->buffer_size;

-   }

-

-   png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),

-      num_to_check);

-   png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);

-

-   if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))

-   {

-      if (num_checked < 4 &&

-          png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))

-         png_error(png_ptr, "Not a PNG file");

-      else

-         png_error(png_ptr, "PNG file corrupted by ASCII conversion");

-   }

-   else

-   {

-      if (png_ptr->sig_bytes >= 8)

-      {

-         png_ptr->process_mode = PNG_READ_CHUNK_MODE;

-      }

-   }

+    png_size_t num_checked = png_ptr->sig_bytes,

+               num_to_check = 8 - num_checked;

+

+    if(png_ptr->buffer_size < num_to_check)

+    {

+        num_to_check = png_ptr->buffer_size;

+    }

+

+    png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),

+                         num_to_check);

+    png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);

+

+    if(png_sig_cmp(info_ptr->signature, num_checked, num_to_check))

+    {

+        if(num_checked < 4 &&

+           png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))

+            png_error(png_ptr, "Not a PNG file");

+        else

+            png_error(png_ptr, "PNG file corrupted by ASCII conversion");

+    }

+    else

+    {

+        if(png_ptr->sig_bytes >= 8)

+        {

+            png_ptr->process_mode = PNG_READ_CHUNK_MODE;

+        }

+    }

 }

 

 void /* PRIVATE */

 png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)

 {

-      PNG_IHDR;

-      PNG_IDAT;

-      PNG_IEND;

-      PNG_PLTE;

+    PNG_IHDR;

+    PNG_IDAT;

+    PNG_IEND;

+    PNG_PLTE;

 #ifdef PNG_READ_bKGD_SUPPORTED

-      PNG_bKGD;

+    PNG_bKGD;

 #endif

 #ifdef PNG_READ_cHRM_SUPPORTED

-      PNG_cHRM;

+    PNG_cHRM;

 #endif

 #ifdef PNG_READ_gAMA_SUPPORTED

-      PNG_gAMA;

+    PNG_gAMA;

 #endif

 #ifdef PNG_READ_hIST_SUPPORTED

-      PNG_hIST;

+    PNG_hIST;

 #endif

 #ifdef PNG_READ_iCCP_SUPPORTED

-      PNG_iCCP;

+    PNG_iCCP;

 #endif

 #ifdef PNG_READ_iTXt_SUPPORTED

-      PNG_iTXt;

+    PNG_iTXt;

 #endif

 #ifdef PNG_READ_oFFs_SUPPORTED

-      PNG_oFFs;

+    PNG_oFFs;

 #endif

 #ifdef PNG_READ_pCAL_SUPPORTED

-      PNG_pCAL;

+    PNG_pCAL;

 #endif

 #ifdef PNG_READ_pHYs_SUPPORTED

-      PNG_pHYs;

+    PNG_pHYs;

 #endif

 #ifdef PNG_READ_sBIT_SUPPORTED

-      PNG_sBIT;

+    PNG_sBIT;

 #endif

 #ifdef PNG_READ_sCAL_SUPPORTED

-      PNG_sCAL;

+    PNG_sCAL;

 #endif

 #ifdef PNG_READ_sRGB_SUPPORTED

-      PNG_sRGB;

+    PNG_sRGB;

 #endif

 #ifdef PNG_READ_sPLT_SUPPORTED

-      PNG_sPLT;

+    PNG_sPLT;

 #endif

 #ifdef PNG_READ_tEXt_SUPPORTED

-      PNG_tEXt;

+    PNG_tEXt;

 #endif

 #ifdef PNG_READ_tIME_SUPPORTED

-      PNG_tIME;

+    PNG_tIME;

 #endif

 #ifdef PNG_READ_tRNS_SUPPORTED

-      PNG_tRNS;

+    PNG_tRNS;

 #endif

 #ifdef PNG_READ_zTXt_SUPPORTED

-      PNG_zTXt;

+    PNG_zTXt;

 #endif

 

-   /* First we make sure we have enough data for the 4 byte chunk name

-    * and the 4 byte chunk length before proceeding with decoding the

-    * chunk data.  To fully decode each of these chunks, we also make

-    * sure we have enough data in the buffer for the 4 byte CRC at the

-    * end of every chunk (except IDAT, which is handled separately).

-    */

-   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))

-   {

-      png_byte chunk_length[4];

-

-      if (png_ptr->buffer_size < 8)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_fill_buffer(png_ptr, chunk_length, 4);

-      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);

-      png_reset_crc(png_ptr);

-      png_crc_read(png_ptr, png_ptr->chunk_name, 4);

-      png_check_chunk_name(png_ptr, png_ptr->chunk_name);

-      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;

-   }

-

-   if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-     if (png_ptr->mode & PNG_AFTER_IDAT)

-        png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;

-

-   if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))

-   {

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

-      {

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

-   }

+    /* First we make sure we have enough data for the 4 byte chunk name

+     * and the 4 byte chunk length before proceeding with decoding the

+     * chunk data.  To fully decode each of these chunks, we also make

+     * sure we have enough data in the buffer for the 4 byte CRC at the

+     * end of every chunk (except IDAT, which is handled separately).

+     */

+    if(!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))

+    {

+        png_byte chunk_length[4];

+

+        if(png_ptr->buffer_size < 8)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

+

+        png_push_fill_buffer(png_ptr, chunk_length, 4);

+        png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);

+        png_reset_crc(png_ptr);

+        png_crc_read(png_ptr, png_ptr->chunk_name, 4);

+        png_check_chunk_name(png_ptr, png_ptr->chunk_name);

+        png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;

+    }

+

+    if(!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+        if(png_ptr->mode & PNG_AFTER_IDAT)

+            png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;

+

+    if(!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))

+    {

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

+        {

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

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-         png_ptr->mode |= PNG_HAVE_IDAT;

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

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

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

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

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

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

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

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

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

-      {

-         if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))

-            if (png_ptr->push_length == 0)

-               return;

-

-         if (png_ptr->mode & PNG_AFTER_IDAT)

-            png_benign_error(png_ptr, "Too many IDATs found");

-      }

-

-      png_ptr->idat_size = png_ptr->push_length;

-      png_ptr->mode |= PNG_HAVE_IDAT;

-      png_ptr->process_mode = PNG_READ_IDAT_MODE;

-      png_push_have_info(png_ptr, info_ptr);

-      png_ptr->zstream.avail_out =

-          (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,

-          png_ptr->iwidth) + 1;

-      png_ptr->zstream.next_out = png_ptr->row_buf;

-      return;

-   }

+        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->mode & PNG_AFTER_IDAT)

+                png_benign_error(png_ptr, "Too many IDATs found");

+        }

+

+        png_ptr->idat_size = png_ptr->push_length;

+        png_ptr->mode |= PNG_HAVE_IDAT;

+        png_ptr->process_mode = PNG_READ_IDAT_MODE;

+        png_push_have_info(png_ptr, info_ptr);

+        png_ptr->zstream.avail_out =

+            (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,

+                                png_ptr->iwidth) + 1;

+        png_ptr->zstream.next_out = png_ptr->row_buf;

+        return;

+    }

 

 #ifdef PNG_READ_gAMA_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_sBIT_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_cHRM_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_sRGB_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_iCCP_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_sPLT_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_tRNS_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_bKGD_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_hIST_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_hIST, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_pHYs_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_oFFs_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);

-   }

+    else if(!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

+

+        png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);

+    }

 #endif

 

 #ifdef PNG_READ_pCAL_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_sCAL_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_tIME_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_tIME, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_tEXt_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_zTXt_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

 #ifdef PNG_READ_iTXt_SUPPORTED

-   else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

+    else if(!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

 

-      png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);

-   }

+        png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);

+    }

 

 #endif

-   else

-   {

-      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-      png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);

-   }

-

-   png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;

+    else

+    {

+        if(png_ptr->push_length + 4 > png_ptr->buffer_size)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

+        png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);

+    }

+

+    png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;

 }

 

 void /* PRIVATE */

 png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)

 {

-   png_ptr->process_mode = PNG_SKIP_MODE;

-   png_ptr->skip_length = skip;

+    png_ptr->process_mode = PNG_SKIP_MODE;

+    png_ptr->skip_length = skip;

 }

 

 void /* PRIVATE */

 png_push_crc_finish(png_structp png_ptr)

 {

-   if (png_ptr->skip_length && png_ptr->save_buffer_size)

-   {

-      png_size_t save_size;

-

-      if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)

-         save_size = (png_size_t)png_ptr->skip_length;

-      else

-         save_size = png_ptr->save_buffer_size;

-

-      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);

-

-      png_ptr->skip_length -= save_size;

-      png_ptr->buffer_size -= save_size;

-      png_ptr->save_buffer_size -= save_size;

-      png_ptr->save_buffer_ptr += save_size;

-   }

-   if (png_ptr->skip_length && png_ptr->current_buffer_size)

-   {

-      png_size_t save_size;

-

-      if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)

-         save_size = (png_size_t)png_ptr->skip_length;

-      else

-         save_size = png_ptr->current_buffer_size;

-

-      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);

-

-      png_ptr->skip_length -= save_size;

-      png_ptr->buffer_size -= save_size;

-      png_ptr->current_buffer_size -= save_size;

-      png_ptr->current_buffer_ptr += save_size;

-   }

-   if (!png_ptr->skip_length)

-   {

-      if (png_ptr->buffer_size < 4)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_crc_finish(png_ptr, 0);

-      png_ptr->process_mode = PNG_READ_CHUNK_MODE;

-   }

+    if(png_ptr->skip_length && png_ptr->save_buffer_size)

+    {

+        png_size_t save_size;

+

+        if(png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)

+            save_size = (png_size_t)png_ptr->skip_length;

+        else

+            save_size = png_ptr->save_buffer_size;

+

+        png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);

+

+        png_ptr->skip_length -= save_size;

+        png_ptr->buffer_size -= save_size;

+        png_ptr->save_buffer_size -= save_size;

+        png_ptr->save_buffer_ptr += save_size;

+    }

+    if(png_ptr->skip_length && png_ptr->current_buffer_size)

+    {

+        png_size_t save_size;

+

+        if(png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)

+            save_size = (png_size_t)png_ptr->skip_length;

+        else

+            save_size = png_ptr->current_buffer_size;

+

+        png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);

+

+        png_ptr->skip_length -= save_size;

+        png_ptr->buffer_size -= save_size;

+        png_ptr->current_buffer_size -= save_size;

+        png_ptr->current_buffer_ptr += save_size;

+    }

+    if(!png_ptr->skip_length)

+    {

+        if(png_ptr->buffer_size < 4)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

+

+        png_crc_finish(png_ptr, 0);

+        png_ptr->process_mode = PNG_READ_CHUNK_MODE;

+    }

 }

 

 void PNGAPI

 png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)

 {

-   png_bytep ptr;

-

-   if (png_ptr == NULL)

-      return;

-

-   ptr = buffer;

-   if (png_ptr->save_buffer_size)

-   {

-      png_size_t save_size;

-

-      if (length < png_ptr->save_buffer_size)

-         save_size = length;

-      else

-         save_size = png_ptr->save_buffer_size;

-

-      png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);

-      length -= save_size;

-      ptr += save_size;

-      png_ptr->buffer_size -= save_size;

-      png_ptr->save_buffer_size -= save_size;

-      png_ptr->save_buffer_ptr += save_size;

-   }

-   if (length && png_ptr->current_buffer_size)

-   {

-      png_size_t save_size;

-

-      if (length < png_ptr->current_buffer_size)

-         save_size = length;

-

-      else

-         save_size = png_ptr->current_buffer_size;

-

-      png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);

-      png_ptr->buffer_size -= save_size;

-      png_ptr->current_buffer_size -= save_size;

-      png_ptr->current_buffer_ptr += save_size;

-   }

+    png_bytep ptr;

+

+    if(png_ptr == NULL)

+        return;

+

+    ptr = buffer;

+    if(png_ptr->save_buffer_size)

+    {

+        png_size_t save_size;

+

+        if(length < png_ptr->save_buffer_size)

+            save_size = length;

+        else

+            save_size = png_ptr->save_buffer_size;

+

+        png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);

+        length -= save_size;

+        ptr += save_size;

+        png_ptr->buffer_size -= save_size;

+        png_ptr->save_buffer_size -= save_size;

+        png_ptr->save_buffer_ptr += save_size;

+    }

+    if(length && png_ptr->current_buffer_size)

+    {

+        png_size_t save_size;

+

+        if(length < png_ptr->current_buffer_size)

+            save_size = length;

+

+        else

+            save_size = png_ptr->current_buffer_size;

+

+        png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);

+        png_ptr->buffer_size -= save_size;

+        png_ptr->current_buffer_size -= save_size;

+        png_ptr->current_buffer_ptr += save_size;

+    }

 }

 

 void /* PRIVATE */

 png_push_save_buffer(png_structp png_ptr)

 {

-   if (png_ptr->save_buffer_size)

-   {

-      if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)

-      {

-         png_size_t i, istop;

-         png_bytep sp;

-         png_bytep dp;

-

-         istop = png_ptr->save_buffer_size;

-         for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;

-            i < istop; i++, sp++, dp++)

-         {

-            *dp = *sp;

-         }

-      }

-   }

-   if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >

-      png_ptr->save_buffer_max)

-   {

-      png_size_t new_max;

-      png_bytep old_buffer;

-

-      if (png_ptr->save_buffer_size > PNG_SIZE_MAX -

-         (png_ptr->current_buffer_size + 256))

-      {

-        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_warn(png_ptr,

-         (png_size_t)new_max);

-      if (png_ptr->save_buffer == NULL)

-      {

+    if(png_ptr->save_buffer_size)

+    {

+        if(png_ptr->save_buffer_ptr != png_ptr->save_buffer)

+        {

+            png_size_t i, istop;

+            png_bytep sp;

+            png_bytep dp;

+

+            istop = png_ptr->save_buffer_size;

+            for(i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;

+                i < istop; i++, sp++, dp++)

+            {

+                *dp = *sp;

+            }

+        }

+    }

+    if(png_ptr->save_buffer_size + png_ptr->current_buffer_size >

+       png_ptr->save_buffer_max)

+    {

+        png_size_t new_max;

+        png_bytep old_buffer;

+

+        if(png_ptr->save_buffer_size > PNG_SIZE_MAX -

+           (png_ptr->current_buffer_size + 256))

+        {

+            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_warn(png_ptr,

+                               (png_size_t)new_max);

+        if(png_ptr->save_buffer == NULL)

+        {

+            png_free(png_ptr, old_buffer);

+            png_error(png_ptr, "Insufficient memory for save_buffer");

+        }

+        png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);

         png_free(png_ptr, old_buffer);

-        png_error(png_ptr, "Insufficient memory for save_buffer");

-      }

-      png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);

-      png_free(png_ptr, old_buffer);

-      png_ptr->save_buffer_max = new_max;

-   }

-   if (png_ptr->current_buffer_size)

-   {

-      png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,

-         png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);

-      png_ptr->save_buffer_size += png_ptr->current_buffer_size;

-      png_ptr->current_buffer_size = 0;

-   }

-   png_ptr->save_buffer_ptr = png_ptr->save_buffer;

-   png_ptr->buffer_size = 0;

+        png_ptr->save_buffer_max = new_max;

+    }

+    if(png_ptr->current_buffer_size)

+    {

+        png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,

+                   png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);

+        png_ptr->save_buffer_size += png_ptr->current_buffer_size;

+        png_ptr->current_buffer_size = 0;

+    }

+    png_ptr->save_buffer_ptr = png_ptr->save_buffer;

+    png_ptr->buffer_size = 0;

 }

 

 void /* PRIVATE */

 png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,

-   png_size_t buffer_length)

+                        png_size_t buffer_length)

 {

-   png_ptr->current_buffer = buffer;

-   png_ptr->current_buffer_size = buffer_length;

-   png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;

-   png_ptr->current_buffer_ptr = png_ptr->current_buffer;

+    png_ptr->current_buffer = buffer;

+    png_ptr->current_buffer_size = buffer_length;

+    png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;

+    png_ptr->current_buffer_ptr = png_ptr->current_buffer;

 }

 

 void /* PRIVATE */

 png_push_read_IDAT(png_structp png_ptr)

 {

-   PNG_IDAT;

-   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))

-   {

-      png_byte chunk_length[4];

-

-      if (png_ptr->buffer_size < 8)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_fill_buffer(png_ptr, chunk_length, 4);

-      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);

-      png_reset_crc(png_ptr);

-      png_crc_read(png_ptr, png_ptr->chunk_name, 4);

-      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;

-

-      if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-      {

-         png_ptr->process_mode = PNG_READ_CHUNK_MODE;

-         if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

-            png_error(png_ptr, "Not enough compressed data");

-         return;

-      }

-

-      png_ptr->idat_size = png_ptr->push_length;

-   }

-   if (png_ptr->idat_size && png_ptr->save_buffer_size)

-   {

-      png_size_t save_size;

-

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

-      }

-      else

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

-      png_ptr->save_buffer_ptr += save_size;

-   }

-   if (png_ptr->idat_size && png_ptr->current_buffer_size)

-   {

-      png_size_t save_size;

-

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

-      }

-      else

-         save_size = png_ptr->current_buffer_size;

-

-      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);

-      if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

-         png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);

-

-      png_ptr->idat_size -= save_size;

-      png_ptr->buffer_size -= save_size;

-      png_ptr->current_buffer_size -= save_size;

-      png_ptr->current_buffer_ptr += save_size;

-   }

-   if (!png_ptr->idat_size)

-   {

-      if (png_ptr->buffer_size < 4)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_crc_finish(png_ptr, 0);

-      png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;

-      png_ptr->mode |= PNG_AFTER_IDAT;

-   }

+    PNG_IDAT;

+    if(!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))

+    {

+        png_byte chunk_length[4];

+

+        if(png_ptr->buffer_size < 8)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

+

+        png_push_fill_buffer(png_ptr, chunk_length, 4);

+        png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);

+        png_reset_crc(png_ptr);

+        png_crc_read(png_ptr, png_ptr->chunk_name, 4);

+        png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;

+

+        if(png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+        {

+            png_ptr->process_mode = PNG_READ_CHUNK_MODE;

+            if(!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

+                png_error(png_ptr, "Not enough compressed data");

+            return;

+        }

+

+        png_ptr->idat_size = png_ptr->push_length;

+    }

+    if(png_ptr->idat_size && png_ptr->save_buffer_size)

+    {

+        png_size_t save_size;

+

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

+        }

+        else

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

+        png_ptr->save_buffer_ptr += save_size;

+    }

+    if(png_ptr->idat_size && png_ptr->current_buffer_size)

+    {

+        png_size_t save_size;

+

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

+        }

+        else

+            save_size = png_ptr->current_buffer_size;

+

+        png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);

+        if(!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

+            png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);

+

+        png_ptr->idat_size -= save_size;

+        png_ptr->buffer_size -= save_size;

+        png_ptr->current_buffer_size -= save_size;

+        png_ptr->current_buffer_ptr += save_size;

+    }

+    if(!png_ptr->idat_size)

+    {

+        if(png_ptr->buffer_size < 4)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

+

+        png_crc_finish(png_ptr, 0);

+        png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;

+        png_ptr->mode |= PNG_AFTER_IDAT;

+    }

 }

 

 void /* PRIVATE */

 png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,

-   png_size_t buffer_length)

+                      png_size_t buffer_length)

 {

-   int ret;

-

-   if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length)

-      png_benign_error(png_ptr, "Extra compression data");

-

-   png_ptr->zstream.next_in = buffer;

-   png_ptr->zstream.avail_in = (uInt)buffer_length;

-   for (;;)

-   {

-      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

-      if (ret != Z_OK)

-      {

-         if (ret == Z_STREAM_END)

-         {

-            if (png_ptr->zstream.avail_in)

-               png_benign_error(png_ptr, "Extra compressed data");

-

-            if (!(png_ptr->zstream.avail_out))

+    int ret;

+

+    if((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length)

+        png_benign_error(png_ptr, "Extra compression data");

+

+    png_ptr->zstream.next_in = buffer;

+    png_ptr->zstream.avail_in = (uInt)buffer_length;

+    for(;;)

+    {

+        ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

+        if(ret != Z_OK)

+        {

+            if(ret == Z_STREAM_END)

             {

-               png_push_process_row(png_ptr);

-            }

+                if(png_ptr->zstream.avail_in)

+                    png_benign_error(png_ptr, "Extra compressed data");

 

-            png_ptr->mode |= PNG_AFTER_IDAT;

-            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

-            break;

-         }

-         else if (ret == Z_BUF_ERROR)

-            break;

+                if(!(png_ptr->zstream.avail_out))

+                {

+                    png_push_process_row(png_ptr);

+                }

+

+                png_ptr->mode |= PNG_AFTER_IDAT;

+                png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

+                break;

+            }

+            else if(ret == Z_BUF_ERROR)

+                break;

 

-         else

-            png_error(png_ptr, "Decompression Error");

-      }

-      if (!(png_ptr->zstream.avail_out))

-      {

-         if ((

+            else

+                png_error(png_ptr, "Decompression Error");

+        }

+        if(!(png_ptr->zstream.avail_out))

+        {

+            if((

 #ifdef PNG_READ_INTERLACING_SUPPORTED

-             png_ptr->interlaced && png_ptr->pass > 6) ||

-             (!png_ptr->interlaced &&

+                   png_ptr->interlaced && png_ptr->pass > 6) ||

+               (!png_ptr->interlaced &&

 #endif

-             png_ptr->row_number == png_ptr->num_rows))

-         {

-           if (png_ptr->zstream.avail_in)

-             png_warning(png_ptr, "Too much data in IDAT chunks");

-           png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

-           break;

-         }

-         png_push_process_row(png_ptr);

-         png_ptr->zstream.avail_out =

-             (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,

-             png_ptr->iwidth) + 1;

-         png_ptr->zstream.next_out = png_ptr->row_buf;

-      }

-

-      else

-         break;

-   }

+                png_ptr->row_number == png_ptr->num_rows))

+            {

+                if(png_ptr->zstream.avail_in)

+                    png_warning(png_ptr, "Too much data in IDAT chunks");

+                png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

+                break;

+            }

+            png_push_process_row(png_ptr);

+            png_ptr->zstream.avail_out =

+                (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,

+                                    png_ptr->iwidth) + 1;

+            png_ptr->zstream.next_out = png_ptr->row_buf;

+        }

+

+        else

+            break;

+    }

 }

 

 void /* PRIVATE */

 png_push_process_row(png_structp png_ptr)

 {

-   png_ptr->row_info.color_type = png_ptr->color_type;

-   png_ptr->row_info.width = png_ptr->iwidth;

-   png_ptr->row_info.channels = png_ptr->channels;

-   png_ptr->row_info.bit_depth = png_ptr->bit_depth;

-   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;

+    png_ptr->row_info.color_type = png_ptr->color_type;

+    png_ptr->row_info.width = png_ptr->iwidth;

+    png_ptr->row_info.channels = png_ptr->channels;

+    png_ptr->row_info.bit_depth = png_ptr->bit_depth;

+    png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;

 

-   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

-       png_ptr->row_info.width);

+    png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

+                                 png_ptr->row_info.width);

 

-   png_read_filter_row(png_ptr, &(png_ptr->row_info),

-      png_ptr->row_buf + 1, png_ptr->prev_row + 1,

-      (int)(png_ptr->row_buf[0]));

+    png_read_filter_row(png_ptr, &(png_ptr->row_info),

+                        png_ptr->row_buf + 1, png_ptr->prev_row + 1,

+                        (int)(png_ptr->row_buf[0]));

 

-   png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);

+    png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);

 

-   if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))

-      png_do_read_transformations(png_ptr);

+    if(png_ptr->transformations || (png_ptr->flags & PNG_FLAG_STRIP_ALPHA))

+        png_do_read_transformations(png_ptr);

 

 #ifdef PNG_READ_INTERLACING_SUPPORTED

-   /* Blow up interlaced rows to full size */

-   if (png_ptr->interlaced && (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);

- */

-         png_do_read_interlace(png_ptr);

-

-    switch (png_ptr->pass)

+    /* Blow up interlaced rows to full size */

+    if(png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

     {

-         case 0:

-         {

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

+             */

+            png_do_read_interlace(png_ptr);

+

+        switch(png_ptr->pass)

+        {

+        case 0:

+        {

             int i;

-            for (i = 0; i < 8 && png_ptr->pass == 0; i++)

+            for(i = 0; i < 8 && png_ptr->pass == 0; i++)

             {

-               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-               png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */

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

+            if(png_ptr->pass == 2)  /* Pass 1 might be empty */

             {

-               for (i = 0; i < 4 && png_ptr->pass == 2; i++)

-               {

-                  png_push_have_row(png_ptr, NULL);

-                  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 && png_ptr->height <= 4)

+            if(png_ptr->pass == 4 && png_ptr->height <= 4)

             {

-               for (i = 0; i < 2 && png_ptr->pass == 4; i++)

-               {

-                  png_push_have_row(png_ptr, NULL);

-                  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 && png_ptr->height <= 4)

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

-         {

+        case 1:

+        {

             int i;

-            for (i = 0; i < 8 && png_ptr->pass == 1; i++)

+            for(i = 0; i < 8 && png_ptr->pass == 1; i++)

             {

-               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-               png_read_push_finish_row(png_ptr);

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

+            if(png_ptr->pass == 2)  /* Skip top 4 generated rows */

             {

-               for (i = 0; i < 4 && png_ptr->pass == 2; i++)

-               {

-                  png_push_have_row(png_ptr, NULL);

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

+                }

             }

 

             break;

-         }

+        }

 

-         case 2:

-         {

+        case 2:

+        {

             int i;

 

-            for (i = 0; i < 4 && png_ptr->pass == 2; 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);

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

+            for(i = 0; i < 4 && png_ptr->pass == 2; i++)

             {

-               png_push_have_row(png_ptr, NULL);

-               png_read_push_finish_row(png_ptr);

+                png_push_have_row(png_ptr, NULL);

+                png_read_push_finish_row(png_ptr);

             }

 

-            if (png_ptr->pass == 4) /* Pass 3 might be empty */

+            if(png_ptr->pass == 4)  /* Pass 3 might be empty */

             {

-               for (i = 0; i < 2 && png_ptr->pass == 4; i++)

-               {

-                  png_push_have_row(png_ptr, NULL);

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

+                }

             }

 

             break;

-         }

+        }

 

-         case 3:

-         {

+        case 3:

+        {

             int i;

 

-            for (i = 0; i < 4 && png_ptr->pass == 3; 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);

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

+            if(png_ptr->pass == 4)  /* Skip top two generated rows */

             {

-               for (i = 0; i < 2 && png_ptr->pass == 4; i++)

-               {

-                  png_push_have_row(png_ptr, NULL);

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

+                }

             }

 

             break;

-         }

+        }

 

-         case 4:

-         {

+        case 4:

+        {

             int i;

 

-            for (i = 0; i < 2 && png_ptr->pass == 4; 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);

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

+            for(i = 0; i < 2 && png_ptr->pass == 4; i++)

             {

-               png_push_have_row(png_ptr, NULL);

-               png_read_push_finish_row(png_ptr);

+                png_push_have_row(png_ptr, NULL);

+                png_read_push_finish_row(png_ptr);

             }

 

-            if (png_ptr->pass == 6) /* Pass 5 might be empty */

+            if(png_ptr->pass == 6)  /* Pass 5 might be empty */

             {

-               png_push_have_row(png_ptr, NULL);

-               png_read_push_finish_row(png_ptr);

+                png_push_have_row(png_ptr, NULL);

+                png_read_push_finish_row(png_ptr);

             }

 

             break;

-         }

+        }

 

-         case 5:

-         {

+        case 5:

+        {

             int i;

 

-            for (i = 0; i < 2 && png_ptr->pass == 5; 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);

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

+            if(png_ptr->pass == 6)  /* Skip top generated row */

             {

-               png_push_have_row(png_ptr, NULL);

-               png_read_push_finish_row(png_ptr);

+                png_push_have_row(png_ptr, NULL);

+                png_read_push_finish_row(png_ptr);

             }

 

             break;

-         }

-         case 6:

-         {

+        }

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

+            if(png_ptr->pass != 6)

+                break;

 

             png_push_have_row(png_ptr, NULL);

             png_read_push_finish_row(png_ptr);

-         }

-      }

-   }

-   else

+        }

+        }

+    }

+    else

 #endif

-   {

-      png_push_have_row(png_ptr, png_ptr->row_buf + 1);

-      png_read_push_finish_row(png_ptr);

-   }

+    {

+        png_push_have_row(png_ptr, png_ptr->row_buf + 1);

+        png_read_push_finish_row(png_ptr);

+    }

 }

 

 void /* PRIVATE */

 png_read_push_finish_row(png_structp png_ptr)

 {

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

-   PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};

+    /* Start of interlace block */

+    PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};

 

-   /* Offset to next interlace block */

-   PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};

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

-   PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};

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

-   PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};

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

-    * it, uncomment it here and in png.h

-   PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};

-   */

+    /* Height of interlace block.  This is not currently used - if you need

+     * it, uncomment it here and in png.h

+    PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};

+    */

 

-   png_ptr->row_number++;

-   if (png_ptr->row_number < png_ptr->num_rows)

-      return;

+    png_ptr->row_number++;

+    if(png_ptr->row_number < png_ptr->num_rows)

+        return;

 

 #ifdef PNG_READ_INTERLACING_SUPPORTED

-   if (png_ptr->interlaced)

-   {

-      png_ptr->row_number = 0;

-      png_memset(png_ptr->prev_row, 0,

-         png_ptr->rowbytes + 1);

-      do

-      {

-         png_ptr->pass++;

-         if ((png_ptr->pass == 1 && png_ptr->width < 5) ||

-             (png_ptr->pass == 3 && png_ptr->width < 3) ||

-             (png_ptr->pass == 5 && png_ptr->width < 2))

-           png_ptr->pass++;

-

-         if (png_ptr->pass > 7)

-            png_ptr->pass--;

-

-         if (png_ptr->pass >= 7)

-            break;

-

-         png_ptr->iwidth = (png_ptr->width +

-            png_pass_inc[png_ptr->pass] - 1 -

-            png_pass_start[png_ptr->pass]) /

-            png_pass_inc[png_ptr->pass];

-

-         if (png_ptr->transformations & PNG_INTERLACE)

-            break;

-

-         png_ptr->num_rows = (png_ptr->height +

-            png_pass_yinc[png_ptr->pass] - 1 -

-            png_pass_ystart[png_ptr->pass]) /

-            png_pass_yinc[png_ptr->pass];

-

-      } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);

-   }

+    if(png_ptr->interlaced)

+    {

+        png_ptr->row_number = 0;

+        png_memset(png_ptr->prev_row, 0,

+                   png_ptr->rowbytes + 1);

+        do

+        {

+            png_ptr->pass++;

+            if((png_ptr->pass == 1 && png_ptr->width < 5) ||

+               (png_ptr->pass == 3 && png_ptr->width < 3) ||

+               (png_ptr->pass == 5 && png_ptr->width < 2))

+                png_ptr->pass++;

+

+            if(png_ptr->pass > 7)

+                png_ptr->pass--;

+

+            if(png_ptr->pass >= 7)

+                break;

+

+            png_ptr->iwidth = (png_ptr->width +

+                               png_pass_inc[png_ptr->pass] - 1 -

+                               png_pass_start[png_ptr->pass]) /

+                              png_pass_inc[png_ptr->pass];

+

+            if(png_ptr->transformations & PNG_INTERLACE)

+                break;

+

+            png_ptr->num_rows = (png_ptr->height +

+                                 png_pass_yinc[png_ptr->pass] - 1 -

+                                 png_pass_ystart[png_ptr->pass]) /

+                                png_pass_yinc[png_ptr->pass];

+

+        }

+        while(png_ptr->iwidth == 0 || png_ptr->num_rows == 0);

+    }

 #endif /* PNG_READ_INTERLACING_SUPPORTED */

 }

 

 #ifdef PNG_READ_tEXt_SUPPORTED

 void /* PRIVATE */

 png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32

-   length)

+                     length)

 {

-   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

-      {

-         png_error(png_ptr, "Out of place tEXt");

-         info_ptr = info_ptr; /* To quiet some compiler warnings */

-      }

+    if(!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

+    {

+        png_error(png_ptr, "Out of place tEXt");

+        info_ptr = info_ptr; /* To quiet some compiler warnings */

+    }

 

 #ifdef PNG_MAX_MALLOC_64K

-   png_ptr->skip_length = 0;  /* This may not be necessary */

-

-   if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */

-   {

-      png_warning(png_ptr, "tEXt chunk too large to fit in memory");

-      png_ptr->skip_length = length - (png_uint_32)65535L;

-      length = (png_uint_32)65535L;

-   }

+    png_ptr->skip_length = 0;  /* This may not be necessary */

+

+    if(length > (png_uint_32)65535L)  /* Can't hold entire string in memory */

+    {

+        png_warning(png_ptr, "tEXt chunk too large to fit in memory");

+        png_ptr->skip_length = length - (png_uint_32)65535L;

+        length = (png_uint_32)65535L;

+    }

 #endif

 

-   png_ptr->current_text = (png_charp)png_malloc(png_ptr,

-      (png_size_t)(length + 1));

-   png_ptr->current_text[length] = '\0';

-   png_ptr->current_text_ptr = png_ptr->current_text;

-   png_ptr->current_text_size = (png_size_t)length;

-   png_ptr->current_text_left = (png_size_t)length;

-   png_ptr->process_mode = PNG_READ_tEXt_MODE;

+    png_ptr->current_text = (png_charp)png_malloc(png_ptr,

+                            (png_size_t)(length + 1));

+    png_ptr->current_text[length] = '\0';

+    png_ptr->current_text_ptr = png_ptr->current_text;

+    png_ptr->current_text_size = (png_size_t)length;

+    png_ptr->current_text_left = (png_size_t)length;

+    png_ptr->process_mode = PNG_READ_tEXt_MODE;

 }

 

 void /* PRIVATE */

 png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr->buffer_size && png_ptr->current_text_left)

-   {

-      png_size_t text_size;

-

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

-   }

-   if (!(png_ptr->current_text_left))

-   {

-      png_textp text_ptr;

-      png_charp text;

-      png_charp key;

-      int ret;

-

-      if (png_ptr->buffer_size < 4)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_crc_finish(png_ptr);

+    if(png_ptr->buffer_size && png_ptr->current_text_left)

+    {

+        png_size_t text_size;

+

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

+    }

+    if(!(png_ptr->current_text_left))

+    {

+        png_textp text_ptr;

+        png_charp text;

+        png_charp key;

+        int ret;

+

+        if(png_ptr->buffer_size < 4)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

+

+        png_push_crc_finish(png_ptr);

 

 #ifdef PNG_MAX_MALLOC_64K

-      if (png_ptr->skip_length)

-         return;

+        if(png_ptr->skip_length)

+            return;

 #endif

 

-      key = png_ptr->current_text;

+        key = png_ptr->current_text;

 

-      for (text = key; *text; text++)

-         /* Empty loop */ ;

+        for(text = key; *text; text++)

+            /* Empty loop */ ;

 

-      if (text < key + png_ptr->current_text_size)

-         text++;

+        if(text < key + png_ptr->current_text_size)

+            text++;

 

-      text_ptr = (png_textp)png_malloc(png_ptr,

-         png_sizeof(png_text));

-      text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;

-      text_ptr->key = key;

+        text_ptr = (png_textp)png_malloc(png_ptr,

+                                         png_sizeof(png_text));

+        text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;

+        text_ptr->key = key;

 #ifdef PNG_iTXt_SUPPORTED

-      text_ptr->lang = NULL;

-      text_ptr->lang_key = NULL;

+        text_ptr->lang = NULL;

+        text_ptr->lang_key = NULL;

 #endif

-      text_ptr->text = text;

+        text_ptr->text = text;

 

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

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

 

-      png_free(png_ptr, key);

-      png_free(png_ptr, text_ptr);

-      png_ptr->current_text = NULL;

+        png_free(png_ptr, key);

+        png_free(png_ptr, text_ptr);

+        png_ptr->current_text = NULL;

 

-      if (ret)

-        png_warning(png_ptr, "Insufficient memory to store text chunk");

-   }

+        if(ret)

+            png_warning(png_ptr, "Insufficient memory to store text chunk");

+    }

 }

 #endif

 

 #ifdef PNG_READ_zTXt_SUPPORTED

 void /* PRIVATE */

 png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32

-   length)

+                     length)

 {

-   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

-      {

-         png_error(png_ptr, "Out of place zTXt");

-         info_ptr = info_ptr; /* To quiet some compiler warnings */

-      }

+    if(!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

+    {

+        png_error(png_ptr, "Out of place zTXt");

+        info_ptr = info_ptr; /* To quiet some compiler warnings */

+    }

 

 #ifdef PNG_MAX_MALLOC_64K

-   /* We can't handle zTXt chunks > 64K, since we don't have enough space

-    * to be able to store the uncompressed data.  Actually, the threshold

-    * is probably around 32K, but it isn't as definite as 64K is.

-    */

-   if (length > (png_uint_32)65535L)

-   {

-      png_warning(png_ptr, "zTXt chunk too large to fit in memory");

-      png_push_crc_skip(png_ptr, length);

-      return;

-   }

+    /* We can't handle zTXt chunks > 64K, since we don't have enough space

+     * to be able to store the uncompressed data.  Actually, the threshold

+     * is probably around 32K, but it isn't as definite as 64K is.

+     */

+    if(length > (png_uint_32)65535L)

+    {

+        png_warning(png_ptr, "zTXt chunk too large to fit in memory");

+        png_push_crc_skip(png_ptr, length);

+        return;

+    }

 #endif

 

-   png_ptr->current_text = (png_charp)png_malloc(png_ptr,

-      (png_size_t)(length + 1));

-   png_ptr->current_text[length] = '\0';

-   png_ptr->current_text_ptr = png_ptr->current_text;

-   png_ptr->current_text_size = (png_size_t)length;

-   png_ptr->current_text_left = (png_size_t)length;

-   png_ptr->process_mode = PNG_READ_zTXt_MODE;

+    png_ptr->current_text = (png_charp)png_malloc(png_ptr,

+                            (png_size_t)(length + 1));

+    png_ptr->current_text[length] = '\0';

+    png_ptr->current_text_ptr = png_ptr->current_text;

+    png_ptr->current_text_size = (png_size_t)length;

+    png_ptr->current_text_left = (png_size_t)length;

+    png_ptr->process_mode = PNG_READ_zTXt_MODE;

 }

 

 void /* PRIVATE */

 png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr->buffer_size && png_ptr->current_text_left)

-   {

-      png_size_t text_size;

-

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

-   }

-   if (!(png_ptr->current_text_left))

-   {

-      png_textp text_ptr;

-      png_charp text;

-      png_charp key;

-      int ret;

-      png_size_t text_size, key_size;

-

-      if (png_ptr->buffer_size < 4)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_crc_finish(png_ptr);

-

-      key = png_ptr->current_text;

-

-      for (text = key; *text; text++)

-         /* Empty loop */ ;

-

-      /* zTXt can't have zero text */

-      if (text >= key + png_ptr->current_text_size)

-      {

-         png_ptr->current_text = NULL;

-         png_free(png_ptr, key);

-         return;

-      }

-

-      text++;

-

-      if (*text != PNG_TEXT_COMPRESSION_zTXt) /* Check compression byte */

-      {

-         png_ptr->current_text = NULL;

-         png_free(png_ptr, key);

-         return;

-      }

-

-      text++;

-

-      png_ptr->zstream.next_in = (png_bytep )text;

-      png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -

-         (text - key));

-      png_ptr->zstream.next_out = png_ptr->zbuf;

-      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-

-      key_size = text - key;

-      text_size = 0;

-      text = NULL;

-      ret = Z_STREAM_END;

-

-      while (png_ptr->zstream.avail_in)

-      {

-         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

-         if (ret != Z_OK && ret != Z_STREAM_END)

-         {

-            inflateReset(&png_ptr->zstream);

-            png_ptr->zstream.avail_in = 0;

+    if(png_ptr->buffer_size && png_ptr->current_text_left)

+    {

+        png_size_t text_size;

+

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

+    }

+    if(!(png_ptr->current_text_left))

+    {

+        png_textp text_ptr;

+        png_charp text;

+        png_charp key;

+        int ret;

+        png_size_t text_size, key_size;

+

+        if(png_ptr->buffer_size < 4)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

+

+        png_push_crc_finish(png_ptr);

+

+        key = png_ptr->current_text;

+

+        for(text = key; *text; text++)

+            /* Empty loop */ ;

+

+        /* zTXt can't have zero text */

+        if(text >= key + png_ptr->current_text_size)

+        {

             png_ptr->current_text = NULL;

             png_free(png_ptr, key);

-            png_free(png_ptr, text);

             return;

-         }

-         if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)

-         {

-            if (text == NULL)

-            {

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

+        text++;

 

-               png_memcpy(text, key, key_size);

+        if(*text != PNG_TEXT_COMPRESSION_zTXt)  /* Check compression byte */

+        {

+            png_ptr->current_text = NULL;

+            png_free(png_ptr, key);

+            return;

+        }

 

-               text_size = key_size + png_ptr->zbuf_size -

-                  png_ptr->zstream.avail_out;

+        text++;

 

-               *(text + text_size) = '\0';

+        png_ptr->zstream.next_in = (png_bytep)text;

+        png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -

+                                           (text - key));

+        png_ptr->zstream.next_out = png_ptr->zbuf;

+        png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+

+        key_size = text - key;

+        text_size = 0;

+        text = NULL;

+        ret = Z_STREAM_END;

+

+        while(png_ptr->zstream.avail_in)

+        {

+            ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

+            if(ret != Z_OK && ret != Z_STREAM_END)

+            {

+                inflateReset(&png_ptr->zstream);

+                png_ptr->zstream.avail_in = 0;

+                png_ptr->current_text = NULL;

+                png_free(png_ptr, key);

+                png_free(png_ptr, text);

+                return;

+            }

+            if(!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)

+            {

+                if(text == NULL)

+                {

+                    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

+                {

+                    png_charp tmp;

+

+                    tmp = text;

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

+                }

+                if(ret != Z_STREAM_END)

+                {

+                    png_ptr->zstream.next_out = png_ptr->zbuf;

+                    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+                }

             }

             else

             {

-               png_charp tmp;

+                break;

+            }

 

-               tmp = text;

-               text = (png_charp)png_malloc(png_ptr, text_size +

-                  (png_ptr->zbuf_size 

-                  - png_ptr->zstream.avail_out + 1));

+            if(ret == Z_STREAM_END)

+                break;

+        }

 

-               png_memcpy(text, tmp, text_size);

-               png_free(png_ptr, tmp);

+        inflateReset(&png_ptr->zstream);

+        png_ptr->zstream.avail_in = 0;

 

-               png_memcpy(text + text_size, png_ptr->zbuf,

-                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);

+        if(ret != Z_STREAM_END)

+        {

+            png_ptr->current_text = NULL;

+            png_free(png_ptr, key);

+            png_free(png_ptr, text);

+            return;

+        }

 

-               text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;

-               *(text + text_size) = '\0';

-            }

-            if (ret != Z_STREAM_END)

-            {

-               png_ptr->zstream.next_out = png_ptr->zbuf;

-               png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-            }

-         }

-         else

-         {

-            break;

-         }

+        png_ptr->current_text = NULL;

+        png_free(png_ptr, key);

+        key = text;

+        text += key_size;

 

-         if (ret == Z_STREAM_END)

-            break;

-      }

-

-      inflateReset(&png_ptr->zstream);

-      png_ptr->zstream.avail_in = 0;

-

-      if (ret != Z_STREAM_END)

-      {

-         png_ptr->current_text = NULL;

-         png_free(png_ptr, key);

-         png_free(png_ptr, text);

-         return;

-      }

-

-      png_ptr->current_text = NULL;

-      png_free(png_ptr, key);

-      key = text;

-      text += key_size;

-

-      text_ptr = (png_textp)png_malloc(png_ptr,

-          png_sizeof(png_text));

-      text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;

-      text_ptr->key = key;

+        text_ptr = (png_textp)png_malloc(png_ptr,

+                                         png_sizeof(png_text));

+        text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;

+        text_ptr->key = key;

 #ifdef PNG_iTXt_SUPPORTED

-      text_ptr->lang = NULL;

-      text_ptr->lang_key = NULL;

+        text_ptr->lang = NULL;

+        text_ptr->lang_key = NULL;

 #endif

-      text_ptr->text = text;

+        text_ptr->text = text;

 

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

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

 

-      png_free(png_ptr, key);

-      png_free(png_ptr, text_ptr);

+        png_free(png_ptr, key);

+        png_free(png_ptr, text_ptr);

 

-      if (ret)

-        png_warning(png_ptr, "Insufficient memory to store text chunk");

-   }

+        if(ret)

+            png_warning(png_ptr, "Insufficient memory to store text chunk");

+    }

 }

 #endif

 

 #ifdef PNG_READ_iTXt_SUPPORTED

 void /* PRIVATE */

 png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32

-   length)

+                     length)

 {

-   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

-      {

-         png_error(png_ptr, "Out of place iTXt");

-         info_ptr = info_ptr; /* To quiet some compiler warnings */

-      }

+    if(!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

+    {

+        png_error(png_ptr, "Out of place iTXt");

+        info_ptr = info_ptr; /* To quiet some compiler warnings */

+    }

 

 #ifdef PNG_MAX_MALLOC_64K

-   png_ptr->skip_length = 0;  /* This may not be necessary */

-

-   if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */

-   {

-      png_warning(png_ptr, "iTXt chunk too large to fit in memory");

-      png_ptr->skip_length = length - (png_uint_32)65535L;

-      length = (png_uint_32)65535L;

-   }

+    png_ptr->skip_length = 0;  /* This may not be necessary */

+

+    if(length > (png_uint_32)65535L)  /* Can't hold entire string in memory */

+    {

+        png_warning(png_ptr, "iTXt chunk too large to fit in memory");

+        png_ptr->skip_length = length - (png_uint_32)65535L;

+        length = (png_uint_32)65535L;

+    }

 #endif

 

-   png_ptr->current_text = (png_charp)png_malloc(png_ptr,

-      (png_size_t)(length + 1));

-   png_ptr->current_text[length] = '\0';

-   png_ptr->current_text_ptr = png_ptr->current_text;

-   png_ptr->current_text_size = (png_size_t)length;

-   png_ptr->current_text_left = (png_size_t)length;

-   png_ptr->process_mode = PNG_READ_iTXt_MODE;

+    png_ptr->current_text = (png_charp)png_malloc(png_ptr,

+                            (png_size_t)(length + 1));

+    png_ptr->current_text[length] = '\0';

+    png_ptr->current_text_ptr = png_ptr->current_text;

+    png_ptr->current_text_size = (png_size_t)length;

+    png_ptr->current_text_left = (png_size_t)length;

+    png_ptr->process_mode = PNG_READ_iTXt_MODE;

 }

 

 void /* PRIVATE */

 png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)

 {

 

-   if (png_ptr->buffer_size && png_ptr->current_text_left)

-   {

-      png_size_t text_size;

-

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

-   }

-   if (!(png_ptr->current_text_left))

-   {

-      png_textp text_ptr;

-      png_charp key;

-      int comp_flag;

-      png_charp lang;

-      png_charp lang_key;

-      png_charp text;

-      int ret;

-

-      if (png_ptr->buffer_size < 4)

-      {

-         png_push_save_buffer(png_ptr);

-         return;

-      }

-

-      png_push_crc_finish(png_ptr);

+    if(png_ptr->buffer_size && png_ptr->current_text_left)

+    {

+        png_size_t text_size;

+

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

+    }

+    if(!(png_ptr->current_text_left))

+    {

+        png_textp text_ptr;

+        png_charp key;

+        int comp_flag;

+        png_charp lang;

+        png_charp lang_key;

+        png_charp text;

+        int ret;

+

+        if(png_ptr->buffer_size < 4)

+        {

+            png_push_save_buffer(png_ptr);

+            return;

+        }

+

+        png_push_crc_finish(png_ptr);

 

 #ifdef PNG_MAX_MALLOC_64K

-      if (png_ptr->skip_length)

-         return;

+        if(png_ptr->skip_length)

+            return;

 #endif

 

-      key = png_ptr->current_text;

+        key = png_ptr->current_text;

 

-      for (lang = key; *lang; lang++)

-         /* Empty loop */ ;

+        for(lang = key; *lang; lang++)

+            /* Empty loop */ ;

 

-      if (lang < key + png_ptr->current_text_size - 3)

-         lang++;

+        if(lang < key + png_ptr->current_text_size - 3)

+            lang++;

 

-      comp_flag = *lang++;

-      lang++;     /* Skip comp_type, always zero */

+        comp_flag = *lang++;

+        lang++;     /* Skip comp_type, always zero */

 

-      for (lang_key = lang; *lang_key; lang_key++)

-         /* Empty loop */ ;

+        for(lang_key = lang; *lang_key; lang_key++)

+            /* Empty loop */ ;

 

-      lang_key++;        /* Skip NUL separator */

+        lang_key++;        /* Skip NUL separator */

 

-      text=lang_key;

+        text = lang_key;

 

-      if (lang_key < key + png_ptr->current_text_size - 1)

-      {

-        for (; *text; text++)

-           /* Empty loop */ ;

-      }

+        if(lang_key < key + png_ptr->current_text_size - 1)

+        {

+            for(; *text; text++)

+                /* Empty loop */ ;

+        }

 

-      if (text < key + png_ptr->current_text_size)

-         text++;

+        if(text < key + png_ptr->current_text_size)

+            text++;

 

-      text_ptr = (png_textp)png_malloc(png_ptr,

-         png_sizeof(png_text));

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

-      text_ptr->lang_key = lang_key;

-      text_ptr->text = text;

-      text_ptr->text_length = 0;

-      text_ptr->itxt_length = png_strlen(text);

+        text_ptr->compression = comp_flag + 2;

+        text_ptr->key = key;

+        text_ptr->lang = lang;

+        text_ptr->lang_key = lang_key;

+        text_ptr->text = text;

+        text_ptr->text_length = 0;

+        text_ptr->itxt_length = png_strlen(text);

 

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

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

 

-      png_ptr->current_text = NULL;

+        png_ptr->current_text = NULL;

 

-      png_free(png_ptr, text_ptr);

-      if (ret)

-         png_warning(png_ptr, "Insufficient memory to store iTXt chunk");

-   }

+        png_free(png_ptr, text_ptr);

+        if(ret)

+            png_warning(png_ptr, "Insufficient memory to store iTXt chunk");

+    }

 }

 #endif

 

@@ -1582,146 +1583,146 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
  */

 void /* PRIVATE */

 png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32

-   length)

+                        length)

 {

-   png_uint_32 skip = 0;

+    png_uint_32 skip = 0;

 

-   if (!(png_ptr->chunk_name[0] & 0x20))

-   {

+    if(!(png_ptr->chunk_name[0] & 0x20))

+    {

 #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

-      if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

-         PNG_HANDLE_CHUNK_ALWAYS

+        if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

+           PNG_HANDLE_CHUNK_ALWAYS

 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED

-         && png_ptr->read_user_chunk_fn == NULL

+           && png_ptr->read_user_chunk_fn == NULL

 #endif

-         )

+          )

 #endif

-         png_chunk_error(png_ptr, "unknown critical chunk");

+            png_chunk_error(png_ptr, "unknown critical chunk");

 

-      info_ptr = info_ptr; /* To quiet some compiler warnings */

-   }

+        info_ptr = info_ptr; /* To quiet some compiler warnings */

+    }

 

 #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

-   if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)

-   {

+    if(png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)

+    {

 #ifdef PNG_MAX_MALLOC_64K

-      if (length > (png_uint_32)65535L)

-      {

-          png_warning(png_ptr, "unknown chunk too large to fit in memory");

-          skip = length - (png_uint_32)65535L;

-          length = (png_uint_32)65535L;

-      }

+        if(length > (png_uint_32)65535L)

+        {

+            png_warning(png_ptr, "unknown chunk too large to fit in memory");

+            skip = length - (png_uint_32)65535L;

+            length = (png_uint_32)65535L;

+        }

 #endif

-      png_memcpy((png_charp)png_ptr->unknown_chunk.name,

-                 (png_charp)png_ptr->chunk_name, 

-                 png_sizeof(png_ptr->unknown_chunk.name));

-      png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]

+        png_memcpy((png_charp)png_ptr->unknown_chunk.name,

+                   (png_charp)png_ptr->chunk_name,

+                   png_sizeof(png_ptr->unknown_chunk.name));

+        png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]

         = '\0';

 

-      png_ptr->unknown_chunk.size = (png_size_t)length;

+        png_ptr->unknown_chunk.size = (png_size_t)length;

 

-      if (length == 0)

-         png_ptr->unknown_chunk.data = NULL;

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

-      }

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

+        }

 

 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED

-      if (png_ptr->read_user_chunk_fn != NULL)

-      {

-         /* Callback to user unknown chunk handler */

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

-               if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

-                    PNG_HANDLE_CHUNK_ALWAYS)

-                  png_chunk_error(png_ptr, "unknown critical chunk");

-            png_set_unknown_chunks(png_ptr, info_ptr,

-               &png_ptr->unknown_chunk, 1);

-         }

-      }

-

-      else

+        if(png_ptr->read_user_chunk_fn != NULL)

+        {

+            /* Callback to user unknown chunk handler */

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

+                    if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

+                       PNG_HANDLE_CHUNK_ALWAYS)

+                        png_chunk_error(png_ptr, "unknown critical chunk");

+                png_set_unknown_chunks(png_ptr, info_ptr,

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

-   }

+            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

+    else

 #endif

-      skip=length;

-   png_push_crc_skip(png_ptr, skip);

+        skip = length;

+    png_push_crc_skip(png_ptr, skip);

 }

 

 void /* PRIVATE */

 png_push_have_info(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr->info_fn != NULL)

-      (*(png_ptr->info_fn))(png_ptr, info_ptr);

+    if(png_ptr->info_fn != NULL)

+        (*(png_ptr->info_fn))(png_ptr, info_ptr);

 }

 

 void /* PRIVATE */

 png_push_have_end(png_structp png_ptr, png_infop info_ptr)

 {

-   if (png_ptr->end_fn != NULL)

-      (*(png_ptr->end_fn))(png_ptr, info_ptr);

+    if(png_ptr->end_fn != NULL)

+        (*(png_ptr->end_fn))(png_ptr, info_ptr);

 }

 

 void /* PRIVATE */

 png_push_have_row(png_structp png_ptr, png_bytep row)

 {

-   if (png_ptr->row_fn != NULL)

-      (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,

-         (int)png_ptr->pass);

+    if(png_ptr->row_fn != NULL)

+        (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,

+                             (int)png_ptr->pass);

 }

 

 void PNGAPI

-png_progressive_combine_row (png_structp png_ptr,

-   png_bytep old_row, png_bytep new_row)

+png_progressive_combine_row(png_structp png_ptr,

+                            png_bytep old_row, png_bytep new_row)

 {

-   PNG_CONST int FARDATA png_pass_dsp_mask[7] =

-      {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};

+    PNG_CONST int FARDATA png_pass_dsp_mask[7] =

+    {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};

 

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

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

 }

 

 void PNGAPI

 png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,

-   png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,

-   png_progressive_end_ptr end_fn)

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

+    png_ptr->info_fn = info_fn;

+    png_ptr->row_fn = row_fn;

+    png_ptr->end_fn = end_fn;

 

-   png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);

+    png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);

 }

 

 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;

+    return png_ptr->io_ptr;

 }

 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

diff --git a/src/libpng/pngpriv.h b/src/libpng/pngpriv.h
index 166c281f4..dd2fe98d5 100644
--- a/src/libpng/pngpriv.h
+++ b/src/libpng/pngpriv.h
@@ -43,10 +43,10 @@
 

 #ifdef PNG_FLOATING_POINT_SUPPORTED

 #  ifdef MACOS

-     /* We need to check that <math.h> hasn't already been included earlier

-      * as it seems it doesn't agree with <fp.h>, yet we should really use

-      * <fp.h> if possible.

-      */

+/* We need to check that <math.h> hasn't already been included earlier

+ * as it seems it doesn't agree with <fp.h>, yet we should really use

+ * <fp.h> if possible.

+ */

 #    if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)

 #      include <fp.h>

 #    endif

@@ -54,9 +54,9 @@
 #    include <math.h>

 #  endif

 #  if defined(_AMIGA) && defined(__SASC) && defined(_M68881)

-     /* Amiga SAS/C: We must include builtin FPU functions when compiling using

-      * MATH=68881

-      */

+/* Amiga SAS/C: We must include builtin FPU functions when compiling using

+ * MATH=68881

+ */

 #    include <m68881.h>

 #  endif

 #endif

@@ -109,7 +109,7 @@
 #define PNG_DITHER              0x0040

 #define PNG_BACKGROUND          0x0080

 #define PNG_BACKGROUND_EXPAND   0x0100

-                          /*    0x0200 unused */

+/*    0x0200 unused */

 #define PNG_16_TO_8             0x0400

 #define PNG_RGBA                0x0800

 #define PNG_EXPAND              0x1000

@@ -124,14 +124,14 @@
 #define PNG_RGB_TO_GRAY_ERR   0x200000L

 #define PNG_RGB_TO_GRAY_WARN  0x400000L

 #define PNG_RGB_TO_GRAY       0x600000L  /* two bits, RGB_TO_GRAY_ERR|WARN */

-                       /*     0x800000L     Unused */

+/*     0x800000L     Unused */

 #define PNG_ADD_ALPHA         0x1000000L  /* Added to libpng-1.2.7 */

 #define PNG_EXPAND_tRNS       0x2000000L  /* Added to libpng-1.2.9 */

-                       /*   0x4000000L  unused */

-                       /*   0x8000000L  unused */

-                       /*  0x10000000L  unused */

-                       /*  0x20000000L  unused */

-                       /*  0x40000000L  unused */

+/*   0x4000000L  unused */

+/*   0x8000000L  unused */

+/*  0x10000000L  unused */

+/*  0x20000000L  unused */

+/*  0x40000000L  unused */

 

 /* Flags for png_create_struct */

 #define PNG_STRUCT_PNG   0x0001

@@ -156,9 +156,9 @@
 #define PNG_FLAG_CRC_ANCILLARY_NOWARN     0x0200

 #define PNG_FLAG_CRC_CRITICAL_USE         0x0400

 #define PNG_FLAG_CRC_CRITICAL_IGNORE      0x0800

-                                /*        0x1000  unused */

-                                /*        0x2000  unused */

-                                /*        0x4000  unused */

+/*        0x1000  unused */

+/*        0x2000  unused */

+/*        0x4000  unused */

 #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS      0x8000L

 #define PNG_FLAG_KEEP_UNSAFE_CHUNKS       0x10000L

 #define PNG_FLAG_LIBRARY_MISMATCH         0x20000L

@@ -168,13 +168,13 @@
 #define PNG_FLAG_ADD_ALPHA                0x200000L  /* Added to libpng-1.2.8 */

 #define PNG_FLAG_STRIP_ALPHA              0x400000L  /* Added to libpng-1.2.8 */

 #define PNG_FLAG_BENIGN_ERRORS_WARN       0x800000L  /* Added to libpng-1.4.0 */

-                                  /*     0x1000000L  unused */

-                                  /*     0x2000000L  unused */

-                                  /*     0x4000000L  unused */

-                                  /*     0x8000000L  unused */

-                                  /*    0x10000000L  unused */

-                                  /*    0x20000000L  unused */

-                                  /*    0x40000000L  unused */

+/*     0x1000000L  unused */

+/*     0x2000000L  unused */

+/*     0x4000000L  unused */

+/*     0x8000000L  unused */

+/*    0x10000000L  unused */

+/*    0x20000000L  unused */

+/*    0x40000000L  unused */

 

 #define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \

                                      PNG_FLAG_CRC_ANCILLARY_NOWARN)

@@ -238,612 +238,612 @@
 extern "C" {

 #endif /* __cplusplus */

 

-/* These functions are used internally in the code.  They generally

- * shouldn't be used unless you are writing code to add or replace some

- * functionality in libpng.  More information about most functions can

- * be found in the files where the functions are located.

- */

+    /* These functions are used internally in the code.  They generally

+     * shouldn't be used unless you are writing code to add or replace some

+     * functionality in libpng.  More information about most functions can

+     * be found in the files where the functions are located.

+     */

 

-/* Allocate memory for an internal libpng struct */

-PNG_EXTERN png_voidp png_create_struct PNGARG((int type));

+    /* Allocate memory for an internal libpng struct */

+    PNG_EXTERN png_voidp png_create_struct PNGARG((int type));

 

-/* Free memory from internal libpng struct */

-PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));

+    /* Free memory from internal libpng struct */

+    PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));

 

-PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr

-  malloc_fn, png_voidp mem_ptr));

-PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,

-   png_free_ptr free_fn, png_voidp mem_ptr));

+    PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr

+            malloc_fn, png_voidp mem_ptr));

+    PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,

+            png_free_ptr free_fn, png_voidp mem_ptr));

 

-/* Free any memory that info_ptr points to and reset struct. */

-PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

+    /* Free any memory that info_ptr points to and reset struct. */

+    PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,

+                                            png_infop info_ptr));

 

-/* Function to allocate memory for zlib.  PNGAPI is disallowed. */

-PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size));

+    /* Function to allocate memory for zlib.  PNGAPI is disallowed. */

+    PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size));

 

-/* Function to free memory for zlib.  PNGAPI is disallowed. */

-PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));

+    /* Function to free memory for zlib.  PNGAPI is disallowed. */

+    PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));

 

-/* Next four functions are used internally as callbacks.  PNGAPI is required

- * but not PNG_EXPORT.  PNGAPI added at libpng version 1.2.3. */

+    /* Next four functions are used internally as callbacks.  PNGAPI is required

+     * but not PNG_EXPORT.  PNGAPI added at libpng version 1.2.3. */

 

-PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr,

-   png_bytep data, png_size_t length));

+    PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr,

+            png_bytep data, png_size_t length));

 

 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr,

-   png_bytep buffer, png_size_t length));

+    PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr,

+            png_bytep buffer, png_size_t length));

 #endif

 

-PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr,

-   png_bytep data, png_size_t length));

+    PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr,

+            png_bytep data, png_size_t length));

 

 #ifdef PNG_WRITE_FLUSH_SUPPORTED

 #ifdef PNG_STDIO_SUPPORTED

-PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr));

+    PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr));

 #endif

 #endif

 

-/* Reset the CRC variable */

-PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));

+    /* Reset the CRC variable */

+    PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));

 

-/* Write the "data" buffer to whatever output you are using */

-PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data,

-   png_size_t length));

+    /* Write the "data" buffer to whatever output you are using */

+    PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data,

+                                           png_size_t length));

 

-/* Read the chunk header (length + type name) */

-PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr));

+    /* Read the chunk header (length + type name) */

+    PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr));

 

-/* Read data from whatever input you are using into the "data" buffer */

-PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,

-   png_size_t length));

+    /* Read data from whatever input you are using into the "data" buffer */

+    PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,

+                                          png_size_t length));

 

-/* Read bytes into buf, and update png_ptr->crc */

-PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,

-   png_size_t length));

+    /* Read bytes into buf, and update png_ptr->crc */

+    PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,

+                                         png_size_t length));

 

-/* Decompress data in a chunk that uses compression */

+    /* Decompress data in a chunk that uses compression */

 #if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \

     defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)

-PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr,

-   int comp_type, png_size_t chunklength, png_size_t prefix_length,

-   png_size_t *data_length));

+    PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr,

+            int comp_type, png_size_t chunklength, png_size_t prefix_length,

+            png_size_t *data_length));

 #endif

 

-/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */

-PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip));

+    /* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */

+    PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip));

 

-/* Read the CRC from the file and compare it to the libpng calculated CRC */

-PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr));

+    /* Read the CRC from the file and compare it to the libpng calculated CRC */

+    PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr));

 

-/* Calculate the CRC over a section of data.  Note that we are only

- * passing a maximum of 64K on systems that have this as a memory limit,

- * since this is the maximum buffer size we can specify.

- */

-PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr,

-   png_size_t length));

+    /* Calculate the CRC over a section of data.  Note that we are only

+     * passing a maximum of 64K on systems that have this as a memory limit,

+     * since this is the maximum buffer size we can specify.

+     */

+    PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr,

+            png_size_t length));

 

 #ifdef PNG_WRITE_FLUSH_SUPPORTED

-PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));

+    PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));

 #endif

 

-/* Write various chunks */

+    /* Write various chunks */

 

-/* Write the IHDR chunk, and update the png_struct with the necessary

- * information.

- */

-PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,

-   png_uint_32 height,

-   int bit_depth, int color_type, int compression_method, int filter_method,

-   int interlace_method));

+    /* Write the IHDR chunk, and update the png_struct with the necessary

+     * information.

+     */

+    PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,

+                                           png_uint_32 height,

+                                           int bit_depth, int color_type, int compression_method, int filter_method,

+                                           int interlace_method));

 

-PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette,

-   png_uint_32 num_pal));

+    PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette,

+                                           png_uint_32 num_pal));

 

-PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,

-   png_size_t length));

+    PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,

+                                           png_size_t length));

 

-PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr));

+    PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr));

 

 #ifdef PNG_WRITE_gAMA_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));

+    PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

-PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr,

-    png_fixed_point file_gamma));

+    PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr,

+            png_fixed_point file_gamma));

 #endif

 #endif

 

 #ifdef PNG_WRITE_sBIT_SUPPORTED

-PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit,

-   int color_type));

+    PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit,

+                                           int color_type));

 #endif

 

 #ifdef PNG_WRITE_cHRM_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,

-   double white_x, double white_y,

-   double red_x, double red_y, double green_x, double green_y,

-   double blue_x, double blue_y));

+    PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,

+                                           double white_x, double white_y,

+                                           double red_x, double red_y, double green_x, double green_y,

+                                           double blue_x, double blue_y));

 #endif

-PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,

-   png_fixed_point int_white_x, png_fixed_point int_white_y,

-   png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

-   int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

-   png_fixed_point int_blue_y));

+    PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,

+            png_fixed_point int_white_x, png_fixed_point int_white_y,

+            png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

+            int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

+            png_fixed_point int_blue_y));

 #endif

 

 #ifdef PNG_WRITE_sRGB_SUPPORTED

-PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,

-   int intent));

+    PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,

+                                           int intent));

 #endif

 

 #ifdef PNG_WRITE_iCCP_SUPPORTED

-PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,

-   png_charp name, int compression_type,

-   png_charp profile, int proflen));

-   /* Note to maintainer: profile should be png_bytep */

+    PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,

+                                           png_charp name, int compression_type,

+                                           png_charp profile, int proflen));

+    /* Note to maintainer: profile should be png_bytep */

 #endif

 

 #ifdef PNG_WRITE_sPLT_SUPPORTED

-PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,

-   png_sPLT_tp palette));

+    PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,

+                                           png_sPLT_tp palette));

 #endif

 

 #ifdef PNG_WRITE_tRNS_SUPPORTED

-PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,

-   png_color_16p values, int number, int color_type));

+    PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,

+                                           png_color_16p values, int number, int color_type));

 #endif

 

 #ifdef PNG_WRITE_bKGD_SUPPORTED

-PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,

-   png_color_16p values, int color_type));

+    PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,

+                                           png_color_16p values, int color_type));

 #endif

 

 #ifdef PNG_WRITE_hIST_SUPPORTED

-PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,

-   int num_hist));

+    PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,

+                                           int num_hist));

 #endif

 

 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \

     defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

-PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,

-   png_charp key, png_charpp new_key));

+    PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,

+            png_charp key, png_charpp new_key));

 #endif

 

 #ifdef PNG_WRITE_tEXt_SUPPORTED

-PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key,

-   png_charp text, png_size_t text_len));

+    PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key,

+                                           png_charp text, png_size_t text_len));

 #endif

 

 #ifdef PNG_WRITE_zTXt_SUPPORTED

-PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key,

-   png_charp text, png_size_t text_len, int compression));

+    PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key,

+                                           png_charp text, png_size_t text_len, int compression));

 #endif

 

 #ifdef PNG_WRITE_iTXt_SUPPORTED

-PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,

-   int compression, png_charp key, png_charp lang, png_charp lang_key,

-   png_charp text));

+    PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,

+                                           int compression, png_charp key, png_charp lang, png_charp lang_key,

+                                           png_charp text));

 #endif

 

 #ifdef PNG_TEXT_SUPPORTED  /* Added at version 1.0.14 and 1.2.4 */

-PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_textp text_ptr, int num_text));

+    PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,

+                                          png_infop info_ptr, png_textp text_ptr, int num_text));

 #endif

 

 #ifdef PNG_WRITE_oFFs_SUPPORTED

-PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,

-   png_int_32 x_offset, png_int_32 y_offset, int unit_type));

+    PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,

+                                           png_int_32 x_offset, png_int_32 y_offset, int unit_type));

 #endif

 

 #ifdef PNG_WRITE_pCAL_SUPPORTED

-PNG_EXTERN void png_write_pCAL PNGARG((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));

+    PNG_EXTERN void png_write_pCAL PNGARG((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));

 #endif

 

 #ifdef PNG_WRITE_pHYs_SUPPORTED

-PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,

-   png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,

-   int unit_type));

+    PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,

+                                           png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,

+                                           int unit_type));

 #endif

 

 #ifdef PNG_WRITE_tIME_SUPPORTED

-PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,

-   png_timep mod_time));

+    PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,

+                                           png_timep mod_time));

 #endif

 

 #ifdef PNG_WRITE_sCAL_SUPPORTED

 #if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)

-PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr,

-   int unit, double width, double height));

+    PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr,

+                                           int unit, double width, double height));

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

-PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,

-   int unit, png_charp width, png_charp height));

+    PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,

+                                            int unit, png_charp width, png_charp height));

 #endif

 #endif

 #endif

 

-/* Called when finished processing a row of data */

-PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));

+    /* Called when finished processing a row of data */

+    PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));

 

-/* Internal use only.   Called before first row of data */

-PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));

+    /* Internal use only.   Called before first row of data */

+    PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));

 

 #ifdef PNG_READ_GAMMA_SUPPORTED

-PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr,

-   png_byte bit_depth));

+    PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr,

+            png_byte bit_depth));

 #endif

 

-/* Combine a row of data, dealing with alpha, etc. if requested */

-PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,

-   int mask));

+    /* Combine a row of data, dealing with alpha, etc. if requested */

+    PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,

+                                            int mask));

 

 #ifdef PNG_READ_INTERLACING_SUPPORTED

-/* Expand an interlaced row */

-/* OLD pre-1.0.9 interface:

-PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,

-   png_bytep row, int pass, png_uint_32 transformations));

- */

-PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));

+    /* Expand an interlaced row */

+    /* OLD pre-1.0.9 interface:

+    PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,

+       png_bytep row, int pass, png_uint_32 transformations));

+     */

+    PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));

 #endif

 

-/* GRR TO DO (2.0 or whenever):  simplify other internal calling interfaces */

+    /* GRR TO DO (2.0 or whenever):  simplify other internal calling interfaces */

 

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

-/* Grab pixels out of a row for an interlaced pass */

-PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,

-   png_bytep row, int pass));

+    /* Grab pixels out of a row for an interlaced pass */

+    PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,

+            png_bytep row, int pass));

 #endif

 

-/* Unfilter a row */

-PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,

-   png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter));

+    /* Unfilter a row */

+    PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,

+            png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter));

 

-/* Choose the best filter to use and filter the row data */

-PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,

-   png_row_infop row_info));

+    /* Choose the best filter to use and filter the row data */

+    PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,

+            png_row_infop row_info));

 

-/* Write out the filtered row. */

-PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,

-   png_bytep filtered_row));

-/* Finish a row while reading, dealing with interlacing passes, etc. */

-PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));

+    /* Write out the filtered row. */

+    PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,

+            png_bytep filtered_row));

+    /* Finish a row while reading, dealing with interlacing passes, etc. */

+    PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));

 

-/* Initialize the row buffers, etc. */

-PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr));

-/* Optional call to update the users info structure */

-PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

+    /* Initialize the row buffers, etc. */

+    PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr));

+    /* Optional call to update the users info structure */

+    PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 

-/* These are the functions that do the transformations */

+    /* These are the functions that do the transformations */

 #ifdef PNG_READ_FILLER_SUPPORTED

-PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,

-   png_bytep row, png_uint_32 filler, png_uint_32 flags));

+    PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,

+            png_bytep row, png_uint_32 filler, png_uint_32 flags));

 #endif

 

 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED

-PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,

-   png_bytep row));

+    PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,

+            png_bytep row));

 #endif

 

 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

-PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,

-   png_bytep row));

+    PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,

+            png_bytep row));

 #endif

 

 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

-PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,

-   png_bytep row));

+    PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,

+            png_bytep row));

 #endif

 

 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

-PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,

-   png_bytep row));

+    PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,

+            png_bytep row));

 #endif

 

 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \

     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

-PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,

-   png_bytep row, png_uint_32 flags));

+    PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,

+            png_bytep row, png_uint_32 flags));

 #endif

 

 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

-PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row));

+    PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row));

 #endif

 

 #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \

     defined(PNG_WRITE_PACKSWAP_SUPPORTED)

-PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row));

+    PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row));

 #endif

 

 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop

-   row_info, png_bytep row));

+    PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop

+            row_info, png_bytep row));

 #endif

 

 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,

-   png_bytep row));

+    PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,

+            png_bytep row));

 #endif

 

 #ifdef PNG_READ_PACK_SUPPORTED

-PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row));

+    PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row));

 #endif

 

 #ifdef PNG_READ_SHIFT_SUPPORTED

-PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row,

-   png_color_8p sig_bits));

+    PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row,

+                                           png_color_8p sig_bits));

 #endif

 

 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)

-PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row));

+    PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row));

 #endif

 

 #ifdef PNG_READ_16_TO_8_SUPPORTED

-PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row));

+    PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row));

 #endif

 

 #ifdef PNG_READ_DITHER_SUPPORTED

-PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info,

-   png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup));

+    PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info,

+                                          png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup));

 

 #  ifdef PNG_CORRECT_PALETTE_SUPPORTED

-PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,

-   png_colorp palette, int num_palette));

+    PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,

+            png_colorp palette, int num_palette));

 #  endif

 #endif

 

 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)

-PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row));

+    PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row));

 #endif

 

 #ifdef PNG_WRITE_PACK_SUPPORTED

-PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,

-   png_bytep row, png_uint_32 bit_depth));

+    PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,

+                                        png_bytep row, png_uint_32 bit_depth));

 #endif

 

 #ifdef PNG_WRITE_SHIFT_SUPPORTED

-PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row,

-   png_color_8p bit_depth));

+    PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row,

+                                         png_color_8p bit_depth));

 #endif

 

 #ifdef PNG_READ_BACKGROUND_SUPPORTED

 #ifdef PNG_READ_GAMMA_SUPPORTED

-PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,

-   png_color_16p trans_color, png_color_16p background,

-   png_color_16p background_1,

-   png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,

-   png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,

-   png_uint_16pp gamma_16_to_1, int gamma_shift));

+    PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,

+            png_color_16p trans_color, png_color_16p background,

+            png_color_16p background_1,

+            png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,

+            png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,

+            png_uint_16pp gamma_16_to_1, int gamma_shift));

 #else

-PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,

-   png_color_16p trans_color, png_color_16p background));

+    PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,

+            png_color_16p trans_color, png_color_16p background));

 #endif

 #endif

 

 #ifdef PNG_READ_GAMMA_SUPPORTED

-PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row,

-   png_bytep gamma_table, png_uint_16pp gamma_16_table,

-   int gamma_shift));

+    PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row,

+                                         png_bytep gamma_table, png_uint_16pp gamma_16_table,

+                                         int gamma_shift));

 #endif

 

 #ifdef PNG_READ_EXPAND_SUPPORTED

-PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,

-   png_bytep row, png_colorp palette, png_bytep trans, int num_trans));

-PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,

-   png_bytep row, png_color_16p trans_value));

+    PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,

+            png_bytep row, png_colorp palette, png_bytep trans, int num_trans));

+    PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,

+                                          png_bytep row, png_color_16p trans_value));

 #endif

 

-/* The following decodes the appropriate chunks, and does error correction,

- * then calls the appropriate callback for the chunk if it is valid.

- */

+    /* The following decodes the appropriate chunks, and does error correction,

+     * then calls the appropriate callback for the chunk if it is valid.

+     */

 

-/* Decode the IHDR chunk */

-PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

-PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

-PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    /* Decode the IHDR chunk */

+    PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

+    PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

+    PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 

 #ifdef PNG_READ_bKGD_SUPPORTED

-PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_cHRM_SUPPORTED

-PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_gAMA_SUPPORTED

-PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_hIST_SUPPORTED

-PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_iCCP_SUPPORTED

-extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                        png_uint_32 length));

 #endif /* PNG_READ_iCCP_SUPPORTED */

 

 #ifdef PNG_READ_iTXt_SUPPORTED

-PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_oFFs_SUPPORTED

-PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_pCAL_SUPPORTED

-PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_pHYs_SUPPORTED

-PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_sBIT_SUPPORTED

-PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_sCAL_SUPPORTED

-PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_sPLT_SUPPORTED

-extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                        png_uint_32 length));

 #endif /* PNG_READ_sPLT_SUPPORTED */

 

 #ifdef PNG_READ_sRGB_SUPPORTED

-PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_tEXt_SUPPORTED

-PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_tIME_SUPPORTED

-PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_tRNS_SUPPORTED

-PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

 #ifdef PNG_READ_zTXt_SUPPORTED

-PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 length));

+    PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                            png_uint_32 length));

 #endif

 

-PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 length));

+    PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 length));

 

-PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,

-   png_bytep chunk_name));

+    PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,

+            png_bytep chunk_name));

 

-/* Handle the transformations for reading and writing */

-PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));

-PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));

+    /* Handle the transformations for reading and writing */

+    PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));

+    PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));

 

-PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr));

+    PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr));

 

 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));

-PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,

-   png_uint_32 length));

-PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));

-PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));

-PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,

-   png_bytep buffer, png_size_t buffer_length));

-PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));

-PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,

-   png_bytep buffer, png_size_t buffer_length));

-PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));

-PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 length));

-PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));

-PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

-PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));

+    PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

+    PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

+    PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));

+    PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,

+            png_uint_32 length));

+    PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));

+    PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));

+    PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,

+            png_bytep buffer, png_size_t buffer_length));

+    PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));

+    PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,

+            png_bytep buffer, png_size_t buffer_length));

+    PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));

+    PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 length));

+    PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

+    PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

+    PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));

+    PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

+    PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

+    PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));

 #ifdef PNG_READ_tEXt_SUPPORTED

-PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 length));

-PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

+    PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 length));

+    PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 #endif

 #ifdef PNG_READ_zTXt_SUPPORTED

-PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 length));

-PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

+    PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 length));

+    PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 #endif

 #ifdef PNG_READ_iTXt_SUPPORTED

-PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr, png_uint_32 length));

-PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,

-   png_infop info_ptr));

+    PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,

+            png_infop info_ptr, png_uint_32 length));

+    PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,

+            png_infop info_ptr));

 #endif

 

 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

 

 #ifdef PNG_MNG_FEATURES_SUPPORTED

-PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,

-   png_bytep row));

-PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,

-   png_bytep row));

+    PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,

+            png_bytep row));

+    PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,

+            png_bytep row));

 #endif

 

-/* Added at libpng version 1.4.0 */

+    /* Added at libpng version 1.4.0 */

 #ifdef PNG_cHRM_SUPPORTED

-PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr,

-   png_fixed_point int_white_x, png_fixed_point int_white_y,

-   png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

-   int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

-   png_fixed_point int_blue_y));

+    PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr,

+            png_fixed_point int_white_x, png_fixed_point int_white_y,

+            png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

+            int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

+            png_fixed_point int_blue_y));

 #endif

 

 #ifdef PNG_cHRM_SUPPORTED

 #ifdef PNG_CHECK_cHRM_SUPPORTED

-/* Added at libpng version 1.2.34 and 1.4.0 */

-PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2,

-   unsigned long *hi_product, unsigned long *lo_product));

+    /* Added at libpng version 1.2.34 and 1.4.0 */

+    PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2,

+            unsigned long *hi_product, unsigned long *lo_product));

 #endif

 #endif

 

-/* Added at libpng version 1.4.0 */

-PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr,

-   png_uint_32 width, png_uint_32 height, int bit_depth,

-   int color_type, int interlace_type, int compression_type,

-   int filter_type));

+    /* Added at libpng version 1.4.0 */

+    PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr,

+                                           png_uint_32 width, png_uint_32 height, int bit_depth,

+                                           int color_type, int interlace_type, int compression_type,

+                                           int filter_type));

 

-/* Free all memory used by the read (old method - NOT DLL EXPORTED) */

-extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr,

-   png_infop end_info_ptr));

+    /* Free all memory used by the read (old method - NOT DLL EXPORTED) */

+    extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr,

+                                         png_infop end_info_ptr));

 

-/* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */

-extern void png_write_destroy PNGARG((png_structp png_ptr));

+    /* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */

+    extern void png_write_destroy PNGARG((png_structp png_ptr));

 

 #ifdef USE_FAR_KEYWORD  /* memory model conversion function */

-extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,

-   int check));

+    extern void *png_far_to_near PNGARG((png_structp png_ptr, png_voidp ptr,

+                                         int check));

 #endif /* USE_FAR_KEYWORD */

 

-/* Define PNG_DEBUG at compile time for debugging information.  Higher

- * numbers for PNG_DEBUG mean more debugging information.  This has

- * only been added since version 0.95 so it is not implemented throughout

- * libpng yet, but more support will be added as needed.

- */

+    /* Define PNG_DEBUG at compile time for debugging information.  Higher

+     * numbers for PNG_DEBUG mean more debugging information.  This has

+     * only been added since version 0.95 so it is not implemented throughout

+     * libpng yet, but more support will be added as needed.

+     */

 #ifdef PNG_DEBUG

 #if (PNG_DEBUG > 0)

 #if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER)

@@ -868,9 +868,9 @@ extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,
 #endif /* PNG_DEBUG_FILE */

 

 #if (PNG_DEBUG > 1)

-/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on

- * non-ISO compilers

- */

+    /* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on

+     * non-ISO compilers

+     */

 #  ifdef __STDC__

 #    ifndef png_debug

 #      define png_debug(l,m) \

@@ -946,7 +946,7 @@ extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,
 #define png_debug2(l, m, p1, p2)

 #endif

 

-/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */

+    /* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */

 

 #ifdef __cplusplus

 }

diff --git a/src/libpng/pngread.c b/src/libpng/pngread.c
index 3c19061e6..b7f4ad707 100644
--- a/src/libpng/pngread.c
+++ b/src/libpng/pngread.c
@@ -23,12 +23,12 @@
 /* Create a PNG structure for reading, and allocate any memory needed. */

 png_structp PNGAPI

 png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn)

+                       png_error_ptr error_fn, png_error_ptr warn_fn)

 {

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,

-      warn_fn, NULL, NULL, NULL));

+    return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,

+                                     warn_fn, NULL, NULL, NULL));

 }

 

 /* Alternate create PNG structure for reading, and allocate any memory

@@ -36,168 +36,175 @@ png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
  */

 png_structp PNGAPI

 png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

-   png_malloc_ptr malloc_fn, png_free_ptr free_fn)

+                         png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

+                         png_malloc_ptr malloc_fn, png_free_ptr free_fn)

 {

 #endif /* PNG_USER_MEM_SUPPORTED */

 

 #ifdef PNG_SETJMP_SUPPORTED

-   volatile

+    volatile

 #endif

-   png_structp png_ptr;

-   volatile int png_cleanup_needed = 0;

+    png_structp png_ptr;

+    volatile int png_cleanup_needed = 0;

 

 #ifdef PNG_SETJMP_SUPPORTED

 #ifdef USE_FAR_KEYWORD

-   jmp_buf jmpbuf;

+    jmp_buf jmpbuf;

 #endif

 #endif

 

-   int i;

+    int i;

 

-   png_debug(1, "in png_create_read_struct");

+    png_debug(1, "in png_create_read_struct");

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,

-      malloc_fn, mem_ptr);

+    png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,

+              malloc_fn, mem_ptr);

 #else

-   png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

+    png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

 #endif

-   if (png_ptr == NULL)

-      return (NULL);

+    if(png_ptr == NULL)

+        return (NULL);

 

-   /* Added at libpng-1.2.6 */

+    /* Added at libpng-1.2.6 */

 #ifdef PNG_USER_LIMITS_SUPPORTED

-   png_ptr->user_width_max = PNG_USER_WIDTH_MAX;

-   png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;

+    png_ptr->user_width_max = PNG_USER_WIDTH_MAX;

+    png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;

 #  ifdef PNG_USER_CHUNK_CACHE_MAX

-   /* Added at libpng-1.2.43 and 1.4.0 */

-   png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;

+    /* Added at libpng-1.2.43 and 1.4.0 */

+    png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;

 #  endif

 #  ifdef PNG_SET_USER_CHUNK_MALLOC_MAX

-   /* Added at libpng-1.2.43 and 1.4.1 */

-   png_ptr->user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;

+    /* Added at libpng-1.2.43 and 1.4.1 */

+    png_ptr->user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;

 #  endif

 #endif

 

 #ifdef PNG_SETJMP_SUPPORTED

-/* Applications that neglect to set up their own setjmp() and then

-   encounter a png_error() will longjmp here.  Since the jmpbuf is

-   then meaningless we abort instead of returning. */

+    /* Applications that neglect to set up their own setjmp() and then

+       encounter a png_error() will longjmp here.  Since the jmpbuf is

+       then meaningless we abort instead of returning. */

 #ifdef USE_FAR_KEYWORD

-   if (setjmp(jmpbuf))

+    if(setjmp(jmpbuf))

 #else

-   if (setjmp(png_jmpbuf(png_ptr))) /* Sets longjmp to match setjmp */

+    if(setjmp(png_jmpbuf(png_ptr)))  /* Sets longjmp to match setjmp */

 #endif

-      PNG_ABORT();

+        PNG_ABORT();

 #ifdef USE_FAR_KEYWORD

-   png_memcpy(png_jmpbuf(png_ptr), jmpbuf, png_sizeof(jmp_buf));

+    png_memcpy(png_jmpbuf(png_ptr), jmpbuf, png_sizeof(jmp_buf));

 #endif

 #endif /* PNG_SETJMP_SUPPORTED */

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);

+    png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);

 #endif

 

-   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

+    png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

 

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

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

+        png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

 

 

-    if (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'))

-      {

+        /* 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'))

+        {

 #ifdef PNG_STDIO_SUPPORTED

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

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

 #endif

 #ifdef PNG_ERROR_NUMBERS_SUPPORTED

-         png_ptr->flags = 0;

-#endif

-         png_warning(png_ptr,

-            "Incompatible libpng version in application and library");

-

-         png_cleanup_needed = 1;

-      }

-   }

-

-   if (!png_cleanup_needed)

-   {

-   /* Initialize zbuf - compression buffer */

-   png_ptr->zbuf_size = PNG_ZBUF_SIZE;

-   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->zstream.zalloc = png_zalloc;

-   png_ptr->zstream.zfree = png_zfree;

-   png_ptr->zstream.opaque = (voidpf)png_ptr;

-

-   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_ptr->flags = 0;

+#endif

+            png_warning(png_ptr,

+                        "Incompatible libpng version in application and library");

+

+            png_cleanup_needed = 1;

+        }

+    }

+

+    if(!png_cleanup_needed)

+    {

+        /* Initialize zbuf - compression buffer */

+        png_ptr->zbuf_size = PNG_ZBUF_SIZE;

+        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->zstream.zalloc = png_zalloc;

+    png_ptr->zstream.zfree = png_zfree;

+    png_ptr->zstream.opaque = (voidpf)png_ptr;

+

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

-      }

-   }

-

-   if (png_cleanup_needed)

-   {

-      /* Clean up PNG structure and deallocate any memory. */

-      png_free(png_ptr, png_ptr->zbuf);

-      png_ptr->zbuf = NULL;

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

+    {

+        /* 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_ptr->zstream.next_out = png_ptr->zbuf;

-   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+    png_ptr->zstream.next_out = png_ptr->zbuf;

+    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

 

-   png_set_read_fn(png_ptr, NULL, NULL);

+    png_set_read_fn(png_ptr, NULL, NULL);

 

 

-   return (png_ptr);

+    return (png_ptr);

 }

 

 

@@ -213,211 +220,211 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
 void PNGAPI

 png_read_info(png_structp png_ptr, png_infop info_ptr)

 {

-   png_debug(1, "in png_read_info");

- 

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

-      return;

- 

-   /* If we haven't checked all of the PNG signature bytes, do so now. */

-   if (png_ptr->sig_bytes < 8)

-   {

-      png_size_t num_checked = png_ptr->sig_bytes,

-                 num_to_check = 8 - num_checked;

+    png_debug(1, "in png_read_info");

+

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

+        return;

+

+    /* If we haven't checked all of the PNG signature bytes, do so now. */

+    if(png_ptr->sig_bytes < 8)

+    {

+        png_size_t num_checked = png_ptr->sig_bytes,

+                   num_to_check = 8 - num_checked;

 

 #ifdef PNG_IO_STATE_SUPPORTED

-      png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE;

-#endif

-

-      png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);

-      png_ptr->sig_bytes = 8;

-

-      if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))

-      {

-         if (num_checked < 4 &&

-             png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))

-            png_error(png_ptr, "Not a PNG file");

-         else

-            png_error(png_ptr, "PNG file corrupted by ASCII conversion");

-      }

-      if (num_checked < 3)

-         png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

-   }

-

-   for (;;)

-   {

-      PNG_IHDR;

-      PNG_IDAT;

-      PNG_IEND;

-      PNG_PLTE;

+        png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE;

+#endif

+

+        png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);

+        png_ptr->sig_bytes = 8;

+

+        if(png_sig_cmp(info_ptr->signature, num_checked, num_to_check))

+        {

+            if(num_checked < 4 &&

+               png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))

+                png_error(png_ptr, "Not a PNG file");

+            else

+                png_error(png_ptr, "PNG file corrupted by ASCII conversion");

+        }

+        if(num_checked < 3)

+            png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

+    }

+

+    for(;;)

+    {

+        PNG_IHDR;

+        PNG_IDAT;

+        PNG_IEND;

+        PNG_PLTE;

 #ifdef PNG_READ_bKGD_SUPPORTED

-      PNG_bKGD;

+        PNG_bKGD;

 #endif

 #ifdef PNG_READ_cHRM_SUPPORTED

-      PNG_cHRM;

+        PNG_cHRM;

 #endif

 #ifdef PNG_READ_gAMA_SUPPORTED

-      PNG_gAMA;

+        PNG_gAMA;

 #endif

 #ifdef PNG_READ_hIST_SUPPORTED

-      PNG_hIST;

+        PNG_hIST;

 #endif

 #ifdef PNG_READ_iCCP_SUPPORTED

-      PNG_iCCP;

+        PNG_iCCP;

 #endif

 #ifdef PNG_READ_iTXt_SUPPORTED

-      PNG_iTXt;

+        PNG_iTXt;

 #endif

 #ifdef PNG_READ_oFFs_SUPPORTED

-      PNG_oFFs;

+        PNG_oFFs;

 #endif

 #ifdef PNG_READ_pCAL_SUPPORTED

-      PNG_pCAL;

+        PNG_pCAL;

 #endif

 #ifdef PNG_READ_pHYs_SUPPORTED

-      PNG_pHYs;

+        PNG_pHYs;

 #endif

 #ifdef PNG_READ_sBIT_SUPPORTED

-      PNG_sBIT;

+        PNG_sBIT;

 #endif

 #ifdef PNG_READ_sCAL_SUPPORTED

-      PNG_sCAL;

+        PNG_sCAL;

 #endif

 #ifdef PNG_READ_sPLT_SUPPORTED

-      PNG_sPLT;

+        PNG_sPLT;

 #endif

 #ifdef PNG_READ_sRGB_SUPPORTED

-      PNG_sRGB;

+        PNG_sRGB;

 #endif

 #ifdef PNG_READ_tEXt_SUPPORTED

-      PNG_tEXt;

+        PNG_tEXt;

 #endif

 #ifdef PNG_READ_tIME_SUPPORTED

-      PNG_tIME;

+        PNG_tIME;

 #endif

 #ifdef PNG_READ_tRNS_SUPPORTED

-      PNG_tRNS;

+        PNG_tRNS;

 #endif

 #ifdef PNG_READ_zTXt_SUPPORTED

-      PNG_zTXt;

-#endif

-      png_uint_32 length = png_read_chunk_header(png_ptr);

-      PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;

-

-      /* This should be a binary subdivision search or a hash for

-       * matching the chunk name rather than a linear search.

-       */

-      if (!png_memcmp(chunk_name, png_IDAT, 4))

-        if (png_ptr->mode & PNG_AFTER_IDAT)

-          png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;

-

-      if (!png_memcmp(chunk_name, png_IHDR, 4))

-         png_handle_IHDR(png_ptr, info_ptr, length);

-      else if (!png_memcmp(chunk_name, png_IEND, 4))

-         png_handle_IEND(png_ptr, info_ptr, length);

+        PNG_zTXt;

+#endif

+        png_uint_32 length = png_read_chunk_header(png_ptr);

+        PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;

+

+        /* This should be a binary subdivision search or a hash for

+         * matching the chunk name rather than a linear search.

+         */

+        if(!png_memcmp(chunk_name, png_IDAT, 4))

+            if(png_ptr->mode & PNG_AFTER_IDAT)

+                png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;

+

+        if(!png_memcmp(chunk_name, png_IHDR, 4))

+            png_handle_IHDR(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_IEND, 4))

+            png_handle_IEND(png_ptr, info_ptr, length);

 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-      else if (png_handle_as_unknown(png_ptr, chunk_name))

-      {

-         if (!png_memcmp(chunk_name, png_IDAT, 4))

+        else if(png_handle_as_unknown(png_ptr, chunk_name))

+        {

+            if(!png_memcmp(chunk_name, png_IDAT, 4))

+                png_ptr->mode |= PNG_HAVE_IDAT;

+            png_handle_unknown(png_ptr, info_ptr, length);

+            if(!png_memcmp(chunk_name, png_PLTE, 4))

+                png_ptr->mode |= PNG_HAVE_PLTE;

+            else if(!png_memcmp(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");

+                break;

+            }

+        }

+#endif

+        else if(!png_memcmp(chunk_name, png_PLTE, 4))

+            png_handle_PLTE(png_ptr, info_ptr, length);

+        else if(!png_memcmp(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");

+

+            png_ptr->idat_size = length;

             png_ptr->mode |= PNG_HAVE_IDAT;

-         png_handle_unknown(png_ptr, info_ptr, length);

-         if (!png_memcmp(chunk_name, png_PLTE, 4))

-            png_ptr->mode |= PNG_HAVE_PLTE;

-         else if (!png_memcmp(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");

             break;

-         }

-      }

-#endif

-      else if (!png_memcmp(chunk_name, png_PLTE, 4))

-         png_handle_PLTE(png_ptr, info_ptr, length);

-      else if (!png_memcmp(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");

-

-         png_ptr->idat_size = length;

-         png_ptr->mode |= PNG_HAVE_IDAT;

-         break;

-      }

+        }

 #ifdef PNG_READ_bKGD_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_bKGD, 4))

-         png_handle_bKGD(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_bKGD, 4))

+            png_handle_bKGD(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_cHRM_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_cHRM, 4))

-         png_handle_cHRM(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_cHRM, 4))

+            png_handle_cHRM(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_gAMA_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_gAMA, 4))

-         png_handle_gAMA(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_gAMA, 4))

+            png_handle_gAMA(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_hIST_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_hIST, 4))

-         png_handle_hIST(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_hIST, 4))

+            png_handle_hIST(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_oFFs_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_oFFs, 4))

-         png_handle_oFFs(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_oFFs, 4))

+            png_handle_oFFs(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_pCAL_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_pCAL, 4))

-         png_handle_pCAL(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_pCAL, 4))

+            png_handle_pCAL(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_sCAL_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sCAL, 4))

-         png_handle_sCAL(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_sCAL, 4))

+            png_handle_sCAL(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_pHYs_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_pHYs, 4))

-         png_handle_pHYs(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_pHYs, 4))

+            png_handle_pHYs(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_sBIT_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sBIT, 4))

-         png_handle_sBIT(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_sBIT, 4))

+            png_handle_sBIT(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_sRGB_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sRGB, 4))

-         png_handle_sRGB(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_sRGB, 4))

+            png_handle_sRGB(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_iCCP_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_iCCP, 4))

-         png_handle_iCCP(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_iCCP, 4))

+            png_handle_iCCP(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_sPLT_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sPLT, 4))

-         png_handle_sPLT(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_sPLT, 4))

+            png_handle_sPLT(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_tEXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tEXt, 4))

-         png_handle_tEXt(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_tEXt, 4))

+            png_handle_tEXt(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_tIME_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tIME, 4))

-         png_handle_tIME(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_tIME, 4))

+            png_handle_tIME(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_tRNS_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tRNS, 4))

-         png_handle_tRNS(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_tRNS, 4))

+            png_handle_tRNS(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_zTXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_zTXt, 4))

-         png_handle_zTXt(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_zTXt, 4))

+            png_handle_zTXt(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_iTXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_iTXt, 4))

-         png_handle_iTXt(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_iTXt, 4))

+            png_handle_iTXt(png_ptr, info_ptr, length);

 #endif

-      else

-         png_handle_unknown(png_ptr, info_ptr, length);

-   }

+        else

+            png_handle_unknown(png_ptr, info_ptr, length);

+    }

 }

 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

 

@@ -425,17 +432,17 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
 void PNGAPI

 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->flags & PNG_FLAG_ROW_INIT))

-      png_read_start_row(png_ptr);

-   else

-      png_warning(png_ptr,

-      "Ignoring extra png_read_update_info() call; row buffer not reallocated");

-

-   png_read_transform_info(png_ptr, info_ptr);

+    png_debug(1, "in png_read_update_info");

+

+    if(png_ptr == NULL)

+        return;

+    if(!(png_ptr->flags & PNG_FLAG_ROW_INIT))

+        png_read_start_row(png_ptr);

+    else

+        png_warning(png_ptr,

+                    "Ignoring extra png_read_update_info() call; row buffer not reallocated");

+

+    png_read_transform_info(png_ptr, info_ptr);

 }

 

 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED

@@ -447,12 +454,12 @@ png_read_update_info(png_structp png_ptr, png_infop info_ptr)
 void PNGAPI

 png_start_read_image(png_structp png_ptr)

 {

-   png_debug(1, "in png_start_read_image");

- 

-   if (png_ptr == NULL)

-      return;

-   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

-      png_read_start_row(png_ptr);

+    png_debug(1, "in png_start_read_image");

+

+    if(png_ptr == NULL)

+        return;

+    if(!(png_ptr->flags & PNG_FLAG_ROW_INIT))

+        png_read_start_row(png_ptr);

 }

 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

 

@@ -460,233 +467,235 @@ png_start_read_image(png_structp png_ptr)
 void PNGAPI

 png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)

 {

-   PNG_IDAT;

-   PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,

-      0xff};

-   PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};

-   int ret;

- 

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

-      png_read_start_row(png_ptr);

-   if (png_ptr->row_number == 0 && png_ptr->pass == 0)

-   {

-   /* Check for transforms that have been set but were defined out */

+    PNG_IDAT;

+    PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,

+                                          0xff

+                                         };

+    PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};

+    int ret;

+

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

+        png_read_start_row(png_ptr);

+    if(png_ptr->row_number == 0 && png_ptr->pass == 0)

+    {

+        /* 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_READ_INVERT_SUPPORTED is not defined");

+        if(png_ptr->transformations & PNG_INVERT_MONO)

+            png_warning(png_ptr, "PNG_READ_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_READ_FILLER_SUPPORTED is not defined");

+        if(png_ptr->transformations & PNG_FILLER)

+            png_warning(png_ptr, "PNG_READ_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_READ_PACKSWAP_SUPPORTED is not defined");

+        if(png_ptr->transformations & PNG_PACKSWAP)

+            png_warning(png_ptr, "PNG_READ_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_READ_PACK_SUPPORTED is not defined");

+        if(png_ptr->transformations & PNG_PACK)

+            png_warning(png_ptr, "PNG_READ_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_READ_SHIFT_SUPPORTED is not defined");

+        if(png_ptr->transformations & PNG_SHIFT)

+            png_warning(png_ptr, "PNG_READ_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_READ_BGR_SUPPORTED is not defined");

+        if(png_ptr->transformations & PNG_BGR)

+            png_warning(png_ptr, "PNG_READ_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_READ_SWAP_SUPPORTED is not defined");

+        if(png_ptr->transformations & PNG_SWAP_BYTES)

+            png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");

 #endif

-   }

+    }

 

 #ifdef PNG_READ_INTERLACING_SUPPORTED

-   /* If interlaced and we do not need a new row, combine row and return */

-   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

-   {

-      switch (png_ptr->pass)

-      {

-         case 0:

-            if (png_ptr->row_number & 0x07)

+    /* If interlaced and we do not need a new row, combine row and return */

+    if(png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

+    {

+        switch(png_ptr->pass)

+        {

+        case 0:

+            if(png_ptr->row_number & 0x07)

             {

-               if (dsp_row != NULL)

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

+                if(dsp_row != NULL)

+                    png_combine_row(png_ptr, dsp_row,

+                                    png_pass_dsp_mask[png_ptr->pass]);

+                png_read_finish_row(png_ptr);

+                return;

             }

             break;

-         case 1:

-            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)

+        case 1:

+            if((png_ptr->row_number & 0x07) || png_ptr->width < 5)

             {

-               if (dsp_row != NULL)

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

+                if(dsp_row != NULL)

+                    png_combine_row(png_ptr, dsp_row,

+                                    png_pass_dsp_mask[png_ptr->pass]);

+                png_read_finish_row(png_ptr);

+                return;

             }

             break;

-         case 2:

-            if ((png_ptr->row_number & 0x07) != 4)

+        case 2:

+            if((png_ptr->row_number & 0x07) != 4)

             {

-               if (dsp_row != NULL && (png_ptr->row_number & 4))

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

+                if(dsp_row != NULL && (png_ptr->row_number & 4))

+                    png_combine_row(png_ptr, dsp_row,

+                                    png_pass_dsp_mask[png_ptr->pass]);

+                png_read_finish_row(png_ptr);

+                return;

             }

             break;

-         case 3:

-            if ((png_ptr->row_number & 3) || png_ptr->width < 3)

+        case 3:

+            if((png_ptr->row_number & 3) || png_ptr->width < 3)

             {

-               if (dsp_row != NULL)

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

+                if(dsp_row != NULL)

+                    png_combine_row(png_ptr, dsp_row,

+                                    png_pass_dsp_mask[png_ptr->pass]);

+                png_read_finish_row(png_ptr);

+                return;

             }

             break;

-         case 4:

-            if ((png_ptr->row_number & 3) != 2)

+        case 4:

+            if((png_ptr->row_number & 3) != 2)

             {

-               if (dsp_row != NULL && (png_ptr->row_number & 2))

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

+                if(dsp_row != NULL && (png_ptr->row_number & 2))

+                    png_combine_row(png_ptr, dsp_row,

+                                    png_pass_dsp_mask[png_ptr->pass]);

+                png_read_finish_row(png_ptr);

+                return;

             }

             break;

-         case 5:

-            if ((png_ptr->row_number & 1) || png_ptr->width < 2)

+        case 5:

+            if((png_ptr->row_number & 1) || png_ptr->width < 2)

             {

-               if (dsp_row != NULL)

-                  png_combine_row(png_ptr, dsp_row,

-                     png_pass_dsp_mask[png_ptr->pass]);

-               png_read_finish_row(png_ptr);

-               return;

+                if(dsp_row != NULL)

+                    png_combine_row(png_ptr, dsp_row,

+                                    png_pass_dsp_mask[png_ptr->pass]);

+                png_read_finish_row(png_ptr);

+                return;

             }

             break;

-         case 6:

-            if (!(png_ptr->row_number & 1))

+        case 6:

+            if(!(png_ptr->row_number & 1))

+            {

+                png_read_finish_row(png_ptr);

+                return;

+            }

+            break;

+        }

+    }

+#endif

+

+    if(!(png_ptr->mode & PNG_HAVE_IDAT))

+        png_error(png_ptr, "Invalid attempt to read row data");

+

+    png_ptr->zstream.next_out = png_ptr->row_buf;

+    png_ptr->zstream.avail_out =

+        (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,

+                            png_ptr->iwidth) + 1);

+    do

+    {

+        if(!(png_ptr->zstream.avail_in))

+        {

+            while(!png_ptr->idat_size)

             {

-               png_read_finish_row(png_ptr);

-               return;

+                png_crc_finish(png_ptr, 0);

+

+                png_ptr->idat_size = png_read_chunk_header(png_ptr);

+                if(png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+                    png_error(png_ptr, "Not enough image data");

             }

+            png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;

+            png_ptr->zstream.next_in = png_ptr->zbuf;

+            if(png_ptr->zbuf_size > png_ptr->idat_size)

+                png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;

+            png_crc_read(png_ptr, png_ptr->zbuf,

+                         (png_size_t)png_ptr->zstream.avail_in);

+            png_ptr->idat_size -= png_ptr->zstream.avail_in;

+        }

+        ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

+        if(ret == Z_STREAM_END)

+        {

+            if(png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||

+               png_ptr->idat_size)

+                png_benign_error(png_ptr, "Extra compressed data");

+            png_ptr->mode |= PNG_AFTER_IDAT;

+            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

             break;

-      }

-   }

-#endif

-

-   if (!(png_ptr->mode & PNG_HAVE_IDAT))

-      png_error(png_ptr, "Invalid attempt to read row data");

-

-   png_ptr->zstream.next_out = png_ptr->row_buf;

-   png_ptr->zstream.avail_out =

-       (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,

-       png_ptr->iwidth) + 1);

-   do

-   {

-      if (!(png_ptr->zstream.avail_in))

-      {

-         while (!png_ptr->idat_size)

-         {

-            png_crc_finish(png_ptr, 0);

-

-            png_ptr->idat_size = png_read_chunk_header(png_ptr);

-            if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-               png_error(png_ptr, "Not enough image data");

-         }

-         png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;

-         png_ptr->zstream.next_in = png_ptr->zbuf;

-         if (png_ptr->zbuf_size > png_ptr->idat_size)

-            png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;

-         png_crc_read(png_ptr, png_ptr->zbuf,

-            (png_size_t)png_ptr->zstream.avail_in);

-         png_ptr->idat_size -= png_ptr->zstream.avail_in;

-      }

-      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

-      if (ret == Z_STREAM_END)

-      {

-         if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||

-            png_ptr->idat_size)

-            png_benign_error(png_ptr, "Extra compressed data");

-         png_ptr->mode |= PNG_AFTER_IDAT;

-         png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

-         break;

-      }

-      if (ret != Z_OK)

-         png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :

-                   "Decompression error");

-

-   } while (png_ptr->zstream.avail_out);

-

-   png_ptr->row_info.color_type = png_ptr->color_type;

-   png_ptr->row_info.width = png_ptr->iwidth;

-   png_ptr->row_info.channels = png_ptr->channels;

-   png_ptr->row_info.bit_depth = png_ptr->bit_depth;

-   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;

-   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

-       png_ptr->row_info.width);

-

-   if (png_ptr->row_buf[0])

-   png_read_filter_row(png_ptr, &(png_ptr->row_info),

-      png_ptr->row_buf + 1, png_ptr->prev_row + 1,

-      (int)(png_ptr->row_buf[0]));

-

-   png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);

+        }

+        if(ret != Z_OK)

+            png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :

+                      "Decompression error");

+

+    }

+    while(png_ptr->zstream.avail_out);

+

+    png_ptr->row_info.color_type = png_ptr->color_type;

+    png_ptr->row_info.width = png_ptr->iwidth;

+    png_ptr->row_info.channels = png_ptr->channels;

+    png_ptr->row_info.bit_depth = png_ptr->bit_depth;

+    png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;

+    png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

+                                 png_ptr->row_info.width);

+

+    if(png_ptr->row_buf[0])

+        png_read_filter_row(png_ptr, &(png_ptr->row_info),

+                            png_ptr->row_buf + 1, png_ptr->prev_row + 1,

+                            (int)(png_ptr->row_buf[0]));

+

+    png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);

 

 #ifdef PNG_MNG_FEATURES_SUPPORTED

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

-      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

-   {

-      /* Intrapixel differencing */

-      png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);

-   }

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

+       (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

+    {

+        /* Intrapixel differencing */

+        png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    }

 #endif

 

 

-   if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))

-      png_do_read_transformations(png_ptr);

+    if(png_ptr->transformations || (png_ptr->flags & PNG_FLAG_STRIP_ALPHA))

+        png_do_read_transformations(png_ptr);

 

 #ifdef PNG_READ_INTERLACING_SUPPORTED

-   /* Blow up interlaced rows to full size */

-   if (png_ptr->interlaced &&

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

-          */

-         png_do_read_interlace(png_ptr);

-

-      if (dsp_row != NULL)

-         png_combine_row(png_ptr, dsp_row,

-            png_pass_dsp_mask[png_ptr->pass]);

-      if (row != NULL)

-         png_combine_row(png_ptr, row,

-            png_pass_mask[png_ptr->pass]);

-   }

-   else

-#endif

-   {

-      if (row != NULL)

-         png_combine_row(png_ptr, row, 0xff);

-      if (dsp_row != NULL)

-         png_combine_row(png_ptr, dsp_row, 0xff);

-   }

-   png_read_finish_row(png_ptr);

-

-   if (png_ptr->read_row_fn != NULL)

-      (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

+    /* Blow up interlaced rows to full size */

+    if(png_ptr->interlaced &&

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

+             */

+            png_do_read_interlace(png_ptr);

+

+        if(dsp_row != NULL)

+            png_combine_row(png_ptr, dsp_row,

+                            png_pass_dsp_mask[png_ptr->pass]);

+        if(row != NULL)

+            png_combine_row(png_ptr, row,

+                            png_pass_mask[png_ptr->pass]);

+    }

+    else

+#endif

+    {

+        if(row != NULL)

+            png_combine_row(png_ptr, row, 0xff);

+        if(dsp_row != NULL)

+            png_combine_row(png_ptr, dsp_row, 0xff);

+    }

+    png_read_finish_row(png_ptr);

+

+    if(png_ptr->read_row_fn != NULL)

+        (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

 }

 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

 

@@ -717,40 +726,40 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
 

 void PNGAPI

 png_read_rows(png_structp png_ptr, png_bytepp row,

-   png_bytepp display_row, png_uint_32 num_rows)

+              png_bytepp display_row, png_uint_32 num_rows)

 {

-   png_uint_32 i;

-   png_bytepp rp;

-   png_bytepp dp;

-

-   png_debug(1, "in png_read_rows");

- 

-   if (png_ptr == NULL)

-      return;

-   rp = row;

-   dp = display_row;

-   if (rp != NULL && dp != NULL)

-      for (i = 0; i < num_rows; i++)

-      {

-         png_bytep rptr = *rp++;

-         png_bytep dptr = *dp++;

-

-         png_read_row(png_ptr, rptr, dptr);

-      }

-   else if (rp != NULL)

-      for (i = 0; i < num_rows; i++)

-      {

-         png_bytep rptr = *rp;

-         png_read_row(png_ptr, rptr, NULL);

-         rp++;

-      }

-   else if (dp != NULL)

-      for (i = 0; i < num_rows; i++)

-      {

-         png_bytep dptr = *dp;

-         png_read_row(png_ptr, NULL, dptr);

-         dp++;

-      }

+    png_uint_32 i;

+    png_bytepp rp;

+    png_bytepp dp;

+

+    png_debug(1, "in png_read_rows");

+

+    if(png_ptr == NULL)

+        return;

+    rp = row;

+    dp = display_row;

+    if(rp != NULL && dp != NULL)

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

+        {

+            png_bytep rptr = *rp++;

+            png_bytep dptr = *dp++;

+

+            png_read_row(png_ptr, rptr, dptr);

+        }

+    else if(rp != NULL)

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

+        {

+            png_bytep rptr = *rp;

+            png_read_row(png_ptr, rptr, NULL);

+            rp++;

+        }

+    else if(dp != NULL)

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

+        {

+            png_bytep dptr = *dp;

+            png_read_row(png_ptr, NULL, dptr);

+            dp++;

+        }

 }

 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

 

@@ -770,37 +779,37 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
 void PNGAPI

 png_read_image(png_structp png_ptr, png_bytepp image)

 {

-   png_uint_32 i, image_height;

-   int pass, j;

-   png_bytepp rp;

+    png_uint_32 i, image_height;

+    int pass, j;

+    png_bytepp rp;

 

-   png_debug(1, "in png_read_image");

- 

-   if (png_ptr == NULL)

-      return;

+    png_debug(1, "in png_read_image");

+

+    if(png_ptr == NULL)

+        return;

 

 #ifdef PNG_READ_INTERLACING_SUPPORTED

-   pass = png_set_interlace_handling(png_ptr);

+    pass = png_set_interlace_handling(png_ptr);

 #else

-   if (png_ptr->interlaced)

-      png_error(png_ptr,

-        "Cannot read interlaced image -- interlace handler disabled");

-   pass = 1;

+    if(png_ptr->interlaced)

+        png_error(png_ptr,

+                  "Cannot read interlaced image -- interlace handler disabled");

+    pass = 1;

 #endif

 

 

-   image_height=png_ptr->height;

-   png_ptr->num_rows = image_height; /* Make sure this is set correctly */

+    image_height = png_ptr->height;

+    png_ptr->num_rows = image_height; /* Make sure this is set correctly */

 

-   for (j = 0; j < pass; j++)

-   {

-      rp = image;

-      for (i = 0; i < image_height; i++)

-      {

-         png_read_row(png_ptr, *rp, NULL);

-         rp++;

-      }

-   }

+    for(j = 0; j < pass; j++)

+    {

+        rp = image;

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

+        {

+            png_read_row(png_ptr, *rp, NULL);

+            rp++;

+        }

+    }

 }

 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

 

@@ -812,373 +821,374 @@ png_read_image(png_structp png_ptr, png_bytepp image)
 void PNGAPI

 png_read_end(png_structp png_ptr, png_infop info_ptr)

 {

-   png_debug(1, "in png_read_end");

- 

-   if (png_ptr == NULL)

-      return;

-   png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */

-

-   do

-   {

-      PNG_IHDR;

-      PNG_IDAT;

-      PNG_IEND;

-      PNG_PLTE;

+    png_debug(1, "in png_read_end");

+

+    if(png_ptr == NULL)

+        return;

+    png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */

+

+    do

+    {

+        PNG_IHDR;

+        PNG_IDAT;

+        PNG_IEND;

+        PNG_PLTE;

 #ifdef PNG_READ_bKGD_SUPPORTED

-      PNG_bKGD;

+        PNG_bKGD;

 #endif

 #ifdef PNG_READ_cHRM_SUPPORTED

-      PNG_cHRM;

+        PNG_cHRM;

 #endif

 #ifdef PNG_READ_gAMA_SUPPORTED

-      PNG_gAMA;

+        PNG_gAMA;

 #endif

 #ifdef PNG_READ_hIST_SUPPORTED

-      PNG_hIST;

+        PNG_hIST;

 #endif

 #ifdef PNG_READ_iCCP_SUPPORTED

-      PNG_iCCP;

+        PNG_iCCP;

 #endif

 #ifdef PNG_READ_iTXt_SUPPORTED

-      PNG_iTXt;

+        PNG_iTXt;

 #endif

 #ifdef PNG_READ_oFFs_SUPPORTED

-      PNG_oFFs;

+        PNG_oFFs;

 #endif

 #ifdef PNG_READ_pCAL_SUPPORTED

-      PNG_pCAL;

+        PNG_pCAL;

 #endif

 #ifdef PNG_READ_pHYs_SUPPORTED

-      PNG_pHYs;

+        PNG_pHYs;

 #endif

 #ifdef PNG_READ_sBIT_SUPPORTED

-      PNG_sBIT;

+        PNG_sBIT;

 #endif

 #ifdef PNG_READ_sCAL_SUPPORTED

-      PNG_sCAL;

+        PNG_sCAL;

 #endif

 #ifdef PNG_READ_sPLT_SUPPORTED

-      PNG_sPLT;

+        PNG_sPLT;

 #endif

 #ifdef PNG_READ_sRGB_SUPPORTED

-      PNG_sRGB;

+        PNG_sRGB;

 #endif

 #ifdef PNG_READ_tEXt_SUPPORTED

-      PNG_tEXt;

+        PNG_tEXt;

 #endif

 #ifdef PNG_READ_tIME_SUPPORTED

-      PNG_tIME;

+        PNG_tIME;

 #endif

 #ifdef PNG_READ_tRNS_SUPPORTED

-      PNG_tRNS;

+        PNG_tRNS;

 #endif

 #ifdef PNG_READ_zTXt_SUPPORTED

-      PNG_zTXt;

+        PNG_zTXt;

 #endif

-      png_uint_32 length = png_read_chunk_header(png_ptr);

-      PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;

+        png_uint_32 length = png_read_chunk_header(png_ptr);

+        PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;

 

-      if (!png_memcmp(chunk_name, png_IHDR, 4))

-         png_handle_IHDR(png_ptr, info_ptr, length);

-      else if (!png_memcmp(chunk_name, png_IEND, 4))

-         png_handle_IEND(png_ptr, info_ptr, length);

+        if(!png_memcmp(chunk_name, png_IHDR, 4))

+            png_handle_IHDR(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_IEND, 4))

+            png_handle_IEND(png_ptr, info_ptr, length);

 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-      else if (png_handle_as_unknown(png_ptr, chunk_name))

-      {

-         if (!png_memcmp(chunk_name, png_IDAT, 4))

-         {

-            if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))

-               png_benign_error(png_ptr, "Too many IDATs found");

-         }

-         png_handle_unknown(png_ptr, info_ptr, length);

-         if (!png_memcmp(chunk_name, png_PLTE, 4))

-            png_ptr->mode |= PNG_HAVE_PLTE;

-      }

-#endif

-      else if (!png_memcmp(chunk_name, png_IDAT, 4))

-      {

-         /* Zero length IDATs are legal after the last IDAT has been

-          * read, but not after other chunks have been read.

-          */

-         if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))

-            png_benign_error(png_ptr, "Too many IDATs found");

-         png_crc_finish(png_ptr, length);

-      }

-      else if (!png_memcmp(chunk_name, png_PLTE, 4))

-         png_handle_PLTE(png_ptr, info_ptr, length);

+        else if(png_handle_as_unknown(png_ptr, chunk_name))

+        {

+            if(!png_memcmp(chunk_name, png_IDAT, 4))

+            {

+                if((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))

+                    png_benign_error(png_ptr, "Too many IDATs found");

+            }

+            png_handle_unknown(png_ptr, info_ptr, length);

+            if(!png_memcmp(chunk_name, png_PLTE, 4))

+                png_ptr->mode |= PNG_HAVE_PLTE;

+        }

+#endif

+        else if(!png_memcmp(chunk_name, png_IDAT, 4))

+        {

+            /* Zero length IDATs are legal after the last IDAT has been

+             * read, but not after other chunks have been read.

+             */

+            if((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))

+                png_benign_error(png_ptr, "Too many IDATs found");

+            png_crc_finish(png_ptr, length);

+        }

+        else if(!png_memcmp(chunk_name, png_PLTE, 4))

+            png_handle_PLTE(png_ptr, info_ptr, length);

 #ifdef PNG_READ_bKGD_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_bKGD, 4))

-         png_handle_bKGD(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_bKGD, 4))

+            png_handle_bKGD(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_cHRM_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_cHRM, 4))

-         png_handle_cHRM(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_cHRM, 4))

+            png_handle_cHRM(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_gAMA_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_gAMA, 4))

-         png_handle_gAMA(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_gAMA, 4))

+            png_handle_gAMA(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_hIST_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_hIST, 4))

-         png_handle_hIST(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_hIST, 4))

+            png_handle_hIST(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_oFFs_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_oFFs, 4))

-         png_handle_oFFs(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_oFFs, 4))

+            png_handle_oFFs(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_pCAL_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_pCAL, 4))

-         png_handle_pCAL(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_pCAL, 4))

+            png_handle_pCAL(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_sCAL_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sCAL, 4))

-         png_handle_sCAL(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_sCAL, 4))

+            png_handle_sCAL(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_pHYs_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_pHYs, 4))

-         png_handle_pHYs(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_pHYs, 4))

+            png_handle_pHYs(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_sBIT_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sBIT, 4))

-         png_handle_sBIT(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_sBIT, 4))

+            png_handle_sBIT(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_sRGB_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sRGB, 4))

-         png_handle_sRGB(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_sRGB, 4))

+            png_handle_sRGB(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_iCCP_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_iCCP, 4))

-         png_handle_iCCP(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_iCCP, 4))

+            png_handle_iCCP(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_sPLT_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_sPLT, 4))

-         png_handle_sPLT(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_sPLT, 4))

+            png_handle_sPLT(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_tEXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tEXt, 4))

-         png_handle_tEXt(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_tEXt, 4))

+            png_handle_tEXt(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_tIME_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tIME, 4))

-         png_handle_tIME(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_tIME, 4))

+            png_handle_tIME(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_tRNS_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_tRNS, 4))

-         png_handle_tRNS(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_tRNS, 4))

+            png_handle_tRNS(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_zTXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_zTXt, 4))

-         png_handle_zTXt(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_zTXt, 4))

+            png_handle_zTXt(png_ptr, info_ptr, length);

 #endif

 #ifdef PNG_READ_iTXt_SUPPORTED

-      else if (!png_memcmp(chunk_name, png_iTXt, 4))

-         png_handle_iTXt(png_ptr, info_ptr, length);

+        else if(!png_memcmp(chunk_name, png_iTXt, 4))

+            png_handle_iTXt(png_ptr, info_ptr, length);

 #endif

-      else

-         png_handle_unknown(png_ptr, info_ptr, length);

-   } while (!(png_ptr->mode & PNG_HAVE_IEND));

+        else

+            png_handle_unknown(png_ptr, info_ptr, length);

+    }

+    while(!(png_ptr->mode & PNG_HAVE_IEND));

 }

 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

 

 /* Free all memory used by the read */

 void PNGAPI

 png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,

-   png_infopp end_info_ptr_ptr)

+                        png_infopp end_info_ptr_ptr)

 {

-   png_structp png_ptr = NULL;

-   png_infop info_ptr = NULL, end_info_ptr = NULL;

+    png_structp png_ptr = NULL;

+    png_infop info_ptr = NULL, end_info_ptr = NULL;

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_free_ptr free_fn = NULL;

-   png_voidp mem_ptr = NULL;

+    png_free_ptr free_fn = NULL;

+    png_voidp mem_ptr = NULL;

 #endif

 

-   png_debug(1, "in png_destroy_read_struct");

- 

-   if (png_ptr_ptr != NULL)

-      png_ptr = *png_ptr_ptr;

-   if (png_ptr == NULL)

-      return;

+    png_debug(1, "in png_destroy_read_struct");

+

+    if(png_ptr_ptr != NULL)

+        png_ptr = *png_ptr_ptr;

+    if(png_ptr == NULL)

+        return;

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   free_fn = png_ptr->free_fn;

-   mem_ptr = png_ptr->mem_ptr;

+    free_fn = png_ptr->free_fn;

+    mem_ptr = png_ptr->mem_ptr;

 #endif

 

-   if (info_ptr_ptr != NULL)

-      info_ptr = *info_ptr_ptr;

+    if(info_ptr_ptr != NULL)

+        info_ptr = *info_ptr_ptr;

 

-   if (end_info_ptr_ptr != NULL)

-      end_info_ptr = *end_info_ptr_ptr;

+    if(end_info_ptr_ptr != NULL)

+        end_info_ptr = *end_info_ptr_ptr;

 

-   png_read_destroy(png_ptr, info_ptr, end_info_ptr);

+    png_read_destroy(png_ptr, info_ptr, end_info_ptr);

 

-   if (info_ptr != NULL)

-   {

+    if(info_ptr != NULL)

+    {

 #ifdef PNG_TEXT_SUPPORTED

-      png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);

+        png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);

 #endif

 

 #ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,

-          (png_voidp)mem_ptr);

+        png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,

+                             (png_voidp)mem_ptr);

 #else

-      png_destroy_struct((png_voidp)info_ptr);

+        png_destroy_struct((png_voidp)info_ptr);

 #endif

-      *info_ptr_ptr = NULL;

-   }

+        *info_ptr_ptr = NULL;

+    }

 

-   if (end_info_ptr != NULL)

-   {

+    if(end_info_ptr != NULL)

+    {

 #ifdef PNG_READ_TEXT_SUPPORTED

-      png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);

+        png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);

 #endif

 #ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,

-         (png_voidp)mem_ptr);

+        png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,

+                             (png_voidp)mem_ptr);

 #else

-      png_destroy_struct((png_voidp)end_info_ptr);

+        png_destroy_struct((png_voidp)end_info_ptr);

 #endif

-      *end_info_ptr_ptr = NULL;

-   }

+        *end_info_ptr_ptr = NULL;

+    }

 

-   if (png_ptr != NULL)

-   {

+    if(png_ptr != 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

-      *png_ptr_ptr = NULL;

-   }

+        *png_ptr_ptr = NULL;

+    }

 }

 

 /* Free all memory used by the read (old method) */

 void /* PRIVATE */

 png_read_destroy(png_structp png_ptr, png_infop info_ptr,

-    png_infop end_info_ptr)

+                 png_infop end_info_ptr)

 {

 #ifdef PNG_SETJMP_SUPPORTED

-   jmp_buf tmp_jmp;

+    jmp_buf tmp_jmp;

 #endif

-   png_error_ptr error_fn;

-   png_error_ptr warning_fn;

-   png_voidp error_ptr;

+    png_error_ptr error_fn;

+    png_error_ptr warning_fn;

+    png_voidp error_ptr;

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_free_ptr free_fn;

+    png_free_ptr free_fn;

 #endif

 

-   png_debug(1, "in png_read_destroy");

- 

-   if (info_ptr != NULL)

-      png_info_destroy(png_ptr, info_ptr);

+    png_debug(1, "in png_read_destroy");

 

-   if (end_info_ptr != NULL)

-      png_info_destroy(png_ptr, end_info_ptr);

+    if(info_ptr != NULL)

+        png_info_destroy(png_ptr, info_ptr);

 

-   png_free(png_ptr, png_ptr->zbuf);

-   png_free(png_ptr, png_ptr->big_row_buf);

-   png_free(png_ptr, png_ptr->prev_row);

-   png_free(png_ptr, png_ptr->chunkdata);

+    if(end_info_ptr != NULL)

+        png_info_destroy(png_ptr, end_info_ptr);

+

+    png_free(png_ptr, png_ptr->zbuf);

+    png_free(png_ptr, png_ptr->big_row_buf);

+    png_free(png_ptr, png_ptr->prev_row);

+    png_free(png_ptr, png_ptr->chunkdata);

 #ifdef PNG_READ_DITHER_SUPPORTED

-   png_free(png_ptr, png_ptr->palette_lookup);

-   png_free(png_ptr, png_ptr->dither_index);

+    png_free(png_ptr, png_ptr->palette_lookup);

+    png_free(png_ptr, png_ptr->dither_index);

 #endif

 #ifdef PNG_READ_GAMMA_SUPPORTED

-   png_free(png_ptr, png_ptr->gamma_table);

+    png_free(png_ptr, png_ptr->gamma_table);

 #endif

 #ifdef PNG_READ_BACKGROUND_SUPPORTED

-   png_free(png_ptr, png_ptr->gamma_from_1);

-   png_free(png_ptr, png_ptr->gamma_to_1);

+    png_free(png_ptr, png_ptr->gamma_from_1);

+    png_free(png_ptr, png_ptr->gamma_to_1);

 #endif

-   if (png_ptr->free_me & PNG_FREE_PLTE)

-      png_zfree(png_ptr, png_ptr->palette);

-   png_ptr->free_me &= ~PNG_FREE_PLTE;

+    if(png_ptr->free_me & PNG_FREE_PLTE)

+        png_zfree(png_ptr, png_ptr->palette);

+    png_ptr->free_me &= ~PNG_FREE_PLTE;

 #if defined(PNG_tRNS_SUPPORTED) || \

     defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-   if (png_ptr->free_me & PNG_FREE_TRNS)

-      png_free(png_ptr, png_ptr->trans_alpha);

-   png_ptr->free_me &= ~PNG_FREE_TRNS;

+    if(png_ptr->free_me & PNG_FREE_TRNS)

+        png_free(png_ptr, png_ptr->trans_alpha);

+    png_ptr->free_me &= ~PNG_FREE_TRNS;

 #endif

 #ifdef PNG_READ_hIST_SUPPORTED

-   if (png_ptr->free_me & PNG_FREE_HIST)

-      png_free(png_ptr, png_ptr->hist);

-   png_ptr->free_me &= ~PNG_FREE_HIST;

+    if(png_ptr->free_me & PNG_FREE_HIST)

+        png_free(png_ptr, png_ptr->hist);

+    png_ptr->free_me &= ~PNG_FREE_HIST;

 #endif

 #ifdef PNG_READ_GAMMA_SUPPORTED

-   if (png_ptr->gamma_16_table != NULL)

-   {

-      int i;

-      int istop = (1 << (8 - png_ptr->gamma_shift));

-      for (i = 0; i < istop; i++)

-      {

-         png_free(png_ptr, png_ptr->gamma_16_table[i]);

-      }

-   png_free(png_ptr, png_ptr->gamma_16_table);

-   }

+    if(png_ptr->gamma_16_table != NULL)

+    {

+        int i;

+        int istop = (1 << (8 - png_ptr->gamma_shift));

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

+        {

+            png_free(png_ptr, png_ptr->gamma_16_table[i]);

+        }

+        png_free(png_ptr, png_ptr->gamma_16_table);

+    }

 #ifdef PNG_READ_BACKGROUND_SUPPORTED

-   if (png_ptr->gamma_16_from_1 != NULL)

-   {

-      int i;

-      int istop = (1 << (8 - png_ptr->gamma_shift));

-      for (i = 0; i < istop; i++)

-      {

-         png_free(png_ptr, png_ptr->gamma_16_from_1[i]);

-      }

-   png_free(png_ptr, png_ptr->gamma_16_from_1);

-   }

-   if (png_ptr->gamma_16_to_1 != NULL)

-   {

-      int i;

-      int istop = (1 << (8 - png_ptr->gamma_shift));

-      for (i = 0; i < istop; i++)

-      {

-         png_free(png_ptr, png_ptr->gamma_16_to_1[i]);

-      }

-   png_free(png_ptr, png_ptr->gamma_16_to_1);

-   }

+    if(png_ptr->gamma_16_from_1 != NULL)

+    {

+        int i;

+        int istop = (1 << (8 - png_ptr->gamma_shift));

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

+        {

+            png_free(png_ptr, png_ptr->gamma_16_from_1[i]);

+        }

+        png_free(png_ptr, png_ptr->gamma_16_from_1);

+    }

+    if(png_ptr->gamma_16_to_1 != NULL)

+    {

+        int i;

+        int istop = (1 << (8 - png_ptr->gamma_shift));

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

+        {

+            png_free(png_ptr, png_ptr->gamma_16_to_1[i]);

+        }

+        png_free(png_ptr, png_ptr->gamma_16_to_1);

+    }

 #endif

 #endif

 #ifdef PNG_TIME_RFC1123_SUPPORTED

-   png_free(png_ptr, png_ptr->time_buffer);

+    png_free(png_ptr, png_ptr->time_buffer);

 #endif

 

-   inflateEnd(&png_ptr->zstream);

+    inflateEnd(&png_ptr->zstream);

 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED

-   png_free(png_ptr, png_ptr->save_buffer);

+    png_free(png_ptr, png_ptr->save_buffer);

 #endif

 

 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED

 #ifdef PNG_TEXT_SUPPORTED

-   png_free(png_ptr, png_ptr->current_text);

+    png_free(png_ptr, png_ptr->current_text);

 #endif /* PNG_TEXT_SUPPORTED */

 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

 

-   /* Save the important info out of the png_struct, in case it is

-    * being used again.

-    */

+    /* Save the important info out of the png_struct, in case it is

+     * being used again.

+     */

 #ifdef PNG_SETJMP_SUPPORTED

-   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));

+    png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));

 #endif

 

-   error_fn = png_ptr->error_fn;

-   warning_fn = png_ptr->warning_fn;

-   error_ptr = png_ptr->error_ptr;

+    error_fn = png_ptr->error_fn;

+    warning_fn = png_ptr->warning_fn;

+    error_ptr = png_ptr->error_ptr;

 #ifdef PNG_USER_MEM_SUPPORTED

-   free_fn = png_ptr->free_fn;

+    free_fn = png_ptr->free_fn;

 #endif

 

-   png_memset(png_ptr, 0, png_sizeof(png_struct));

+    png_memset(png_ptr, 0, png_sizeof(png_struct));

 

-   png_ptr->error_fn = error_fn;

-   png_ptr->warning_fn = warning_fn;

-   png_ptr->error_ptr = error_ptr;

+    png_ptr->error_fn = error_fn;

+    png_ptr->warning_fn = warning_fn;

+    png_ptr->error_ptr = error_ptr;

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_ptr->free_fn = free_fn;

+    png_ptr->free_fn = free_fn;

 #endif

 

 #ifdef PNG_SETJMP_SUPPORTED

-   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));

+    png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));

 #endif

 

 }

@@ -1186,9 +1196,9 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr,
 void PNGAPI

 png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)

 {

-   if (png_ptr == NULL)

-      return;

-   png_ptr->read_row_fn = read_row_fn;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->read_row_fn = read_row_fn;

 }

 

 

@@ -1196,164 +1206,164 @@ png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
 #ifdef PNG_INFO_IMAGE_SUPPORTED

 void PNGAPI

 png_read_png(png_structp png_ptr, png_infop info_ptr,

-                           int transforms,

-                           voidp params)

+             int transforms,

+             voidp params)

 {

-   int row;

+    int row;

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

-   /* png_read_info() gives us all of the information from the

-    * PNG file before the first IDAT (image data chunk).

-    */

-   png_read_info(png_ptr, info_ptr);

-   if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))

-      png_error(png_ptr, "Image is too high to process with png_read_png()");

+    /* png_read_info() gives us all of the information from the

+     * PNG file before the first IDAT (image data chunk).

+     */

+    png_read_info(png_ptr, info_ptr);

+    if(info_ptr->height > PNG_UINT_32_MAX / png_sizeof(png_bytep))

+        png_error(png_ptr, "Image is too high to process with png_read_png()");

 

-   /* -------------- image transformations start here ------------------- */

+    /* -------------- image transformations start here ------------------- */

 

 #ifdef PNG_READ_16_TO_8_SUPPORTED

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

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

 #endif

 

 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED

-   /* Strip alpha bytes from the input data without combining with

-    * the background (not recommended).

-    */

-   if (transforms & PNG_TRANSFORM_STRIP_ALPHA)

-      png_set_strip_alpha(png_ptr);

+    /* Strip alpha bytes from the input data without combining with

+     * the background (not recommended).

+     */

+    if(transforms & PNG_TRANSFORM_STRIP_ALPHA)

+        png_set_strip_alpha(png_ptr);

 #endif

 

 #if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)

-   /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single

-    * byte into separate bytes (useful for paletted and grayscale images).

-    */

-   if (transforms & PNG_TRANSFORM_PACKING)

-      png_set_packing(png_ptr);

+    /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single

+     * byte into separate bytes (useful for paletted and grayscale images).

+     */

+    if(transforms & PNG_TRANSFORM_PACKING)

+        png_set_packing(png_ptr);

 #endif

 

 #ifdef PNG_READ_PACKSWAP_SUPPORTED

-   /* Change the order of packed pixels to least significant bit first

-    * (not useful if you are using png_set_packing).

-    */

-   if (transforms & PNG_TRANSFORM_PACKSWAP)

-      png_set_packswap(png_ptr);

+    /* Change the order of packed pixels to least significant bit first

+     * (not useful if you are using png_set_packing).

+     */

+    if(transforms & PNG_TRANSFORM_PACKSWAP)

+        png_set_packswap(png_ptr);

 #endif

 

 #ifdef PNG_READ_EXPAND_SUPPORTED

-   /* Expand paletted colors into true RGB triplets

-    * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel

-    * Expand paletted or RGB images with transparency to full alpha

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

-         png_set_expand(png_ptr);

+    /* Expand paletted colors into true RGB triplets

+     * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel

+     * Expand paletted or RGB images with transparency to full alpha

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

+            png_set_expand(png_ptr);

 #endif

 

-   /* We don't handle background color or gamma transformation or dithering.

-    */

+    /* We don't handle background color or gamma transformation or dithering.

+     */

 

 #ifdef PNG_READ_INVERT_SUPPORTED

-   /* Invert monochrome files to have 0 as white and 1 as black

-    */

-   if (transforms & PNG_TRANSFORM_INVERT_MONO)

-      png_set_invert_mono(png_ptr);

+    /* Invert monochrome files to have 0 as white and 1 as black

+     */

+    if(transforms & PNG_TRANSFORM_INVERT_MONO)

+        png_set_invert_mono(png_ptr);

 #endif

 

 #ifdef PNG_READ_SHIFT_SUPPORTED

-   /* If you want to shift the pixel values from the range [0,255] or

-    * [0,65535] to the original [0,7] or [0,31], or whatever range the

-    * colors were originally in:

-    */

-   if ((transforms & PNG_TRANSFORM_SHIFT)

+    /* If you want to shift the pixel values from the range [0,255] or

+     * [0,65535] to the original [0,7] or [0,31], or whatever range the

+     * colors were originally in:

+     */

+    if((transforms & PNG_TRANSFORM_SHIFT)

        && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))

-   {

-      png_color_8p sig_bit;

+    {

+        png_color_8p sig_bit;

 

-      png_get_sBIT(png_ptr, info_ptr, &sig_bit);

-      png_set_shift(png_ptr, sig_bit);

-   }

+        png_get_sBIT(png_ptr, info_ptr, &sig_bit);

+        png_set_shift(png_ptr, sig_bit);

+    }

 #endif

 

 #ifdef PNG_READ_BGR_SUPPORTED

-   /* Flip the RGB pixels to BGR (or RGBA to BGRA)

-    */

-   if (transforms & PNG_TRANSFORM_BGR)

-      png_set_bgr(png_ptr);

+    /* Flip the RGB pixels to BGR (or RGBA to BGRA)

+     */

+    if(transforms & PNG_TRANSFORM_BGR)

+        png_set_bgr(png_ptr);

 #endif

 

 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED

-   /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)

-    */

-   if (transforms & PNG_TRANSFORM_SWAP_ALPHA)

-       png_set_swap_alpha(png_ptr);

+    /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)

+     */

+    if(transforms & PNG_TRANSFORM_SWAP_ALPHA)

+        png_set_swap_alpha(png_ptr);

 #endif

 

 #ifdef PNG_READ_SWAP_SUPPORTED

-   /* Swap bytes of 16 bit files to least significant byte first

-    */

-   if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)

-      png_set_swap(png_ptr);

+    /* Swap bytes of 16 bit files to least significant byte first

+     */

+    if(transforms & PNG_TRANSFORM_SWAP_ENDIAN)

+        png_set_swap(png_ptr);

 #endif

 

-/* Added at libpng-1.2.41 */

+    /* Added at libpng-1.2.41 */

 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

-   /* Invert the alpha channel from opacity to transparency

-    */

-   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)

-       png_set_invert_alpha(png_ptr);

+    /* Invert the alpha channel from opacity to transparency

+     */

+    if(transforms & PNG_TRANSFORM_INVERT_ALPHA)

+        png_set_invert_alpha(png_ptr);

 #endif

 

-/* Added at libpng-1.2.41 */

+    /* Added at libpng-1.2.41 */

 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-   /* Expand grayscale image to RGB

-    */

-   if (transforms & PNG_TRANSFORM_GRAY_TO_RGB)

-       png_set_gray_to_rgb(png_ptr);

+    /* Expand grayscale image to RGB

+     */

+    if(transforms & PNG_TRANSFORM_GRAY_TO_RGB)

+        png_set_gray_to_rgb(png_ptr);

 #endif

 

-   /* We don't handle adding filler bytes */

+    /* We don't handle adding filler bytes */

 

-   /* Optional call to gamma correct and add the background to the palette

-    * and update info structure.  REQUIRED if you are expecting libpng to

-    * update the palette for you (i.e., you selected such a transform above).

-    */

-   png_read_update_info(png_ptr, info_ptr);

+    /* Optional call to gamma correct and add the background to the palette

+     * and update info structure.  REQUIRED if you are expecting libpng to

+     * update the palette for you (i.e., you selected such a transform above).

+     */

+    png_read_update_info(png_ptr, info_ptr);

 

-   /* -------------- image transformations end here ------------------- */

+    /* -------------- image transformations end here ------------------- */

 

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

-   if (info_ptr->row_pointers == NULL)

-   {

-    png_uint_32 iptr;

+    png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);

+    if(info_ptr->row_pointers == NULL)

+    {

+        png_uint_32 iptr;

 

-      info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,

-         info_ptr->height * png_sizeof(png_bytep));

-      for (iptr=0; iptr<info_ptr->height; iptr++)

-         info_ptr->row_pointers[iptr] = NULL;

+        info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,

+                                 info_ptr->height * png_sizeof(png_bytep));

+        for(iptr = 0; iptr < info_ptr->height; iptr++)

+            info_ptr->row_pointers[iptr] = NULL;

 

-      info_ptr->free_me |= PNG_FREE_ROWS;

+        info_ptr->free_me |= PNG_FREE_ROWS;

 

-      for (row = 0; row < (int)info_ptr->height; row++)

-         info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,

-            png_get_rowbytes(png_ptr, info_ptr));

-   }

+        for(row = 0; row < (int)info_ptr->height; row++)

+            info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,

+                                          png_get_rowbytes(png_ptr, info_ptr));

+    }

 

-   png_read_image(png_ptr, info_ptr->row_pointers);

-   info_ptr->valid |= PNG_INFO_IDAT;

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

-   png_read_end(png_ptr, info_ptr);

+    /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */

+    png_read_end(png_ptr, info_ptr);

 

-   transforms = transforms; /* Quiet compiler warnings */

-   params = params;

+    transforms = transforms; /* Quiet compiler warnings */

+    params = params;

 

 }

 #endif /* PNG_INFO_IMAGE_SUPPORTED */

diff --git a/src/libpng/pngrio.c b/src/libpng/pngrio.c
index 990fe3f5a..6bae87b88 100644
--- a/src/libpng/pngrio.c
+++ b/src/libpng/pngrio.c
@@ -32,12 +32,12 @@
 void /* PRIVATE */

 png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   png_debug1(4, "reading %d bytes", (int)length);

- 

-   if (png_ptr->read_data_fn != NULL)

-      (*(png_ptr->read_data_fn))(png_ptr, data, length);

-   else

-      png_error(png_ptr, "Call to NULL read function");

+    png_debug1(4, "reading %d bytes", (int)length);

+

+    if(png_ptr->read_data_fn != NULL)

+        (*(png_ptr->read_data_fn))(png_ptr, data, length);

+    else

+        png_error(png_ptr, "Call to NULL read function");

 }

 

 #ifdef PNG_STDIO_SUPPORTED

@@ -50,17 +50,17 @@ png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 void PNGAPI

 png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   png_size_t check;

+    png_size_t check;

 

-   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.

-    */

-   check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr);

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

+     */

+    check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr);

 

-   if (check != length)

-      png_error(png_ptr, "Read Error");

+    if(check != length)

+        png_error(png_ptr, "Read Error");

 }

 #else

 /* This is the model-independent version. Since the standard I/O library

@@ -74,41 +74,41 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 static void PNGAPI

 png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   png_size_t check;

-   png_byte *n_data;

-   png_FILE_p io_ptr;

+    png_size_t check;

+    png_byte *n_data;

+    png_FILE_p io_ptr;

 

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

-   if ((png_bytep)n_data == data)

-   {

-      check = fread(n_data, 1, length, io_ptr);

-   }

-   else

-   {

-      png_byte buf[NEAR_BUF_SIZE];

-      png_size_t read, remaining, err;

-      check = 0;

-      remaining = length;

-      do

-      {

-         read = MIN(NEAR_BUF_SIZE, remaining);

-         err = fread(buf, 1, read, io_ptr);

-         png_memcpy(data, buf, read); /* copy far buffer to near buffer */

-         if (err != read)

-            break;

-         else

-            check += err;

-         data += read;

-         remaining -= read;

-      }

-      while (remaining != 0);

-   }

-   if ((png_uint_32)check != (png_uint_32)length)

-      png_error(png_ptr, "read Error");

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

+    if((png_bytep)n_data == data)

+    {

+        check = fread(n_data, 1, length, io_ptr);

+    }

+    else

+    {

+        png_byte buf[NEAR_BUF_SIZE];

+        png_size_t read, remaining, err;

+        check = 0;

+        remaining = length;

+        do

+        {

+            read = MIN(NEAR_BUF_SIZE, remaining);

+            err = fread(buf, 1, read, io_ptr);

+            png_memcpy(data, buf, read); /* copy far buffer to near buffer */

+            if(err != read)

+                break;

+            else

+                check += err;

+            data += read;

+            remaining -= read;

+        }

+        while(remaining != 0);

+    }

+    if((png_uint_32)check != (png_uint_32)length)

+        png_error(png_ptr, "read Error");

 }

 #endif

 #endif

@@ -131,33 +131,33 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
  */

 void PNGAPI

 png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,

-   png_rw_ptr read_data_fn)

+                png_rw_ptr read_data_fn)

 {

-   if (png_ptr == NULL)

-      return;

-   png_ptr->io_ptr = io_ptr;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->io_ptr = io_ptr;

 

 #ifdef PNG_STDIO_SUPPORTED

-   if (read_data_fn != NULL)

-      png_ptr->read_data_fn = read_data_fn;

-   else

-      png_ptr->read_data_fn = png_default_read_data;

+    if(read_data_fn != NULL)

+        png_ptr->read_data_fn = read_data_fn;

+    else

+        png_ptr->read_data_fn = png_default_read_data;

 #else

-   png_ptr->read_data_fn = read_data_fn;

+    png_ptr->read_data_fn = read_data_fn;

 #endif

 

-   /* It is an error to write to a read device */

-   if (png_ptr->write_data_fn != NULL)

-   {

-      png_ptr->write_data_fn = NULL;

-      png_warning(png_ptr,

-         "It's an error to set both read_data_fn and write_data_fn in the ");

-      png_warning(png_ptr,

-         "same structure.  Resetting write_data_fn to NULL");

-   }

+    /* It is an error to write to a read device */

+    if(png_ptr->write_data_fn != NULL)

+    {

+        png_ptr->write_data_fn = NULL;

+        png_warning(png_ptr,

+                    "It's an error to set both read_data_fn and write_data_fn in the ");

+        png_warning(png_ptr,

+                    "same structure.  Resetting write_data_fn to NULL");

+    }

 

 #ifdef PNG_WRITE_FLUSH_SUPPORTED

-   png_ptr->output_flush_fn = NULL;

+    png_ptr->output_flush_fn = NULL;

 #endif

 }

 #endif /* PNG_READ_SUPPORTED */

diff --git a/src/libpng/pngrtran.c b/src/libpng/pngrtran.c
index 728e8d477..920812733 100644
--- a/src/libpng/pngrtran.c
+++ b/src/libpng/pngrtran.c
@@ -25,68 +25,68 @@
 void PNGAPI

 png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)

 {

-   png_debug(1, "in png_set_crc_action");

- 

-   if (png_ptr == NULL)

-      return;

-

-   /* Tell libpng how we react to CRC errors in critical chunks */

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

-         break;

-   }

-

-   /* Tell libpng how we react to CRC errors in ancillary chunks */

-   switch (ancil_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_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;

-         break;

-   }

+    png_debug(1, "in png_set_crc_action");

+

+    if(png_ptr == NULL)

+        return;

+

+    /* Tell libpng how we react to CRC errors in critical chunks */

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

+        break;

+    }

+

+    /* Tell libpng how we react to CRC errors in ancillary chunks */

+    switch(ancil_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_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;

+        break;

+    }

 }

 

 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \

@@ -94,25 +94,25 @@ png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
 /* Handle alpha and tRNS via a background color */

 void PNGAPI

 png_set_background(png_structp png_ptr,

-   png_color_16p background_color, int background_gamma_code,

-   int need_expand, double background_gamma)

+                   png_color_16p background_color, int background_gamma_code,

+                   int need_expand, double background_gamma)

 {

-   png_debug(1, "in png_set_background");

- 

-   if (png_ptr == NULL)

-      return;

-   if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)

-   {

-      png_warning(png_ptr, "Application must supply a known background gamma");

-      return;

-   }

-

-   png_ptr->transformations |= PNG_BACKGROUND;

-   png_memcpy(&(png_ptr->background), background_color,

-      png_sizeof(png_color_16));

-   png_ptr->background_gamma = (float)background_gamma;

-   png_ptr->background_gamma_type = (png_byte)(background_gamma_code);

-   png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);

+    png_debug(1, "in png_set_background");

+

+    if(png_ptr == NULL)

+        return;

+    if(background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)

+    {

+        png_warning(png_ptr, "Application must supply a known background gamma");

+        return;

+    }

+

+    png_ptr->transformations |= PNG_BACKGROUND;

+    png_memcpy(&(png_ptr->background), background_color,

+               png_sizeof(png_color_16));

+    png_ptr->background_gamma = (float)background_gamma;

+    png_ptr->background_gamma_type = (png_byte)(background_gamma_code);

+    png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);

 }

 #endif

 

@@ -121,11 +121,11 @@ png_set_background(png_structp png_ptr,
 void PNGAPI

 png_set_strip_16(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_strip_16");

+    png_debug(1, "in png_set_strip_16");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_16_TO_8;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->transformations |= PNG_16_TO_8;

 }

 #endif

 

@@ -133,11 +133,11 @@ png_set_strip_16(png_structp png_ptr)
 void PNGAPI

 png_set_strip_alpha(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_strip_alpha");

+    png_debug(1, "in png_set_strip_alpha");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;

 }

 #endif

 

@@ -153,388 +153,388 @@ png_set_strip_alpha(png_structp png_ptr)
 

 typedef struct png_dsort_struct

 {

-   struct png_dsort_struct FAR * next;

-   png_byte left;

-   png_byte right;

+    struct png_dsort_struct FAR * next;

+    png_byte left;

+    png_byte right;

 } png_dsort;

 typedef png_dsort FAR *       png_dsortp;

 typedef png_dsort FAR * FAR * png_dsortpp;

 

 void PNGAPI

 png_set_dither(png_structp png_ptr, png_colorp palette,

-   int num_palette, int maximum_colors, png_uint_16p histogram,

-   int full_dither)

+               int num_palette, int maximum_colors, png_uint_16p histogram,

+               int full_dither)

 {

-   png_debug(1, "in png_set_dither");

-

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_DITHER;

-

-   if (!full_dither)

-   {

-      int i;

-

-      png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,

-         (png_uint_32)(num_palette * png_sizeof(png_byte)));

-      for (i = 0; i < num_palette; i++)

-         png_ptr->dither_index[i] = (png_byte)i;

-   }

-

-   if (num_palette > maximum_colors)

-   {

-      if (histogram != NULL)

-      {

-         /* This is easy enough, just throw out the least used colors.

-          * Perhaps not the best solution, but good enough.

-          */

-

-         int i;

-

-         /* Initialize an array to sort colors */

-         png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,

-            (png_uint_32)(num_palette * png_sizeof(png_byte)));

-

-         /* Initialize the dither_sort array */

-         for (i = 0; i < num_palette; i++)

-            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.

-          */

-

-         for (i = num_palette - 1; i >= maximum_colors; i--)

-         {

-            int done; /* To stop early if the list is pre-sorted */

-            int j;

-

-            done = 1;

-            for (j = 0; j < i; j++)

-            {

-               if (histogram[png_ptr->dither_sort[j]]

-                   < histogram[png_ptr->dither_sort[j + 1]])

-               {

-                  png_byte t;

-

-                  t = png_ptr->dither_sort[j];

-                  png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];

-                  png_ptr->dither_sort[j + 1] = t;

-                  done = 0;

-               }

-            }

-            if (done)

-               break;

-         }

+    png_debug(1, "in png_set_dither");

+

+    if(png_ptr == NULL)

+        return;

+    png_ptr->transformations |= PNG_DITHER;

+

+    if(!full_dither)

+    {

+        int i;

 

-         /* Swap the palette around, and set up a table, if necessary */

-         if (full_dither)

-         {

-            int j = num_palette;

+        png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,

+                                (png_uint_32)(num_palette * png_sizeof(png_byte)));

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

+            png_ptr->dither_index[i] = (png_byte)i;

+    }

 

-            /* Put all the useful colors within the max, but don't

-             * move the others.

+    if(num_palette > maximum_colors)

+    {

+        if(histogram != NULL)

+        {

+            /* This is easy enough, just throw out the least used colors.

+             * Perhaps not the best solution, but good enough.

              */

-            for (i = 0; i < maximum_colors; i++)

-            {

-               if ((int)png_ptr->dither_sort[i] >= maximum_colors)

-               {

-                  do

-                     j--;

-                  while ((int)png_ptr->dither_sort[j] >= maximum_colors);

-                  palette[i] = palette[j];

-               }

-            }

-         }

-         else

-         {

-            int j = num_palette;

 

-            /* Move all the used colors inside the max limit, and

-             * develop a translation table.

+            int i;

+

+            /* Initialize an array to sort colors */

+            png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,

+                                   (png_uint_32)(num_palette * png_sizeof(png_byte)));

+

+            /* Initialize the dither_sort array */

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

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

              */

-            for (i = 0; i < maximum_colors; i++)

+

+            for(i = num_palette - 1; i >= maximum_colors; i--)

             {

-               /* Only move the colors we need to */

-               if ((int)png_ptr->dither_sort[i] >= maximum_colors)

-               {

-                  png_color tmp_color;

-

-                  do

-                     j--;

-                  while ((int)png_ptr->dither_sort[j] >= maximum_colors);

-

-                  tmp_color = palette[j];

-                  palette[j] = palette[i];

-                  palette[i] = tmp_color;

-                  /* Indicate where the color went */

-                  png_ptr->dither_index[j] = (png_byte)i;

-                  png_ptr->dither_index[i] = (png_byte)j;

-               }

+                int done; /* To stop early if the list is pre-sorted */

+                int j;

+

+                done = 1;

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

+                {

+                    if(histogram[png_ptr->dither_sort[j]]

+                       < histogram[png_ptr->dither_sort[j + 1]])

+                    {

+                        png_byte t;

+

+                        t = png_ptr->dither_sort[j];

+                        png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];

+                        png_ptr->dither_sort[j + 1] = t;

+                        done = 0;

+                    }

+                }

+                if(done)

+                    break;

             }

 

-            /* Find closest color for those colors we are not using */

-            for (i = 0; i < num_palette; i++)

+            /* Swap the palette around, and set up a table, if necessary */

+            if(full_dither)

             {

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

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

-                  {

-                     int d;

-

-                     d = PNG_COLOR_DIST(palette[d_index], palette[k]);

-

-                     if (d < min_d)

-                     {

-                        min_d = d;

-                        min_k = k;

-                     }

-                  }

-                  /* Point to closest color */

-                  png_ptr->dither_index[i] = (png_byte)min_k;

-               }

+                int j = num_palette;

+

+                /* 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)

+                    {

+                        do

+                            j--;

+                        while((int)png_ptr->dither_sort[j] >= maximum_colors);

+                        palette[i] = palette[j];

+                    }

+                }

+            }

+            else

+            {

+                int j = num_palette;

+

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

+                    if((int)png_ptr->dither_sort[i] >= maximum_colors)

+                    {

+                        png_color tmp_color;

+

+                        do

+                            j--;

+                        while((int)png_ptr->dither_sort[j] >= maximum_colors);

+

+                        tmp_color = palette[j];

+                        palette[j] = palette[i];

+                        palette[i] = tmp_color;

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

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

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

+                        {

+                            int d;

+

+                            d = PNG_COLOR_DIST(palette[d_index], palette[k]);

+

+                            if(d < min_d)

+                            {

+                                min_d = d;

+                                min_k = k;

+                            }

+                        }

+                        /* Point to closest color */

+                        png_ptr->dither_index[i] = (png_byte)min_k;

+                    }

+                }

             }

-         }

-         png_free(png_ptr, png_ptr->dither_sort);

-         png_ptr->dither_sort = NULL;

-      }

-      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]

-          */

-         int i;

-         int max_d;

-         int num_new_palette;

-         png_dsortp t;

-         png_dsortpp hash;

-

-         t = NULL;

-

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

-         for (i = 0; i < num_palette; i++)

-         {

-            png_ptr->index_to_palette[i] = (png_byte)i;

-            png_ptr->palette_to_index[i] = (png_byte)i;

-         }

-

-         hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 *

-            png_sizeof(png_dsortp)));

-

-         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.

-          */

-         max_d = 96;

-

-         while (num_new_palette > maximum_colors)

-         {

-            for (i = 0; i < num_new_palette - 1; i++)

+            png_free(png_ptr, png_ptr->dither_sort);

+            png_ptr->dither_sort = NULL;

+        }

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

+             */

+            int i;

+            int max_d;

+            int num_new_palette;

+            png_dsortp t;

+            png_dsortpp hash;

+

+            t = NULL;

+

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

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

             {

-               int j;

-

-               for (j = i + 1; j < num_new_palette; j++)

-               {

-                  int d;

-

-                  d = PNG_COLOR_DIST(palette[i], palette[j]);

-

-                  if (d <= max_d)

-                  {

-

-                     t = (png_dsortp)png_malloc_warn(png_ptr,

-                         (png_uint_32)(png_sizeof(png_dsort)));

-                     if (t == NULL)

-                         break;

-                     t->next = hash[d];

-                     t->left = (png_byte)i;

-                     t->right = (png_byte)j;

-                     hash[d] = t;

-                  }

-               }

-               if (t == NULL)

-                  break;

+                png_ptr->index_to_palette[i] = (png_byte)i;

+                png_ptr->palette_to_index[i] = (png_byte)i;

             }

 

-            if (t != NULL)

-            for (i = 0; i <= max_d; i++)

+            hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 *

+                                           png_sizeof(png_dsortp)));

+

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

+             */

+            max_d = 96;

+

+            while(num_new_palette > maximum_colors)

             {

-               if (hash[i] != NULL)

-               {

-                  png_dsortp p;

-

-                  for (p = hash[i]; p; p = p->next)

-                  {

-                     if ((int)png_ptr->index_to_palette[p->left]

-                        < num_new_palette &&

-                        (int)png_ptr->index_to_palette[p->right]

-                        < num_new_palette)

-                     {

-                        int j, next_j;

-

-                        if (num_new_palette & 0x01)

+                for(i = 0; i < num_new_palette - 1; i++)

+                {

+                    int j;

+

+                    for(j = i + 1; j < num_new_palette; j++)

+                    {

+                        int d;

+

+                        d = PNG_COLOR_DIST(palette[i], palette[j]);

+

+                        if(d <= max_d)

                         {

-                           j = p->left;

-                           next_j = p->right;

+

+                            t = (png_dsortp)png_malloc_warn(png_ptr,

+                                                            (png_uint_32)(png_sizeof(png_dsort)));

+                            if(t == NULL)

+                                break;

+                            t->next = hash[d];

+                            t->left = (png_byte)i;

+                            t->right = (png_byte)j;

+                            hash[d] = t;

                         }

-                        else

+                    }

+                    if(t == NULL)

+                        break;

+                }

+

+                if(t != NULL)

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

+                    {

+                        if(hash[i] != NULL)

                         {

-                           j = p->right;

-                           next_j = p->left;

+                            png_dsortp p;

+

+                            for(p = hash[i]; p; p = p->next)

+                            {

+                                if((int)png_ptr->index_to_palette[p->left]

+                                   < num_new_palette &&

+                                   (int)png_ptr->index_to_palette[p->right]

+                                   < num_new_palette)

+                                {

+                                    int j, next_j;

+

+                                    if(num_new_palette & 0x01)

+                                    {

+                                        j = p->left;

+                                        next_j = p->right;

+                                    }

+                                    else

+                                    {

+                                        j = p->right;

+                                        next_j = p->left;

+                                    }

+

+                                    num_new_palette--;

+                                    palette[png_ptr->index_to_palette[j]]

+                                    = palette[num_new_palette];

+                                    if(!full_dither)

+                                    {

+                                        int k;

+

+                                        for(k = 0; k < num_palette; k++)

+                                        {

+                                            if(png_ptr->dither_index[k] ==

+                                               png_ptr->index_to_palette[j])

+                                                png_ptr->dither_index[k] =

+                                                    png_ptr->index_to_palette[next_j];

+                                            if((int)png_ptr->dither_index[k] ==

+                                               num_new_palette)

+                                                png_ptr->dither_index[k] =

+                                                    png_ptr->index_to_palette[j];

+                                        }

+                                    }

+

+                                    png_ptr->index_to_palette[png_ptr->palette_to_index

+                                                              [num_new_palette]] = png_ptr->index_to_palette[j];

+                                    png_ptr->palette_to_index[png_ptr->index_to_palette[j]]

+                                    = png_ptr->palette_to_index[num_new_palette];

+

+                                    png_ptr->index_to_palette[j] =

+                                        (png_byte)num_new_palette;

+                                    png_ptr->palette_to_index[num_new_palette] =

+                                        (png_byte)j;

+                                }

+                                if(num_new_palette <= maximum_colors)

+                                    break;

+                            }

+                            if(num_new_palette <= maximum_colors)

+                                break;

                         }

-

-                        num_new_palette--;

-                        palette[png_ptr->index_to_palette[j]]

-                          = palette[num_new_palette];

-                        if (!full_dither)

+                    }

+

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

+                {

+                    if(hash[i] != NULL)

+                    {

+                        png_dsortp p = hash[i];

+                        while(p)

                         {

-                           int k;

-

-                           for (k = 0; k < num_palette; k++)

-                           {

-                              if (png_ptr->dither_index[k] ==

-                                 png_ptr->index_to_palette[j])

-                                 png_ptr->dither_index[k] =

-                                    png_ptr->index_to_palette[next_j];

-                              if ((int)png_ptr->dither_index[k] ==

-                                 num_new_palette)

-                                 png_ptr->dither_index[k] =

-                                    png_ptr->index_to_palette[j];

-                           }

+                            t = p->next;

+                            png_free(png_ptr, p);

+                            p = t;

                         }

-

-                        png_ptr->index_to_palette[png_ptr->palette_to_index

-                           [num_new_palette]] = png_ptr->index_to_palette[j];

-                        png_ptr->palette_to_index[png_ptr->index_to_palette[j]]

-                           = png_ptr->palette_to_index[num_new_palette];

-

-                        png_ptr->index_to_palette[j] =

-                            (png_byte)num_new_palette;

-                        png_ptr->palette_to_index[num_new_palette] =

-                            (png_byte)j;

-                     }

-                     if (num_new_palette <= maximum_colors)

-                        break;

-                  }

-                  if (num_new_palette <= maximum_colors)

-                     break;

-               }

+                    }

+                    hash[i] = 0;

+                }

+                max_d += 96;

             }

+            png_free(png_ptr, hash);

+            png_free(png_ptr, png_ptr->palette_to_index);

+            png_free(png_ptr, png_ptr->index_to_palette);

+            png_ptr->palette_to_index = NULL;

+            png_ptr->index_to_palette = NULL;

+        }

+        num_palette = maximum_colors;

+    }

+    if(png_ptr->palette == NULL)

+    {

+        png_ptr->palette = palette;

+    }

+    png_ptr->num_palette = (png_uint_16)num_palette;

 

-            for (i = 0; i < 769; i++)

-            {

-               if (hash[i] != NULL)

-               {

-                  png_dsortp p = hash[i];

-                  while (p)

-                  {

-                     t = p->next;

-                     png_free(png_ptr, p);

-                     p = t;

-                  }

-               }

-               hash[i] = 0;

-            }

-            max_d += 96;

-         }

-         png_free(png_ptr, hash);

-         png_free(png_ptr, png_ptr->palette_to_index);

-         png_free(png_ptr, png_ptr->index_to_palette);

-         png_ptr->palette_to_index = NULL;

-         png_ptr->index_to_palette = NULL;

-      }

-      num_palette = maximum_colors;

-   }

-   if (png_ptr->palette == NULL)

-   {

-      png_ptr->palette = palette;

-   }

-   png_ptr->num_palette = (png_uint_16)num_palette;

-

-   if (full_dither)

-   {

-      int i;

-      png_bytep distance;

-      int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +

-         PNG_DITHER_BLUE_BITS;

-      int num_red = (1 << PNG_DITHER_RED_BITS);

-      int num_green = (1 << PNG_DITHER_GREEN_BITS);

-      int num_blue = (1 << PNG_DITHER_BLUE_BITS);

-      png_size_t num_entries = ((png_size_t)1 << total_bits);

-

-      png_ptr->palette_lookup = (png_bytep )png_calloc(png_ptr,

-         (png_uint_32)(num_entries * png_sizeof(png_byte)));

-

-      distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *

-         png_sizeof(png_byte)));

-      png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));

-

-      for (i = 0; i < num_palette; i++)

-      {

-         int ir, ig, ib;

-         int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));

-         int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));

-         int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));

-

-         for (ir = 0; ir < num_red; ir++)

-         {

-            /* int dr = abs(ir - r); */

-            int dr = ((ir > r) ? ir - r : r - ir);

-            int index_r = (ir << (PNG_DITHER_BLUE_BITS +

-                PNG_DITHER_GREEN_BITS));

-

-            for (ig = 0; ig < num_green; ig++)

+    if(full_dither)

+    {

+        int i;

+        png_bytep distance;

+        int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +

+                         PNG_DITHER_BLUE_BITS;

+        int num_red = (1 << PNG_DITHER_RED_BITS);

+        int num_green = (1 << PNG_DITHER_GREEN_BITS);

+        int num_blue = (1 << PNG_DITHER_BLUE_BITS);

+        png_size_t num_entries = ((png_size_t)1 << total_bits);

+

+        png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr,

+                                  (png_uint_32)(num_entries * png_sizeof(png_byte)));

+

+        distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *

+                                         png_sizeof(png_byte)));

+        png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));

+

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

+        {

+            int ir, ig, ib;

+            int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));

+            int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));

+            int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));

+

+            for(ir = 0; ir < num_red; ir++)

             {

-               /* int dg = abs(ig - g); */

-               int dg = ((ig > g) ? ig - g : g - ig);

-               int dt = dr + dg;

-               int dm = ((dr > dg) ? dr : dg);

-               int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);

-

-               for (ib = 0; ib < num_blue; ib++)

-               {

-                  int d_index = index_g | ib;

-                  /* int db = abs(ib - b); */

-                  int db = ((ib > b) ? ib - b : b - ib);

-                  int dmax = ((dm > db) ? dm : db);

-                  int d = dmax + dt + db;

-

-                  if (d < (int)distance[d_index])

-                  {

-                     distance[d_index] = (png_byte)d;

-                     png_ptr->palette_lookup[d_index] = (png_byte)i;

-                  }

-               }

+                /* int dr = abs(ir - r); */

+                int dr = ((ir > r) ? ir - r : r - ir);

+                int index_r = (ir << (PNG_DITHER_BLUE_BITS +

+                                      PNG_DITHER_GREEN_BITS));

+

+                for(ig = 0; ig < num_green; ig++)

+                {

+                    /* int dg = abs(ig - g); */

+                    int dg = ((ig > g) ? ig - g : g - ig);

+                    int dt = dr + dg;

+                    int dm = ((dr > dg) ? dr : dg);

+                    int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);

+

+                    for(ib = 0; ib < num_blue; ib++)

+                    {

+                        int d_index = index_g | ib;

+                        /* int db = abs(ib - b); */

+                        int db = ((ib > b) ? ib - b : b - ib);

+                        int dmax = ((dm > db) ? dm : db);

+                        int d = dmax + dt + db;

+

+                        if(d < (int)distance[d_index])

+                        {

+                            distance[d_index] = (png_byte)d;

+                            png_ptr->palette_lookup[d_index] = (png_byte)i;

+                        }

+                    }

+                }

             }

-         }

-      }

+        }

 

-      png_free(png_ptr, distance);

-   }

+        png_free(png_ptr, distance);

+    }

 }

 #endif

 

@@ -551,17 +551,17 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
 void PNGAPI

 png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)

 {

-   png_debug(1, "in png_set_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) ||

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

-     png_ptr->transformations |= PNG_GAMMA;

-   png_ptr->gamma = (float)file_gamma;

-   png_ptr->screen_gamma = (float)scrn_gamma;

+        png_ptr->transformations |= PNG_GAMMA;

+    png_ptr->gamma = (float)file_gamma;

+    png_ptr->screen_gamma = (float)scrn_gamma;

 }

 #endif

 

@@ -573,13 +573,13 @@ png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
 void PNGAPI

 png_set_expand(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_expand");

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

+    png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);

+    png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

 }

 

 /* GRR 19990627:  the following three functions currently are identical

@@ -604,26 +604,26 @@ png_set_expand(png_structp png_ptr)
 void PNGAPI

 png_set_palette_to_rgb(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_palette_to_rgb");

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

+    png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);

+    png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

 }

 

 /* Expand grayscale images of less than 8-bit depth to 8 bits. */

 void PNGAPI

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

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

+    png_ptr->transformations |= PNG_EXPAND;

+    png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

 }

 

 

@@ -632,10 +632,10 @@ png_set_expand_gray_1_2_4_to_8(png_structp png_ptr)
 void PNGAPI

 png_set_tRNS_to_alpha(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_tRNS_to_alpha");

+    png_debug(1, "in png_set_tRNS_to_alpha");

 

-   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);

-   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

+    png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);

+    png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

 }

 #endif /* defined(PNG_READ_EXPAND_SUPPORTED) */

 

@@ -643,10 +643,10 @@ png_set_tRNS_to_alpha(png_structp png_ptr)
 void PNGAPI

 png_set_gray_to_rgb(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_gray_to_rgb");

+    png_debug(1, "in png_set_gray_to_rgb");

 

-   png_ptr->transformations |= PNG_GRAY_TO_RGB;

-   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

+    png_ptr->transformations |= PNG_GRAY_TO_RGB;

+    png_ptr->flags &= ~PNG_FLAG_ROW_INIT;

 }

 #endif

 

@@ -658,68 +658,71 @@ png_set_gray_to_rgb(png_structp png_ptr)
 

 void PNGAPI

 png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,

-   double green)

+                    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

 

 void PNGAPI

 png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,

-   png_fixed_point red, png_fixed_point green)

+                          png_fixed_point red, png_fixed_point green)

 {

-   png_debug(1, "in png_set_rgb_to_gray");

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

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

+    case 3:

+        png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;

+    }

+    if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

 #ifdef PNG_READ_EXPAND_SUPPORTED

-      png_ptr->transformations |= PNG_EXPAND;

+        png_ptr->transformations |= PNG_EXPAND;

 #else

-   {

-      png_warning(png_ptr,

-        "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED");

-      png_ptr->transformations &= ~PNG_RGB_TO_GRAY;

-   }

+    {

+        png_warning(png_ptr,

+                    "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED");

+        png_ptr->transformations &= ~PNG_RGB_TO_GRAY;

+    }

 #endif

-   {

-      png_uint_16 red_int, green_int;

-      if (red < 0 || green < 0)

-      {

-         red_int   =  6968; /* .212671 * 32768 + .5 */

-         green_int = 23434; /* .715160 * 32768 + .5 */

-      }

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

-      }

-      else

-      {

-         png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");

-         red_int   =  6968;

-         green_int = 23434;

-      }

-      png_ptr->rgb_to_gray_red_coeff   = red_int;

-      png_ptr->rgb_to_gray_green_coeff = green_int;

-      png_ptr->rgb_to_gray_blue_coeff  =

-         (png_uint_16)(32768 - red_int - green_int);

-   }

+    {

+        png_uint_16 red_int, green_int;

+        if(red < 0 || green < 0)

+        {

+            red_int   =  6968; /* .212671 * 32768 + .5 */

+            green_int = 23434; /* .715160 * 32768 + .5 */

+        }

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

+        }

+        else

+        {

+            png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");

+            red_int   =  6968;

+            green_int = 23434;

+        }

+        png_ptr->rgb_to_gray_red_coeff   = red_int;

+        png_ptr->rgb_to_gray_green_coeff = green_int;

+        png_ptr->rgb_to_gray_blue_coeff  =

+            (png_uint_16)(32768 - red_int - green_int);

+    }

 }

 #endif

 

@@ -727,16 +730,16 @@ png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

 void PNGAPI

 png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr

-   read_user_transform_fn)

+                               read_user_transform_fn)

 {

-   png_debug(1, "in png_set_read_user_transform_fn");

+    png_debug(1, "in png_set_read_user_transform_fn");

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-   png_ptr->transformations |= PNG_USER_TRANSFORM;

-   png_ptr->read_user_transform_fn = read_user_transform_fn;

+    png_ptr->transformations |= PNG_USER_TRANSFORM;

+    png_ptr->read_user_transform_fn = read_user_transform_fn;

 #endif

 }

 #endif

@@ -747,413 +750,414 @@ png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
 void /* PRIVATE */

 png_init_read_transformations(png_structp png_ptr)

 {

-   png_debug(1, "in png_init_read_transformations");

+    png_debug(1, "in png_init_read_transformations");

 

-  {

+    {

 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \

     defined(PNG_READ_SHIFT_SUPPORTED) || \

     defined(PNG_READ_GAMMA_SUPPORTED)

-   int color_type = png_ptr->color_type;

+        int color_type = png_ptr->color_type;

 #endif

 

 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)

 

 #ifdef 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

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

-    * PNG_BACKGROUND_IS_GRAY only to decide when to do the

-    * png_do_gray_to_rgb() transformation.

-    */

-   if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&

-       !(color_type & PNG_COLOR_MASK_COLOR))

-   {

-          png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;

-   } else if ((png_ptr->transformations & PNG_BACKGROUND) &&

-              !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&

-              (png_ptr->transformations & PNG_GRAY_TO_RGB) &&

-              png_ptr->background.red == png_ptr->background.green &&

-              png_ptr->background.red == png_ptr->background.blue)

-   {

-          png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;

-          png_ptr->background.gray = png_ptr->background.red;

-   }

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

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

+         * PNG_BACKGROUND_IS_GRAY only to decide when to do the

+         * png_do_gray_to_rgb() transformation.

+         */

+        if((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&

+           !(color_type & PNG_COLOR_MASK_COLOR))

+        {

+            png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;

+        }

+        else if((png_ptr->transformations & PNG_BACKGROUND) &&

+                !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&

+                (png_ptr->transformations & PNG_GRAY_TO_RGB) &&

+                png_ptr->background.red == png_ptr->background.green &&

+                png_ptr->background.red == png_ptr->background.blue)

+        {

+            png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;

+            png_ptr->background.gray = png_ptr->background.red;

+        }

 #endif

 

-   if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&

-       (png_ptr->transformations & PNG_EXPAND))

-   {

-      if (!(color_type & PNG_COLOR_MASK_COLOR))  /* i.e., GRAY or GRAY_ALPHA */

-      {

-         /* Expand background and tRNS chunks */

-         switch (png_ptr->bit_depth)

-         {

-            case 1:

-               png_ptr->background.gray *= (png_uint_16)0xff;

-               png_ptr->background.red = png_ptr->background.green

-                 =  png_ptr->background.blue = png_ptr->background.gray;

-               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))

-               {

-                 png_ptr->trans_color.gray *= (png_uint_16)0xff;

-                 png_ptr->trans_color.red = png_ptr->trans_color.green

-                   = 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

-                 = png_ptr->background.blue = png_ptr->background.gray;

-               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))

-               {

-                 png_ptr->trans_color.gray *= (png_uint_16)0x55;

-                 png_ptr->trans_color.red = png_ptr->trans_color.green

-                   = 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

-                 = png_ptr->background.blue = png_ptr->background.gray;

-               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))

-               {

-                 png_ptr->trans_color.gray *= (png_uint_16)0x11;

-                 png_ptr->trans_color.red = png_ptr->trans_color.green

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

-               break;

-         }

-      }

-      else if (color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         png_ptr->background.red   =

-            png_ptr->palette[png_ptr->background.index].red;

-         png_ptr->background.green =

-            png_ptr->palette[png_ptr->background.index].green;

-         png_ptr->background.blue  =

-            png_ptr->palette[png_ptr->background.index].blue;

+        if((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&

+           (png_ptr->transformations & PNG_EXPAND))

+        {

+            if(!(color_type & PNG_COLOR_MASK_COLOR))   /* i.e., GRAY or GRAY_ALPHA */

+            {

+                /* Expand background and tRNS chunks */

+                switch(png_ptr->bit_depth)

+                {

+                case 1:

+                    png_ptr->background.gray *= (png_uint_16)0xff;

+                    png_ptr->background.red = png_ptr->background.green

+                                              =  png_ptr->background.blue = png_ptr->background.gray;

+                    if(!(png_ptr->transformations & PNG_EXPAND_tRNS))

+                    {

+                        png_ptr->trans_color.gray *= (png_uint_16)0xff;

+                        png_ptr->trans_color.red = png_ptr->trans_color.green

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

+                                              = png_ptr->background.blue = png_ptr->background.gray;

+                    if(!(png_ptr->transformations & PNG_EXPAND_tRNS))

+                    {

+                        png_ptr->trans_color.gray *= (png_uint_16)0x55;

+                        png_ptr->trans_color.red = png_ptr->trans_color.green

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

+                                              = png_ptr->background.blue = png_ptr->background.gray;

+                    if(!(png_ptr->transformations & PNG_EXPAND_tRNS))

+                    {

+                        png_ptr->trans_color.gray *= (png_uint_16)0x11;

+                        png_ptr->trans_color.red = png_ptr->trans_color.green

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

+                    break;

+                }

+            }

+            else if(color_type == PNG_COLOR_TYPE_PALETTE)

+            {

+                png_ptr->background.red   =

+                    png_ptr->palette[png_ptr->background.index].red;

+                png_ptr->background.green =

+                    png_ptr->palette[png_ptr->background.index].green;

+                png_ptr->background.blue  =

+                    png_ptr->palette[png_ptr->background.index].blue;

 

 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

-        if (png_ptr->transformations & PNG_INVERT_ALPHA)

-        {

+                if(png_ptr->transformations & PNG_INVERT_ALPHA)

+                {

 #ifdef PNG_READ_EXPAND_SUPPORTED

-           if (!(png_ptr->transformations & PNG_EXPAND_tRNS))

+                    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

-            */

-              int i, istop;

-              istop=(int)png_ptr->num_trans;

-              for (i=0; i<istop; i++)

-                 png_ptr->trans_alpha[i] = (png_byte)(255 - png_ptr->trans_alpha[i]);

-           }

-        }

+                    {

+                        /* 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++)

+                            png_ptr->trans_alpha[i] = (png_byte)(255 - png_ptr->trans_alpha[i]);

+                    }

+                }

 #endif

 

-      }

-   }

+            }

+        }

 #endif

 

 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)

-   png_ptr->background_1 = png_ptr->background;

+        png_ptr->background_1 = png_ptr->background;

 #endif

 #if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)

 

-   if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)

-       && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)

-         < PNG_GAMMA_THRESHOLD))

-   {

-    int i, k;

-    k=0;

-    for (i=0; i<png_ptr->num_trans; i++)

-    {

-      if (png_ptr->trans_alpha[i] != 0 && png_ptr->trans_alpha[i] != 0xff)

-        k=1; /* Partial transparency is present */

-    }

-    if (k == 0)

-      png_ptr->transformations &= ~PNG_GAMMA;

-   }

+        if((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)

+           && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)

+               < PNG_GAMMA_THRESHOLD))

+        {

+            int i, k;

+            k = 0;

+            for(i = 0; i < png_ptr->num_trans; i++)

+            {

+                if(png_ptr->trans_alpha[i] != 0 && png_ptr->trans_alpha[i] != 0xff)

+                    k = 1; /* Partial transparency is present */

+            }

+            if(k == 0)

+                png_ptr->transformations &= ~PNG_GAMMA;

+        }

 

-   if ((png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) &&

-        png_ptr->gamma != 0.0)

-   {

-      png_build_gamma_table(png_ptr, png_ptr->bit_depth);

+        if((png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) &&

+           png_ptr->gamma != 0.0)

+        {

+            png_build_gamma_table(png_ptr, png_ptr->bit_depth);

 

 #ifdef PNG_READ_BACKGROUND_SUPPORTED

-      if (png_ptr->transformations & PNG_BACKGROUND)

-      {

-         if (color_type == PNG_COLOR_TYPE_PALETTE)

-         {

-           /* Could skip if no transparency */

-            png_color back, back_1;

-            png_colorp palette = png_ptr->palette;

-            int num_palette = png_ptr->num_palette;

-            int i;

-            if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)

+            if(png_ptr->transformations & PNG_BACKGROUND)

             {

-               back.red = png_ptr->gamma_table[png_ptr->background.red];

-               back.green = png_ptr->gamma_table[png_ptr->background.green];

-               back.blue = png_ptr->gamma_table[png_ptr->background.blue];

+                if(color_type == PNG_COLOR_TYPE_PALETTE)

+                {

+                    /* Could skip if no transparency */

+                    png_color back, back_1;

+                    png_colorp palette = png_ptr->palette;

+                    int num_palette = png_ptr->num_palette;

+                    int i;

+                    if(png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)

+                    {

+                        back.red = png_ptr->gamma_table[png_ptr->background.red];

+                        back.green = png_ptr->gamma_table[png_ptr->background.green];

+                        back.blue = png_ptr->gamma_table[png_ptr->background.blue];

+

+                        back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];

+                        back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];

+                        back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];

+                    }

+                    else

+                    {

+                        double g, gs;

+

+                        switch(png_ptr->background_gamma_type)

+                        {

+                        case PNG_BACKGROUND_GAMMA_SCREEN:

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

+                                        png_ptr->screen_gamma);

+                            break;

+                        default:

+                            g = 1.0;    /* back_1 */

+                            gs = 1.0;   /* back */

+                        }

 

-               back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];

-               back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];

-               back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];

-            }

-            else

-            {

-               double g, gs;

-

-               switch (png_ptr->background_gamma_type)

-               {

-                  case PNG_BACKGROUND_GAMMA_SCREEN:

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

-                                 png_ptr->screen_gamma);

-                     break;

-                  default:

-                     g = 1.0;    /* back_1 */

-                     gs = 1.0;   /* back */

-               }

-

-               if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)

-               {

-                  back.red   = (png_byte)png_ptr->background.red;

-                  back.green = (png_byte)png_ptr->background.green;

-                  back.blue  = (png_byte)png_ptr->background.blue;

-               }

-               else

-               {

-                  back.red = (png_byte)(pow(

-                     (double)png_ptr->background.red/255.0, gs) * 255.0 + .5);

-                  back.green = (png_byte)(pow(

-                     (double)png_ptr->background.green/255.0, gs) * 255.0

-                         + .5);

-                  back.blue = (png_byte)(pow(

-                     (double)png_ptr->background.blue/255.0, gs) * 255.0 + .5);

-               }

-

-               back_1.red = (png_byte)(pow(

-                  (double)png_ptr->background.red/255.0, g) * 255.0 + .5);

-               back_1.green = (png_byte)(pow(

-                  (double)png_ptr->background.green/255.0, g) * 255.0 + .5);

-               back_1.blue = (png_byte)(pow(

-                  (double)png_ptr->background.blue/255.0, g) * 255.0 + .5);

-            }

-            for (i = 0; i < num_palette; i++)

-            {

-               if (i < (int)png_ptr->num_trans && png_ptr->trans_alpha[i] != 0xff)

-               {

-                  if (png_ptr->trans_alpha[i] == 0)

-                  {

-                     palette[i] = back;

-                  }

-                  else /* if (png_ptr->trans_alpha[i] != 0xff) */

-                  {

-                     png_byte v, w;

-

-                     v = png_ptr->gamma_to_1[palette[i].red];

-                     png_composite(w, v, png_ptr->trans_alpha[i], back_1.red);

-                     palette[i].red = png_ptr->gamma_from_1[w];

-

-                     v = png_ptr->gamma_to_1[palette[i].green];

-                     png_composite(w, v, png_ptr->trans_alpha[i], back_1.green);

-                     palette[i].green = png_ptr->gamma_from_1[w];

-

-                     v = png_ptr->gamma_to_1[palette[i].blue];

-                     png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue);

-                     palette[i].blue = png_ptr->gamma_from_1[w];

-                  }

-               }

-               else

-               {

-                  palette[i].red = png_ptr->gamma_table[palette[i].red];

-                  palette[i].green = png_ptr->gamma_table[palette[i].green];

-                  palette[i].blue = png_ptr->gamma_table[palette[i].blue];

-               }

-            }

-            /* Prevent the transformations being done again, and make sure

-             * that the now spurious alpha channel is stripped - the code

-             * has just reduced background composition and gamma correction

-             * to a simple alpha channel strip.

-             */

-            png_ptr->transformations &= ~PNG_BACKGROUND;

-            png_ptr->transformations &= ~PNG_GAMMA;

-            png_ptr->transformations |= PNG_STRIP_ALPHA;

-         }

-         /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */

-         else

-         /* color_type != PNG_COLOR_TYPE_PALETTE */

-         {

-            double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);

-            double g = 1.0;

-            double gs = 1.0;

-

-            switch (png_ptr->background_gamma_type)

-            {

-               case PNG_BACKGROUND_GAMMA_SCREEN:

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

-                     png_ptr->screen_gamma);

-                  break;

-            }

+                        if(fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)

+                        {

+                            back.red   = (png_byte)png_ptr->background.red;

+                            back.green = (png_byte)png_ptr->background.green;

+                            back.blue  = (png_byte)png_ptr->background.blue;

+                        }

+                        else

+                        {

+                            back.red = (png_byte)(pow(

+                                                      (double)png_ptr->background.red / 255.0, gs) * 255.0 + .5);

+                            back.green = (png_byte)(pow(

+                                                        (double)png_ptr->background.green / 255.0, gs) * 255.0

+                                                    + .5);

+                            back.blue = (png_byte)(pow(

+                                                       (double)png_ptr->background.blue / 255.0, gs) * 255.0 + .5);

+                        }

+

+                        back_1.red = (png_byte)(pow(

+                                                    (double)png_ptr->background.red / 255.0, g) * 255.0 + .5);

+                        back_1.green = (png_byte)(pow(

+                                                      (double)png_ptr->background.green / 255.0, g) * 255.0 + .5);

+                        back_1.blue = (png_byte)(pow(

+                                                     (double)png_ptr->background.blue / 255.0, g) * 255.0 + .5);

+                    }

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

+                    {

+                        if(i < (int)png_ptr->num_trans && png_ptr->trans_alpha[i] != 0xff)

+                        {

+                            if(png_ptr->trans_alpha[i] == 0)

+                            {

+                                palette[i] = back;

+                            }

+                            else /* if (png_ptr->trans_alpha[i] != 0xff) */

+                            {

+                                png_byte v, w;

+

+                                v = png_ptr->gamma_to_1[palette[i].red];

+                                png_composite(w, v, png_ptr->trans_alpha[i], back_1.red);

+                                palette[i].red = png_ptr->gamma_from_1[w];

+

+                                v = png_ptr->gamma_to_1[palette[i].green];

+                                png_composite(w, v, png_ptr->trans_alpha[i], back_1.green);

+                                palette[i].green = png_ptr->gamma_from_1[w];

+

+                                v = png_ptr->gamma_to_1[palette[i].blue];

+                                png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue);

+                                palette[i].blue = png_ptr->gamma_from_1[w];

+                            }

+                        }

+                        else

+                        {

+                            palette[i].red = png_ptr->gamma_table[palette[i].red];

+                            palette[i].green = png_ptr->gamma_table[palette[i].green];

+                            palette[i].blue = png_ptr->gamma_table[palette[i].blue];

+                        }

+                    }

+                    /* Prevent the transformations being done again, and make sure

+                     * that the now spurious alpha channel is stripped - the code

+                     * has just reduced background composition and gamma correction

+                     * to a simple alpha channel strip.

+                     */

+                    png_ptr->transformations &= ~PNG_BACKGROUND;

+                    png_ptr->transformations &= ~PNG_GAMMA;

+                    png_ptr->transformations |= PNG_STRIP_ALPHA;

+                }

+                /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */

+                else

+                    /* color_type != PNG_COLOR_TYPE_PALETTE */

+                {

+                    double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);

+                    double g = 1.0;

+                    double gs = 1.0;

+

+                    switch(png_ptr->background_gamma_type)

+                    {

+                    case PNG_BACKGROUND_GAMMA_SCREEN:

+                        g = (png_ptr->screen_gamma);

+                        gs = 1.0;

+                        break;

 

-            png_ptr->background_1.gray = (png_uint_16)(pow(

-               (double)png_ptr->background.gray / m, g) * m + .5);

-            png_ptr->background.gray = (png_uint_16)(pow(

-               (double)png_ptr->background.gray / m, gs) * m + .5);

+                    case PNG_BACKGROUND_GAMMA_FILE:

+                        g = 1.0 / (png_ptr->gamma);

+                        gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

+                        break;

 

-            if ((png_ptr->background.red != png_ptr->background.green) ||

-                (png_ptr->background.red != png_ptr->background.blue) ||

-                (png_ptr->background.red != png_ptr->background.gray))

-            {

-               /* RGB or RGBA with color background */

-               png_ptr->background_1.red = (png_uint_16)(pow(

-                  (double)png_ptr->background.red / m, g) * m + .5);

-               png_ptr->background_1.green = (png_uint_16)(pow(

-                  (double)png_ptr->background.green / m, g) * m + .5);

-               png_ptr->background_1.blue = (png_uint_16)(pow(

-                  (double)png_ptr->background.blue / m, g) * m + .5);

-               png_ptr->background.red = (png_uint_16)(pow(

-                  (double)png_ptr->background.red / m, gs) * m + .5);

-               png_ptr->background.green = (png_uint_16)(pow(

-                  (double)png_ptr->background.green / m, gs) * m + .5);

-               png_ptr->background.blue = (png_uint_16)(pow(

-                  (double)png_ptr->background.blue / m, gs) * m + .5);

+                    case PNG_BACKGROUND_GAMMA_UNIQUE:

+                        g = 1.0 / (png_ptr->background_gamma);

+                        gs = 1.0 / (png_ptr->background_gamma *

+                                    png_ptr->screen_gamma);

+                        break;

+                    }

+

+                    png_ptr->background_1.gray = (png_uint_16)(pow(

+                                                     (double)png_ptr->background.gray / m, g) * m + .5);

+                    png_ptr->background.gray = (png_uint_16)(pow(

+                                                   (double)png_ptr->background.gray / m, gs) * m + .5);

+

+                    if((png_ptr->background.red != png_ptr->background.green) ||

+                       (png_ptr->background.red != png_ptr->background.blue) ||

+                       (png_ptr->background.red != png_ptr->background.gray))

+                    {

+                        /* RGB or RGBA with color background */

+                        png_ptr->background_1.red = (png_uint_16)(pow(

+                                                        (double)png_ptr->background.red / m, g) * m + .5);

+                        png_ptr->background_1.green = (png_uint_16)(pow(

+                                                          (double)png_ptr->background.green / m, g) * m + .5);

+                        png_ptr->background_1.blue = (png_uint_16)(pow(

+                                                         (double)png_ptr->background.blue / m, g) * m + .5);

+                        png_ptr->background.red = (png_uint_16)(pow(

+                                (double)png_ptr->background.red / m, gs) * m + .5);

+                        png_ptr->background.green = (png_uint_16)(pow(

+                                                        (double)png_ptr->background.green / m, gs) * m + .5);

+                        png_ptr->background.blue = (png_uint_16)(pow(

+                                                       (double)png_ptr->background.blue / m, gs) * m + .5);

+                    }

+                    else

+                    {

+                        /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */

+                        png_ptr->background_1.red = png_ptr->background_1.green

+                                                    = png_ptr->background_1.blue = png_ptr->background_1.gray;

+                        png_ptr->background.red = png_ptr->background.green

+                                                  = png_ptr->background.blue = png_ptr->background.gray;

+                    }

+                }

             }

             else

-            {

-               /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */

-               png_ptr->background_1.red = png_ptr->background_1.green

-                 = png_ptr->background_1.blue = png_ptr->background_1.gray;

-               png_ptr->background.red = png_ptr->background.green

-                 = png_ptr->background.blue = png_ptr->background.gray;

-            }

-         }

-      }

-      else

-      /* Transformation does not include PNG_BACKGROUND */

+                /* Transformation does not include PNG_BACKGROUND */

 #endif /* PNG_READ_BACKGROUND_SUPPORTED */

-      if (color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         png_colorp palette = png_ptr->palette;

-         int num_palette = png_ptr->num_palette;

-         int i;

-

-         for (i = 0; i < num_palette; i++)

-         {

-            palette[i].red = png_ptr->gamma_table[palette[i].red];

-            palette[i].green = png_ptr->gamma_table[palette[i].green];

-            palette[i].blue = png_ptr->gamma_table[palette[i].blue];

-         }

-

-         /* Done the gamma correction. */

-         png_ptr->transformations &= ~PNG_GAMMA;

-      }

-   }

+                if(color_type == PNG_COLOR_TYPE_PALETTE)

+                {

+                    png_colorp palette = png_ptr->palette;

+                    int num_palette = png_ptr->num_palette;

+                    int i;

+

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

+                    {

+                        palette[i].red = png_ptr->gamma_table[palette[i].red];

+                        palette[i].green = png_ptr->gamma_table[palette[i].green];

+                        palette[i].blue = png_ptr->gamma_table[palette[i].blue];

+                    }

+

+                    /* Done the gamma correction. */

+                    png_ptr->transformations &= ~PNG_GAMMA;

+                }

+        }

 #ifdef PNG_READ_BACKGROUND_SUPPORTED

-   else

+        else

 #endif

 #endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */

 #ifdef PNG_READ_BACKGROUND_SUPPORTED

-   /* No GAMMA transformation */

-   if ((png_ptr->transformations & PNG_BACKGROUND) &&

-       (color_type == PNG_COLOR_TYPE_PALETTE))

-   {

-      int i;

-      int istop = (int)png_ptr->num_trans;

-      png_color back;

-      png_colorp palette = png_ptr->palette;

-

-      back.red   = (png_byte)png_ptr->background.red;

-      back.green = (png_byte)png_ptr->background.green;

-      back.blue  = (png_byte)png_ptr->background.blue;

-

-      for (i = 0; i < istop; i++)

-      {

-         if (png_ptr->trans_alpha[i] == 0)

-         {

-            palette[i] = back;

-         }

-         else if (png_ptr->trans_alpha[i] != 0xff)

-         {

-            /* The png_composite() macro is defined in png.h */

-            png_composite(palette[i].red, palette[i].red,

-               png_ptr->trans_alpha[i], back.red);

-            png_composite(palette[i].green, palette[i].green,

-               png_ptr->trans_alpha[i], back.green);

-            png_composite(palette[i].blue, palette[i].blue,

-               png_ptr->trans_alpha[i], back.blue);

-         }

-      }

-

-      /* Handled alpha, still need to strip the channel. */

-      png_ptr->transformations &= ~PNG_BACKGROUND;

-      png_ptr->transformations |= PNG_STRIP_ALPHA;

-   }

+            /* No GAMMA transformation */

+            if((png_ptr->transformations & PNG_BACKGROUND) &&

+               (color_type == PNG_COLOR_TYPE_PALETTE))

+            {

+                int i;

+                int istop = (int)png_ptr->num_trans;

+                png_color back;

+                png_colorp palette = png_ptr->palette;

+

+                back.red   = (png_byte)png_ptr->background.red;

+                back.green = (png_byte)png_ptr->background.green;

+                back.blue  = (png_byte)png_ptr->background.blue;

+

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

+                {

+                    if(png_ptr->trans_alpha[i] == 0)

+                    {

+                        palette[i] = back;

+                    }

+                    else if(png_ptr->trans_alpha[i] != 0xff)

+                    {

+                        /* The png_composite() macro is defined in png.h */

+                        png_composite(palette[i].red, palette[i].red,

+                                      png_ptr->trans_alpha[i], back.red);

+                        png_composite(palette[i].green, palette[i].green,

+                                      png_ptr->trans_alpha[i], back.green);

+                        png_composite(palette[i].blue, palette[i].blue,

+                                      png_ptr->trans_alpha[i], back.blue);

+                    }

+                }

+

+                /* Handled alpha, still need to strip the channel. */

+                png_ptr->transformations &= ~PNG_BACKGROUND;

+                png_ptr->transformations |= PNG_STRIP_ALPHA;

+            }

 #endif /* PNG_READ_BACKGROUND_SUPPORTED */

 

 #ifdef PNG_READ_SHIFT_SUPPORTED

-   if ((png_ptr->transformations & PNG_SHIFT) &&

-      (color_type == PNG_COLOR_TYPE_PALETTE))

-   {

-      png_uint_16 i;

-      png_uint_16 istop = png_ptr->num_palette;

-      int sr = 8 - png_ptr->sig_bit.red;

-      int sg = 8 - png_ptr->sig_bit.green;

-      int sb = 8 - png_ptr->sig_bit.blue;

-

-      if (sr < 0 || sr > 8)

-         sr = 0;

-      if (sg < 0 || sg > 8)

-         sg = 0;

-      if (sb < 0 || sb > 8)

-         sb = 0;

-      for (i = 0; i < istop; i++)

-      {

-         png_ptr->palette[i].red >>= sr;

-         png_ptr->palette[i].green >>= sg;

-         png_ptr->palette[i].blue >>= sb;

-      }

-   }

+        if((png_ptr->transformations & PNG_SHIFT) &&

+           (color_type == PNG_COLOR_TYPE_PALETTE))

+        {

+            png_uint_16 i;

+            png_uint_16 istop = png_ptr->num_palette;

+            int sr = 8 - png_ptr->sig_bit.red;

+            int sg = 8 - png_ptr->sig_bit.green;

+            int sb = 8 - png_ptr->sig_bit.blue;

+

+            if(sr < 0 || sr > 8)

+                sr = 0;

+            if(sg < 0 || sg > 8)

+                sg = 0;

+            if(sb < 0 || sb > 8)

+                sb = 0;

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

+            {

+                png_ptr->palette[i].red >>= sr;

+                png_ptr->palette[i].green >>= sg;

+                png_ptr->palette[i].blue >>= sb;

+            }

+        }

 #endif  /* PNG_READ_SHIFT_SUPPORTED */

- }

+    }

 #if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \

  && !defined(PNG_READ_BACKGROUND_SUPPORTED)

-   if (png_ptr)

-      return;

+    if(png_ptr)

+        return;

 #endif

 }

 

@@ -1164,135 +1168,135 @@ png_init_read_transformations(png_structp png_ptr)
 void /* PRIVATE */

 png_read_transform_info(png_structp png_ptr, png_infop info_ptr)

 {

-   png_debug(1, "in png_read_transform_info");

+    png_debug(1, "in png_read_transform_info");

 

 #ifdef PNG_READ_EXPAND_SUPPORTED

-   if (png_ptr->transformations & PNG_EXPAND)

-   {

-      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         if (png_ptr->num_trans &&

-              (png_ptr->transformations & PNG_EXPAND_tRNS))

-            info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;

-         else

-            info_ptr->color_type = PNG_COLOR_TYPE_RGB;

-         info_ptr->bit_depth = 8;

-         info_ptr->num_trans = 0;

-      }

-      else

-      {

-         if (png_ptr->num_trans)

-         {

-            if (png_ptr->transformations & PNG_EXPAND_tRNS)

-              info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;

-         }

-         if (info_ptr->bit_depth < 8)

+    if(png_ptr->transformations & PNG_EXPAND)

+    {

+        if(info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+        {

+            if(png_ptr->num_trans &&

+               (png_ptr->transformations & PNG_EXPAND_tRNS))

+                info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;

+            else

+                info_ptr->color_type = PNG_COLOR_TYPE_RGB;

             info_ptr->bit_depth = 8;

-         info_ptr->num_trans = 0;

-      }

-   }

+            info_ptr->num_trans = 0;

+        }

+        else

+        {

+            if(png_ptr->num_trans)

+            {

+                if(png_ptr->transformations & PNG_EXPAND_tRNS)

+                    info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;

+            }

+            if(info_ptr->bit_depth < 8)

+                info_ptr->bit_depth = 8;

+            info_ptr->num_trans = 0;

+        }

+    }

 #endif

 

 #ifdef PNG_READ_BACKGROUND_SUPPORTED

-   if (png_ptr->transformations & PNG_BACKGROUND)

-   {

-      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;

-      info_ptr->num_trans = 0;

-      info_ptr->background = png_ptr->background;

-   }

+    if(png_ptr->transformations & PNG_BACKGROUND)

+    {

+        info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;

+        info_ptr->num_trans = 0;

+        info_ptr->background = png_ptr->background;

+    }

 #endif

 

 #ifdef PNG_READ_GAMMA_SUPPORTED

-   if (png_ptr->transformations & PNG_GAMMA)

-   {

+    if(png_ptr->transformations & PNG_GAMMA)

+    {

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-      info_ptr->gamma = png_ptr->gamma;

+        info_ptr->gamma = png_ptr->gamma;

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

-      info_ptr->int_gamma = png_ptr->int_gamma;

+        info_ptr->int_gamma = png_ptr->int_gamma;

 #endif

-   }

+    }

 #endif

 

 #ifdef PNG_READ_16_TO_8_SUPPORTED

-   if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))

-      info_ptr->bit_depth = 8;

+    if((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))

+        info_ptr->bit_depth = 8;

 #endif

 

 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-   if (png_ptr->transformations & PNG_GRAY_TO_RGB)

-      info_ptr->color_type |= PNG_COLOR_MASK_COLOR;

+    if(png_ptr->transformations & PNG_GRAY_TO_RGB)

+        info_ptr->color_type |= PNG_COLOR_MASK_COLOR;

 #endif

 

 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-   if (png_ptr->transformations & PNG_RGB_TO_GRAY)

-      info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;

+    if(png_ptr->transformations & PNG_RGB_TO_GRAY)

+        info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;

 #endif

 

 #ifdef PNG_READ_DITHER_SUPPORTED

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

-      }

-   }

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

+        }

+    }

 #endif

 

 #ifdef PNG_READ_PACK_SUPPORTED

-   if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))

-      info_ptr->bit_depth = 8;

+    if((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))

+        info_ptr->bit_depth = 8;

 #endif

 

-   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      info_ptr->channels = 1;

-   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)

-      info_ptr->channels = 3;

-   else

-      info_ptr->channels = 1;

+    if(info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+        info_ptr->channels = 1;

+    else if(info_ptr->color_type & PNG_COLOR_MASK_COLOR)

+        info_ptr->channels = 3;

+    else

+        info_ptr->channels = 1;

 

 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED

-   if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)

-      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;

+    if(png_ptr->flags & PNG_FLAG_STRIP_ALPHA)

+        info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;

 #endif

 

-   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)

-      info_ptr->channels++;

+    if(info_ptr->color_type & PNG_COLOR_MASK_ALPHA)

+        info_ptr->channels++;

 

 #ifdef PNG_READ_FILLER_SUPPORTED

-   /* STRIP_ALPHA and FILLER allowed:  MASK_ALPHA bit stripped above */

-   if ((png_ptr->transformations & PNG_FILLER) &&

+    /* STRIP_ALPHA and FILLER allowed:  MASK_ALPHA bit stripped above */

+    if((png_ptr->transformations & PNG_FILLER) &&

        ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||

-       (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))

-   {

-      info_ptr->channels++;

-      /* If adding a true alpha channel not just filler */

-      if (png_ptr->transformations & PNG_ADD_ALPHA)

-        info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;

-   }

+        (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))

+    {

+        info_ptr->channels++;

+        /* If adding a true alpha channel not just filler */

+        if(png_ptr->transformations & PNG_ADD_ALPHA)

+            info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;

+    }

 #endif

 

 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \

 defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

-   if (png_ptr->transformations & PNG_USER_TRANSFORM)

-     {

-       if (info_ptr->bit_depth < png_ptr->user_transform_depth)

-         info_ptr->bit_depth = png_ptr->user_transform_depth;

-       if (info_ptr->channels < png_ptr->user_transform_channels)

-         info_ptr->channels = png_ptr->user_transform_channels;

-     }

+    if(png_ptr->transformations & PNG_USER_TRANSFORM)

+    {

+        if(info_ptr->bit_depth < png_ptr->user_transform_depth)

+            info_ptr->bit_depth = png_ptr->user_transform_depth;

+        if(info_ptr->channels < png_ptr->user_transform_channels)

+            info_ptr->channels = png_ptr->user_transform_channels;

+    }

 #endif

 

-   info_ptr->pixel_depth = (png_byte)(info_ptr->channels *

-      info_ptr->bit_depth);

+    info_ptr->pixel_depth = (png_byte)(info_ptr->channels *

+                                       info_ptr->bit_depth);

 

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

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

 

 #ifndef PNG_READ_EXPAND_SUPPORTED

-   if (png_ptr)

-      return;

+    if(png_ptr)

+        return;

 #endif

 }

 

@@ -1303,243 +1307,243 @@ defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
 void /* PRIVATE */

 png_do_read_transformations(png_structp png_ptr)

 {

-   png_debug(1, "in png_do_read_transformations");

+    png_debug(1, "in png_do_read_transformations");

 

-   if (png_ptr->row_buf == NULL)

-   {

+    if(png_ptr->row_buf == NULL)

+    {

 #ifdef PNG_STDIO_SUPPORTED

-      char msg[50];

+        char msg[50];

 

-      png_snprintf2(msg, 50,

-         "NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number,

-         png_ptr->pass);

-      png_error(png_ptr, msg);

+        png_snprintf2(msg, 50,

+                      "NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number,

+                      png_ptr->pass);

+        png_error(png_ptr, msg);

 #else

-      png_error(png_ptr, "NULL row buffer");

+        png_error(png_ptr, "NULL row buffer");

 #endif

-   }

+    }

 #ifdef PNG_WARN_UNINITIALIZED_ROW

-   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

-       */

+    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

+         */

 #if (PNG_WARN_UNINITIALIZED_ROW==1)

-      png_error(png_ptr, "Uninitialized row");

+        png_error(png_ptr, "Uninitialized row");

 #else

-      png_warning(png_ptr, "Uninitialized row");

+        png_warning(png_ptr, "Uninitialized row");

 #endif

 #endif

 

 #ifdef PNG_READ_EXPAND_SUPPORTED

-   if (png_ptr->transformations & PNG_EXPAND)

-   {

-      if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,

-            png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);

-      }

-      else

-      {

-         if (png_ptr->num_trans &&

-             (png_ptr->transformations & PNG_EXPAND_tRNS))

-            png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,

-               &(png_ptr->trans_color));

-         else

-            png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,

-               NULL);

-      }

-   }

+    if(png_ptr->transformations & PNG_EXPAND)

+    {

+        if(png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)

+        {

+            png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                                  png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);

+        }

+        else

+        {

+            if(png_ptr->num_trans &&

+               (png_ptr->transformations & PNG_EXPAND_tRNS))

+                png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                              &(png_ptr->trans_color));

+            else

+                png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                              NULL);

+        }

+    }

 #endif

 

 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED

-   if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)

-      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));

+    if(png_ptr->flags & PNG_FLAG_STRIP_ALPHA)

+        png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                            PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));

 #endif

 

 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

-   if (png_ptr->transformations & PNG_RGB_TO_GRAY)

-   {

-      int rgb_error =

-         png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info),

-             png_ptr->row_buf + 1);

-      if (rgb_error)

-      {

-         png_ptr->rgb_to_gray_status=1;

-         if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==

-             PNG_RGB_TO_GRAY_WARN)

-            png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");

-         if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==

-             PNG_RGB_TO_GRAY_ERR)

-            png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");

-      }

-   }

+    if(png_ptr->transformations & PNG_RGB_TO_GRAY)

+    {

+        int rgb_error =

+            png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info),

+                               png_ptr->row_buf + 1);

+        if(rgb_error)

+        {

+            png_ptr->rgb_to_gray_status = 1;

+            if((png_ptr->transformations & PNG_RGB_TO_GRAY) ==

+               PNG_RGB_TO_GRAY_WARN)

+                png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");

+            if((png_ptr->transformations & PNG_RGB_TO_GRAY) ==

+               PNG_RGB_TO_GRAY_ERR)

+                png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");

+        }

+    }

 #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.

+     */

 

 #ifdef 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 ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&

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

+        png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 

 #ifdef PNG_READ_BACKGROUND_SUPPORTED

-   if ((png_ptr->transformations & PNG_BACKGROUND) &&

-      ((png_ptr->num_trans != 0 ) ||

-      (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))

-      png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         &(png_ptr->trans_color), &(png_ptr->background)

+    if((png_ptr->transformations & PNG_BACKGROUND) &&

+       ((png_ptr->num_trans != 0) ||

+        (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))

+        png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                          &(png_ptr->trans_color), &(png_ptr->background)

 #ifdef PNG_READ_GAMMA_SUPPORTED

-         , &(png_ptr->background_1),

-         png_ptr->gamma_table, png_ptr->gamma_from_1,

-         png_ptr->gamma_to_1, png_ptr->gamma_16_table,

-         png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,

-         png_ptr->gamma_shift

+                          , &(png_ptr->background_1),

+                          png_ptr->gamma_table, png_ptr->gamma_from_1,

+                          png_ptr->gamma_to_1, png_ptr->gamma_16_table,

+                          png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,

+                          png_ptr->gamma_shift

 #endif

-);

+                         );

 #endif

 

 #ifdef PNG_READ_GAMMA_SUPPORTED

-   if ((png_ptr->transformations & PNG_GAMMA) &&

+    if((png_ptr->transformations & PNG_GAMMA) &&

 #ifdef PNG_READ_BACKGROUND_SUPPORTED

        !((png_ptr->transformations & PNG_BACKGROUND) &&

-       ((png_ptr->num_trans != 0) ||

-       (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&

+         ((png_ptr->num_trans != 0) ||

+          (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&

 #endif

        (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_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                     png_ptr->gamma_table, png_ptr->gamma_16_table,

+                     png_ptr->gamma_shift);

 #endif

 

 #ifdef PNG_READ_16_TO_8_SUPPORTED

-   if (png_ptr->transformations & PNG_16_TO_8)

-      png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_16_TO_8)

+        png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 

 #ifdef PNG_READ_DITHER_SUPPORTED

-   if (png_ptr->transformations & PNG_DITHER)

-   {

-      png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,

-         png_ptr->palette_lookup, png_ptr->dither_index);

-      if (png_ptr->row_info.rowbytes == (png_uint_32)0)

-         png_error(png_ptr, "png_do_dither returned rowbytes=0");

-   }

+    if(png_ptr->transformations & PNG_DITHER)

+    {

+        png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,

+                      png_ptr->palette_lookup, png_ptr->dither_index);

+        if(png_ptr->row_info.rowbytes == (png_uint_32)0)

+            png_error(png_ptr, "png_do_dither returned rowbytes=0");

+    }

 #endif

 

 #ifdef PNG_READ_INVERT_SUPPORTED

-   if (png_ptr->transformations & PNG_INVERT_MONO)

-      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_INVERT_MONO)

+        png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 

 #ifdef PNG_READ_SHIFT_SUPPORTED

-   if (png_ptr->transformations & PNG_SHIFT)

-      png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         &(png_ptr->shift));

+    if(png_ptr->transformations & PNG_SHIFT)

+        png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                       &(png_ptr->shift));

 #endif

 

 #ifdef PNG_READ_PACK_SUPPORTED

-   if (png_ptr->transformations & PNG_PACK)

-      png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_PACK)

+        png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 

 #ifdef PNG_READ_BGR_SUPPORTED

-   if (png_ptr->transformations & PNG_BGR)

-      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_BGR)

+        png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 

 #ifdef PNG_READ_PACKSWAP_SUPPORTED

-   if (png_ptr->transformations & PNG_PACKSWAP)

-      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_PACKSWAP)

+        png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 

 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-   /* If gray -> RGB, do so now only if we did not do so above */

-   if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&

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

+        png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 

 #ifdef PNG_READ_FILLER_SUPPORTED

-   if (png_ptr->transformations & PNG_FILLER)

-      png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         (png_uint_32)png_ptr->filler, png_ptr->flags);

+    if(png_ptr->transformations & PNG_FILLER)

+        png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                           (png_uint_32)png_ptr->filler, png_ptr->flags);

 #endif

 

 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

-   if (png_ptr->transformations & PNG_INVERT_ALPHA)

-      png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_INVERT_ALPHA)

+        png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 

 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED

-   if (png_ptr->transformations & PNG_SWAP_ALPHA)

-      png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_SWAP_ALPHA)

+        png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 

 #ifdef PNG_READ_SWAP_SUPPORTED

-   if (png_ptr->transformations & PNG_SWAP_BYTES)

-      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_SWAP_BYTES)

+        png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 

 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-   if (png_ptr->transformations & PNG_USER_TRANSFORM)

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

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

 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED

-      if (png_ptr->user_transform_depth)

-         png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;

-      if (png_ptr->user_transform_channels)

-         png_ptr->row_info.channels = png_ptr->user_transform_channels;

+        if(png_ptr->user_transform_depth)

+            png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;

+        if(png_ptr->user_transform_channels)

+            png_ptr->row_info.channels = png_ptr->user_transform_channels;

 #endif

-      png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *

-         png_ptr->row_info.channels);

-      png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

-         png_ptr->row_info.width);

-   }

+        png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *

+                                        png_ptr->row_info.channels);

+        png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

+                                     png_ptr->row_info.width);

+    }

 #endif

 

 }

@@ -1554,83 +1558,83 @@ png_do_read_transformations(png_structp png_ptr)
 void /* PRIVATE */

 png_do_unpack(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_unpack");

+    png_debug(1, "in png_do_unpack");

 

-   if (row_info->bit_depth < 8)

-   {

-      png_uint_32 i;

-      png_uint_32 row_width=row_info->width;

+    if(row_info->bit_depth < 8)

+    {

+        png_uint_32 i;

+        png_uint_32 row_width = row_info->width;

 

-      switch (row_info->bit_depth)

-      {

-         case 1:

-         {

+        switch(row_info->bit_depth)

+        {

+        case 1:

+        {

             png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);

             png_bytep dp = row + (png_size_t)row_width - 1;

             png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07);

-            for (i = 0; i < row_width; i++)

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

             {

-               *dp = (png_byte)((*sp >> shift) & 0x01);

-               if (shift == 7)

-               {

-                  shift = 0;

-                  sp--;

-               }

-               else

-                  shift++;

-

-               dp--;

+                *dp = (png_byte)((*sp >> shift) & 0x01);

+                if(shift == 7)

+                {

+                    shift = 0;

+                    sp--;

+                }

+                else

+                    shift++;

+

+                dp--;

             }

             break;

-         }

+        }

 

-         case 2:

-         {

+        case 2:

+        {

 

             png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);

             png_bytep dp = row + (png_size_t)row_width - 1;

             png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

-            for (i = 0; i < row_width; i++)

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

             {

-               *dp = (png_byte)((*sp >> shift) & 0x03);

-               if (shift == 6)

-               {

-                  shift = 0;

-                  sp--;

-               }

-               else

-                  shift += 2;

-

-               dp--;

+                *dp = (png_byte)((*sp >> shift) & 0x03);

+                if(shift == 6)

+                {

+                    shift = 0;

+                    sp--;

+                }

+                else

+                    shift += 2;

+

+                dp--;

             }

             break;

-         }

+        }

 

-         case 4:

-         {

+        case 4:

+        {

             png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);

             png_bytep dp = row + (png_size_t)row_width - 1;

             png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);

-            for (i = 0; i < row_width; i++)

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

             {

-               *dp = (png_byte)((*sp >> shift) & 0x0f);

-               if (shift == 4)

-               {

-                  shift = 0;

-                  sp--;

-               }

-               else

-                  shift = 4;

-

-               dp--;

+                *dp = (png_byte)((*sp >> shift) & 0x0f);

+                if(shift == 4)

+                {

+                    shift = 0;

+                    sp--;

+                }

+                else

+                    shift = 4;

+

+                dp--;

             }

             break;

-         }

-      }

-      row_info->bit_depth = 8;

-      row_info->pixel_depth = (png_byte)(8 * row_info->channels);

-      row_info->rowbytes = row_width * row_info->channels;

-   }

+        }

+        }

+        row_info->bit_depth = 8;

+        row_info->pixel_depth = (png_byte)(8 * row_info->channels);

+        row_info->rowbytes = row_width * row_info->channels;

+    }

 }

 #endif

 

@@ -1643,105 +1647,105 @@ png_do_unpack(png_row_infop row_info, png_bytep row)
 void /* PRIVATE */

 png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)

 {

-   png_debug(1, "in png_do_unshift");

-

-   if (

-       row_info->color_type != PNG_COLOR_TYPE_PALETTE)

-   {

-      int shift[4];

-      int channels = 0;

-      int c;

-      png_uint_16 value = 0;

-      png_uint_32 row_width = row_info->width;

-

-      if (row_info->color_type & PNG_COLOR_MASK_COLOR)

-      {

-         shift[channels++] = row_info->bit_depth - sig_bits->red;

-         shift[channels++] = row_info->bit_depth - sig_bits->green;

-         shift[channels++] = row_info->bit_depth - sig_bits->blue;

-      }

-      else

-      {

-         shift[channels++] = row_info->bit_depth - sig_bits->gray;

-      }

-      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)

-      {

-         shift[channels++] = row_info->bit_depth - sig_bits->alpha;

-      }

-

-      for (c = 0; c < channels; c++)

-      {

-         if (shift[c] <= 0)

-            shift[c] = 0;

-         else

-            value = 1;

-      }

-

-      if (!value)

-         return;

-

-      switch (row_info->bit_depth)

-      {

-         case 2:

-         {

+    png_debug(1, "in png_do_unshift");

+

+    if(

+        row_info->color_type != PNG_COLOR_TYPE_PALETTE)

+    {

+        int shift[4];

+        int channels = 0;

+        int c;

+        png_uint_16 value = 0;

+        png_uint_32 row_width = row_info->width;

+

+        if(row_info->color_type & PNG_COLOR_MASK_COLOR)

+        {

+            shift[channels++] = row_info->bit_depth - sig_bits->red;

+            shift[channels++] = row_info->bit_depth - sig_bits->green;

+            shift[channels++] = row_info->bit_depth - sig_bits->blue;

+        }

+        else

+        {

+            shift[channels++] = row_info->bit_depth - sig_bits->gray;

+        }

+        if(row_info->color_type & PNG_COLOR_MASK_ALPHA)

+        {

+            shift[channels++] = row_info->bit_depth - sig_bits->alpha;

+        }

+

+        for(c = 0; c < channels; c++)

+        {

+            if(shift[c] <= 0)

+                shift[c] = 0;

+            else

+                value = 1;

+        }

+

+        if(!value)

+            return;

+

+        switch(row_info->bit_depth)

+        {

+        case 2:

+        {

             png_bytep bp;

             png_uint_32 i;

             png_uint_32 istop = row_info->rowbytes;

 

-            for (bp = row, i = 0; i < istop; i++)

+            for(bp = row, i = 0; i < istop; i++)

             {

-               *bp >>= 1;

-               *bp++ &= 0x55;

+                *bp >>= 1;

+                *bp++ &= 0x55;

             }

             break;

-         }

+        }

 

-         case 4:

-         {

+        case 4:

+        {

             png_bytep bp = row;

             png_uint_32 i;

             png_uint_32 istop = row_info->rowbytes;

             png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) |

-               (png_byte)((int)0xf >> shift[0]));

+                                       (png_byte)((int)0xf >> shift[0]));

 

-            for (i = 0; i < istop; i++)

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

             {

-               *bp >>= shift[0];

-               *bp++ &= mask;

+                *bp >>= shift[0];

+                *bp++ &= mask;

             }

             break;

-         }

+        }

 

-         case 8:

-         {

+        case 8:

+        {

             png_bytep bp = row;

             png_uint_32 i;

             png_uint_32 istop = row_width * channels;

 

-            for (i = 0; i < istop; i++)

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

             {

-               *bp++ >>= shift[i%channels];

+                *bp++ >>= shift[i%channels];

             }

             break;

-         }

+        }

 

-         case 16:

-         {

+        case 16:

+        {

             png_bytep bp = row;

             png_uint_32 i;

             png_uint_32 istop = channels * row_width;

 

-            for (i = 0; i < istop; i++)

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

             {

-               value = (png_uint_16)((*bp << 8) + *(bp + 1));

-               value >>= shift[i%channels];

-               *bp++ = (png_byte)(value >> 8);

-               *bp++ = (png_byte)(value & 0xff);

+                value = (png_uint_16)((*bp << 8) + *(bp + 1));

+                value >>= shift[i%channels];

+                *bp++ = (png_byte)(value >> 8);

+                *bp++ = (png_byte)(value & 0xff);

             }

             break;

-         }

-      }

-   }

+        }

+        }

+    }

 }

 #endif

 

@@ -1750,53 +1754,53 @@ png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
 void /* PRIVATE */

 png_do_chop(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_chop");

+    png_debug(1, "in png_do_chop");

 

-   if (row_info->bit_depth == 16)

-   {

-      png_bytep sp = row;

-      png_bytep dp = row;

-      png_uint_32 i;

-      png_uint_32 istop = row_info->width * row_info->channels;

+    if(row_info->bit_depth == 16)

+    {

+        png_bytep sp = row;

+        png_bytep dp = row;

+        png_uint_32 i;

+        png_uint_32 istop = row_info->width * row_info->channels;

 

-      for (i = 0; i<istop; i++, sp += 2, dp++)

-      {

+        for(i = 0; i < istop; i++, sp += 2, dp++)

+        {

 #ifdef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED

-      /* This does a more accurate scaling of the 16-bit color

-       * value, rather than a simple low-byte truncation.

-       *

-       * What the ideal calculation should be:

-       *   *dp = (((((png_uint_32)(*sp) << 8) |

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

-       *

-       * GRR: here's the exact calculation with shifts:

-       *   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:

-       *   *dp = ((((png_uint_32)(*sp) << 8) |

-       *          (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8;

-       *

-       * What we actually do to avoid extra shifting and conversion:

-       */

-

-         *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0);

+            /* This does a more accurate scaling of the 16-bit color

+             * value, rather than a simple low-byte truncation.

+             *

+             * What the ideal calculation should be:

+             *   *dp = (((((png_uint_32)(*sp) << 8) |

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

+             *

+             * GRR: here's the exact calculation with shifts:

+             *   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:

+             *   *dp = ((((png_uint_32)(*sp) << 8) |

+             *          (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8;

+             *

+             * What we actually do to avoid extra shifting and conversion:

+             */

+

+            *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0);

 #else

-       /* Simply discard the low order byte */

-         *dp = *sp;

+            /* Simply discard the low order byte */

+            *dp = *sp;

 #endif

-      }

-      row_info->bit_depth = 8;

-      row_info->pixel_depth = (png_byte)(8 * row_info->channels);

-      row_info->rowbytes = row_info->width * row_info->channels;

-   }

+        }

+        row_info->bit_depth = 8;

+        row_info->pixel_depth = (png_byte)(8 * row_info->channels);

+        row_info->rowbytes = row_info->width * row_info->channels;

+    }

 }

 #endif

 

@@ -1804,89 +1808,89 @@ png_do_chop(png_row_infop row_info, png_bytep row)
 void /* PRIVATE */

 png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_read_swap_alpha");

-

-   {

-      png_uint_32 row_width = row_info->width;

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-      {

-         /* This converts from RGBA to ARGB */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_byte save;

-            png_uint_32 i;

+    png_debug(1, "in png_do_read_swap_alpha");

 

-            for (i = 0; i < row_width; i++)

+    {

+        png_uint_32 row_width = row_info->width;

+        if(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+        {

+            /* This converts from RGBA to ARGB */

+            if(row_info->bit_depth == 8)

             {

-               save = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = save;

+                png_bytep sp = row + row_info->rowbytes;

+                png_bytep dp = sp;

+                png_byte save;

+                png_uint_32 i;

+

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

+                {

+                    save = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = save;

+                }

             }

-         }

-         /* This converts from RRGGBBAA to AARRGGBB */

-         else

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_byte save[2];

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

+            /* This converts from RRGGBBAA to AARRGGBB */

+            else

             {

-               save[0] = *(--sp);

-               save[1] = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = save[0];

-               *(--dp) = save[1];

+                png_bytep sp = row + row_info->rowbytes;

+                png_bytep dp = sp;

+                png_byte save[2];

+                png_uint_32 i;

+

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

+                {

+                    save[0] = *(--sp);

+                    save[1] = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = save[0];

+                    *(--dp) = save[1];

+                }

             }

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         /* This converts from GA to AG */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_byte save;

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

+        }

+        else if(row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+        {

+            /* This converts from GA to AG */

+            if(row_info->bit_depth == 8)

             {

-               save = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = save;

+                png_bytep sp = row + row_info->rowbytes;

+                png_bytep dp = sp;

+                png_byte save;

+                png_uint_32 i;

+

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

+                {

+                    save = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = save;

+                }

             }

-         }

-         /* This converts from GGAA to AAGG */

-         else

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_byte save[2];

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

+            /* This converts from GGAA to AAGG */

+            else

             {

-               save[0] = *(--sp);

-               save[1] = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = save[0];

-               *(--dp) = save[1];

+                png_bytep sp = row + row_info->rowbytes;

+                png_bytep dp = sp;

+                png_byte save[2];

+                png_uint_32 i;

+

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

+                {

+                    save[0] = *(--sp);

+                    save[1] = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = save[0];

+                    *(--dp) = save[1];

+                }

             }

-         }

-      }

-   }

+        }

+    }

 }

 #endif

 

@@ -1894,95 +1898,95 @@ png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
 void /* PRIVATE */

 png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_read_invert_alpha");

-

-   {

-      png_uint_32 row_width = row_info->width;

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-      {

-         /* This inverts the alpha channel in RGBA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_uint_32 i;

+    png_debug(1, "in png_do_read_invert_alpha");

 

-            for (i = 0; i < row_width; i++)

+    {

+        png_uint_32 row_width = row_info->width;

+        if(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+        {

+            /* This inverts the alpha channel in RGBA */

+            if(row_info->bit_depth == 8)

             {

-               *(--dp) = (png_byte)(255 - *(--sp));

-

-/*             This does nothing:

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               We can replace it with:

-*/

-               sp-=3;

-               dp=sp;

+                png_bytep sp = row + row_info->rowbytes;

+                png_bytep dp = sp;

+                png_uint_32 i;

+

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

+                {

+                    *(--dp) = (png_byte)(255 - *(--sp));

+

+                    /*             This does nothing:

+                                   *(--dp) = *(--sp);

+                                   *(--dp) = *(--sp);

+                                   *(--dp) = *(--sp);

+                                   We can replace it with:

+                    */

+                    sp -= 3;

+                    dp = sp;

+                }

             }

-         }

-         /* This inverts the alpha channel in RRGGBBAA */

-         else

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

+            /* This inverts the alpha channel in RRGGBBAA */

+            else

             {

-               *(--dp) = (png_byte)(255 - *(--sp));

-               *(--dp) = (png_byte)(255 - *(--sp));

-

-/*             This does nothing:

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               We can replace it with:

-*/

-               sp-=6;

-               dp=sp;

+                png_bytep sp = row + row_info->rowbytes;

+                png_bytep dp = sp;

+                png_uint_32 i;

+

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

+                {

+                    *(--dp) = (png_byte)(255 - *(--sp));

+                    *(--dp) = (png_byte)(255 - *(--sp));

+

+                    /*             This does nothing:

+                                   *(--dp) = *(--sp);

+                                   *(--dp) = *(--sp);

+                                   *(--dp) = *(--sp);

+                                   *(--dp) = *(--sp);

+                                   *(--dp) = *(--sp);

+                                   *(--dp) = *(--sp);

+                                   We can replace it with:

+                    */

+                    sp -= 6;

+                    dp = sp;

+                }

             }

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         /* This inverts the alpha channel in GA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

+        }

+        else if(row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+        {

+            /* This inverts the alpha channel in GA */

+            if(row_info->bit_depth == 8)

             {

-               *(--dp) = (png_byte)(255 - *(--sp));

-               *(--dp) = *(--sp);

+                png_bytep sp = row + row_info->rowbytes;

+                png_bytep dp = sp;

+                png_uint_32 i;

+

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

+                {

+                    *(--dp) = (png_byte)(255 - *(--sp));

+                    *(--dp) = *(--sp);

+                }

             }

-         }

-         /* This inverts the alpha channel in GGAA */

-         else

-         {

-            png_bytep sp  = row + row_info->rowbytes;

-            png_bytep dp = sp;

-            png_uint_32 i;

-

-            for (i = 0; i < row_width; i++)

+            /* This inverts the alpha channel in GGAA */

+            else

             {

-               *(--dp) = (png_byte)(255 - *(--sp));

-               *(--dp) = (png_byte)(255 - *(--sp));

-/*

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-*/

-               sp-=2;

-               dp=sp;

+                png_bytep sp  = row + row_info->rowbytes;

+                png_bytep dp = sp;

+                png_uint_32 i;

+

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

+                {

+                    *(--dp) = (png_byte)(255 - *(--sp));

+                    *(--dp) = (png_byte)(255 - *(--sp));

+                    /*

+                                   *(--dp) = *(--sp);

+                                   *(--dp) = *(--sp);

+                    */

+                    sp -= 2;

+                    dp = sp;

+                }

             }

-         }

-      }

-   }

+        }

+    }

 }

 #endif

 

@@ -1990,173 +1994,173 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
 /* Add filler channel if we have RGB color */

 void /* PRIVATE */

 png_do_read_filler(png_row_infop row_info, png_bytep row,

-   png_uint_32 filler, png_uint_32 flags)

+                   png_uint_32 filler, png_uint_32 flags)

 {

-   png_uint_32 i;

-   png_uint_32 row_width = row_info->width;

-

-   png_byte hi_filler = (png_byte)((filler>>8) & 0xff);

-   png_byte lo_filler = (png_byte)(filler & 0xff);

-

-   png_debug(1, "in png_do_read_filler");

-

-   if (

-       row_info->color_type == PNG_COLOR_TYPE_GRAY)

-   {

-      if (row_info->bit_depth == 8)

-      {

-         /* This changes the data from G to GX */

-         if (flags & PNG_FLAG_FILLER_AFTER)

-         {

-            png_bytep sp = row + (png_size_t)row_width;

-            png_bytep dp =  sp + (png_size_t)row_width;

-            for (i = 1; i < row_width; i++)

+    png_uint_32 i;

+    png_uint_32 row_width = row_info->width;

+

+    png_byte hi_filler = (png_byte)((filler >> 8) & 0xff);

+    png_byte lo_filler = (png_byte)(filler & 0xff);

+

+    png_debug(1, "in png_do_read_filler");

+

+    if(

+        row_info->color_type == PNG_COLOR_TYPE_GRAY)

+    {

+        if(row_info->bit_depth == 8)

+        {

+            /* This changes the data from G to GX */

+            if(flags & PNG_FLAG_FILLER_AFTER)

             {

-               *(--dp) = lo_filler;

-               *(--dp) = *(--sp);

+                png_bytep sp = row + (png_size_t)row_width;

+                png_bytep dp =  sp + (png_size_t)row_width;

+                for(i = 1; i < row_width; i++)

+                {

+                    *(--dp) = lo_filler;

+                    *(--dp) = *(--sp);

+                }

+                *(--dp) = lo_filler;

+                row_info->channels = 2;

+                row_info->pixel_depth = 16;

+                row_info->rowbytes = row_width * 2;

             }

-            *(--dp) = lo_filler;

-            row_info->channels = 2;

-            row_info->pixel_depth = 16;

-            row_info->rowbytes = row_width * 2;

-         }

-      /* This changes the data from G to XG */

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width;

-            png_bytep dp = sp  + (png_size_t)row_width;

-            for (i = 0; i < row_width; i++)

+            /* This changes the data from G to XG */

+            else

             {

-               *(--dp) = *(--sp);

-               *(--dp) = lo_filler;

+                png_bytep sp = row + (png_size_t)row_width;

+                png_bytep dp = sp  + (png_size_t)row_width;

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

+                {

+                    *(--dp) = *(--sp);

+                    *(--dp) = lo_filler;

+                }

+                row_info->channels = 2;

+                row_info->pixel_depth = 16;

+                row_info->rowbytes = row_width * 2;

             }

-            row_info->channels = 2;

-            row_info->pixel_depth = 16;

-            row_info->rowbytes = row_width * 2;

-         }

-      }

-      else if (row_info->bit_depth == 16)

-      {

-         /* This changes the data from GG to GGXX */

-         if (flags & PNG_FLAG_FILLER_AFTER)

-         {

-            png_bytep sp = row + (png_size_t)row_width * 2;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 1; i < row_width; i++)

+        }

+        else if(row_info->bit_depth == 16)

+        {

+            /* This changes the data from GG to GGXX */

+            if(flags & PNG_FLAG_FILLER_AFTER)

             {

-               *(--dp) = hi_filler;

-               *(--dp) = lo_filler;

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

+                png_bytep sp = row + (png_size_t)row_width * 2;

+                png_bytep dp = sp  + (png_size_t)row_width * 2;

+                for(i = 1; i < row_width; i++)

+                {

+                    *(--dp) = hi_filler;

+                    *(--dp) = lo_filler;

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                }

+                *(--dp) = hi_filler;

+                *(--dp) = lo_filler;

+                row_info->channels = 2;

+                row_info->pixel_depth = 32;

+                row_info->rowbytes = row_width * 4;

             }

-            *(--dp) = hi_filler;

-            *(--dp) = lo_filler;

-            row_info->channels = 2;

-            row_info->pixel_depth = 32;

-            row_info->rowbytes = row_width * 4;

-         }

-         /* This changes the data from GG to XXGG */

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width * 2;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 0; i < row_width; i++)

+            /* This changes the data from GG to XXGG */

+            else

             {

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = hi_filler;

-               *(--dp) = lo_filler;

+                png_bytep sp = row + (png_size_t)row_width * 2;

+                png_bytep dp = sp  + (png_size_t)row_width * 2;

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

+                {

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = hi_filler;

+                    *(--dp) = lo_filler;

+                }

+                row_info->channels = 2;

+                row_info->pixel_depth = 32;

+                row_info->rowbytes = row_width * 4;

             }

-            row_info->channels = 2;

-            row_info->pixel_depth = 32;

-            row_info->rowbytes = row_width * 4;

-         }

-      }

-   } /* COLOR_TYPE == GRAY */

-   else if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-   {

-      if (row_info->bit_depth == 8)

-      {

-         /* This changes the data from RGB to RGBX */

-         if (flags & PNG_FLAG_FILLER_AFTER)

-         {

-            png_bytep sp = row + (png_size_t)row_width * 3;

-            png_bytep dp = sp  + (png_size_t)row_width;

-            for (i = 1; i < row_width; i++)

+        }

+    } /* COLOR_TYPE == GRAY */

+    else if(row_info->color_type == PNG_COLOR_TYPE_RGB)

+    {

+        if(row_info->bit_depth == 8)

+        {

+            /* This changes the data from RGB to RGBX */

+            if(flags & PNG_FLAG_FILLER_AFTER)

             {

-               *(--dp) = lo_filler;

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

+                png_bytep sp = row + (png_size_t)row_width * 3;

+                png_bytep dp = sp  + (png_size_t)row_width;

+                for(i = 1; i < row_width; i++)

+                {

+                    *(--dp) = lo_filler;

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                }

+                *(--dp) = lo_filler;

+                row_info->channels = 4;

+                row_info->pixel_depth = 32;

+                row_info->rowbytes = row_width * 4;

             }

-            *(--dp) = lo_filler;

-            row_info->channels = 4;

-            row_info->pixel_depth = 32;

-            row_info->rowbytes = row_width * 4;

-         }

-      /* This changes the data from RGB to XRGB */

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width * 3;

-            png_bytep dp = sp + (png_size_t)row_width;

-            for (i = 0; i < row_width; i++)

+            /* This changes the data from RGB to XRGB */

+            else

             {

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = lo_filler;

+                png_bytep sp = row + (png_size_t)row_width * 3;

+                png_bytep dp = sp + (png_size_t)row_width;

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

+                {

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = lo_filler;

+                }

+                row_info->channels = 4;

+                row_info->pixel_depth = 32;

+                row_info->rowbytes = row_width * 4;

             }

-            row_info->channels = 4;

-            row_info->pixel_depth = 32;

-            row_info->rowbytes = row_width * 4;

-         }

-      }

-      else if (row_info->bit_depth == 16)

-      {

-         /* This changes the data from RRGGBB to RRGGBBXX */

-         if (flags & PNG_FLAG_FILLER_AFTER)

-         {

-            png_bytep sp = row + (png_size_t)row_width * 6;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 1; i < row_width; i++)

+        }

+        else if(row_info->bit_depth == 16)

+        {

+            /* This changes the data from RRGGBB to RRGGBBXX */

+            if(flags & PNG_FLAG_FILLER_AFTER)

             {

-               *(--dp) = hi_filler;

-               *(--dp) = lo_filler;

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

+                png_bytep sp = row + (png_size_t)row_width * 6;

+                png_bytep dp = sp  + (png_size_t)row_width * 2;

+                for(i = 1; i < row_width; i++)

+                {

+                    *(--dp) = hi_filler;

+                    *(--dp) = lo_filler;

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                }

+                *(--dp) = hi_filler;

+                *(--dp) = lo_filler;

+                row_info->channels = 4;

+                row_info->pixel_depth = 64;

+                row_info->rowbytes = row_width * 8;

             }

-            *(--dp) = hi_filler;

-            *(--dp) = lo_filler;

-            row_info->channels = 4;

-            row_info->pixel_depth = 64;

-            row_info->rowbytes = row_width * 8;

-         }

-         /* This changes the data from RRGGBB to XXRRGGBB */

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width * 6;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 0; i < row_width; i++)

+            /* This changes the data from RRGGBB to XXRRGGBB */

+            else

             {

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = *(--sp);

-               *(--dp) = hi_filler;

-               *(--dp) = lo_filler;

+                png_bytep sp = row + (png_size_t)row_width * 6;

+                png_bytep dp = sp  + (png_size_t)row_width * 2;

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

+                {

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = *(--sp);

+                    *(--dp) = hi_filler;

+                    *(--dp) = lo_filler;

+                }

+                row_info->channels = 4;

+                row_info->pixel_depth = 64;

+                row_info->rowbytes = row_width * 8;

             }

-            row_info->channels = 4;

-            row_info->pixel_depth = 64;

-            row_info->rowbytes = row_width * 8;

-         }

-      }

-   } /* COLOR_TYPE == RGB */

+        }

+    } /* COLOR_TYPE == RGB */

 }

 #endif

 

@@ -2165,79 +2169,79 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
 void /* PRIVATE */

 png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)

 {

-   png_uint_32 i;

-   png_uint_32 row_width = row_info->width;

-

-   png_debug(1, "in png_do_gray_to_rgb");

-

-   if (row_info->bit_depth >= 8 &&

-      !(row_info->color_type & PNG_COLOR_MASK_COLOR))

-   {

-      if (row_info->color_type == PNG_COLOR_TYPE_GRAY)

-      {

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + (png_size_t)row_width - 1;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 0; i < row_width; i++)

+    png_uint_32 i;

+    png_uint_32 row_width = row_info->width;

+

+    png_debug(1, "in png_do_gray_to_rgb");

+

+    if(row_info->bit_depth >= 8 &&

+       !(row_info->color_type & PNG_COLOR_MASK_COLOR))

+    {

+        if(row_info->color_type == PNG_COLOR_TYPE_GRAY)

+        {

+            if(row_info->bit_depth == 8)

             {

-               *(dp--) = *sp;

-               *(dp--) = *sp;

-               *(dp--) = *(sp--);

+                png_bytep sp = row + (png_size_t)row_width - 1;

+                png_bytep dp = sp  + (png_size_t)row_width * 2;

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

+                {

+                    *(dp--) = *sp;

+                    *(dp--) = *sp;

+                    *(dp--) = *(sp--);

+                }

             }

-         }

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width * 2 - 1;

-            png_bytep dp = sp  + (png_size_t)row_width * 4;

-            for (i = 0; i < row_width; i++)

+            else

             {

-               *(dp--) = *sp;

-               *(dp--) = *(sp - 1);

-               *(dp--) = *sp;

-               *(dp--) = *(sp - 1);

-               *(dp--) = *(sp--);

-               *(dp--) = *(sp--);

+                png_bytep sp = row + (png_size_t)row_width * 2 - 1;

+                png_bytep dp = sp  + (png_size_t)row_width * 4;

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

+                {

+                    *(dp--) = *sp;

+                    *(dp--) = *(sp - 1);

+                    *(dp--) = *sp;

+                    *(dp--) = *(sp - 1);

+                    *(dp--) = *(sp--);

+                    *(dp--) = *(sp--);

+                }

             }

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp = row + (png_size_t)row_width * 2 - 1;

-            png_bytep dp = sp  + (png_size_t)row_width * 2;

-            for (i = 0; i < row_width; i++)

+        }

+        else if(row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+        {

+            if(row_info->bit_depth == 8)

             {

-               *(dp--) = *(sp--);

-               *(dp--) = *sp;

-               *(dp--) = *sp;

-               *(dp--) = *(sp--);

+                png_bytep sp = row + (png_size_t)row_width * 2 - 1;

+                png_bytep dp = sp  + (png_size_t)row_width * 2;

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

+                {

+                    *(dp--) = *(sp--);

+                    *(dp--) = *sp;

+                    *(dp--) = *sp;

+                    *(dp--) = *(sp--);

+                }

             }

-         }

-         else

-         {

-            png_bytep sp = row + (png_size_t)row_width * 4 - 1;

-            png_bytep dp = sp  + (png_size_t)row_width * 4;

-            for (i = 0; i < row_width; i++)

+            else

             {

-               *(dp--) = *(sp--);

-               *(dp--) = *(sp--);

-               *(dp--) = *sp;

-               *(dp--) = *(sp - 1);

-               *(dp--) = *sp;

-               *(dp--) = *(sp - 1);

-               *(dp--) = *(sp--);

-               *(dp--) = *(sp--);

+                png_bytep sp = row + (png_size_t)row_width * 4 - 1;

+                png_bytep dp = sp  + (png_size_t)row_width * 4;

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

+                {

+                    *(dp--) = *(sp--);

+                    *(dp--) = *(sp--);

+                    *(dp--) = *sp;

+                    *(dp--) = *(sp - 1);

+                    *(dp--) = *sp;

+                    *(dp--) = *(sp - 1);

+                    *(dp--) = *(sp--);

+                    *(dp--) = *(sp--);

+                }

             }

-         }

-      }

-      row_info->channels += (png_byte)2;

-      row_info->color_type |= PNG_COLOR_MASK_COLOR;

-      row_info->pixel_depth = (png_byte)(row_info->channels *

-         row_info->bit_depth);

-      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-   }

+        }

+        row_info->channels += (png_byte)2;

+        row_info->color_type |= PNG_COLOR_MASK_COLOR;

+        row_info->pixel_depth = (png_byte)(row_info->channels *

+                                           row_info->bit_depth);

+        row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

+    }

 }

 #endif

 

@@ -2267,233 +2271,245 @@ int /* PRIVATE */
 png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)

 

 {

-   png_uint_32 i;

+    png_uint_32 i;

 

-   png_uint_32 row_width = row_info->width;

-   int rgb_error = 0;

+    png_uint_32 row_width = row_info->width;

+    int rgb_error = 0;

 

-   png_debug(1, "in png_do_rgb_to_gray");

+    png_debug(1, "in png_do_rgb_to_gray");

 

-   if (

-      (row_info->color_type & PNG_COLOR_MASK_COLOR))

-   {

-      png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;

-      png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;

-      png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;

+    if(

+        (row_info->color_type & PNG_COLOR_MASK_COLOR))

+    {

+        png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;

+        png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;

+        png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;

 

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-      {

-         if (row_info->bit_depth == 8)

-         {

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-            if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)

+        if(row_info->color_type == PNG_COLOR_TYPE_RGB)

+        {

+            if(row_info->bit_depth == 8)

             {

-               png_bytep sp = row;

-               png_bytep dp = row;

-

-               for (i = 0; i < row_width; i++)

-               {

-                  png_byte red   = png_ptr->gamma_to_1[*(sp++)];

-                  png_byte green = png_ptr->gamma_to_1[*(sp++)];

-                  png_byte blue  = png_ptr->gamma_to_1[*(sp++)];

-                  if (red != green || red != blue)

-                  {

-                     rgb_error |= 1;

-                     *(dp++) = png_ptr->gamma_from_1[

-                       (rc*red + gc*green + bc*blue)>>15];

-                  }

-                  else

-                     *(dp++) = *(sp - 1);

-               }

-            }

-            else

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+                if(png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)

+                {

+                    png_bytep sp = row;

+                    png_bytep dp = row;

+

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

+                    {

+                        png_byte red   = png_ptr->gamma_to_1[*(sp++)];

+                        png_byte green = png_ptr->gamma_to_1[*(sp++)];

+                        png_byte blue  = png_ptr->gamma_to_1[*(sp++)];

+                        if(red != green || red != blue)

+                        {

+                            rgb_error |= 1;

+                            *(dp++) = png_ptr->gamma_from_1[

+                                          (rc*red + gc*green + bc*blue)>>15];

+                        }

+                        else

+                            *(dp++) = *(sp - 1);

+                    }

+                }

+                else

 #endif

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_byte red   = *(sp++);

-                  png_byte green = *(sp++);

-                  png_byte blue  = *(sp++);

-                  if (red != green || red != blue)

-                  {

-                     rgb_error |= 1;

-                     *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);

-                  }

-                  else

-                     *(dp++) = *(sp - 1);

-               }

+                {

+                    png_bytep sp = row;

+                    png_bytep dp = row;

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

+                    {

+                        png_byte red   = *(sp++);

+                        png_byte green = *(sp++);

+                        png_byte blue  = *(sp++);

+                        if(red != green || red != blue)

+                        {

+                            rgb_error |= 1;

+                            *(dp++) = (png_byte)((rc * red + gc * green + bc * blue) >> 15);

+                        }

+                        else

+                            *(dp++) = *(sp - 1);

+                    }

+                }

             }

-         }

 

-         else /* RGB bit_depth == 16 */

-         {

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-            if (png_ptr->gamma_16_to_1 != NULL &&

-                png_ptr->gamma_16_from_1 != NULL)

+            else /* RGB bit_depth == 16 */

             {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 red, green, blue, w;

-

-                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-

-                  if (red == green && red == blue)

-                     w = red;

-                  else

-                  {

-                     png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>

-                                  png_ptr->gamma_shift][red>>8];

-                     png_uint_16 green_1 =

-                         png_ptr->gamma_16_to_1[(green&0xff) >>

-                                  png_ptr->gamma_shift][green>>8];

-                     png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>

-                                  png_ptr->gamma_shift][blue>>8];

-                     png_uint_16 gray16  = (png_uint_16)((rc*red_1 + gc*green_1

-                                  + bc*blue_1)>>15);

-                     w = png_ptr->gamma_16_from_1[(gray16&0xff) >>

-                         png_ptr->gamma_shift][gray16 >> 8];

-                     rgb_error |= 1;

-                  }

-

-                  *(dp++) = (png_byte)((w>>8) & 0xff);

-                  *(dp++) = (png_byte)(w & 0xff);

-               }

-            }

-            else

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+                if(png_ptr->gamma_16_to_1 != NULL &&

+                   png_ptr->gamma_16_from_1 != NULL)

+                {

+                    png_bytep sp = row;

+                    png_bytep dp = row;

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

+                    {

+                        png_uint_16 red, green, blue, w;

+

+                        red   = (png_uint_16)(((*(sp)) << 8) | *(sp + 1));

+                        sp += 2;

+                        green = (png_uint_16)(((*(sp)) << 8) | *(sp + 1));

+                        sp += 2;

+                        blue  = (png_uint_16)(((*(sp)) << 8) | *(sp + 1));

+                        sp += 2;

+

+                        if(red == green && red == blue)

+                            w = red;

+                        else

+                        {

+                            png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>

+                                                  png_ptr->gamma_shift][red>>8];

+                            png_uint_16 green_1 =

+                                png_ptr->gamma_16_to_1[(green&0xff) >>

+                                                       png_ptr->gamma_shift][green>>8];

+                            png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>

+                                                  png_ptr->gamma_shift][blue>>8];

+                            png_uint_16 gray16  = (png_uint_16)((rc * red_1 + gc * green_1

+                                                                 + bc * blue_1) >> 15);

+                            w = png_ptr->gamma_16_from_1[(gray16&0xff) >>

+                                                         png_ptr->gamma_shift][gray16 >> 8];

+                            rgb_error |= 1;

+                        }

+

+                        *(dp++) = (png_byte)((w >> 8) & 0xff);

+                        *(dp++) = (png_byte)(w & 0xff);

+                    }

+                }

+                else

 #endif

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 red, green, blue, gray16;

-

-                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-

-                  if (red != green || red != blue)

-                     rgb_error |= 1;

-                  gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);

-                  *(dp++) = (png_byte)((gray16>>8) & 0xff);

-                  *(dp++) = (png_byte)(gray16 & 0xff);

-               }

+                {

+                    png_bytep sp = row;

+                    png_bytep dp = row;

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

+                    {

+                        png_uint_16 red, green, blue, gray16;

+

+                        red   = (png_uint_16)(((*(sp)) << 8) | *(sp + 1));

+                        sp += 2;

+                        green = (png_uint_16)(((*(sp)) << 8) | *(sp + 1));

+                        sp += 2;

+                        blue  = (png_uint_16)(((*(sp)) << 8) | *(sp + 1));

+                        sp += 2;

+

+                        if(red != green || red != blue)

+                            rgb_error |= 1;

+                        gray16  = (png_uint_16)((rc * red + gc * green + bc * blue) >> 15);

+                        *(dp++) = (png_byte)((gray16 >> 8) & 0xff);

+                        *(dp++) = (png_byte)(gray16 & 0xff);

+                    }

+                }

             }

-         }

-      }

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-      {

-         if (row_info->bit_depth == 8)

-         {

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-            if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)

+        }

+        if(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+        {

+            if(row_info->bit_depth == 8)

             {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_byte red   = png_ptr->gamma_to_1[*(sp++)];

-                  png_byte green = png_ptr->gamma_to_1[*(sp++)];

-                  png_byte blue  = png_ptr->gamma_to_1[*(sp++)];

-                  if (red != green || red != blue)

-                     rgb_error |= 1;

-                  *(dp++) =  png_ptr->gamma_from_1

-                             [(rc*red + gc*green + bc*blue)>>15];

-                  *(dp++) = *(sp++);  /* alpha */

-               }

-            }

-            else

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+                if(png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)

+                {

+                    png_bytep sp = row;

+                    png_bytep dp = row;

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

+                    {

+                        png_byte red   = png_ptr->gamma_to_1[*(sp++)];

+                        png_byte green = png_ptr->gamma_to_1[*(sp++)];

+                        png_byte blue  = png_ptr->gamma_to_1[*(sp++)];

+                        if(red != green || red != blue)

+                            rgb_error |= 1;

+                        *(dp++) =  png_ptr->gamma_from_1

+                                   [(rc*red + gc*green + bc*blue)>>15];

+                        *(dp++) = *(sp++);  /* alpha */

+                    }

+                }

+                else

 #endif

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_byte red   = *(sp++);

-                  png_byte green = *(sp++);

-                  png_byte blue  = *(sp++);

-                  if (red != green || red != blue)

-                     rgb_error |= 1;

-                  *(dp++) =  (png_byte)((rc*red + gc*green + bc*blue)>>15);

-                  *(dp++) = *(sp++);  /* alpha */

-               }

+                {

+                    png_bytep sp = row;

+                    png_bytep dp = row;

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

+                    {

+                        png_byte red   = *(sp++);

+                        png_byte green = *(sp++);

+                        png_byte blue  = *(sp++);

+                        if(red != green || red != blue)

+                            rgb_error |= 1;

+                        *(dp++) = (png_byte)((rc * red + gc * green + bc * blue) >> 15);

+                        *(dp++) = *(sp++);  /* alpha */

+                    }

+                }

             }

-         }

-         else /* RGBA bit_depth == 16 */

-         {

-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

-            if (png_ptr->gamma_16_to_1 != NULL &&

-                png_ptr->gamma_16_from_1 != NULL)

+            else /* RGBA bit_depth == 16 */

             {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 red, green, blue, w;

-

-                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

-

-                  if (red == green && red == blue)

-                     w = red;

-                  else

-                  {

-                     png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>

-                         png_ptr->gamma_shift][red>>8];

-                     png_uint_16 green_1 =

-                         png_ptr->gamma_16_to_1[(green&0xff) >>

-                         png_ptr->gamma_shift][green>>8];

-                     png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>

-                         png_ptr->gamma_shift][blue>>8];

-                     png_uint_16 gray16  = (png_uint_16)((rc * red_1

-                         + gc * green_1 + bc * blue_1)>>15);

-                     w = png_ptr->gamma_16_from_1[(gray16&0xff) >>

-                         png_ptr->gamma_shift][gray16 >> 8];

-                     rgb_error |= 1;

-                  }

-

-                  *(dp++) = (png_byte)((w>>8) & 0xff);

-                  *(dp++) = (png_byte)(w & 0xff);

-                  *(dp++) = *(sp++);  /* alpha */

-                  *(dp++) = *(sp++);

-               }

-            }

-            else

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+                if(png_ptr->gamma_16_to_1 != NULL &&

+                   png_ptr->gamma_16_from_1 != NULL)

+                {

+                    png_bytep sp = row;

+                    png_bytep dp = row;

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

+                    {

+                        png_uint_16 red, green, blue, w;

+

+                        red   = (png_uint_16)(((*(sp)) << 8) | *(sp + 1));

+                        sp += 2;

+                        green = (png_uint_16)(((*(sp)) << 8) | *(sp + 1));

+                        sp += 2;

+                        blue  = (png_uint_16)(((*(sp)) << 8) | *(sp + 1));

+                        sp += 2;

+

+                        if(red == green && red == blue)

+                            w = red;

+                        else

+                        {

+                            png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>

+                                                  png_ptr->gamma_shift][red>>8];

+                            png_uint_16 green_1 =

+                                png_ptr->gamma_16_to_1[(green&0xff) >>

+                                                       png_ptr->gamma_shift][green>>8];

+                            png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>

+                                                  png_ptr->gamma_shift][blue>>8];

+                            png_uint_16 gray16  = (png_uint_16)((rc * red_1

+                                                                 + gc * green_1 + bc * blue_1) >> 15);

+                            w = png_ptr->gamma_16_from_1[(gray16&0xff) >>

+                                                         png_ptr->gamma_shift][gray16 >> 8];

+                            rgb_error |= 1;

+                        }

+

+                        *(dp++) = (png_byte)((w >> 8) & 0xff);

+                        *(dp++) = (png_byte)(w & 0xff);

+                        *(dp++) = *(sp++);  /* alpha */

+                        *(dp++) = *(sp++);

+                    }

+                }

+                else

 #endif

-            {

-               png_bytep sp = row;

-               png_bytep dp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 red, green, blue, gray16;

-                  red   = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;

-                  green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;

-                  blue  = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;

-                  if (red != green || red != blue)

-                     rgb_error |= 1;

-                  gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);

-                  *(dp++) = (png_byte)((gray16>>8) & 0xff);

-                  *(dp++) = (png_byte)(gray16 & 0xff);

-                  *(dp++) = *(sp++);  /* alpha */

-                  *(dp++) = *(sp++);

-               }

+                {

+                    png_bytep sp = row;

+                    png_bytep dp = row;

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

+                    {

+                        png_uint_16 red, green, blue, gray16;

+                        red   = (png_uint_16)((*(sp) << 8) | *(sp + 1));

+                        sp += 2;

+                        green = (png_uint_16)((*(sp) << 8) | *(sp + 1));

+                        sp += 2;

+                        blue  = (png_uint_16)((*(sp) << 8) | *(sp + 1));

+                        sp += 2;

+                        if(red != green || red != blue)

+                            rgb_error |= 1;

+                        gray16  = (png_uint_16)((rc * red + gc * green + bc * blue) >> 15);

+                        *(dp++) = (png_byte)((gray16 >> 8) & 0xff);

+                        *(dp++) = (png_byte)(gray16 & 0xff);

+                        *(dp++) = *(sp++);  /* alpha */

+                        *(dp++) = *(sp++);

+                    }

+                }

             }

-         }

-      }

-   row_info->channels -= (png_byte)2;

-      row_info->color_type &= ~PNG_COLOR_MASK_COLOR;

-      row_info->pixel_depth = (png_byte)(row_info->channels *

-         row_info->bit_depth);

-      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-   }

-   return rgb_error;

+        }

+        row_info->channels -= (png_byte)2;

+        row_info->color_type &= ~PNG_COLOR_MASK_COLOR;

+        row_info->pixel_depth = (png_byte)(row_info->channels *

+                                           row_info->bit_depth);

+        row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

+    }

+    return rgb_error;

 }

 #endif

 

@@ -2505,50 +2521,50 @@ png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
 void PNGAPI

 png_build_grayscale_palette(int bit_depth, png_colorp palette)

 {

-   int num_palette;

-   int color_inc;

-   int i;

-   int v;

-

-   png_debug(1, "in png_do_build_grayscale_palette");

-

-   if (palette == NULL)

-      return;

-

-   switch (bit_depth)

-   {

-      case 1:

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

-         break;

-   }

-

-   for (i = 0, v = 0; i < num_palette; i++, v += color_inc)

-   {

-      palette[i].red = (png_byte)v;

-      palette[i].green = (png_byte)v;

-      palette[i].blue = (png_byte)v;

-   }

+    int num_palette;

+    int color_inc;

+    int i;

+    int v;

+

+    png_debug(1, "in png_do_build_grayscale_palette");

+

+    if(palette == NULL)

+        return;

+

+    switch(bit_depth)

+    {

+    case 1:

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

+        break;

+    }

+

+    for(i = 0, v = 0; i < num_palette; i++, v += color_inc)

+    {

+        palette[i].red = (png_byte)v;

+        palette[i].green = (png_byte)v;

+        palette[i].blue = (png_byte)v;

+    }

 }

 

 

@@ -2559,688 +2575,688 @@ png_build_grayscale_palette(int bit_depth, png_colorp palette)
  */

 void /* PRIVATE */

 png_do_background(png_row_infop row_info, png_bytep row,

-   png_color_16p trans_color, png_color_16p background

+                  png_color_16p trans_color, png_color_16p background

 #ifdef PNG_READ_GAMMA_SUPPORTED

-   , png_color_16p background_1,

-   png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,

-   png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,

-   png_uint_16pp gamma_16_to_1, int gamma_shift

+                  , png_color_16p background_1,

+                  png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,

+                  png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,

+                  png_uint_16pp gamma_16_to_1, int gamma_shift

 #endif

-   )

+                 )

 {

-   png_bytep sp, dp;

-   png_uint_32 i;

-   png_uint_32 row_width=row_info->width;

-   int shift;

-

-   png_debug(1, "in png_do_background");

-

-   if (background != NULL &&

-      (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||

-      (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_color)))

-   {

-      switch (row_info->color_type)

-      {

-         case PNG_COLOR_TYPE_GRAY:

-         {

-            switch (row_info->bit_depth)

+    png_bytep sp, dp;

+    png_uint_32 i;

+    png_uint_32 row_width = row_info->width;

+    int shift;

+

+    png_debug(1, "in png_do_background");

+

+    if(background != NULL &&

+       (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||

+        (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_color)))

+    {

+        switch(row_info->color_type)

+        {

+        case PNG_COLOR_TYPE_GRAY:

+        {

+            switch(row_info->bit_depth)

             {

-               case 1:

-               {

-                  sp = row;

-                  shift = 7;

-                  for (i = 0; i < row_width; i++)

-                  {

-                     if ((png_uint_16)((*sp >> shift) & 0x01)

-                        == trans_color->gray)

-                     {

+            case 1:

+            {

+                sp = row;

+                shift = 7;

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

+                {

+                    if((png_uint_16)((*sp >> shift) & 0x01)

+                       == trans_color->gray)

+                    {

                         *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);

                         *sp |= (png_byte)(background->gray << shift);

-                     }

-                     if (!shift)

-                     {

+                    }

+                    if(!shift)

+                    {

                         shift = 7;

                         sp++;

-                     }

-                     else

+                    }

+                    else

                         shift--;

-                  }

-                  break;

-               }

+                }

+                break;

+            }

 

-               case 2:

-               {

+            case 2:

+            {

 #ifdef PNG_READ_GAMMA_SUPPORTED

-                  if (gamma_table != NULL)

-                  {

-                     sp = row;

-                     shift = 6;

-                     for (i = 0; i < row_width; i++)

-                     {

-                        if ((png_uint_16)((*sp >> shift) & 0x03)

-                            == trans_color->gray)

+                if(gamma_table != NULL)

+                {

+                    sp = row;

+                    shift = 6;

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

+                    {

+                        if((png_uint_16)((*sp >> shift) & 0x03)

+                           == trans_color->gray)

                         {

-                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

-                           *sp |= (png_byte)(background->gray << shift);

+                            *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

+                            *sp |= (png_byte)(background->gray << shift);

                         }

                         else

                         {

-                           png_byte p = (png_byte)((*sp >> shift) & 0x03);

-                           png_byte g = (png_byte)((gamma_table [p | (p << 2) |

-                               (p << 4) | (p << 6)] >> 6) & 0x03);

-                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

-                           *sp |= (png_byte)(g << shift);

+                            png_byte p = (png_byte)((*sp >> shift) & 0x03);

+                            png_byte g = (png_byte)((gamma_table [p | (p << 2) |

+                                                                  (p << 4) | (p << 6)] >> 6) & 0x03);

+                            *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

+                            *sp |= (png_byte)(g << shift);

                         }

-                        if (!shift)

+                        if(!shift)

                         {

-                           shift = 6;

-                           sp++;

+                            shift = 6;

+                            sp++;

                         }

                         else

-                           shift -= 2;

-                     }

-                  }

-                  else

+                            shift -= 2;

+                    }

+                }

+                else

 #endif

-                  {

-                     sp = row;

-                     shift = 6;

-                     for (i = 0; i < row_width; i++)

-                     {

-                        if ((png_uint_16)((*sp >> shift) & 0x03)

-                            == trans_color->gray)

+                {

+                    sp = row;

+                    shift = 6;

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

+                    {

+                        if((png_uint_16)((*sp >> shift) & 0x03)

+                           == trans_color->gray)

                         {

-                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

-                           *sp |= (png_byte)(background->gray << shift);

+                            *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

+                            *sp |= (png_byte)(background->gray << shift);

                         }

-                        if (!shift)

+                        if(!shift)

                         {

-                           shift = 6;

-                           sp++;

+                            shift = 6;

+                            sp++;

                         }

                         else

-                           shift -= 2;

-                     }

-                  }

-                  break;

-               }

-

-               case 4:

-               {

+                            shift -= 2;

+                    }

+                }

+                break;

+            }

+

+            case 4:

+            {

 #ifdef PNG_READ_GAMMA_SUPPORTED

-                  if (gamma_table != NULL)

-                  {

-                     sp = row;

-                     shift = 4;

-                     for (i = 0; i < row_width; i++)

-                     {

-                        if ((png_uint_16)((*sp >> shift) & 0x0f)

-                            == trans_color->gray)

+                if(gamma_table != NULL)

+                {

+                    sp = row;

+                    shift = 4;

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

+                    {

+                        if((png_uint_16)((*sp >> shift) & 0x0f)

+                           == trans_color->gray)

                         {

-                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

-                           *sp |= (png_byte)(background->gray << shift);

+                            *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

+                            *sp |= (png_byte)(background->gray << shift);

                         }

                         else

                         {

-                           png_byte p = (png_byte)((*sp >> shift) & 0x0f);

-                           png_byte g = (png_byte)((gamma_table[p |

-                             (p << 4)] >> 4) & 0x0f);

-                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

-                           *sp |= (png_byte)(g << shift);

+                            png_byte p = (png_byte)((*sp >> shift) & 0x0f);

+                            png_byte g = (png_byte)((gamma_table[p |

+                                                                 (p << 4)] >> 4) & 0x0f);

+                            *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

+                            *sp |= (png_byte)(g << shift);

                         }

-                        if (!shift)

+                        if(!shift)

                         {

-                           shift = 4;

-                           sp++;

+                            shift = 4;

+                            sp++;

                         }

                         else

-                           shift -= 4;

-                     }

-                  }

-                  else

+                            shift -= 4;

+                    }

+                }

+                else

 #endif

-                  {

-                     sp = row;

-                     shift = 4;

-                     for (i = 0; i < row_width; i++)

-                     {

-                        if ((png_uint_16)((*sp >> shift) & 0x0f)

-                            == trans_color->gray)

+                {

+                    sp = row;

+                    shift = 4;

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

+                    {

+                        if((png_uint_16)((*sp >> shift) & 0x0f)

+                           == trans_color->gray)

                         {

-                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

-                           *sp |= (png_byte)(background->gray << shift);

+                            *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

+                            *sp |= (png_byte)(background->gray << shift);

                         }

-                        if (!shift)

+                        if(!shift)

                         {

-                           shift = 4;

-                           sp++;

+                            shift = 4;

+                            sp++;

                         }

                         else

-                           shift -= 4;

-                     }

-                  }

-                  break;

-               }

-

-               case 8:

-               {

+                            shift -= 4;

+                    }

+                }

+                break;

+            }

+

+            case 8:

+            {

 #ifdef PNG_READ_GAMMA_SUPPORTED

-                  if (gamma_table != NULL)

-                  {

-                     sp = row;

-                     for (i = 0; i < row_width; i++, sp++)

-                     {

-                        if (*sp == trans_color->gray)

+                if(gamma_table != NULL)

+                {

+                    sp = row;

+                    for(i = 0; i < row_width; i++, sp++)

+                    {

+                        if(*sp == trans_color->gray)

                         {

-                           *sp = (png_byte)background->gray;

+                            *sp = (png_byte)background->gray;

                         }

                         else

                         {

-                           *sp = gamma_table[*sp];

+                            *sp = gamma_table[*sp];

                         }

-                     }

-                  }

-                  else

+                    }

+                }

+                else

 #endif

-                  {

-                     sp = row;

-                     for (i = 0; i < row_width; i++, sp++)

-                     {

-                        if (*sp == trans_color->gray)

+                {

+                    sp = row;

+                    for(i = 0; i < row_width; i++, sp++)

+                    {

+                        if(*sp == trans_color->gray)

                         {

-                           *sp = (png_byte)background->gray;

+                            *sp = (png_byte)background->gray;

                         }

-                     }

-                  }

-                  break;

-               }

+                    }

+                }

+                break;

+            }

 

-               case 16:

-               {

+            case 16:

+            {

 #ifdef PNG_READ_GAMMA_SUPPORTED

-                  if (gamma_16 != NULL)

-                  {

-                     sp = row;

-                     for (i = 0; i < row_width; i++, sp += 2)

-                     {

+                if(gamma_16 != NULL)

+                {

+                    sp = row;

+                    for(i = 0; i < row_width; i++, sp += 2)

+                    {

                         png_uint_16 v;

 

                         v = (png_uint_16)(((*sp) << 8) + *(sp + 1));

-                        if (v == trans_color->gray)

+                        if(v == trans_color->gray)

                         {

-                           /* Background is already in screen gamma */

-                           *sp = (png_byte)((background->gray >> 8) & 0xff);

-                           *(sp + 1) = (png_byte)(background->gray & 0xff);

+                            /* Background is already in screen gamma */

+                            *sp = (png_byte)((background->gray >> 8) & 0xff);

+                            *(sp + 1) = (png_byte)(background->gray & 0xff);

                         }

                         else

                         {

-                           v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

-                           *sp = (png_byte)((v >> 8) & 0xff);

-                           *(sp + 1) = (png_byte)(v & 0xff);

+                            v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

+                            *sp = (png_byte)((v >> 8) & 0xff);

+                            *(sp + 1) = (png_byte)(v & 0xff);

                         }

-                     }

-                  }

-                  else

+                    }

+                }

+                else

 #endif

-                  {

-                     sp = row;

-                     for (i = 0; i < row_width; i++, sp += 2)

-                     {

+                {

+                    sp = row;

+                    for(i = 0; i < row_width; i++, sp += 2)

+                    {

                         png_uint_16 v;

 

                         v = (png_uint_16)(((*sp) << 8) + *(sp + 1));

-                        if (v == trans_color->gray)

+                        if(v == trans_color->gray)

                         {

-                           *sp = (png_byte)((background->gray >> 8) & 0xff);

-                           *(sp + 1) = (png_byte)(background->gray & 0xff);

+                            *sp = (png_byte)((background->gray >> 8) & 0xff);

+                            *(sp + 1) = (png_byte)(background->gray & 0xff);

                         }

-                     }

-                  }

-                  break;

-               }

+                    }

+                }

+                break;

+            }

             }

             break;

-         }

+        }

 

-         case PNG_COLOR_TYPE_RGB:

-         {

-            if (row_info->bit_depth == 8)

+        case PNG_COLOR_TYPE_RGB:

+        {

+            if(row_info->bit_depth == 8)

             {

 #ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_table != NULL)

-               {

-                  sp = row;

-                  for (i = 0; i < row_width; i++, sp += 3)

-                  {

-                     if (*sp == trans_color->red &&

-                        *(sp + 1) == trans_color->green &&

-                        *(sp + 2) == trans_color->blue)

-                     {

-                        *sp = (png_byte)background->red;

-                        *(sp + 1) = (png_byte)background->green;

-                        *(sp + 2) = (png_byte)background->blue;

-                     }

-                     else

-                     {

-                        *sp = gamma_table[*sp];

-                        *(sp + 1) = gamma_table[*(sp + 1)];

-                        *(sp + 2) = gamma_table[*(sp + 2)];

-                     }

-                  }

-               }

-               else

+                if(gamma_table != NULL)

+                {

+                    sp = row;

+                    for(i = 0; i < row_width; i++, sp += 3)

+                    {

+                        if(*sp == trans_color->red &&

+                           *(sp + 1) == trans_color->green &&

+                           *(sp + 2) == trans_color->blue)

+                        {

+                            *sp = (png_byte)background->red;

+                            *(sp + 1) = (png_byte)background->green;

+                            *(sp + 2) = (png_byte)background->blue;

+                        }

+                        else

+                        {

+                            *sp = gamma_table[*sp];

+                            *(sp + 1) = gamma_table[*(sp + 1)];

+                            *(sp + 2) = gamma_table[*(sp + 2)];

+                        }

+                    }

+                }

+                else

 #endif

-               {

-                  sp = row;

-                  for (i = 0; i < row_width; i++, sp += 3)

-                  {

-                     if (*sp == trans_color->red &&

-                        *(sp + 1) == trans_color->green &&

-                        *(sp + 2) == trans_color->blue)

-                     {

-                        *sp = (png_byte)background->red;

-                        *(sp + 1) = (png_byte)background->green;

-                        *(sp + 2) = (png_byte)background->blue;

-                     }

-                  }

-               }

+                {

+                    sp = row;

+                    for(i = 0; i < row_width; i++, sp += 3)

+                    {

+                        if(*sp == trans_color->red &&

+                           *(sp + 1) == trans_color->green &&

+                           *(sp + 2) == trans_color->blue)

+                        {

+                            *sp = (png_byte)background->red;

+                            *(sp + 1) = (png_byte)background->green;

+                            *(sp + 2) = (png_byte)background->blue;

+                        }

+                    }

+                }

             }

             else /* if (row_info->bit_depth == 16) */

             {

 #ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_16 != NULL)

-               {

-                  sp = row;

-                  for (i = 0; i < row_width; i++, sp += 6)

-                  {

-                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));

-                     png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

-                     png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));

-                     if (r == trans_color->red && g == trans_color->green &&

-                        b == trans_color->blue)

-                     {

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

-                        *(sp + 3) = (png_byte)(background->green & 0xff);

-                        *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);

-                        *(sp + 5) = (png_byte)(background->blue & 0xff);

-                     }

-                     else

-                     {

-                        png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

-                        *sp = (png_byte)((v >> 8) & 0xff);

-                        *(sp + 1) = (png_byte)(v & 0xff);

-                        v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];

-                        *(sp + 2) = (png_byte)((v >> 8) & 0xff);

-                        *(sp + 3) = (png_byte)(v & 0xff);

-                        v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];

-                        *(sp + 4) = (png_byte)((v >> 8) & 0xff);

-                        *(sp + 5) = (png_byte)(v & 0xff);

-                     }

-                  }

-               }

-               else

+                if(gamma_16 != NULL)

+                {

+                    sp = row;

+                    for(i = 0; i < row_width; i++, sp += 6)

+                    {

+                        png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));

+                        png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) + *(sp + 3));

+                        png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) + *(sp + 5));

+                        if(r == trans_color->red && g == trans_color->green &&

+                           b == trans_color->blue)

+                        {

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

+                            *(sp + 3) = (png_byte)(background->green & 0xff);

+                            *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);

+                            *(sp + 5) = (png_byte)(background->blue & 0xff);

+                        }

+                        else

+                        {

+                            png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

+                            *sp = (png_byte)((v >> 8) & 0xff);

+                            *(sp + 1) = (png_byte)(v & 0xff);

+                            v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];

+                            *(sp + 2) = (png_byte)((v >> 8) & 0xff);

+                            *(sp + 3) = (png_byte)(v & 0xff);

+                            v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];

+                            *(sp + 4) = (png_byte)((v >> 8) & 0xff);

+                            *(sp + 5) = (png_byte)(v & 0xff);

+                        }

+                    }

+                }

+                else

 #endif

-               {

-                  sp = row;

-                  for (i = 0; i < row_width; i++, sp += 6)

-                  {

-                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1));

-                     png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

-                     png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));

-

-                     if (r == trans_color->red && g == trans_color->green &&

-                        b == trans_color->blue)

-                     {

-                        *sp = (png_byte)((background->red >> 8) & 0xff);

-                        *(sp + 1) = (png_byte)(background->red & 0xff);

-                        *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);

-                        *(sp + 3) = (png_byte)(background->green & 0xff);

-                        *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);

-                        *(sp + 5) = (png_byte)(background->blue & 0xff);

-                     }

-                  }

-               }

+                {

+                    sp = row;

+                    for(i = 0; i < row_width; i++, sp += 6)

+                    {

+                        png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));

+                        png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) + *(sp + 3));

+                        png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) + *(sp + 5));

+

+                        if(r == trans_color->red && g == trans_color->green &&

+                           b == trans_color->blue)

+                        {

+                            *sp = (png_byte)((background->red >> 8) & 0xff);

+                            *(sp + 1) = (png_byte)(background->red & 0xff);

+                            *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);

+                            *(sp + 3) = (png_byte)(background->green & 0xff);

+                            *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);

+                            *(sp + 5) = (png_byte)(background->blue & 0xff);

+                        }

+                    }

+                }

             }

             break;

-         }

+        }

 

-         case PNG_COLOR_TYPE_GRAY_ALPHA:

-         {

-            if (row_info->bit_depth == 8)

+        case PNG_COLOR_TYPE_GRAY_ALPHA:

+        {

+            if(row_info->bit_depth == 8)

             {

 #ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&

+                if(gamma_to_1 != NULL && gamma_from_1 != NULL &&

                    gamma_table != NULL)

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 2, dp++)

-                  {

-                     png_uint_16 a = *(sp + 1);

-

-                     if (a == 0xff)

-                     {

-                        *dp = gamma_table[*sp];

-                     }

-                     else if (a == 0)

-                     {

-                        /* Background is already in screen gamma */

-                        *dp = (png_byte)background->gray;

-                     }

-                     else

-                     {

-                        png_byte v, w;

-

-                        v = gamma_to_1[*sp];

-                        png_composite(w, v, a, background_1->gray);

-                        *dp = gamma_from_1[w];

-                     }

-                  }

-               }

-               else

+                {

+                    sp = row;

+                    dp = row;

+                    for(i = 0; i < row_width; i++, sp += 2, dp++)

+                    {

+                        png_uint_16 a = *(sp + 1);

+

+                        if(a == 0xff)

+                        {

+                            *dp = gamma_table[*sp];

+                        }

+                        else if(a == 0)

+                        {

+                            /* Background is already in screen gamma */

+                            *dp = (png_byte)background->gray;

+                        }

+                        else

+                        {

+                            png_byte v, w;

+

+                            v = gamma_to_1[*sp];

+                            png_composite(w, v, a, background_1->gray);

+                            *dp = gamma_from_1[w];

+                        }

+                    }

+                }

+                else

 #endif

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 2, dp++)

-                  {

-                     png_byte a = *(sp + 1);

-

-                     if (a == 0xff)

-                     {

-                        *dp = *sp;

-                     }

+                {

+                    sp = row;

+                    dp = row;

+                    for(i = 0; i < row_width; i++, sp += 2, dp++)

+                    {

+                        png_byte a = *(sp + 1);

+

+                        if(a == 0xff)

+                        {

+                            *dp = *sp;

+                        }

 #ifdef PNG_READ_GAMMA_SUPPORTED

-                     else if (a == 0)

-                     {

-                        *dp = (png_byte)background->gray;

-                     }

-                     else

-                     {

-                        png_composite(*dp, *sp, a, background_1->gray);

-                     }

+                        else if(a == 0)

+                        {

+                            *dp = (png_byte)background->gray;

+                        }

+                        else

+                        {

+                            png_composite(*dp, *sp, a, background_1->gray);

+                        }

 #else

-                     *dp = (png_byte)background->gray;

+                        *dp = (png_byte)background->gray;

 #endif

-                  }

-               }

+                    }

+                }

             }

             else /* if (png_ptr->bit_depth == 16) */

             {

 #ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&

+                if(gamma_16 != NULL && gamma_16_from_1 != NULL &&

                    gamma_16_to_1 != NULL)

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 4, dp += 2)

-                  {

-                     png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

-

-                     if (a == (png_uint_16)0xffff)

-                     {

-                        png_uint_16 v;

+                {

+                    sp = row;

+                    dp = row;

+                    for(i = 0; i < row_width; i++, sp += 4, dp += 2)

+                    {

+                        png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8) + *(sp + 3));

+

+                        if(a == (png_uint_16)0xffff)

+                        {

+                            png_uint_16 v;

 

-                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

-                        *dp = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(v & 0xff);

-                     }

+                            v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

+                            *dp = (png_byte)((v >> 8) & 0xff);

+                            *(dp + 1) = (png_byte)(v & 0xff);

+                        }

 #ifdef PNG_READ_GAMMA_SUPPORTED

-                     else if (a == 0)

+                        else if(a == 0)

 #else

-                     else

+                        else

 #endif

-                     {

-                        /* Background is already in screen gamma */

-                        *dp = (png_byte)((background->gray >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(background->gray & 0xff);

-                     }

+                        {

+                            /* Background is already in screen gamma */

+                            *dp = (png_byte)((background->gray >> 8) & 0xff);

+                            *(dp + 1) = (png_byte)(background->gray & 0xff);

+                        }

 #ifdef PNG_READ_GAMMA_SUPPORTED

-                     else

-                     {

-                        png_uint_16 g, v, w;

-

-                        g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];

-                        png_composite_16(v, g, a, background_1->gray);

-                        w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];

-                        *dp = (png_byte)((w >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(w & 0xff);

-                     }

+                        else

+                        {

+                            png_uint_16 g, v, w;

+

+                            g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];

+                            png_composite_16(v, g, a, background_1->gray);

+                            w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];

+                            *dp = (png_byte)((w >> 8) & 0xff);

+                            *(dp + 1) = (png_byte)(w & 0xff);

+                        }

 #endif

-                  }

-               }

-               else

+                    }

+                }

+                else

 #endif

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 4, dp += 2)

-                  {

-                     png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

-                     if (a == (png_uint_16)0xffff)

-                     {

-                        png_memcpy(dp, sp, 2);

-                     }

+                {

+                    sp = row;

+                    dp = row;

+                    for(i = 0; i < row_width; i++, sp += 4, dp += 2)

+                    {

+                        png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8) + *(sp + 3));

+                        if(a == (png_uint_16)0xffff)

+                        {

+                            png_memcpy(dp, sp, 2);

+                        }

 #ifdef PNG_READ_GAMMA_SUPPORTED

-                     else if (a == 0)

+                        else if(a == 0)

 #else

-                     else

+                        else

 #endif

-                     {

-                        *dp = (png_byte)((background->gray >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(background->gray & 0xff);

-                     }

+                        {

+                            *dp = (png_byte)((background->gray >> 8) & 0xff);

+                            *(dp + 1) = (png_byte)(background->gray & 0xff);

+                        }

 #ifdef PNG_READ_GAMMA_SUPPORTED

-                     else

-                     {

-                        png_uint_16 g, v;

-

-                        g = (png_uint_16)(((*sp) << 8) + *(sp + 1));

-                        png_composite_16(v, g, a, background_1->gray);

-                        *dp = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(v & 0xff);

-                     }

+                        else

+                        {

+                            png_uint_16 g, v;

+

+                            g = (png_uint_16)(((*sp) << 8) + *(sp + 1));

+                            png_composite_16(v, g, a, background_1->gray);

+                            *dp = (png_byte)((v >> 8) & 0xff);

+                            *(dp + 1) = (png_byte)(v & 0xff);

+                        }

 #endif

-                  }

-               }

+                    }

+                }

             }

             break;

-         }

+        }

 

-         case PNG_COLOR_TYPE_RGB_ALPHA:

-         {

-            if (row_info->bit_depth == 8)

+        case PNG_COLOR_TYPE_RGB_ALPHA:

+        {

+            if(row_info->bit_depth == 8)

             {

 #ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&

+                if(gamma_to_1 != NULL && gamma_from_1 != NULL &&

                    gamma_table != NULL)

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 4, dp += 3)

-                  {

-                     png_byte a = *(sp + 3);

-

-                     if (a == 0xff)

-                     {

-                        *dp = gamma_table[*sp];

-                        *(dp + 1) = gamma_table[*(sp + 1)];

-                        *(dp + 2) = gamma_table[*(sp + 2)];

-                     }

-                     else if (a == 0)

-                     {

-                        /* Background is already in screen gamma */

-                        *dp = (png_byte)background->red;

-                        *(dp + 1) = (png_byte)background->green;

-                        *(dp + 2) = (png_byte)background->blue;

-                     }

-                     else

-                     {

-                        png_byte v, w;

-

-                        v = gamma_to_1[*sp];

-                        png_composite(w, v, a, background_1->red);

-                        *dp = gamma_from_1[w];

-                        v = gamma_to_1[*(sp + 1)];

-                        png_composite(w, v, a, background_1->green);

-                        *(dp + 1) = gamma_from_1[w];

-                        v = gamma_to_1[*(sp + 2)];

-                        png_composite(w, v, a, background_1->blue);

-                        *(dp + 2) = gamma_from_1[w];

-                     }

-                  }

-               }

-               else

+                {

+                    sp = row;

+                    dp = row;

+                    for(i = 0; i < row_width; i++, sp += 4, dp += 3)

+                    {

+                        png_byte a = *(sp + 3);

+

+                        if(a == 0xff)

+                        {

+                            *dp = gamma_table[*sp];

+                            *(dp + 1) = gamma_table[*(sp + 1)];

+                            *(dp + 2) = gamma_table[*(sp + 2)];

+                        }

+                        else if(a == 0)

+                        {

+                            /* Background is already in screen gamma */

+                            *dp = (png_byte)background->red;

+                            *(dp + 1) = (png_byte)background->green;

+                            *(dp + 2) = (png_byte)background->blue;

+                        }

+                        else

+                        {

+                            png_byte v, w;

+

+                            v = gamma_to_1[*sp];

+                            png_composite(w, v, a, background_1->red);

+                            *dp = gamma_from_1[w];

+                            v = gamma_to_1[*(sp + 1)];

+                            png_composite(w, v, a, background_1->green);

+                            *(dp + 1) = gamma_from_1[w];

+                            v = gamma_to_1[*(sp + 2)];

+                            png_composite(w, v, a, background_1->blue);

+                            *(dp + 2) = gamma_from_1[w];

+                        }

+                    }

+                }

+                else

 #endif

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 4, dp += 3)

-                  {

-                     png_byte a = *(sp + 3);

-

-                     if (a == 0xff)

-                     {

-                        *dp = *sp;

-                        *(dp + 1) = *(sp + 1);

-                        *(dp + 2) = *(sp + 2);

-                     }

-                     else if (a == 0)

-                     {

-                        *dp = (png_byte)background->red;

-                        *(dp + 1) = (png_byte)background->green;

-                        *(dp + 2) = (png_byte)background->blue;

-                     }

-                     else

-                     {

-                        png_composite(*dp, *sp, a, background->red);

-                        png_composite(*(dp + 1), *(sp + 1), a,

-                           background->green);

-                        png_composite(*(dp + 2), *(sp + 2), a,

-                           background->blue);

-                     }

-                  }

-               }

+                {

+                    sp = row;

+                    dp = row;

+                    for(i = 0; i < row_width; i++, sp += 4, dp += 3)

+                    {

+                        png_byte a = *(sp + 3);

+

+                        if(a == 0xff)

+                        {

+                            *dp = *sp;

+                            *(dp + 1) = *(sp + 1);

+                            *(dp + 2) = *(sp + 2);

+                        }

+                        else if(a == 0)

+                        {

+                            *dp = (png_byte)background->red;

+                            *(dp + 1) = (png_byte)background->green;

+                            *(dp + 2) = (png_byte)background->blue;

+                        }

+                        else

+                        {

+                            png_composite(*dp, *sp, a, background->red);

+                            png_composite(*(dp + 1), *(sp + 1), a,

+                                          background->green);

+                            png_composite(*(dp + 2), *(sp + 2), a,

+                                          background->blue);

+                        }

+                    }

+                }

             }

             else /* if (row_info->bit_depth == 16) */

             {

 #ifdef PNG_READ_GAMMA_SUPPORTED

-               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&

+                if(gamma_16 != NULL && gamma_16_from_1 != NULL &&

                    gamma_16_to_1 != NULL)

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 8, dp += 6)

-                  {

-                     png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))

-                         << 8) + (png_uint_16)(*(sp + 7)));

-                     if (a == (png_uint_16)0xffff)

-                     {

-                        png_uint_16 v;

-

-                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

-                        *dp = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(v & 0xff);

-                        v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];

-                        *(dp + 2) = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 3) = (png_byte)(v & 0xff);

-                        v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];

-                        *(dp + 4) = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 5) = (png_byte)(v & 0xff);

-                     }

-                     else if (a == 0)

-                     {

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

-                        *(dp + 3) = (png_byte)(background->green & 0xff);

-                        *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);

-                        *(dp + 5) = (png_byte)(background->blue & 0xff);

-                     }

-                     else

-                     {

-                        png_uint_16 v, w, x;

-

-                        v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];

-                        png_composite_16(w, v, a, background_1->red);

-                        x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];

-                        *dp = (png_byte)((x >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(x & 0xff);

-                        v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];

-                        png_composite_16(w, v, a, background_1->green);

-                        x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];

-                        *(dp + 2) = (png_byte)((x >> 8) & 0xff);

-                        *(dp + 3) = (png_byte)(x & 0xff);

-                        v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];

-                        png_composite_16(w, v, a, background_1->blue);

-                        x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];

-                        *(dp + 4) = (png_byte)((x >> 8) & 0xff);

-                        *(dp + 5) = (png_byte)(x & 0xff);

-                     }

-                  }

-               }

-               else

+                {

+                    sp = row;

+                    dp = row;

+                    for(i = 0; i < row_width; i++, sp += 8, dp += 6)

+                    {

+                        png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))

+                                                       << 8) + (png_uint_16)(*(sp + 7)));

+                        if(a == (png_uint_16)0xffff)

+                        {

+                            png_uint_16 v;

+

+                            v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

+                            *dp = (png_byte)((v >> 8) & 0xff);

+                            *(dp + 1) = (png_byte)(v & 0xff);

+                            v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];

+                            *(dp + 2) = (png_byte)((v >> 8) & 0xff);

+                            *(dp + 3) = (png_byte)(v & 0xff);

+                            v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];

+                            *(dp + 4) = (png_byte)((v >> 8) & 0xff);

+                            *(dp + 5) = (png_byte)(v & 0xff);

+                        }

+                        else if(a == 0)

+                        {

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

+                            *(dp + 3) = (png_byte)(background->green & 0xff);

+                            *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);

+                            *(dp + 5) = (png_byte)(background->blue & 0xff);

+                        }

+                        else

+                        {

+                            png_uint_16 v, w, x;

+

+                            v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];

+                            png_composite_16(w, v, a, background_1->red);

+                            x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];

+                            *dp = (png_byte)((x >> 8) & 0xff);

+                            *(dp + 1) = (png_byte)(x & 0xff);

+                            v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];

+                            png_composite_16(w, v, a, background_1->green);

+                            x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];

+                            *(dp + 2) = (png_byte)((x >> 8) & 0xff);

+                            *(dp + 3) = (png_byte)(x & 0xff);

+                            v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];

+                            png_composite_16(w, v, a, background_1->blue);

+                            x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];

+                            *(dp + 4) = (png_byte)((x >> 8) & 0xff);

+                            *(dp + 5) = (png_byte)(x & 0xff);

+                        }

+                    }

+                }

+                else

 #endif

-               {

-                  sp = row;

-                  dp = row;

-                  for (i = 0; i < row_width; i++, sp += 8, dp += 6)

-                  {

-                     png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))

-                        << 8) + (png_uint_16)(*(sp + 7)));

-                     if (a == (png_uint_16)0xffff)

-                     {

-                        png_memcpy(dp, sp, 6);

-                     }

-                     else if (a == 0)

-                     {

-                        *dp = (png_byte)((background->red >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(background->red & 0xff);

-                        *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);

-                        *(dp + 3) = (png_byte)(background->green & 0xff);

-                        *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);

-                        *(dp + 5) = (png_byte)(background->blue & 0xff);

-                     }

-                     else

-                     {

-                        png_uint_16 v;

-

-                        png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));

-                        png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)

-                            + *(sp + 3));

-                        png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)

-                            + *(sp + 5));

-

-                        png_composite_16(v, r, a, background->red);

-                        *dp = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 1) = (png_byte)(v & 0xff);

-                        png_composite_16(v, g, a, background->green);

-                        *(dp + 2) = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 3) = (png_byte)(v & 0xff);

-                        png_composite_16(v, b, a, background->blue);

-                        *(dp + 4) = (png_byte)((v >> 8) & 0xff);

-                        *(dp + 5) = (png_byte)(v & 0xff);

-                     }

-                  }

-               }

+                {

+                    sp = row;

+                    dp = row;

+                    for(i = 0; i < row_width; i++, sp += 8, dp += 6)

+                    {

+                        png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))

+                                                       << 8) + (png_uint_16)(*(sp + 7)));

+                        if(a == (png_uint_16)0xffff)

+                        {

+                            png_memcpy(dp, sp, 6);

+                        }

+                        else if(a == 0)

+                        {

+                            *dp = (png_byte)((background->red >> 8) & 0xff);

+                            *(dp + 1) = (png_byte)(background->red & 0xff);

+                            *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);

+                            *(dp + 3) = (png_byte)(background->green & 0xff);

+                            *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);

+                            *(dp + 5) = (png_byte)(background->blue & 0xff);

+                        }

+                        else

+                        {

+                            png_uint_16 v;

+

+                            png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));

+                            png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)

+                                                          + *(sp + 3));

+                            png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)

+                                                          + *(sp + 5));

+

+                            png_composite_16(v, r, a, background->red);

+                            *dp = (png_byte)((v >> 8) & 0xff);

+                            *(dp + 1) = (png_byte)(v & 0xff);

+                            png_composite_16(v, g, a, background->green);

+                            *(dp + 2) = (png_byte)((v >> 8) & 0xff);

+                            *(dp + 3) = (png_byte)(v & 0xff);

+                            png_composite_16(v, b, a, background->blue);

+                            *(dp + 4) = (png_byte)((v >> 8) & 0xff);

+                            *(dp + 5) = (png_byte)(v & 0xff);

+                        }

+                    }

+                }

             }

             break;

-         }

-      }

-

-      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)

-      {

-         row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;

-         row_info->channels--;

-         row_info->pixel_depth = (png_byte)(row_info->channels *

-            row_info->bit_depth);

-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-      }

-   }

+        }

+        }

+

+        if(row_info->color_type & PNG_COLOR_MASK_ALPHA)

+        {

+            row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;

+            row_info->channels--;

+            row_info->pixel_depth = (png_byte)(row_info->channels *

+                                               row_info->bit_depth);

+            row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

+        }

+    }

 }

 #endif

 

@@ -3253,183 +3269,183 @@ png_do_background(png_row_infop row_info, png_bytep row,
  */

 void /* PRIVATE */

 png_do_gamma(png_row_infop row_info, png_bytep row,

-   png_bytep gamma_table, png_uint_16pp gamma_16_table,

-   int gamma_shift)

+             png_bytep gamma_table, png_uint_16pp gamma_16_table,

+             int gamma_shift)

 {

-   png_bytep sp;

-   png_uint_32 i;

-   png_uint_32 row_width=row_info->width;

-

-   png_debug(1, "in png_do_gamma");

-

-   if (

-       ((row_info->bit_depth <= 8 && gamma_table != NULL) ||

-        (row_info->bit_depth == 16 && gamma_16_table != NULL)))

-   {

-      switch (row_info->color_type)

-      {

-         case PNG_COLOR_TYPE_RGB:

-         {

-            if (row_info->bit_depth == 8)

+    png_bytep sp;

+    png_uint_32 i;

+    png_uint_32 row_width = row_info->width;

+

+    png_debug(1, "in png_do_gamma");

+

+    if(

+        ((row_info->bit_depth <= 8 && gamma_table != NULL) ||

+         (row_info->bit_depth == 16 && gamma_16_table != NULL)))

+    {

+        switch(row_info->color_type)

+        {

+        case PNG_COLOR_TYPE_RGB:

+        {

+            if(row_info->bit_depth == 8)

             {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  *sp = gamma_table[*sp];

-                  sp++;

-                  *sp = gamma_table[*sp];

-                  sp++;

-                  *sp = gamma_table[*sp];

-                  sp++;

-               }

+                sp = row;

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

+                {

+                    *sp = gamma_table[*sp];

+                    sp++;

+                    *sp = gamma_table[*sp];

+                    sp++;

+                    *sp = gamma_table[*sp];

+                    sp++;

+                }

             }

             else /* if (row_info->bit_depth == 16) */

             {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 v;

-

-                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-               }

+                sp = row;

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

+                {

+                    png_uint_16 v;

+

+                    v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                    *sp = (png_byte)((v >> 8) & 0xff);

+                    *(sp + 1) = (png_byte)(v & 0xff);

+                    sp += 2;

+                    v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                    *sp = (png_byte)((v >> 8) & 0xff);

+                    *(sp + 1) = (png_byte)(v & 0xff);

+                    sp += 2;

+                    v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                    *sp = (png_byte)((v >> 8) & 0xff);

+                    *(sp + 1) = (png_byte)(v & 0xff);

+                    sp += 2;

+                }

             }

             break;

-         }

+        }

 

-         case PNG_COLOR_TYPE_RGB_ALPHA:

-         {

-            if (row_info->bit_depth == 8)

+        case PNG_COLOR_TYPE_RGB_ALPHA:

+        {

+            if(row_info->bit_depth == 8)

             {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  *sp = gamma_table[*sp];

-                  sp++;

-                  *sp = gamma_table[*sp];

-                  sp++;

-                  *sp = gamma_table[*sp];

-                  sp++;

-                  sp++;

-               }

+                sp = row;

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

+                {

+                    *sp = gamma_table[*sp];

+                    sp++;

+                    *sp = gamma_table[*sp];

+                    sp++;

+                    *sp = gamma_table[*sp];

+                    sp++;

+                    sp++;

+                }

             }

             else /* if (row_info->bit_depth == 16) */

             {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 4;

-               }

+                sp = row;

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

+                {

+                    png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                    *sp = (png_byte)((v >> 8) & 0xff);

+                    *(sp + 1) = (png_byte)(v & 0xff);

+                    sp += 2;

+                    v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                    *sp = (png_byte)((v >> 8) & 0xff);

+                    *(sp + 1) = (png_byte)(v & 0xff);

+                    sp += 2;

+                    v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                    *sp = (png_byte)((v >> 8) & 0xff);

+                    *(sp + 1) = (png_byte)(v & 0xff);

+                    sp += 4;

+                }

             }

             break;

-         }

+        }

 

-         case PNG_COLOR_TYPE_GRAY_ALPHA:

-         {

-            if (row_info->bit_depth == 8)

+        case PNG_COLOR_TYPE_GRAY_ALPHA:

+        {

+            if(row_info->bit_depth == 8)

             {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  *sp = gamma_table[*sp];

-                  sp += 2;

-               }

+                sp = row;

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

+                {

+                    *sp = gamma_table[*sp];

+                    sp += 2;

+                }

             }

             else /* if (row_info->bit_depth == 16) */

             {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 4;

-               }

+                sp = row;

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

+                {

+                    png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                    *sp = (png_byte)((v >> 8) & 0xff);

+                    *(sp + 1) = (png_byte)(v & 0xff);

+                    sp += 4;

+                }

             }

             break;

-         }

+        }

 

-         case PNG_COLOR_TYPE_GRAY:

-         {

-            if (row_info->bit_depth == 2)

+        case PNG_COLOR_TYPE_GRAY:

+        {

+            if(row_info->bit_depth == 2)

             {

-               sp = row;

-               for (i = 0; i < row_width; i += 4)

-               {

-                  int a = *sp & 0xc0;

-                  int b = *sp & 0x30;

-                  int c = *sp & 0x0c;

-                  int d = *sp & 0x03;

-

-                  *sp = (png_byte)(

-                      ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)])   ) & 0xc0)|

-                      ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|

-                      ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|

-                      ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) ));

-                  sp++;

-               }

+                sp = row;

+                for(i = 0; i < row_width; i += 4)

+                {

+                    int a = *sp & 0xc0;

+                    int b = *sp & 0x30;

+                    int c = *sp & 0x0c;

+                    int d = *sp & 0x03;

+

+                    *sp = (png_byte)(

+                              ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)])) & 0xc0) |

+                              ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)]) >> 2) & 0x30) |

+                              ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)]) >> 4) & 0x0c) |

+                              ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d]) >> 6)));

+                    sp++;

+                }

             }

 

-            if (row_info->bit_depth == 4)

+            if(row_info->bit_depth == 4)

             {

-               sp = row;

-               for (i = 0; i < row_width; i += 2)

-               {

-                  int msb = *sp & 0xf0;

-                  int lsb = *sp & 0x0f;

-

-                  *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)

-                      | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));

-                  sp++;

-               }

+                sp = row;

+                for(i = 0; i < row_width; i += 2)

+                {

+                    int msb = *sp & 0xf0;

+                    int lsb = *sp & 0x0f;

+

+                    *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)

+                                     | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));

+                    sp++;

+                }

             }

 

-            else if (row_info->bit_depth == 8)

+            else if(row_info->bit_depth == 8)

             {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  *sp = gamma_table[*sp];

-                  sp++;

-               }

+                sp = row;

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

+                {

+                    *sp = gamma_table[*sp];

+                    sp++;

+                }

             }

 

-            else if (row_info->bit_depth == 16)

+            else if(row_info->bit_depth == 16)

             {

-               sp = row;

-               for (i = 0; i < row_width; i++)

-               {

-                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

-                  *sp = (png_byte)((v >> 8) & 0xff);

-                  *(sp + 1) = (png_byte)(v & 0xff);

-                  sp += 2;

-               }

+                sp = row;

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

+                {

+                    png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                    *sp = (png_byte)((v >> 8) & 0xff);

+                    *(sp + 1) = (png_byte)(v & 0xff);

+                    sp += 2;

+                }

             }

             break;

-         }

-      }

-   }

+        }

+        }

+    }

 }

 #endif

 

@@ -3439,143 +3455,143 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
  */

 void /* PRIVATE */

 png_do_expand_palette(png_row_infop row_info, png_bytep row,

-   png_colorp palette, png_bytep trans_alpha, int num_trans)

+                      png_colorp palette, png_bytep trans_alpha, int num_trans)

 {

-   int shift, value;

-   png_bytep sp, dp;

-   png_uint_32 i;

-   png_uint_32 row_width=row_info->width;

-

-   png_debug(1, "in png_do_expand_palette");

-

-   if (

-       row_info->color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      if (row_info->bit_depth < 8)

-      {

-         switch (row_info->bit_depth)

-         {

+    int shift, value;

+    png_bytep sp, dp;

+    png_uint_32 i;

+    png_uint_32 row_width = row_info->width;

+

+    png_debug(1, "in png_do_expand_palette");

+

+    if(

+        row_info->color_type == PNG_COLOR_TYPE_PALETTE)

+    {

+        if(row_info->bit_depth < 8)

+        {

+            switch(row_info->bit_depth)

+            {

             case 1:

             {

-               sp = row + (png_size_t)((row_width - 1) >> 3);

-               dp = row + (png_size_t)row_width - 1;

-               shift = 7 - (int)((row_width + 7) & 0x07);

-               for (i = 0; i < row_width; i++)

-               {

-                  if ((*sp >> shift) & 0x01)

-                     *dp = 1;

-                  else

-                     *dp = 0;

-                  if (shift == 7)

-                  {

-                     shift = 0;

-                     sp--;

-                  }

-                  else

-                     shift++;

-

-                  dp--;

-               }

-               break;

+                sp = row + (png_size_t)((row_width - 1) >> 3);

+                dp = row + (png_size_t)row_width - 1;

+                shift = 7 - (int)((row_width + 7) & 0x07);

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

+                {

+                    if((*sp >> shift) & 0x01)

+                        *dp = 1;

+                    else

+                        *dp = 0;

+                    if(shift == 7)

+                    {

+                        shift = 0;

+                        sp--;

+                    }

+                    else

+                        shift++;

+

+                    dp--;

+                }

+                break;

             }

 

             case 2:

             {

-               sp = row + (png_size_t)((row_width - 1) >> 2);

-               dp = row + (png_size_t)row_width - 1;

-               shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

-               for (i = 0; i < row_width; i++)

-               {

-                  value = (*sp >> shift) & 0x03;

-                  *dp = (png_byte)value;

-                  if (shift == 6)

-                  {

-                     shift = 0;

-                     sp--;

-                  }

-                  else

-                     shift += 2;

-

-                  dp--;

-               }

-               break;

+                sp = row + (png_size_t)((row_width - 1) >> 2);

+                dp = row + (png_size_t)row_width - 1;

+                shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

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

+                {

+                    value = (*sp >> shift) & 0x03;

+                    *dp = (png_byte)value;

+                    if(shift == 6)

+                    {

+                        shift = 0;

+                        sp--;

+                    }

+                    else

+                        shift += 2;

+

+                    dp--;

+                }

+                break;

             }

 

             case 4:

             {

-               sp = row + (png_size_t)((row_width - 1) >> 1);

-               dp = row + (png_size_t)row_width - 1;

-               shift = (int)((row_width & 0x01) << 2);

-               for (i = 0; i < row_width; i++)

-               {

-                  value = (*sp >> shift) & 0x0f;

-                  *dp = (png_byte)value;

-                  if (shift == 4)

-                  {

-                     shift = 0;

-                     sp--;

-                  }

-                  else

-                     shift += 4;

-

-                  dp--;

-               }

-               break;

+                sp = row + (png_size_t)((row_width - 1) >> 1);

+                dp = row + (png_size_t)row_width - 1;

+                shift = (int)((row_width & 0x01) << 2);

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

+                {

+                    value = (*sp >> shift) & 0x0f;

+                    *dp = (png_byte)value;

+                    if(shift == 4)

+                    {

+                        shift = 0;

+                        sp--;

+                    }

+                    else

+                        shift += 4;

+

+                    dp--;

+                }

+                break;

+            }

             }

-         }

-         row_info->bit_depth = 8;

-         row_info->pixel_depth = 8;

-         row_info->rowbytes = row_width;

-      }

-      switch (row_info->bit_depth)

-      {

-         case 8:

-         {

-            if (trans_alpha != NULL)

+            row_info->bit_depth = 8;

+            row_info->pixel_depth = 8;

+            row_info->rowbytes = row_width;

+        }

+        switch(row_info->bit_depth)

+        {

+        case 8:

+        {

+            if(trans_alpha != NULL)

             {

-               sp = row + (png_size_t)row_width - 1;

-               dp = row + (png_size_t)(row_width << 2) - 1;

-

-               for (i = 0; i < row_width; i++)

-               {

-                  if ((int)(*sp) >= num_trans)

-                     *dp-- = 0xff;

-                  else

-                     *dp-- = trans_alpha[*sp];

-                  *dp-- = palette[*sp].blue;

-                  *dp-- = palette[*sp].green;

-                  *dp-- = palette[*sp].red;

-                  sp--;

-               }

-               row_info->bit_depth = 8;

-               row_info->pixel_depth = 32;

-               row_info->rowbytes = row_width * 4;

-               row_info->color_type = 6;

-               row_info->channels = 4;

+                sp = row + (png_size_t)row_width - 1;

+                dp = row + (png_size_t)(row_width << 2) - 1;

+

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

+                {

+                    if((int)(*sp) >= num_trans)

+                        *dp-- = 0xff;

+                    else

+                        *dp-- = trans_alpha[*sp];

+                    *dp-- = palette[*sp].blue;

+                    *dp-- = palette[*sp].green;

+                    *dp-- = palette[*sp].red;

+                    sp--;

+                }

+                row_info->bit_depth = 8;

+                row_info->pixel_depth = 32;

+                row_info->rowbytes = row_width * 4;

+                row_info->color_type = 6;

+                row_info->channels = 4;

             }

             else

             {

-               sp = row + (png_size_t)row_width - 1;

-               dp = row + (png_size_t)(row_width * 3) - 1;

-

-               for (i = 0; i < row_width; i++)

-               {

-                  *dp-- = palette[*sp].blue;

-                  *dp-- = palette[*sp].green;

-                  *dp-- = palette[*sp].red;

-                  sp--;

-               }

-

-               row_info->bit_depth = 8;

-               row_info->pixel_depth = 24;

-               row_info->rowbytes = row_width * 3;

-               row_info->color_type = 2;

-               row_info->channels = 3;

+                sp = row + (png_size_t)row_width - 1;

+                dp = row + (png_size_t)(row_width * 3) - 1;

+

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

+                {

+                    *dp-- = palette[*sp].blue;

+                    *dp-- = palette[*sp].green;

+                    *dp-- = palette[*sp].red;

+                    sp--;

+                }

+

+                row_info->bit_depth = 8;

+                row_info->pixel_depth = 24;

+                row_info->rowbytes = row_width * 3;

+                row_info->color_type = 2;

+                row_info->channels = 3;

             }

             break;

-         }

-      }

-   }

+        }

+        }

+    }

 }

 

 /* If the bit depth < 8, it is expanded to 8.  Also, if the already

@@ -3583,306 +3599,306 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
  */

 void /* PRIVATE */

 png_do_expand(png_row_infop row_info, png_bytep row,

-   png_color_16p trans_value)

+              png_color_16p trans_value)

 {

-   int shift, value;

-   png_bytep sp, dp;

-   png_uint_32 i;

-   png_uint_32 row_width=row_info->width;

+    int shift, value;

+    png_bytep sp, dp;

+    png_uint_32 i;

+    png_uint_32 row_width = row_info->width;

 

-   png_debug(1, "in png_do_expand");

+    png_debug(1, "in png_do_expand");

 

-   {

-      if (row_info->color_type == PNG_COLOR_TYPE_GRAY)

-      {

-         png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);

+    {

+        if(row_info->color_type == PNG_COLOR_TYPE_GRAY)

+        {

+            png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);

 

-         if (row_info->bit_depth < 8)

-         {

-            switch (row_info->bit_depth)

+            if(row_info->bit_depth < 8)

             {

-               case 1:

-               {

-                  gray = (png_uint_16)((gray&0x01)*0xff);

-                  sp = row + (png_size_t)((row_width - 1) >> 3);

-                  dp = row + (png_size_t)row_width - 1;

-                  shift = 7 - (int)((row_width + 7) & 0x07);

-                  for (i = 0; i < row_width; i++)

-                  {

-                     if ((*sp >> shift) & 0x01)

-                        *dp = 0xff;

-                     else

-                        *dp = 0;

-                     if (shift == 7)

-                     {

-                        shift = 0;

-                        sp--;

-                     }

-                     else

-                        shift++;

+                switch(row_info->bit_depth)

+                {

+                case 1:

+                {

+                    gray = (png_uint_16)((gray & 0x01) * 0xff);

+                    sp = row + (png_size_t)((row_width - 1) >> 3);

+                    dp = row + (png_size_t)row_width - 1;

+                    shift = 7 - (int)((row_width + 7) & 0x07);

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

+                    {

+                        if((*sp >> shift) & 0x01)

+                            *dp = 0xff;

+                        else

+                            *dp = 0;

+                        if(shift == 7)

+                        {

+                            shift = 0;

+                            sp--;

+                        }

+                        else

+                            shift++;

+

+                        dp--;

+                    }

+                    break;

+                }

+

+                case 2:

+                {

+                    gray = (png_uint_16)((gray & 0x03) * 0x55);

+                    sp = row + (png_size_t)((row_width - 1) >> 2);

+                    dp = row + (png_size_t)row_width - 1;

+                    shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

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

+                    {

+                        value = (*sp >> shift) & 0x03;

+                        *dp = (png_byte)(value | (value << 2) | (value << 4) |

+                                         (value << 6));

+                        if(shift == 6)

+                        {

+                            shift = 0;

+                            sp--;

+                        }

+                        else

+                            shift += 2;

+

+                        dp--;

+                    }

+                    break;

+                }

+

+                case 4:

+                {

+                    gray = (png_uint_16)((gray & 0x0f) * 0x11);

+                    sp = row + (png_size_t)((row_width - 1) >> 1);

+                    dp = row + (png_size_t)row_width - 1;

+                    shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);

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

+                    {

+                        value = (*sp >> shift) & 0x0f;

+                        *dp = (png_byte)(value | (value << 4));

+                        if(shift == 4)

+                        {

+                            shift = 0;

+                            sp--;

+                        }

+                        else

+                            shift = 4;

 

-                     dp--;

-                  }

-                  break;

-               }

-

-               case 2:

-               {

-                  gray = (png_uint_16)((gray&0x03)*0x55);

-                  sp = row + (png_size_t)((row_width - 1) >> 2);

-                  dp = row + (png_size_t)row_width - 1;

-                  shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

-                  for (i = 0; i < row_width; i++)

-                  {

-                     value = (*sp >> shift) & 0x03;

-                     *dp = (png_byte)(value | (value << 2) | (value << 4) |

-                        (value << 6));

-                     if (shift == 6)

-                     {

-                        shift = 0;

-                        sp--;

-                     }

-                     else

-                        shift += 2;

+                        dp--;

+                    }

+                    break;

+                }

+                }

 

-                     dp--;

-                  }

-                  break;

-               }

-

-               case 4:

-               {

-                  gray = (png_uint_16)((gray&0x0f)*0x11);

-                  sp = row + (png_size_t)((row_width - 1) >> 1);

-                  dp = row + (png_size_t)row_width - 1;

-                  shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);

-                  for (i = 0; i < row_width; i++)

-                  {

-                     value = (*sp >> shift) & 0x0f;

-                     *dp = (png_byte)(value | (value << 4));

-                     if (shift == 4)

-                     {

-                        shift = 0;

-                        sp--;

-                     }

-                     else

-                        shift = 4;

-

-                     dp--;

-                  }

-                  break;

-               }

+                row_info->bit_depth = 8;

+                row_info->pixel_depth = 8;

+                row_info->rowbytes = row_width;

             }

 

-            row_info->bit_depth = 8;

-            row_info->pixel_depth = 8;

-            row_info->rowbytes = row_width;

-         }

-

-         if (trans_value != NULL)

-         {

-            if (row_info->bit_depth == 8)

+            if(trans_value != NULL)

             {

-               gray = gray & 0xff;

-               sp = row + (png_size_t)row_width - 1;

-               dp = row + (png_size_t)(row_width << 1) - 1;

-               for (i = 0; i < row_width; i++)

-               {

-                  if (*sp == gray)

-                     *dp-- = 0;

-                  else

-                     *dp-- = 0xff;

-                  *dp-- = *sp--;

-               }

-            }

-

-            else if (row_info->bit_depth == 16)

-            {

-               png_byte gray_high = (gray >> 8) & 0xff;

-               png_byte gray_low = gray & 0xff;

-               sp = row + row_info->rowbytes - 1;

-               dp = row + (row_info->rowbytes << 1) - 1;

-               for (i = 0; i < row_width; i++)

-               {

-                  if (*(sp - 1) == gray_high && *(sp) == gray_low)

-                  {

-                     *dp-- = 0;

-                     *dp-- = 0;

-                  }

-                  else

-                  {

-                     *dp-- = 0xff;

-                     *dp-- = 0xff;

-                  }

-                  *dp-- = *sp--;

-                  *dp-- = *sp--;

-               }

+                if(row_info->bit_depth == 8)

+                {

+                    gray = gray & 0xff;

+                    sp = row + (png_size_t)row_width - 1;

+                    dp = row + (png_size_t)(row_width << 1) - 1;

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

+                    {

+                        if(*sp == gray)

+                            *dp-- = 0;

+                        else

+                            *dp-- = 0xff;

+                        *dp-- = *sp--;

+                    }

+                }

+

+                else if(row_info->bit_depth == 16)

+                {

+                    png_byte gray_high = (gray >> 8) & 0xff;

+                    png_byte gray_low = gray & 0xff;

+                    sp = row + row_info->rowbytes - 1;

+                    dp = row + (row_info->rowbytes << 1) - 1;

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

+                    {

+                        if(*(sp - 1) == gray_high && *(sp) == gray_low)

+                        {

+                            *dp-- = 0;

+                            *dp-- = 0;

+                        }

+                        else

+                        {

+                            *dp-- = 0xff;

+                            *dp-- = 0xff;

+                        }

+                        *dp-- = *sp--;

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

+                row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

+                                                  row_width);

             }

-

-            row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;

-            row_info->channels = 2;

-            row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);

-            row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

-               row_width);

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)

-      {

-         if (row_info->bit_depth == 8)

-         {

-            png_byte red = trans_value->red & 0xff;

-            png_byte green = trans_value->green & 0xff;

-            png_byte blue = trans_value->blue & 0xff;

-            sp = row + (png_size_t)row_info->rowbytes - 1;

-            dp = row + (png_size_t)(row_width << 2) - 1;

-            for (i = 0; i < row_width; i++)

+        }

+        else if(row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)

+        {

+            if(row_info->bit_depth == 8)

             {

-               if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)

-                  *dp-- = 0;

-               else

-                  *dp-- = 0xff;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

+                png_byte red = trans_value->red & 0xff;

+                png_byte green = trans_value->green & 0xff;

+                png_byte blue = trans_value->blue & 0xff;

+                sp = row + (png_size_t)row_info->rowbytes - 1;

+                dp = row + (png_size_t)(row_width << 2) - 1;

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

+                {

+                    if(*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)

+                        *dp-- = 0;

+                    else

+                        *dp-- = 0xff;

+                    *dp-- = *sp--;

+                    *dp-- = *sp--;

+                    *dp-- = *sp--;

+                }

             }

-         }

-         else if (row_info->bit_depth == 16)

-         {

-            png_byte red_high = (trans_value->red >> 8) & 0xff;

-            png_byte green_high = (trans_value->green >> 8) & 0xff;

-            png_byte blue_high = (trans_value->blue >> 8) & 0xff;

-            png_byte red_low = trans_value->red & 0xff;

-            png_byte green_low = trans_value->green & 0xff;

-            png_byte blue_low = trans_value->blue & 0xff;

-            sp = row + row_info->rowbytes - 1;

-            dp = row + (png_size_t)(row_width << 3) - 1;

-            for (i = 0; i < row_width; i++)

+            else if(row_info->bit_depth == 16)

             {

-               if (*(sp - 5) == red_high &&

-                  *(sp - 4) == red_low &&

-                  *(sp - 3) == green_high &&

-                  *(sp - 2) == green_low &&

-                  *(sp - 1) == blue_high &&

-                  *(sp    ) == blue_low)

-               {

-                  *dp-- = 0;

-                  *dp-- = 0;

-               }

-               else

-               {

-                  *dp-- = 0xff;

-                  *dp-- = 0xff;

-               }

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

-               *dp-- = *sp--;

+                png_byte red_high = (trans_value->red >> 8) & 0xff;

+                png_byte green_high = (trans_value->green >> 8) & 0xff;

+                png_byte blue_high = (trans_value->blue >> 8) & 0xff;

+                png_byte red_low = trans_value->red & 0xff;

+                png_byte green_low = trans_value->green & 0xff;

+                png_byte blue_low = trans_value->blue & 0xff;

+                sp = row + row_info->rowbytes - 1;

+                dp = row + (png_size_t)(row_width << 3) - 1;

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

+                {

+                    if(*(sp - 5) == red_high &&

+                       *(sp - 4) == red_low &&

+                       *(sp - 3) == green_high &&

+                       *(sp - 2) == green_low &&

+                       *(sp - 1) == blue_high &&

+                       *(sp) == blue_low)

+                    {

+                        *dp-- = 0;

+                        *dp-- = 0;

+                    }

+                    else

+                    {

+                        *dp-- = 0xff;

+                        *dp-- = 0xff;

+                    }

+                    *dp-- = *sp--;

+                    *dp-- = *sp--;

+                    *dp-- = *sp--;

+                    *dp-- = *sp--;

+                    *dp-- = *sp--;

+                    *dp-- = *sp--;

+                }

             }

-         }

-         row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;

-         row_info->channels = 4;

-         row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);

-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-      }

-   }

+            row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;

+            row_info->channels = 4;

+            row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);

+            row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

+        }

+    }

 }

 #endif

 

 #ifdef PNG_READ_DITHER_SUPPORTED

 void /* PRIVATE */

 png_do_dither(png_row_infop row_info, png_bytep row,

-    png_bytep palette_lookup, png_bytep dither_lookup)

+              png_bytep palette_lookup, png_bytep dither_lookup)

 {

-   png_bytep sp, dp;

-   png_uint_32 i;

-   png_uint_32 row_width=row_info->width;

-

-   png_debug(1, "in png_do_dither");

-

-   {

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB &&

-         palette_lookup && row_info->bit_depth == 8)

-      {

-         int r, g, b, p;

-         sp = row;

-         dp = row;

-         for (i = 0; i < row_width; i++)

-         {

-            r = *sp++;

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

-             */

-            p = (((r >> (8 - PNG_DITHER_RED_BITS)) &

-               ((1 << PNG_DITHER_RED_BITS) - 1)) <<

-               (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |

-               (((g >> (8 - PNG_DITHER_GREEN_BITS)) &

-               ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<

-               (PNG_DITHER_BLUE_BITS)) |

-               ((b >> (8 - PNG_DITHER_BLUE_BITS)) &

-               ((1 << PNG_DITHER_BLUE_BITS) - 1));

-

-            *dp++ = palette_lookup[p];

-         }

-         row_info->color_type = PNG_COLOR_TYPE_PALETTE;

-         row_info->channels = 1;

-         row_info->pixel_depth = row_info->bit_depth;

-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&

-         palette_lookup != NULL && row_info->bit_depth == 8)

-      {

-         int r, g, b, p;

-         sp = row;

-         dp = row;

-         for (i = 0; i < row_width; i++)

-         {

-            r = *sp++;

-            g = *sp++;

-            b = *sp++;

-            sp++;

-

-            p = (((r >> (8 - PNG_DITHER_RED_BITS)) &

-               ((1 << PNG_DITHER_RED_BITS) - 1)) <<

-               (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |

-               (((g >> (8 - PNG_DITHER_GREEN_BITS)) &

-               ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<

-               (PNG_DITHER_BLUE_BITS)) |

-               ((b >> (8 - PNG_DITHER_BLUE_BITS)) &

-               ((1 << PNG_DITHER_BLUE_BITS) - 1));

-

-            *dp++ = palette_lookup[p];

-         }

-         row_info->color_type = PNG_COLOR_TYPE_PALETTE;

-         row_info->channels = 1;

-         row_info->pixel_depth = row_info->bit_depth;

-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&

-         dither_lookup && row_info->bit_depth == 8)

-      {

-         sp = row;

-         for (i = 0; i < row_width; i++, sp++)

-         {

-            *sp = dither_lookup[*sp];

-         }

-      }

-   }

+    png_bytep sp, dp;

+    png_uint_32 i;

+    png_uint_32 row_width = row_info->width;

+

+    png_debug(1, "in png_do_dither");

+

+    {

+        if(row_info->color_type == PNG_COLOR_TYPE_RGB &&

+           palette_lookup && row_info->bit_depth == 8)

+        {

+            int r, g, b, p;

+            sp = row;

+            dp = row;

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

+            {

+                r = *sp++;

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

+                 */

+                p = (((r >> (8 - PNG_DITHER_RED_BITS)) &

+                      ((1 << PNG_DITHER_RED_BITS) - 1)) <<

+                     (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |

+                    (((g >> (8 - PNG_DITHER_GREEN_BITS)) &

+                      ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<

+                     (PNG_DITHER_BLUE_BITS)) |

+                    ((b >> (8 - PNG_DITHER_BLUE_BITS)) &

+                     ((1 << PNG_DITHER_BLUE_BITS) - 1));

+

+                *dp++ = palette_lookup[p];

+            }

+            row_info->color_type = PNG_COLOR_TYPE_PALETTE;

+            row_info->channels = 1;

+            row_info->pixel_depth = row_info->bit_depth;

+            row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

+        }

+        else if(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&

+                palette_lookup != NULL && row_info->bit_depth == 8)

+        {

+            int r, g, b, p;

+            sp = row;

+            dp = row;

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

+            {

+                r = *sp++;

+                g = *sp++;

+                b = *sp++;

+                sp++;

+

+                p = (((r >> (8 - PNG_DITHER_RED_BITS)) &

+                      ((1 << PNG_DITHER_RED_BITS) - 1)) <<

+                     (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |

+                    (((g >> (8 - PNG_DITHER_GREEN_BITS)) &

+                      ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<

+                     (PNG_DITHER_BLUE_BITS)) |

+                    ((b >> (8 - PNG_DITHER_BLUE_BITS)) &

+                     ((1 << PNG_DITHER_BLUE_BITS) - 1));

+

+                *dp++ = palette_lookup[p];

+            }

+            row_info->color_type = PNG_COLOR_TYPE_PALETTE;

+            row_info->channels = 1;

+            row_info->pixel_depth = row_info->bit_depth;

+            row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);

+        }

+        else if(row_info->color_type == PNG_COLOR_TYPE_PALETTE &&

+                dither_lookup && row_info->bit_depth == 8)

+        {

+            sp = row;

+            for(i = 0; i < row_width; i++, sp++)

+            {

+                *sp = dither_lookup[*sp];

+            }

+        }

+    }

 }

 #endif

 

 #ifdef PNG_FLOATING_POINT_SUPPORTED

 #ifdef PNG_READ_GAMMA_SUPPORTED

 static PNG_CONST int png_gamma_shift[] =

-   {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00};

+{0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00};

 

 /* We build the 8- or 16-bit gamma tables here.  Note that for 16-bit

  * tables, we don't make a full table if we are reducing to 8-bit in

@@ -3921,218 +3937,218 @@ static PNG_CONST int png_gamma_shift[] =
 void /* PRIVATE */

 png_build_gamma_table(png_structp png_ptr, png_byte bit_depth)

 {

-  png_debug(1, "in png_build_gamma_table");

+    png_debug(1, "in png_build_gamma_table");

 

-  if (bit_depth <= 8)

-  {

-     int i;

-     double g;

+    if(bit_depth <= 8)

+    {

+        int i;

+        double g;

 

-     if (png_ptr->screen_gamma > .000001)

-        g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

+        if(png_ptr->screen_gamma > .000001)

+            g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

 

-     else

-        g = 1.0;

+        else

+            g = 1.0;

 

-     png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,

+        png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,

         (png_uint_32)256);

 

-     for (i = 0; i < 256; i++)

-     {

-        png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,

-           g) * 255.0 + .5);

-     }

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

+        {

+            png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,

+            g) * 255.0 + .5);

+        }

 

 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \

    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

-     if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))

-     {

+        if(png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))

+        {

 

-        g = 1.0 / (png_ptr->gamma);

+            g = 1.0 / (png_ptr->gamma);

 

-        png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,

-           (png_uint_32)256);

+            png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,

+            (png_uint_32)256);

 

-        for (i = 0; i < 256; i++)

-        {

-           png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,

-              g) * 255.0 + .5);

-        }

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

+            {

+                png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,

+                g) * 255.0 + .5);

+            }

 

 

-        png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,

-           (png_uint_32)256);

+            png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,

+            (png_uint_32)256);

 

-        if (png_ptr->screen_gamma > 0.000001)

-           g = 1.0 / png_ptr->screen_gamma;

+            if(png_ptr->screen_gamma > 0.000001)

+                g = 1.0 / png_ptr->screen_gamma;

 

-        else

-           g = png_ptr->gamma;   /* Probably doing rgb_to_gray */

+            else

+                g = png_ptr->gamma;   /* Probably doing rgb_to_gray */

 

-        for (i = 0; i < 256; i++)

-        {

-           png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,

-              g) * 255.0 + .5);

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

+            {

+                png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,

+                g) * 255.0 + .5);

 

+            }

         }

-     }

 #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */

-  }

-  else

-  {

-     double g;

-     int i, j, shift, num;

-     int sig_bit;

-     png_uint_32 ig;

+    }

+    else

+    {

+        double g;

+        int i, j, shift, num;

+        int sig_bit;

+        png_uint_32 ig;

 

-     if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)

-     {

-        sig_bit = (int)png_ptr->sig_bit.red;

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

-     }

-     else

-     {

-        sig_bit = (int)png_ptr->sig_bit.gray;

-     }

+            if((int)png_ptr->sig_bit.blue > sig_bit)

+                sig_bit = png_ptr->sig_bit.blue;

+        }

+        else

+        {

+            sig_bit = (int)png_ptr->sig_bit.gray;

+        }

 

-     if (sig_bit > 0)

-        shift = 16 - sig_bit;

+        if(sig_bit > 0)

+            shift = 16 - sig_bit;

 

-     else

-        shift = 0;

+        else

+            shift = 0;

 

-     if (png_ptr->transformations & PNG_16_TO_8)

-     {

-        if (shift < (16 - PNG_MAX_GAMMA_8))

-           shift = (16 - PNG_MAX_GAMMA_8);

-     }

+        if(png_ptr->transformations & PNG_16_TO_8)

+        {

+            if(shift < (16 - PNG_MAX_GAMMA_8))

+                shift = (16 - PNG_MAX_GAMMA_8);

+        }

 

-     if (shift > 8)

-        shift = 8;

+        if(shift > 8)

+            shift = 8;

 

-     if (shift < 0)

-        shift = 0;

+        if(shift < 0)

+            shift = 0;

 

-     png_ptr->gamma_shift = (png_byte)shift;

+        png_ptr->gamma_shift = (png_byte)shift;

 

-     num = (1 << (8 - shift));

+        num = (1 << (8 - shift));

 

-     if (png_ptr->screen_gamma > .000001)

-        g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

-     else

-        g = 1.0;

+        if(png_ptr->screen_gamma > .000001)

+            g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

+        else

+            g = 1.0;

 

-     png_ptr->gamma_16_table = (png_uint_16pp)png_calloc(png_ptr,

+        png_ptr->gamma_16_table = (png_uint_16pp)png_calloc(png_ptr,

         (png_uint_32)(num * png_sizeof(png_uint_16p)));

 

-     if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))

-     {

-        double fin, fout;

-        png_uint_32 last, max;

-

-        for (i = 0; i < num; i++)

+        if(png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))

         {

-           png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,

-              (png_uint_32)(256 * png_sizeof(png_uint_16)));

-        }

+            double fin, fout;

+            png_uint_32 last, max;

 

-        g = 1.0 / g;

-        last = 0;

-        for (i = 0; i < 256; i++)

-        {

-           fout = ((double)i + 0.5) / 256.0;

-           fin = pow(fout, g);

-           max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));

-           while (last <= max)

-           {

-              png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]

-                 [(int)(last >> (8 - shift))] = (png_uint_16)(

-                 (png_uint_16)i | ((png_uint_16)i << 8));

-              last++;

-           }

-        }

-        while (last < ((png_uint_32)num << 8))

-        {

-           png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]

-              [(int)(last >> (8 - shift))] = (png_uint_16)65535L;

-           last++;

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

+            {

+                png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,

+                (png_uint_32)(256 * png_sizeof(png_uint_16)));

+            }

+

+            g = 1.0 / g;

+            last = 0;

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

+            {

+                fout = ((double)i + 0.5) / 256.0;

+                fin = pow(fout, g);

+                max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));

+                while(last <= max)

+                {

+                    png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]

+                    [(int)(last >> (8 - shift))] = (png_uint_16)(

+                        (png_uint_16)i | ((png_uint_16)i << 8));

+                    last++;

+                }

+            }

+            while(last < ((png_uint_32)num << 8))

+            {

+                png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]

+                [(int)(last >> (8 - shift))] = (png_uint_16)65535L;

+                last++;

+            }

         }

-     }

-     else

-     {

-        for (i = 0; i < num; i++)

+        else

         {

-           png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,

-              (png_uint_32)(256 * png_sizeof(png_uint_16)));

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

+            {

+                png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,

+                (png_uint_32)(256 * png_sizeof(png_uint_16)));

 

-           ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);

+                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] =

-                 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

+                for(j = 0; j < 256; j++)

+                {

+                    png_ptr->gamma_16_table[i][j] =

+                    (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

                     65535.0, g) * 65535.0 + .5);

-           }

+                }

+            }

         }

-     }

 

 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \

    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

-     if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))

-     {

+        if(png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))

+        {

 

-        g = 1.0 / (png_ptr->gamma);

+            g = 1.0 / (png_ptr->gamma);

 

-        png_ptr->gamma_16_to_1 = (png_uint_16pp)png_calloc(png_ptr,

-           (png_uint_32)(num * png_sizeof(png_uint_16p )));

+            png_ptr->gamma_16_to_1 = (png_uint_16pp)png_calloc(png_ptr,

+            (png_uint_32)(num * png_sizeof(png_uint_16p)));

 

-        for (i = 0; i < num; i++)

-        {

-           png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,

-              (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_to_1[i][j] =

-                 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

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

+            {

+                png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,

+                (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_to_1[i][j] =

+                    (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

                     65535.0, g) * 65535.0 + .5);

-           }

-        }

+                }

+            }

 

-        if (png_ptr->screen_gamma > 0.000001)

-           g = 1.0 / png_ptr->screen_gamma;

+            if(png_ptr->screen_gamma > 0.000001)

+                g = 1.0 / png_ptr->screen_gamma;

 

-        else

-           g = png_ptr->gamma;   /* Probably doing rgb_to_gray */

+            else

+                g = png_ptr->gamma;   /* Probably doing rgb_to_gray */

 

-        png_ptr->gamma_16_from_1 = (png_uint_16pp)png_calloc(png_ptr,

-           (png_uint_32)(num * png_sizeof(png_uint_16p)));

+            png_ptr->gamma_16_from_1 = (png_uint_16pp)png_calloc(png_ptr,

+            (png_uint_32)(num * png_sizeof(png_uint_16p)));

 

-        for (i = 0; i < num; i++)

-        {

-           png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,

-              (png_uint_32)(256 * png_sizeof(png_uint_16)));

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

+            {

+                png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,

+                (png_uint_32)(256 * png_sizeof(png_uint_16)));

 

-           ig = (((png_uint_32)i *

-              (png_uint_32)png_gamma_shift[shift]) >> 4);

+                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] =

-                 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

+                for(j = 0; j < 256; j++)

+                {

+                    png_ptr->gamma_16_from_1[i][j] =

+                    (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

                     65535.0, g) * 65535.0 + .5);

-           }

+                }

+            }

         }

-     }

 #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */

-  }

+    }

 }

 #endif

 /* To do: install integer version of png_build_gamma_table here */

@@ -4143,61 +4159,61 @@ png_build_gamma_table(png_structp png_ptr, png_byte bit_depth)
 void /* PRIVATE */

 png_do_read_intrapixel(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_read_intrapixel");

+    png_debug(1, "in png_do_read_intrapixel");

 

-   if (

-       (row_info->color_type & PNG_COLOR_MASK_COLOR))

-   {

-      int bytes_per_pixel;

-      png_uint_32 row_width = row_info->width;

-      if (row_info->bit_depth == 8)

-      {

-         png_bytep rp;

-         png_uint_32 i;

+    if(

+        (row_info->color_type & PNG_COLOR_MASK_COLOR))

+    {

+        int bytes_per_pixel;

+        png_uint_32 row_width = row_info->width;

+        if(row_info->bit_depth == 8)

+        {

+            png_bytep rp;

+            png_uint_32 i;

 

-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-            bytes_per_pixel = 3;

+            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 if(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+                bytes_per_pixel = 4;

 

-         else

-            return;

+            else

+                return;

 

-         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

-         {

-            *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff);

-            *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff);

-         }

-      }

-      else if (row_info->bit_depth == 16)

-      {

-         png_bytep rp;

-         png_uint_32 i;

+            for(i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

+            {

+                *(rp) = (png_byte)((256 + *rp + *(rp + 1)) & 0xff);

+                *(rp + 2) = (png_byte)((256 + *(rp + 2) + *(rp + 1)) & 0xff);

+            }

+        }

+        else if(row_info->bit_depth == 16)

+        {

+            png_bytep rp;

+            png_uint_32 i;

 

-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-            bytes_per_pixel = 6;

+            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 if(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+                bytes_per_pixel = 8;

 

-         else

-            return;

+            else

+                return;

 

-         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

-         {

-            png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);

-            png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);

-            png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);

-            png_uint_32 red  = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL);

-            png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL);

-            *(rp  ) = (png_byte)((red >> 8) & 0xff);

-            *(rp+1) = (png_byte)(red & 0xff);

-            *(rp+4) = (png_byte)((blue >> 8) & 0xff);

-            *(rp+5) = (png_byte)(blue & 0xff);

-         }

-      }

-   }

+            for(i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

+            {

+                png_uint_32 s0   = (*(rp) << 8) | *(rp + 1);

+                png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);

+                png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);

+                png_uint_32 red  = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL);

+                png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL);

+                *(rp) = (png_byte)((red >> 8) & 0xff);

+                *(rp + 1) = (png_byte)(red & 0xff);

+                *(rp + 4) = (png_byte)((blue >> 8) & 0xff);

+                *(rp + 5) = (png_byte)(blue & 0xff);

+            }

+        }

+    }

 }

 #endif /* PNG_MNG_FEATURES_SUPPORTED */

 #endif /* PNG_READ_SUPPORTED */

diff --git a/src/libpng/pngrutil.c b/src/libpng/pngrutil.c
index 0c598671b..fbb737d27 100644
--- a/src/libpng/pngrutil.c
+++ b/src/libpng/pngrutil.c
@@ -23,22 +23,22 @@
 png_uint_32 PNGAPI

 png_get_uint_31(png_structp png_ptr, png_bytep buf)

 {

-   png_uint_32 i = png_get_uint_32(buf);

-   if (i > PNG_UINT_31_MAX)

-     png_error(png_ptr, "PNG unsigned integer out of range");

-   return (i);

+    png_uint_32 i = png_get_uint_32(buf);

+    if(i > PNG_UINT_31_MAX)

+        png_error(png_ptr, "PNG unsigned integer out of range");

+    return (i);

 }

 #ifndef PNG_USE_READ_MACROS

 /* Grab an unsigned 32-bit integer from a buffer in big-endian format. */

 png_uint_32 PNGAPI

 png_get_uint_32(png_bytep buf)

 {

-   png_uint_32 i = ((png_uint_32)(*buf) << 24) +

-      ((png_uint_32)(*(buf + 1)) << 16) +

-      ((png_uint_32)(*(buf + 2)) << 8) +

-      (png_uint_32)(*(buf + 3));

+    png_uint_32 i = ((png_uint_32)(*buf) << 24) +

+                    ((png_uint_32)(*(buf + 1)) << 16) +

+                    ((png_uint_32)(*(buf + 2)) << 8) +

+                    (png_uint_32)(*(buf + 3));

 

-   return (i);

+    return (i);

 }

 

 /* Grab a signed 32-bit integer from a buffer in big-endian format.  The

@@ -48,22 +48,22 @@ png_get_uint_32(png_bytep buf)
 png_int_32 PNGAPI

 png_get_int_32(png_bytep buf)

 {

-   png_int_32 i = ((png_int_32)(*buf) << 24) +

-      ((png_int_32)(*(buf + 1)) << 16) +

-      ((png_int_32)(*(buf + 2)) << 8) +

-      (png_int_32)(*(buf + 3));

+    png_int_32 i = ((png_int_32)(*buf) << 24) +

+                   ((png_int_32)(*(buf + 1)) << 16) +

+                   ((png_int_32)(*(buf + 2)) << 8) +

+                   (png_int_32)(*(buf + 3));

 

-   return (i);

+    return (i);

 }

 

 /* Grab an unsigned 16-bit integer from a buffer in big-endian format. */

 png_uint_16 PNGAPI

 png_get_uint_16(png_bytep buf)

 {

-   png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) +

-      (png_uint_16)(*(buf + 1)));

+    png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) +

+                                  (png_uint_16)(*(buf + 1)));

 

-   return (i);

+    return (i);

 }

 #endif /* PNG_USE_READ_MACROS */

 

@@ -73,51 +73,51 @@ png_get_uint_16(png_bytep buf)
 png_uint_32 /* PRIVATE */

 png_read_chunk_header(png_structp png_ptr)

 {

-   png_byte buf[8];

-   png_uint_32 length;

+    png_byte buf[8];

+    png_uint_32 length;

 

 #ifdef PNG_IO_STATE_SUPPORTED

-   /* Inform the I/O callback that the chunk header is being read.

-    * PNG_IO_CHUNK_HDR requires a single I/O call.

-    */

-   png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR;

+    /* Inform the I/O callback that the chunk header is being read.

+     * PNG_IO_CHUNK_HDR requires a single I/O call.

+     */

+    png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR;

 #endif

 

-   /* Read the length and the chunk name */

-   png_read_data(png_ptr, buf, 8);

-   length = png_get_uint_31(png_ptr, buf);

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

-   png_memcpy(png_ptr->chunk_name, buf + 4, 4);

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

+    png_debug2(0, "Reading %s chunk, length = %lu",

+               png_ptr->chunk_name, length);

 

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

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

-   png_check_chunk_name(png_ptr, png_ptr->chunk_name);

+    /* Check to see if chunk name is valid */

+    png_check_chunk_name(png_ptr, png_ptr->chunk_name);

 

 #ifdef PNG_IO_STATE_SUPPORTED

-   /* Inform the I/O callback that chunk data will (possibly) be read.

-    * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.

-    */

-   png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA;

+    /* Inform the I/O callback that chunk data will (possibly) be read.

+     * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.

+     */

+    png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA;

 #endif

 

-   return length;

+    return length;

 }

 

 /* Read data, and (optionally) run it through the CRC. */

 void /* PRIVATE */

 png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)

 {

-   if (png_ptr == NULL)

-      return;

-   png_read_data(png_ptr, buf, length);

-   png_calculate_crc(png_ptr, buf, length);

+    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

@@ -128,36 +128,36 @@ png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
 int /* PRIVATE */

 png_crc_finish(png_structp png_ptr, png_uint_32 skip)

 {

-   png_size_t i;

-   png_size_t istop = png_ptr->zbuf_size;

-

-   for (i = (png_size_t)skip; i > istop; i -= istop)

-   {

-      png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);

-   }

-   if (i)

-   {

-      png_crc_read(png_ptr, png_ptr->zbuf, i);

-   }

-

-   if (png_crc_error(png_ptr))

-   {

-      if (((png_ptr->chunk_name[0] & 0x20) &&                /* Ancillary */

-          !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||

-          (!(png_ptr->chunk_name[0] & 0x20) &&             /* Critical  */

-          (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))

-      {

-         png_chunk_warning(png_ptr, "CRC error");

-      }

-      else

-      {

-         png_chunk_benign_error(png_ptr, "CRC error");

-         return (0);

-      }

-      return (1);

-   }

-

-   return (0);

+    png_size_t i;

+    png_size_t istop = png_ptr->zbuf_size;

+

+    for(i = (png_size_t)skip; i > istop; i -= istop)

+    {

+        png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);

+    }

+    if(i)

+    {

+        png_crc_read(png_ptr, png_ptr->zbuf, i);

+    }

+

+    if(png_crc_error(png_ptr))

+    {

+        if(((png_ptr->chunk_name[0] & 0x20) &&                 /* Ancillary */

+            !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||

+           (!(png_ptr->chunk_name[0] & 0x20) &&             /* Critical  */

+            (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))

+        {

+            png_chunk_warning(png_ptr, "CRC error");

+        }

+        else

+        {

+            png_chunk_benign_error(png_ptr, "CRC error");

+            return (0);

+        }

+        return (1);

+    }

+

+    return (0);

 }

 

 /* Compare the CRC stored in the PNG file with that calculated by libpng from

@@ -166,128 +166,128 @@ png_crc_finish(png_structp png_ptr, png_uint_32 skip)
 int /* PRIVATE */

 png_crc_error(png_structp png_ptr)

 {

-   png_byte crc_bytes[4];

-   png_uint_32 crc;

-   int need_crc = 1;

-

-   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */

-   {

-      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==

-          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))

-         need_crc = 0;

-   }

-   else                                                    /* critical */

-   {

-      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)

-         need_crc = 0;

-   }

+    png_byte crc_bytes[4];

+    png_uint_32 crc;

+    int need_crc = 1;

+

+    if(png_ptr->chunk_name[0] & 0x20)                      /* ancillary */

+    {

+        if((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==

+           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))

+            need_crc = 0;

+    }

+    else                                                    /* critical */

+    {

+        if(png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)

+            need_crc = 0;

+    }

 

 #ifdef PNG_IO_STATE_SUPPORTED

-   /* Inform the I/O callback that the chunk CRC is being read */

-   /* PNG_IO_CHUNK_CRC requires the I/O to be done at once */

-   png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC;

+    /* Inform the I/O callback that the chunk CRC is being read */

+    /* PNG_IO_CHUNK_CRC requires the I/O to be done at once */

+    png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC;

 #endif

 

-   png_read_data(png_ptr, crc_bytes, 4);

+    png_read_data(png_ptr, crc_bytes, 4);

 

-   if (need_crc)

-   {

-      crc = png_get_uint_32(crc_bytes);

-      return ((int)(crc != png_ptr->crc));

-   }

-   else

-      return (0);

+    if(need_crc)

+    {

+        crc = png_get_uint_32(crc_bytes);

+        return ((int)(crc != png_ptr->crc));

+    }

+    else

+        return (0);

 }

 

 #if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \

     defined(PNG_READ_iCCP_SUPPORTED)

 static png_size_t

 png_inflate(png_structp png_ptr, const png_byte *data, png_size_t size,

-	png_bytep output, png_size_t output_size)

+            png_bytep output, png_size_t output_size)

 {

-   png_size_t count = 0;

-

-   png_ptr->zstream.next_in = (png_bytep)data; /* const_cast: VALID */

-   png_ptr->zstream.avail_in = size;

-

-   while (1)

-   {

-      int ret, avail;

-

-      /* Reset the output buffer each time round - we empty it

-       * after every inflate call.

-       */

-      png_ptr->zstream.next_out = png_ptr->zbuf;

-      png_ptr->zstream.avail_out = png_ptr->zbuf_size;

-

-      ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);

-      avail = png_ptr->zbuf_size - png_ptr->zstream.avail_out;

-

-      /* First copy/count any new output - but only if we didn't

-       * get an error code.

-       */

-      if ((ret == Z_OK || ret == Z_STREAM_END) && avail > 0)

-      {

-         if (output != 0 && output_size > count)

-	 {

-	    int copy = output_size - count;

-	    if (avail < copy) copy = avail;

-	    png_memcpy(output + count, png_ptr->zbuf, copy);

-	 }

-         count += avail;

-      }

-

-      if (ret == Z_OK)

-         continue;

-

-      /* Termination conditions - always reset the zstream, it

-       * must be left in inflateInit state.

-       */

-      png_ptr->zstream.avail_in = 0;

-      inflateReset(&png_ptr->zstream);

-

-      if (ret == Z_STREAM_END)

-         return count; /* NOTE: may be zero. */

-

-      /* Now handle the error codes - the API always returns 0

-       * and the error message is dumped into the uncompressed

-       * buffer if available.

-       */

-      {

-         char *msg, umsg[52];

-	 if (png_ptr->zstream.msg != 0)

-	    msg = png_ptr->zstream.msg;

-	 else

-	 {

+    png_size_t count = 0;

+

+    png_ptr->zstream.next_in = (png_bytep)data; /* const_cast: VALID */

+    png_ptr->zstream.avail_in = size;

+

+    while(1)

+    {

+        int ret, avail;

+

+        /* Reset the output buffer each time round - we empty it

+         * after every inflate call.

+         */

+        png_ptr->zstream.next_out = png_ptr->zbuf;

+        png_ptr->zstream.avail_out = png_ptr->zbuf_size;

+

+        ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);

+        avail = png_ptr->zbuf_size - png_ptr->zstream.avail_out;

+

+        /* First copy/count any new output - but only if we didn't

+         * get an error code.

+         */

+        if((ret == Z_OK || ret == Z_STREAM_END) && avail > 0)

+        {

+            if(output != 0 && output_size > count)

+            {

+                int copy = output_size - count;

+                if(avail < copy) copy = avail;

+                png_memcpy(output + count, png_ptr->zbuf, copy);

+            }

+            count += avail;

+        }

+

+        if(ret == Z_OK)

+            continue;

+

+        /* Termination conditions - always reset the zstream, it

+         * must be left in inflateInit state.

+         */

+        png_ptr->zstream.avail_in = 0;

+        inflateReset(&png_ptr->zstream);

+

+        if(ret == Z_STREAM_END)

+            return count; /* NOTE: may be zero. */

+

+        /* Now handle the error codes - the API always returns 0

+         * and the error message is dumped into the uncompressed

+         * buffer if available.

+         */

+        {

+            char *msg, umsg[52];

+            if(png_ptr->zstream.msg != 0)

+                msg = png_ptr->zstream.msg;

+            else

+            {

 #ifdef PNG_STDIO_SUPPORTED

-	    switch (ret)

-	    {

-	 case Z_BUF_ERROR:

-	    msg = "Buffer error in compressed datastream in %s chunk";

-	    break;

-	 case Z_DATA_ERROR:

-	    msg = "Data error in compressed datastream in %s chunk";

-	    break;

-	 default:

-	    msg = "Incomplete compressed datastream in %s chunk";

-	    break;

-	    }

-

-	    png_snprintf(umsg, sizeof umsg, msg, png_ptr->chunk_name);

-	    msg = umsg;

+                switch(ret)

+                {

+                case Z_BUF_ERROR:

+                    msg = "Buffer error in compressed datastream in %s chunk";

+                    break;

+                case Z_DATA_ERROR:

+                    msg = "Data error in compressed datastream in %s chunk";

+                    break;

+                default:

+                    msg = "Incomplete compressed datastream in %s chunk";

+                    break;

+                }

+

+                png_snprintf(umsg, sizeof umsg, msg, png_ptr->chunk_name);

+                msg = umsg;

 #else

-	    msg = "Damaged compressed datastream in chunk other than IDAT";

+                msg = "Damaged compressed datastream in chunk other than IDAT";

 #endif

-	 }

+            }

 

-         png_warning(png_ptr, msg);

-      }

+            png_warning(png_ptr, msg);

+        }

 

-      /* 0 means an error - notice that this code simple ignores

-       * zero length compressed chunks as a result.

-       */

-      return 0;

-   }

+        /* 0 means an error - notice that this code simple ignores

+         * zero length compressed chunks as a result.

+         */

+        return 0;

+    }

 }

 

 /*

@@ -299,107 +299,107 @@ png_inflate(png_structp png_ptr, const png_byte *data, png_size_t size,
  */

 void /* PRIVATE */

 png_decompress_chunk(png_structp png_ptr, int comp_type,

-    png_size_t chunklength,

-    png_size_t prefix_size, png_size_t *newlength)

+                     png_size_t chunklength,

+                     png_size_t prefix_size, png_size_t *newlength)

 {

-   /* The caller should guarantee this */

-   if (prefix_size > chunklength)

-   {

-      /* The recovery is to delete the chunk. */

-      png_warning(png_ptr, "invalid chunklength");

-      prefix_size = 0; /* To delete everything */

-   }

-

-   else if (comp_type == PNG_COMPRESSION_TYPE_BASE)

-   {

-      png_size_t expanded_size = png_inflate(png_ptr,

-		(png_bytep)(png_ptr->chunkdata + prefix_size),

-                chunklength - prefix_size,

-		0/*output*/, 0/*output size*/);

-

-      /* Now check the limits on this chunk - if the limit fails the

-       * compressed data will be removed, the prefix will remain.

-       */

+    /* The caller should guarantee this */

+    if(prefix_size > chunklength)

+    {

+        /* The recovery is to delete the chunk. */

+        png_warning(png_ptr, "invalid chunklength");

+        prefix_size = 0; /* To delete everything */

+    }

+

+    else if(comp_type == PNG_COMPRESSION_TYPE_BASE)

+    {

+        png_size_t expanded_size = png_inflate(png_ptr,

+                                               (png_bytep)(png_ptr->chunkdata + prefix_size),

+                                               chunklength - prefix_size,

+                                               0/*output*/, 0/*output size*/);

+

+        /* Now check the limits on this chunk - if the limit fails the

+         * compressed data will be removed, the prefix will remain.

+         */

 #ifdef PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED

-      if (png_ptr->user_chunk_malloc_max &&

-          (prefix_size + expanded_size >= png_ptr->user_chunk_malloc_max - 1))

+        if(png_ptr->user_chunk_malloc_max &&

+           (prefix_size + expanded_size >= png_ptr->user_chunk_malloc_max - 1))

 #else

-      if ((PNG_USER_CHUNK_MALLOC_MAX > 0) &&

-          prefix_size + expanded_size >= PNG_USER_CHUNK_MALLOC_MAX - 1)

-#endif

-         png_warning(png_ptr, "Exceeded size limit while expanding chunk");

-

-      /* If the size is zero either there was an error and a message

-       * has already been output (warning) or the size really is zero

-       * and we have nothing to do - the code will exit through the

-       * error case below.

-       */

-      else if (expanded_size > 0)

-      {

-         /* Success (maybe) - really uncompress the chunk. */

-	 png_size_t new_size = 0;

-	 png_charp text = png_malloc_warn(png_ptr,

-			prefix_size + expanded_size + 1);

-

-         if (text != NULL)

-         {

-	    png_memcpy(text, png_ptr->chunkdata, prefix_size);

-	    new_size = png_inflate(png_ptr,

-                (png_bytep)(png_ptr->chunkdata + prefix_size),

-		chunklength - prefix_size,

-                (png_bytep)(text + prefix_size), expanded_size);

-	    text[prefix_size + expanded_size] = 0; /* just in case */

-

-	    if (new_size == expanded_size)

-	    {

-	       png_free(png_ptr, png_ptr->chunkdata);

-	       png_ptr->chunkdata = text;

-	       *newlength = prefix_size + expanded_size;

-	       return; /* The success return! */

-	    }

-      

-	    png_warning(png_ptr, "png_inflate logic error");

-	    png_free(png_ptr, text);

-	 }

-	 else

-          png_warning(png_ptr, "Not enough memory to decompress chunk");

-      }

-   }

-

-   else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */

-   {

-      char umsg[50];

+        if((PNG_USER_CHUNK_MALLOC_MAX > 0) &&

+           prefix_size + expanded_size >= PNG_USER_CHUNK_MALLOC_MAX - 1)

+#endif

+            png_warning(png_ptr, "Exceeded size limit while expanding chunk");

+

+        /* If the size is zero either there was an error and a message

+         * has already been output (warning) or the size really is zero

+         * and we have nothing to do - the code will exit through the

+         * error case below.

+         */

+        else if(expanded_size > 0)

+        {

+            /* Success (maybe) - really uncompress the chunk. */

+            png_size_t new_size = 0;

+            png_charp text = png_malloc_warn(png_ptr,

+                                             prefix_size + expanded_size + 1);

+

+            if(text != NULL)

+            {

+                png_memcpy(text, png_ptr->chunkdata, prefix_size);

+                new_size = png_inflate(png_ptr,

+                                       (png_bytep)(png_ptr->chunkdata + prefix_size),

+                                       chunklength - prefix_size,

+                                       (png_bytep)(text + prefix_size), expanded_size);

+                text[prefix_size + expanded_size] = 0; /* just in case */

+

+                if(new_size == expanded_size)

+                {

+                    png_free(png_ptr, png_ptr->chunkdata);

+                    png_ptr->chunkdata = text;

+                    *newlength = prefix_size + expanded_size;

+                    return; /* The success return! */

+                }

+

+                png_warning(png_ptr, "png_inflate logic error");

+                png_free(png_ptr, text);

+            }

+            else

+                png_warning(png_ptr, "Not enough memory to decompress chunk");

+        }

+    }

+

+    else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */

+    {

+        char umsg[50];

 

 #ifdef PNG_STDIO_SUPPORTED

-      png_snprintf(umsg, sizeof umsg, "Unknown zTXt compression type %d", comp_type);

-      png_warning(png_ptr, umsg);

+        png_snprintf(umsg, sizeof umsg, "Unknown zTXt compression type %d", comp_type);

+        png_warning(png_ptr, umsg);

 #else

-      png_warning(png_ptr, "Unknown zTXt compression type");

-#endif

-

-      /* The recovery is to simply drop the data. */

-   }

-

-   /* Generic error return - leave the prefix, delete the compressed

-    * data, reallocate the chunkdata to remove the potentially large

-    * amount of compressed data.

-    */

-   {

-      png_charp text = png_malloc_warn(png_ptr, prefix_size + 1);

-      if (text != NULL)

-      {

-	 if (prefix_size > 0)

-            png_memcpy(text, png_ptr->chunkdata, prefix_size);

-	 png_free(png_ptr, png_ptr->chunkdata);

-	 png_ptr->chunkdata = text;

-

-	 /* This is an extra zero in the 'uncompressed' part. */

-	 *(png_ptr->chunkdata + prefix_size) = 0x00;

-      }

-      /* Ignore a malloc error here - it is safe. */

-   }

-

-   *newlength = prefix_size;

+        png_warning(png_ptr, "Unknown zTXt compression type");

+#endif

+

+        /* The recovery is to simply drop the data. */

+    }

+

+    /* Generic error return - leave the prefix, delete the compressed

+     * data, reallocate the chunkdata to remove the potentially large

+     * amount of compressed data.

+     */

+    {

+        png_charp text = png_malloc_warn(png_ptr, prefix_size + 1);

+        if(text != NULL)

+        {

+            if(prefix_size > 0)

+                png_memcpy(text, png_ptr->chunkdata, prefix_size);

+            png_free(png_ptr, png_ptr->chunkdata);

+            png_ptr->chunkdata = text;

+

+            /* This is an extra zero in the 'uncompressed' part. */

+            *(png_ptr->chunkdata + prefix_size) = 0x00;

+        }

+        /* Ignore a malloc error here - it is safe. */

+    }

+

+    *newlength = prefix_size;

 }

 #endif

 

@@ -407,215 +407,215 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
 void /* PRIVATE */

 png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_byte buf[13];

-   png_uint_32 width, height;

-   int bit_depth, color_type, compression_type, filter_type;

-   int interlace_type;

-

-   png_debug(1, "in png_handle_IHDR");

-

-   if (png_ptr->mode & PNG_HAVE_IHDR)

-      png_error(png_ptr, "Out of place IHDR");

-

-   /* Check the length */

-   if (length != 13)

-      png_error(png_ptr, "Invalid IHDR chunk");

-

-   png_ptr->mode |= PNG_HAVE_IHDR;

-

-   png_crc_read(png_ptr, buf, 13);

-   png_crc_finish(png_ptr, 0);

-

-   width = png_get_uint_31(png_ptr, buf);

-   height = png_get_uint_31(png_ptr, buf + 4);

-   bit_depth = buf[8];

-   color_type = buf[9];

-   compression_type = buf[10];

-   filter_type = buf[11];

-   interlace_type = buf[12];

-

-   /* Set internal variables */

-   png_ptr->width = width;

-   png_ptr->height = height;

-   png_ptr->bit_depth = (png_byte)bit_depth;

-   png_ptr->interlaced = (png_byte)interlace_type;

-   png_ptr->color_type = (png_byte)color_type;

+    png_byte buf[13];

+    png_uint_32 width, height;

+    int bit_depth, color_type, compression_type, filter_type;

+    int interlace_type;

+

+    png_debug(1, "in png_handle_IHDR");

+

+    if(png_ptr->mode & PNG_HAVE_IHDR)

+        png_error(png_ptr, "Out of place IHDR");

+

+    /* Check the length */

+    if(length != 13)

+        png_error(png_ptr, "Invalid IHDR chunk");

+

+    png_ptr->mode |= PNG_HAVE_IHDR;

+

+    png_crc_read(png_ptr, buf, 13);

+    png_crc_finish(png_ptr, 0);

+

+    width = png_get_uint_31(png_ptr, buf);

+    height = png_get_uint_31(png_ptr, buf + 4);

+    bit_depth = buf[8];

+    color_type = buf[9];

+    compression_type = buf[10];

+    filter_type = buf[11];

+    interlace_type = buf[12];

+

+    /* Set internal variables */

+    png_ptr->width = width;

+    png_ptr->height = height;

+    png_ptr->bit_depth = (png_byte)bit_depth;

+    png_ptr->interlaced = (png_byte)interlace_type;

+    png_ptr->color_type = (png_byte)color_type;

 #ifdef PNG_MNG_FEATURES_SUPPORTED

-   png_ptr->filter_type = (png_byte)filter_type;

-#endif

-   png_ptr->compression_type = (png_byte)compression_type;

-

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

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

-   png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);

-   png_debug1(3, "channels = %d", png_ptr->channels);

-   png_debug1(3, "rowbytes = %lu", png_ptr->rowbytes);

-   png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,

-      color_type, interlace_type, compression_type, filter_type);

+    png_ptr->filter_type = (png_byte)filter_type;

+#endif

+    png_ptr->compression_type = (png_byte)compression_type;

+

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

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

+    png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);

+    png_debug1(3, "channels = %d", png_ptr->channels);

+    png_debug1(3, "rowbytes = %lu", png_ptr->rowbytes);

+    png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,

+                 color_type, interlace_type, compression_type, filter_type);

 }

 

 /* Read and check the palette */

 void /* PRIVATE */

 png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_color palette[PNG_MAX_PALETTE_LENGTH];

-   int num, i;

+    png_color palette[PNG_MAX_PALETTE_LENGTH];

+    int num, i;

 #ifdef PNG_POINTER_INDEXING_SUPPORTED

-   png_colorp pal_ptr;

+    png_colorp pal_ptr;

 #endif

 

-   png_debug(1, "in png_handle_PLTE");

+    png_debug(1, "in png_handle_PLTE");

 

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before PLTE");

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

+    else if(png_ptr->mode & PNG_HAVE_PLTE)

+        png_error(png_ptr, "Duplicate PLTE chunk");

 

-   png_ptr->mode |= PNG_HAVE_PLTE;

+    png_ptr->mode |= PNG_HAVE_PLTE;

 

-   if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))

-   {

-      png_warning(png_ptr,

-        "Ignoring PLTE chunk in grayscale PNG");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

+    if(!(png_ptr->color_type & PNG_COLOR_MASK_COLOR))

+    {

+        png_warning(png_ptr,

+                    "Ignoring PLTE chunk in grayscale PNG");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

 #ifndef PNG_READ_OPT_PLTE_SUPPORTED

-   if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)

-   {

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-#endif

-

-   if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3)

-   {

-      if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)

-      {

-         png_warning(png_ptr, "Invalid palette chunk");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-

-      else

-      {

-         png_error(png_ptr, "Invalid palette chunk");

-      }

-   }

-

-   num = (int)length / 3;

+    if(png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)

+    {

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+#endif

+

+    if(length > 3 * PNG_MAX_PALETTE_LENGTH || length % 3)

+    {

+        if(png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)

+        {

+            png_warning(png_ptr, "Invalid palette chunk");

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+

+        else

+        {

+            png_error(png_ptr, "Invalid palette chunk");

+        }

+    }

+

+    num = (int)length / 3;

 

 #ifdef PNG_POINTER_INDEXING_SUPPORTED

-   for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++)

-   {

-      png_byte buf[3];

-

-      png_crc_read(png_ptr, buf, 3);

-      pal_ptr->red = buf[0];

-      pal_ptr->green = buf[1];

-      pal_ptr->blue = buf[2];

-   }

+    for(i = 0, pal_ptr = palette; i < num; i++, pal_ptr++)

+    {

+        png_byte buf[3];

+

+        png_crc_read(png_ptr, buf, 3);

+        pal_ptr->red = buf[0];

+        pal_ptr->green = buf[1];

+        pal_ptr->blue = buf[2];

+    }

 #else

-   for (i = 0; i < num; i++)

-   {

-      png_byte buf[3];

-

-      png_crc_read(png_ptr, buf, 3);

-      /* Don't depend upon png_color being any order */

-      palette[i].red = buf[0];

-      palette[i].green = buf[1];

-      palette[i].blue = buf[2];

-   }

-#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.

-    */

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

+    {

+        png_byte buf[3];

+

+        png_crc_read(png_ptr, buf, 3);

+        /* Don't depend upon png_color being any order */

+        palette[i].red = buf[0];

+        palette[i].green = buf[1];

+        palette[i].blue = buf[2];

+    }

+#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.

+     */

 #ifndef PNG_READ_OPT_PLTE_SUPPORTED

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+    if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

 #endif

-   {

-      png_crc_finish(png_ptr, 0);

-   }

+    {

+        png_crc_finish(png_ptr, 0);

+    }

 #ifndef PNG_READ_OPT_PLTE_SUPPORTED

-   else if (png_crc_error(png_ptr))  /* Only if we have a CRC error */

-   {

-      /* If we don't want to use the data from an ancillary chunk,

-         we have two options: an error abort, or a warning and we

-         ignore the data in this chunk (which should be OK, since

-         it's considered ancillary for a RGB or RGBA image). */

-      if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))

-      {

-         if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)

-         {

-            png_chunk_benign_error(png_ptr, "CRC error");

-         }

-         else

-         {

+    else if(png_crc_error(png_ptr))   /* Only if we have a CRC error */

+    {

+        /* If we don't want to use the data from an ancillary chunk,

+           we have two options: an error abort, or a warning and we

+           ignore the data in this chunk (which should be OK, since

+           it's considered ancillary for a RGB or RGBA image). */

+        if(!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))

+        {

+            if(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)

+            {

+                png_chunk_benign_error(png_ptr, "CRC error");

+            }

+            else

+            {

+                png_chunk_warning(png_ptr, "CRC error");

+                return;

+            }

+        }

+        /* Otherwise, we (optionally) emit a warning and use the chunk. */

+        else if(!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))

+        {

             png_chunk_warning(png_ptr, "CRC error");

-            return;

-         }

-      }

-      /* Otherwise, we (optionally) emit a warning and use the chunk. */

-      else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))

-      {

-         png_chunk_warning(png_ptr, "CRC error");

-      }

-   }

+        }

+    }

 #endif

 

-   png_set_PLTE(png_ptr, info_ptr, palette, num);

+    png_set_PLTE(png_ptr, info_ptr, palette, num);

 

 #ifdef PNG_READ_tRNS_SUPPORTED

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

-      {

-         if (png_ptr->num_trans > (png_uint_16)num)

-         {

-            png_warning(png_ptr, "Truncating incorrect tRNS chunk length");

-            png_ptr->num_trans = (png_uint_16)num;

-         }

-         if (info_ptr->num_trans > (png_uint_16)num)

-         {

-            png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");

-            info_ptr->num_trans = (png_uint_16)num;

-         }

-      }

-   }

+    if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+    {

+        if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

+        {

+            if(png_ptr->num_trans > (png_uint_16)num)

+            {

+                png_warning(png_ptr, "Truncating incorrect tRNS chunk length");

+                png_ptr->num_trans = (png_uint_16)num;

+            }

+            if(info_ptr->num_trans > (png_uint_16)num)

+            {

+                png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");

+                info_ptr->num_trans = (png_uint_16)num;

+            }

+        }

+    }

 #endif

 

 }

@@ -623,101 +623,101 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_debug(1, "in png_handle_IEND");

+    png_debug(1, "in png_handle_IEND");

 

-   if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))

-   {

-      png_error(png_ptr, "No image in file");

-   }

+    if(!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))

+    {

+        png_error(png_ptr, "No image in file");

+    }

 

-   png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);

+    png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);

 

-   if (length != 0)

-   {

-      png_warning(png_ptr, "Incorrect IEND chunk length");

-   }

-   png_crc_finish(png_ptr, length);

+    if(length != 0)

+    {

+        png_warning(png_ptr, "Incorrect IEND chunk length");

+    }

+    png_crc_finish(png_ptr, length);

 

-   info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */

+    info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */

 }

 

 #ifdef PNG_READ_gAMA_SUPPORTED

 void /* PRIVATE */

 png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_fixed_point igamma;

+    png_fixed_point igamma;

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   float file_gamma;

+    float file_gamma;

 #endif

-   png_byte buf[4];

+    png_byte buf[4];

 

-   png_debug(1, "in png_handle_gAMA");

+    png_debug(1, "in png_handle_gAMA");

 

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before gAMA");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid gAMA after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-      /* Should be an error, but we can cope with it */

-      png_warning(png_ptr, "Out of place gAMA chunk");

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before gAMA");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid gAMA after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(png_ptr->mode & PNG_HAVE_PLTE)

+        /* Should be an error, but we can cope with it */

+        png_warning(png_ptr, "Out of place gAMA chunk");

 

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

+    if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

 #ifdef PNG_READ_sRGB_SUPPORTED

-      && !(info_ptr->valid & PNG_INFO_sRGB)

+       && !(info_ptr->valid & PNG_INFO_sRGB)

 #endif

       )

-   {

-      png_warning(png_ptr, "Duplicate gAMA chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (length != 4)

-   {

-      png_warning(png_ptr, "Incorrect gAMA chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 4);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   igamma = (png_fixed_point)png_get_uint_32(buf);

-   /* Check for zero gamma */

-   if (igamma == 0)

-      {

-         png_warning(png_ptr,

-           "Ignoring gAMA chunk with gamma=0");

-         return;

-      }

+    {

+        png_warning(png_ptr, "Duplicate gAMA chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    if(length != 4)

+    {

+        png_warning(png_ptr, "Incorrect gAMA chunk length");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    png_crc_read(png_ptr, buf, 4);

+    if(png_crc_finish(png_ptr, 0))

+        return;

+

+    igamma = (png_fixed_point)png_get_uint_32(buf);

+    /* Check for zero gamma */

+    if(igamma == 0)

+    {

+        png_warning(png_ptr,

+                    "Ignoring gAMA chunk with gamma=0");

+        return;

+    }

 

 #ifdef PNG_READ_sRGB_SUPPORTED

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))

-      if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))

-      {

-         png_warning(png_ptr,

-           "Ignoring incorrect gAMA value when sRGB is also present");

+    if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))

+        if(PNG_OUT_OF_RANGE(igamma, 45500L, 500))

+        {

+            png_warning(png_ptr,

+                        "Ignoring incorrect gAMA value when sRGB is also present");

 #ifdef PNG_CONSOLE_IO_SUPPORTED

-         fprintf(stderr, "gamma = (%d/100000)", (int)igamma);

+            fprintf(stderr, "gamma = (%d/100000)", (int)igamma);

 #endif

-         return;

-      }

+            return;

+        }

 #endif /* PNG_READ_sRGB_SUPPORTED */

 

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   file_gamma = (float)igamma / (float)100000.0;

+    file_gamma = (float)igamma / (float)100000.0;

 #  ifdef PNG_READ_GAMMA_SUPPORTED

-     png_ptr->gamma = file_gamma;

+    png_ptr->gamma = file_gamma;

 #  endif

-     png_set_gAMA(png_ptr, info_ptr, file_gamma);

+    png_set_gAMA(png_ptr, info_ptr, file_gamma);

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   png_set_gAMA_fixed(png_ptr, info_ptr, igamma);

+    png_set_gAMA_fixed(png_ptr, info_ptr, igamma);

 #endif

 }

 #endif

@@ -726,65 +726,65 @@ png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_size_t truelen;

-   png_byte buf[4];

-

-   png_debug(1, "in png_handle_sBIT");

-

-   buf[0] = buf[1] = buf[2] = buf[3] = 0;

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before sBIT");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid sBIT after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-   {

-      /* Should be an error, but we can cope with it */

-      png_warning(png_ptr, "Out of place sBIT chunk");

-   }

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT))

-   {

-      png_warning(png_ptr, "Duplicate sBIT chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      truelen = 3;

-   else

-      truelen = (png_size_t)png_ptr->channels;

-

-   if (length != truelen || length > 4)

-   {

-      png_warning(png_ptr, "Incorrect sBIT chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, truelen);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)

-   {

-      png_ptr->sig_bit.red = buf[0];

-      png_ptr->sig_bit.green = buf[1];

-      png_ptr->sig_bit.blue = buf[2];

-      png_ptr->sig_bit.alpha = buf[3];

-   }

-   else

-   {

-      png_ptr->sig_bit.gray = buf[0];

-      png_ptr->sig_bit.red = buf[0];

-      png_ptr->sig_bit.green = buf[0];

-      png_ptr->sig_bit.blue = buf[0];

-      png_ptr->sig_bit.alpha = buf[1];

-   }

-   png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));

+    png_size_t truelen;

+    png_byte buf[4];

+

+    png_debug(1, "in png_handle_sBIT");

+

+    buf[0] = buf[1] = buf[2] = buf[3] = 0;

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before sBIT");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid sBIT after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(png_ptr->mode & PNG_HAVE_PLTE)

+    {

+        /* Should be an error, but we can cope with it */

+        png_warning(png_ptr, "Out of place sBIT chunk");

+    }

+    if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT))

+    {

+        png_warning(png_ptr, "Duplicate sBIT chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+        truelen = 3;

+    else

+        truelen = (png_size_t)png_ptr->channels;

+

+    if(length != truelen || length > 4)

+    {

+        png_warning(png_ptr, "Incorrect sBIT chunk length");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    png_crc_read(png_ptr, buf, truelen);

+    if(png_crc_finish(png_ptr, 0))

+        return;

+

+    if(png_ptr->color_type & PNG_COLOR_MASK_COLOR)

+    {

+        png_ptr->sig_bit.red = buf[0];

+        png_ptr->sig_bit.green = buf[1];

+        png_ptr->sig_bit.blue = buf[2];

+        png_ptr->sig_bit.alpha = buf[3];

+    }

+    else

+    {

+        png_ptr->sig_bit.gray = buf[0];

+        png_ptr->sig_bit.red = buf[0];

+        png_ptr->sig_bit.green = buf[0];

+        png_ptr->sig_bit.blue = buf[0];

+        png_ptr->sig_bit.alpha = buf[1];

+    }

+    png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));

 }

 #endif

 

@@ -792,122 +792,122 @@ png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_byte buf[32];

+    png_byte buf[32];

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;

+    float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;

 #endif

-   png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,

-      int_y_green, int_x_blue, int_y_blue;

+    png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,

+                    int_y_green, int_x_blue, int_y_blue;

 

-   png_uint_32 uint_x, uint_y;

+    png_uint_32 uint_x, uint_y;

 

-   png_debug(1, "in png_handle_cHRM");

+    png_debug(1, "in png_handle_cHRM");

 

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before cHRM");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid cHRM after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-      /* Should be an error, but we can cope with it */

-      png_warning(png_ptr, "Missing PLTE before cHRM");

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before cHRM");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid cHRM after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(png_ptr->mode & PNG_HAVE_PLTE)

+        /* Should be an error, but we can cope with it */

+        png_warning(png_ptr, "Missing PLTE before cHRM");

 

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)

+    if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)

 #ifdef PNG_READ_sRGB_SUPPORTED

-      && !(info_ptr->valid & PNG_INFO_sRGB)

+       && !(info_ptr->valid & PNG_INFO_sRGB)

 #endif

       )

-   {

-      png_warning(png_ptr, "Duplicate cHRM chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (length != 32)

-   {

-      png_warning(png_ptr, "Incorrect cHRM chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 32);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   uint_x = png_get_uint_32(buf);

-   uint_y = png_get_uint_32(buf + 4);

-   int_x_white = (png_fixed_point)uint_x;

-   int_y_white = (png_fixed_point)uint_y;

-

-   uint_x = png_get_uint_32(buf + 8);

-   uint_y = png_get_uint_32(buf + 12);

-   int_x_red = (png_fixed_point)uint_x;

-   int_y_red = (png_fixed_point)uint_y;

-

-   uint_x = png_get_uint_32(buf + 16);

-   uint_y = png_get_uint_32(buf + 20);

-   int_x_green = (png_fixed_point)uint_x;

-   int_y_green = (png_fixed_point)uint_y;

-

-   uint_x = png_get_uint_32(buf + 24);

-   uint_y = png_get_uint_32(buf + 28);

-   int_x_blue = (png_fixed_point)uint_x;

-   int_y_blue = (png_fixed_point)uint_y;

+    {

+        png_warning(png_ptr, "Duplicate cHRM chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    if(length != 32)

+    {

+        png_warning(png_ptr, "Incorrect cHRM chunk length");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    png_crc_read(png_ptr, buf, 32);

+    if(png_crc_finish(png_ptr, 0))

+        return;

+

+    uint_x = png_get_uint_32(buf);

+    uint_y = png_get_uint_32(buf + 4);

+    int_x_white = (png_fixed_point)uint_x;

+    int_y_white = (png_fixed_point)uint_y;

+

+    uint_x = png_get_uint_32(buf + 8);

+    uint_y = png_get_uint_32(buf + 12);

+    int_x_red = (png_fixed_point)uint_x;

+    int_y_red = (png_fixed_point)uint_y;

+

+    uint_x = png_get_uint_32(buf + 16);

+    uint_y = png_get_uint_32(buf + 20);

+    int_x_green = (png_fixed_point)uint_x;

+    int_y_green = (png_fixed_point)uint_y;

+

+    uint_x = png_get_uint_32(buf + 24);

+    uint_y = png_get_uint_32(buf + 28);

+    int_x_blue = (png_fixed_point)uint_x;

+    int_y_blue = (png_fixed_point)uint_y;

 

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   white_x = (float)int_x_white / (float)100000.0;

-   white_y = (float)int_y_white / (float)100000.0;

-   red_x   = (float)int_x_red   / (float)100000.0;

-   red_y   = (float)int_y_red   / (float)100000.0;

-   green_x = (float)int_x_green / (float)100000.0;

-   green_y = (float)int_y_green / (float)100000.0;

-   blue_x  = (float)int_x_blue  / (float)100000.0;

-   blue_y  = (float)int_y_blue  / (float)100000.0;

+    white_x = (float)int_x_white / (float)100000.0;

+    white_y = (float)int_y_white / (float)100000.0;

+    red_x   = (float)int_x_red   / (float)100000.0;

+    red_y   = (float)int_y_red   / (float)100000.0;

+    green_x = (float)int_x_green / (float)100000.0;

+    green_y = (float)int_y_green / (float)100000.0;

+    blue_x  = (float)int_x_blue  / (float)100000.0;

+    blue_y  = (float)int_y_blue  / (float)100000.0;

 #endif

 

 #ifdef PNG_READ_sRGB_SUPPORTED

-   if ((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB))

-      {

-      if (PNG_OUT_OF_RANGE(int_x_white, 31270,  1000) ||

-          PNG_OUT_OF_RANGE(int_y_white, 32900,  1000) ||

-          PNG_OUT_OF_RANGE(int_x_red,   64000L, 1000) ||

-          PNG_OUT_OF_RANGE(int_y_red,   33000,  1000) ||

-          PNG_OUT_OF_RANGE(int_x_green, 30000,  1000) ||

-          PNG_OUT_OF_RANGE(int_y_green, 60000L, 1000) ||

-          PNG_OUT_OF_RANGE(int_x_blue,  15000,  1000) ||

-          PNG_OUT_OF_RANGE(int_y_blue,   6000,  1000))

-         {

+    if((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB))

+    {

+        if(PNG_OUT_OF_RANGE(int_x_white, 31270,  1000) ||

+           PNG_OUT_OF_RANGE(int_y_white, 32900,  1000) ||

+           PNG_OUT_OF_RANGE(int_x_red,   64000L, 1000) ||

+           PNG_OUT_OF_RANGE(int_y_red,   33000,  1000) ||

+           PNG_OUT_OF_RANGE(int_x_green, 30000,  1000) ||

+           PNG_OUT_OF_RANGE(int_y_green, 60000L, 1000) ||

+           PNG_OUT_OF_RANGE(int_x_blue,  15000,  1000) ||

+           PNG_OUT_OF_RANGE(int_y_blue,   6000,  1000))

+        {

             png_warning(png_ptr,

-              "Ignoring incorrect cHRM value when sRGB is also present");

+                        "Ignoring incorrect cHRM value when sRGB is also present");

 #ifdef PNG_CONSOLE_IO_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

             fprintf(stderr, "wx=%f, wy=%f, rx=%f, ry=%f\n",

-               white_x, white_y, red_x, red_y);

+                    white_x, white_y, red_x, red_y);

             fprintf(stderr, "gx=%f, gy=%f, bx=%f, by=%f\n",

-               green_x, green_y, blue_x, blue_y);

+                    green_x, green_y, blue_x, blue_y);

 #else

             fprintf(stderr, "wx=%ld, wy=%ld, rx=%ld, ry=%ld\n",

-               int_x_white, int_y_white, int_x_red, int_y_red);

+                    int_x_white, int_y_white, int_x_red, int_y_red);

             fprintf(stderr, "gx=%ld, gy=%ld, bx=%ld, by=%ld\n",

-               int_x_green, int_y_green, int_x_blue, int_y_blue);

+                    int_x_green, int_y_green, int_x_blue, int_y_blue);

 #endif

 #endif /* PNG_CONSOLE_IO_SUPPORTED */

-         }

-         return;

-      }

+        }

+        return;

+    }

 #endif /* PNG_READ_sRGB_SUPPORTED */

 

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

+    png_set_cHRM(png_ptr, info_ptr,

+                 white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   png_set_cHRM_fixed(png_ptr, info_ptr,

-      int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,

-      int_y_green, int_x_blue, int_y_blue);

+    png_set_cHRM_fixed(png_ptr, info_ptr,

+                       int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,

+                       int_y_green, int_x_blue, int_y_blue);

 #endif

 }

 #endif

@@ -916,97 +916,97 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   int intent;

-   png_byte buf[1];

-

-   png_debug(1, "in png_handle_sRGB");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before sRGB");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid sRGB after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-      /* Should be an error, but we can cope with it */

-      png_warning(png_ptr, "Out of place sRGB chunk");

-

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))

-   {

-      png_warning(png_ptr, "Duplicate sRGB chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (length != 1)

-   {

-      png_warning(png_ptr, "Incorrect sRGB chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 1);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   intent = buf[0];

-   /* Check for bad intent */

-   if (intent >= PNG_sRGB_INTENT_LAST)

-   {

-      png_warning(png_ptr, "Unknown sRGB intent");

-      return;

-   }

+    int intent;

+    png_byte buf[1];

+

+    png_debug(1, "in png_handle_sRGB");

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before sRGB");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid sRGB after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(png_ptr->mode & PNG_HAVE_PLTE)

+        /* Should be an error, but we can cope with it */

+        png_warning(png_ptr, "Out of place sRGB chunk");

+

+    if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))

+    {

+        png_warning(png_ptr, "Duplicate sRGB chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    if(length != 1)

+    {

+        png_warning(png_ptr, "Incorrect sRGB chunk length");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    png_crc_read(png_ptr, buf, 1);

+    if(png_crc_finish(png_ptr, 0))

+        return;

+

+    intent = buf[0];

+    /* Check for bad intent */

+    if(intent >= PNG_sRGB_INTENT_LAST)

+    {

+        png_warning(png_ptr, "Unknown sRGB intent");

+        return;

+    }

 

 #if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA))

-   {

-   png_fixed_point igamma;

+    if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA))

+    {

+        png_fixed_point igamma;

 #ifdef PNG_FIXED_POINT_SUPPORTED

-      igamma=info_ptr->int_gamma;

+        igamma = info_ptr->int_gamma;

 #else

 #  ifdef PNG_FLOATING_POINT_SUPPORTED

-      igamma=(png_fixed_point)(info_ptr->gamma * 100000.);

+        igamma = (png_fixed_point)(info_ptr->gamma * 100000.);

 #  endif

 #endif

-      if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))

-      {

-         png_warning(png_ptr,

-           "Ignoring incorrect gAMA value when sRGB is also present");

+        if(PNG_OUT_OF_RANGE(igamma, 45500L, 500))

+        {

+            png_warning(png_ptr,

+                        "Ignoring incorrect gAMA value when sRGB is also present");

 #ifdef PNG_CONSOLE_IO_SUPPORTED

 #  ifdef PNG_FIXED_POINT_SUPPORTED

-         fprintf(stderr, "incorrect gamma=(%d/100000)\n",

-            (int)png_ptr->int_gamma);

+            fprintf(stderr, "incorrect gamma=(%d/100000)\n",

+                    (int)png_ptr->int_gamma);

 #  else

 #    ifdef PNG_FLOATING_POINT_SUPPORTED

-         fprintf(stderr, "incorrect gamma=%f\n", png_ptr->gamma);

+            fprintf(stderr, "incorrect gamma=%f\n", png_ptr->gamma);

 #    endif

 #  endif

 #endif

-      }

-   }

+        }

+    }

 #endif /* PNG_READ_gAMA_SUPPORTED */

 

 #ifdef PNG_READ_cHRM_SUPPORTED

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

-      if (PNG_OUT_OF_RANGE(info_ptr->int_x_white, 31270,  1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_y_white, 32900,  1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_x_red,   64000L, 1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_y_red,   33000,  1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_x_green, 30000,  1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_y_green, 60000L, 1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_x_blue,  15000,  1000) ||

-          PNG_OUT_OF_RANGE(info_ptr->int_y_blue,   6000,  1000))

-         {

+    if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

+        if(PNG_OUT_OF_RANGE(info_ptr->int_x_white, 31270,  1000) ||

+           PNG_OUT_OF_RANGE(info_ptr->int_y_white, 32900,  1000) ||

+           PNG_OUT_OF_RANGE(info_ptr->int_x_red,   64000L, 1000) ||

+           PNG_OUT_OF_RANGE(info_ptr->int_y_red,   33000,  1000) ||

+           PNG_OUT_OF_RANGE(info_ptr->int_x_green, 30000,  1000) ||

+           PNG_OUT_OF_RANGE(info_ptr->int_y_green, 60000L, 1000) ||

+           PNG_OUT_OF_RANGE(info_ptr->int_x_blue,  15000,  1000) ||

+           PNG_OUT_OF_RANGE(info_ptr->int_y_blue,   6000,  1000))

+        {

             png_warning(png_ptr,

-              "Ignoring incorrect cHRM value when sRGB is also present");

-         }

+                        "Ignoring incorrect cHRM value when sRGB is also present");

+        }

 #endif /* PNG_FIXED_POINT_SUPPORTED */

 #endif /* PNG_READ_cHRM_SUPPORTED */

 

-   png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);

+    png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);

 }

 #endif /* PNG_READ_sRGB_SUPPORTED */

 

@@ -1015,130 +1015,130 @@ void /* PRIVATE */
 png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 /* Note: this does not properly handle chunks that are > 64K under DOS */

 {

-   png_byte compression_type;

-   png_bytep pC;

-   png_charp profile;

-   png_uint_32 skip = 0;

-   png_uint_32 profile_size, profile_length;

-   png_size_t slength, prefix_length, data_length;

-

-   png_debug(1, "in png_handle_iCCP");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before iCCP");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid iCCP after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->mode & PNG_HAVE_PLTE)

-      /* Should be an error, but we can cope with it */

-      png_warning(png_ptr, "Out of place iCCP chunk");

-

-   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP))

-   {

-      png_warning(png_ptr, "Duplicate iCCP chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

+    png_byte compression_type;

+    png_bytep pC;

+    png_charp profile;

+    png_uint_32 skip = 0;

+    png_uint_32 profile_size, profile_length;

+    png_size_t slength, prefix_length, data_length;

+

+    png_debug(1, "in png_handle_iCCP");

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before iCCP");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid iCCP after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(png_ptr->mode & PNG_HAVE_PLTE)

+        /* Should be an error, but we can cope with it */

+        png_warning(png_ptr, "Out of place iCCP chunk");

+

+    if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP))

+    {

+        png_warning(png_ptr, "Duplicate iCCP chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

 

 #ifdef PNG_MAX_MALLOC_64K

-   if (length > (png_uint_32)65535L)

-   {

-      png_warning(png_ptr, "iCCP chunk too large to fit in memory");

-      skip = length - (png_uint_32)65535L;

-      length = (png_uint_32)65535L;

-   }

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-

-   if (png_crc_finish(png_ptr, skip))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00;

-

-   for (profile = png_ptr->chunkdata; *profile; profile++)

-      /* Empty loop to find end of name */ ;

-

-   ++profile;

-

-   /* There should be at least one zero (the compression type byte)

-    * following the separator, and we should be on it

-    */

-   if ( profile >= png_ptr->chunkdata + slength - 1)

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      png_warning(png_ptr, "Malformed iCCP chunk");

-      return;

-   }

-

-   /* Compression_type should always be zero */

-   compression_type = *profile++;

-   if (compression_type)

-   {

-      png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");

-      compression_type = 0x00;  /* Reset it to zero (libpng-1.0.6 through 1.0.8

+    if(length > (png_uint_32)65535L)

+    {

+        png_warning(png_ptr, "iCCP chunk too large to fit in memory");

+        skip = length - (png_uint_32)65535L;

+        length = (png_uint_32)65535L;

+    }

+#endif

+

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);

+    slength = (png_size_t)length;

+    png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

+

+    if(png_crc_finish(png_ptr, skip))

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+

+    png_ptr->chunkdata[slength] = 0x00;

+

+    for(profile = png_ptr->chunkdata; *profile; profile++)

+        /* Empty loop to find end of name */ ;

+

+    ++profile;

+

+    /* There should be at least one zero (the compression type byte)

+     * following the separator, and we should be on it

+     */

+    if(profile >= png_ptr->chunkdata + slength - 1)

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        png_warning(png_ptr, "Malformed iCCP chunk");

+        return;

+    }

+

+    /* Compression_type should always be zero */

+    compression_type = *profile++;

+    if(compression_type)

+    {

+        png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");

+        compression_type = 0x00;  /* Reset it to zero (libpng-1.0.6 through 1.0.8

                                  wrote nonzero) */

-   }

-

-   prefix_length = profile - png_ptr->chunkdata;

-   png_decompress_chunk(png_ptr, compression_type,

-     slength, prefix_length, &data_length);

-

-   profile_length = data_length - prefix_length;

-

-   if ( prefix_length > data_length || profile_length < 4)

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      png_warning(png_ptr, "Profile size field missing from iCCP chunk");

-      return;

-   }

-

-   /* Check the profile_size recorded in the first 32 bits of the ICC profile */

-   pC = (png_bytep)(png_ptr->chunkdata + prefix_length);

-   profile_size = ((*(pC    ))<<24) |

-                  ((*(pC + 1))<<16) |

-                  ((*(pC + 2))<< 8) |

-                  ((*(pC + 3))    );

-

-   if (profile_size < profile_length)

-      profile_length = profile_size;

-

-   if (profile_size > profile_length)

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      png_warning(png_ptr, "Ignoring truncated iCCP profile");

+    }

+

+    prefix_length = profile - png_ptr->chunkdata;

+    png_decompress_chunk(png_ptr, compression_type,

+                         slength, prefix_length, &data_length);

+

+    profile_length = data_length - prefix_length;

+

+    if(prefix_length > data_length || profile_length < 4)

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        png_warning(png_ptr, "Profile size field missing from iCCP chunk");

+        return;

+    }

+

+    /* Check the profile_size recorded in the first 32 bits of the ICC profile */

+    pC = (png_bytep)(png_ptr->chunkdata + prefix_length);

+    profile_size = ((*(pC)) << 24) |

+                   ((*(pC + 1)) << 16) |

+                   ((*(pC + 2)) << 8) |

+                   ((*(pC + 3)));

+

+    if(profile_size < profile_length)

+        profile_length = profile_size;

+

+    if(profile_size > profile_length)

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        png_warning(png_ptr, "Ignoring truncated iCCP profile");

 #ifdef PNG_STDIO_SUPPORTED

- {

-    char umsg[50];

-

-    png_snprintf(umsg, 50, "declared profile size = %lu",

-        (unsigned long)profile_size);

-    png_warning(png_ptr, umsg);

-    png_snprintf(umsg, 50, "actual profile length = %lu",

-        (unsigned long)profile_length);

-    png_warning(png_ptr, umsg);

- }

-#endif

-      return;

-   }

-

-   png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,

-     compression_type, png_ptr->chunkdata + prefix_length, profile_length);

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

+        {

+            char umsg[50];

+

+            png_snprintf(umsg, 50, "declared profile size = %lu",

+                         (unsigned long)profile_size);

+            png_warning(png_ptr, umsg);

+            png_snprintf(umsg, 50, "actual profile length = %lu",

+                         (unsigned long)profile_length);

+            png_warning(png_ptr, umsg);

+        }

+#endif

+        return;

+    }

+

+    png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,

+                 compression_type, png_ptr->chunkdata + prefix_length, profile_length);

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = NULL;

 }

 #endif /* PNG_READ_iCCP_SUPPORTED */

 

@@ -1147,161 +1147,171 @@ void /* PRIVATE */
 png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 /* Note: this does not properly handle chunks that are > 64K under DOS */

 {

-   png_bytep entry_start;

-   png_sPLT_t new_palette;

+    png_bytep entry_start;

+    png_sPLT_t new_palette;

 #ifdef PNG_POINTER_INDEXING_SUPPORTED

-   png_sPLT_entryp pp;

+    png_sPLT_entryp pp;

 #endif

-   int data_length, entry_size, i;

-   png_uint_32 skip = 0;

-   png_size_t slength;

+    int data_length, entry_size, i;

+    png_uint_32 skip = 0;

+    png_size_t slength;

 

-   png_debug(1, "in png_handle_sPLT");

+    png_debug(1, "in png_handle_sPLT");

 

 #ifdef PNG_USER_LIMITS_SUPPORTED

 

-   if (png_ptr->user_chunk_cache_max != 0)

-   {

-      if (png_ptr->user_chunk_cache_max == 1)

-      {

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      if (--png_ptr->user_chunk_cache_max == 1)

-      {

-         png_warning(png_ptr, "No space in chunk cache for sPLT");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-   }

-#endif

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before sPLT");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid sPLT after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

+    if(png_ptr->user_chunk_cache_max != 0)

+    {

+        if(png_ptr->user_chunk_cache_max == 1)

+        {

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+        if(--png_ptr->user_chunk_cache_max == 1)

+        {

+            png_warning(png_ptr, "No space in chunk cache for sPLT");

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+    }

+#endif

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before sPLT");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid sPLT after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

 

 #ifdef PNG_MAX_MALLOC_64K

-   if (length > (png_uint_32)65535L)

-   {

-      png_warning(png_ptr, "sPLT chunk too large to fit in memory");

-      skip = length - (png_uint_32)65535L;

-      length = (png_uint_32)65535L;

-   }

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-

-   if (png_crc_finish(png_ptr, skip))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00;

-

-   for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start;

-       entry_start++)

-      /* Empty loop to find end of name */ ;

-   ++entry_start;

-

-   /* A sample depth should follow the separator, and we should be on it  */

-   if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      png_warning(png_ptr, "malformed sPLT chunk");

-      return;

-   }

-

-   new_palette.depth = *entry_start++;

-   entry_size = (new_palette.depth == 8 ? 6 : 10);

-   data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));

-

-   /* Integrity-check the data length */

-   if (data_length % entry_size)

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      png_warning(png_ptr, "sPLT chunk has bad length");

-      return;

-   }

-

-   new_palette.nentries = (png_int_32) ( data_length / entry_size);

-   if ((png_uint_32) new_palette.nentries >

-       (png_uint_32) (PNG_SIZE_MAX / png_sizeof(png_sPLT_entry)))

-   {

-       png_warning(png_ptr, "sPLT chunk too long");

-       return;

-   }

-   new_palette.entries = (png_sPLT_entryp)png_malloc_warn(

-       png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));

-   if (new_palette.entries == NULL)

-   {

-       png_warning(png_ptr, "sPLT chunk requires too much memory");

-       return;

-   }

+    if(length > (png_uint_32)65535L)

+    {

+        png_warning(png_ptr, "sPLT chunk too large to fit in memory");

+        skip = length - (png_uint_32)65535L;

+        length = (png_uint_32)65535L;

+    }

+#endif

+

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);

+    slength = (png_size_t)length;

+    png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

+

+    if(png_crc_finish(png_ptr, skip))

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+

+    png_ptr->chunkdata[slength] = 0x00;

+

+    for(entry_start = (png_bytep)png_ptr->chunkdata; *entry_start;

+        entry_start++)

+        /* Empty loop to find end of name */ ;

+    ++entry_start;

+

+    /* A sample depth should follow the separator, and we should be on it  */

+    if(entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        png_warning(png_ptr, "malformed sPLT chunk");

+        return;

+    }

+

+    new_palette.depth = *entry_start++;

+    entry_size = (new_palette.depth == 8 ? 6 : 10);

+    data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));

+

+    /* Integrity-check the data length */

+    if(data_length % entry_size)

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        png_warning(png_ptr, "sPLT chunk has bad length");

+        return;

+    }

+

+    new_palette.nentries = (png_int_32)(data_length / entry_size);

+    if((png_uint_32) new_palette.nentries >

+       (png_uint_32)(PNG_SIZE_MAX / png_sizeof(png_sPLT_entry)))

+    {

+        png_warning(png_ptr, "sPLT chunk too long");

+        return;

+    }

+    new_palette.entries = (png_sPLT_entryp)png_malloc_warn(

+                              png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));

+    if(new_palette.entries == NULL)

+    {

+        png_warning(png_ptr, "sPLT chunk requires too much memory");

+        return;

+    }

 

 #ifdef PNG_POINTER_INDEXING_SUPPORTED

-   for (i = 0; i < new_palette.nentries; i++)

-   {

-      pp = new_palette.entries + i;

-

-      if (new_palette.depth == 8)

-      {

-          pp->red = *entry_start++;

-          pp->green = *entry_start++;

-          pp->blue = *entry_start++;

-          pp->alpha = *entry_start++;

-      }

-      else

-      {

-          pp->red   = png_get_uint_16(entry_start); entry_start += 2;

-          pp->green = png_get_uint_16(entry_start); entry_start += 2;

-          pp->blue  = png_get_uint_16(entry_start); entry_start += 2;

-          pp->alpha = png_get_uint_16(entry_start); entry_start += 2;

-      }

-      pp->frequency = png_get_uint_16(entry_start); entry_start += 2;

-   }

+    for(i = 0; i < new_palette.nentries; i++)

+    {

+        pp = new_palette.entries + i;

+

+        if(new_palette.depth == 8)

+        {

+            pp->red = *entry_start++;

+            pp->green = *entry_start++;

+            pp->blue = *entry_start++;

+            pp->alpha = *entry_start++;

+        }

+        else

+        {

+            pp->red   = png_get_uint_16(entry_start);

+            entry_start += 2;

+            pp->green = png_get_uint_16(entry_start);

+            entry_start += 2;

+            pp->blue  = png_get_uint_16(entry_start);

+            entry_start += 2;

+            pp->alpha = png_get_uint_16(entry_start);

+            entry_start += 2;

+        }

+        pp->frequency = png_get_uint_16(entry_start);

+        entry_start += 2;

+    }

 #else

-   pp = new_palette.entries;

-   for (i = 0; i < new_palette.nentries; i++)

-   {

-

-      if (new_palette.depth == 8)

-      {

-          pp[i].red   = *entry_start++;

-          pp[i].green = *entry_start++;

-          pp[i].blue  = *entry_start++;

-          pp[i].alpha = *entry_start++;

-      }

-      else

-      {

-          pp[i].red   = png_get_uint_16(entry_start); entry_start += 2;

-          pp[i].green = png_get_uint_16(entry_start); entry_start += 2;

-          pp[i].blue  = png_get_uint_16(entry_start); entry_start += 2;

-          pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2;

-      }

-      pp->frequency = png_get_uint_16(entry_start); entry_start += 2;

-   }

-#endif

-

-   /* Discard all chunk data except the name and stash that */

-   new_palette.name = png_ptr->chunkdata;

-

-   png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-   png_free(png_ptr, new_palette.entries);

+    pp = new_palette.entries;

+    for(i = 0; i < new_palette.nentries; i++)

+    {

+

+        if(new_palette.depth == 8)

+        {

+            pp[i].red   = *entry_start++;

+            pp[i].green = *entry_start++;

+            pp[i].blue  = *entry_start++;

+            pp[i].alpha = *entry_start++;

+        }

+        else

+        {

+            pp[i].red   = png_get_uint_16(entry_start);

+            entry_start += 2;

+            pp[i].green = png_get_uint_16(entry_start);

+            entry_start += 2;

+            pp[i].blue  = png_get_uint_16(entry_start);

+            entry_start += 2;

+            pp[i].alpha = png_get_uint_16(entry_start);

+            entry_start += 2;

+        }

+        pp->frequency = png_get_uint_16(entry_start);

+        entry_start += 2;

+    }

+#endif

+

+    /* Discard all chunk data except the name and stash that */

+    new_palette.name = png_ptr->chunkdata;

+

+    png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);

+

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = NULL;

+    png_free(png_ptr, new_palette.entries);

 }

 #endif /* PNG_READ_sPLT_SUPPORTED */

 

@@ -1309,94 +1319,94 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_byte readbuf[PNG_MAX_PALETTE_LENGTH];

-

-   png_debug(1, "in png_handle_tRNS");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before tRNS");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid tRNS after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

-   {

-      png_warning(png_ptr, "Duplicate tRNS chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

-   {

-      png_byte buf[2];

-

-      if (length != 2)

-      {

-         png_warning(png_ptr, "Incorrect tRNS chunk length");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-

-      png_crc_read(png_ptr, buf, 2);

-      png_ptr->num_trans = 1;

-      png_ptr->trans_color.gray = png_get_uint_16(buf);

-   }

-   else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

-   {

-      png_byte buf[6];

-

-      if (length != 6)

-      {

-         png_warning(png_ptr, "Incorrect tRNS chunk length");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      png_crc_read(png_ptr, buf, (png_size_t)length);

-      png_ptr->num_trans = 1;

-      png_ptr->trans_color.red = png_get_uint_16(buf);

-      png_ptr->trans_color.green = png_get_uint_16(buf + 2);

-      png_ptr->trans_color.blue = png_get_uint_16(buf + 4);

-   }

-   else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      if (!(png_ptr->mode & PNG_HAVE_PLTE))

-      {

-         /* Should be an error, but we can cope with it. */

-         png_warning(png_ptr, "Missing PLTE before tRNS");

-      }

-      if (length > (png_uint_32)png_ptr->num_palette ||

-          length > PNG_MAX_PALETTE_LENGTH)

-      {

-         png_warning(png_ptr, "Incorrect tRNS chunk length");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      if (length == 0)

-      {

-         png_warning(png_ptr, "Zero length tRNS chunk");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      png_crc_read(png_ptr, readbuf, (png_size_t)length);

-      png_ptr->num_trans = (png_uint_16)length;

-   }

-   else

-   {

-      png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (png_crc_finish(png_ptr, 0))

-   {

-      png_ptr->num_trans = 0;

-      return;

-   }

-

-   png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,

-      &(png_ptr->trans_color));

+    png_byte readbuf[PNG_MAX_PALETTE_LENGTH];

+

+    png_debug(1, "in png_handle_tRNS");

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before tRNS");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid tRNS after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

+    {

+        png_warning(png_ptr, "Duplicate tRNS chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    if(png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

+    {

+        png_byte buf[2];

+

+        if(length != 2)

+        {

+            png_warning(png_ptr, "Incorrect tRNS chunk length");

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+

+        png_crc_read(png_ptr, buf, 2);

+        png_ptr->num_trans = 1;

+        png_ptr->trans_color.gray = png_get_uint_16(buf);

+    }

+    else if(png_ptr->color_type == PNG_COLOR_TYPE_RGB)

+    {

+        png_byte buf[6];

+

+        if(length != 6)

+        {

+            png_warning(png_ptr, "Incorrect tRNS chunk length");

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+        png_crc_read(png_ptr, buf, (png_size_t)length);

+        png_ptr->num_trans = 1;

+        png_ptr->trans_color.red = png_get_uint_16(buf);

+        png_ptr->trans_color.green = png_get_uint_16(buf + 2);

+        png_ptr->trans_color.blue = png_get_uint_16(buf + 4);

+    }

+    else if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+    {

+        if(!(png_ptr->mode & PNG_HAVE_PLTE))

+        {

+            /* Should be an error, but we can cope with it. */

+            png_warning(png_ptr, "Missing PLTE before tRNS");

+        }

+        if(length > (png_uint_32)png_ptr->num_palette ||

+           length > PNG_MAX_PALETTE_LENGTH)

+        {

+            png_warning(png_ptr, "Incorrect tRNS chunk length");

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+        if(length == 0)

+        {

+            png_warning(png_ptr, "Zero length tRNS chunk");

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+        png_crc_read(png_ptr, readbuf, (png_size_t)length);

+        png_ptr->num_trans = (png_uint_16)length;

+    }

+    else

+    {

+        png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    if(png_crc_finish(png_ptr, 0))

+    {

+        png_ptr->num_trans = 0;

+        return;

+    }

+

+    png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,

+                 &(png_ptr->trans_color));

 }

 #endif

 

@@ -1404,88 +1414,88 @@ png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_size_t truelen;

-   png_byte buf[6];

-

-   png_debug(1, "in png_handle_bKGD");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before bKGD");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid bKGD after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

+    png_size_t truelen;

+    png_byte buf[6];

+

+    png_debug(1, "in png_handle_bKGD");

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before bKGD");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid bKGD after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

             !(png_ptr->mode & PNG_HAVE_PLTE))

-   {

-      png_warning(png_ptr, "Missing PLTE before bKGD");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD))

-   {

-      png_warning(png_ptr, "Duplicate bKGD chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      truelen = 1;

-   else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)

-      truelen = 6;

-   else

-      truelen = 2;

-

-   if (length != truelen)

-   {

-      png_warning(png_ptr, "Incorrect bKGD chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, truelen);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   /* We convert the index value into RGB components so that we can allow

-    * arbitrary RGB values for background when we have transparency, and

-    * so it is easy to determine the RGB values of the background color

-    * from the info_ptr struct. */

-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      png_ptr->background.index = buf[0];

-      if (info_ptr && info_ptr->num_palette)

-      {

-          if (buf[0] >= info_ptr->num_palette)

-          {

-             png_warning(png_ptr, "Incorrect bKGD chunk index value");

-             return;

-          }

-          png_ptr->background.red =

-             (png_uint_16)png_ptr->palette[buf[0]].red;

-          png_ptr->background.green =

-             (png_uint_16)png_ptr->palette[buf[0]].green;

-          png_ptr->background.blue =

-             (png_uint_16)png_ptr->palette[buf[0]].blue;

-      }

-   }

-   else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */

-   {

-      png_ptr->background.red =

-      png_ptr->background.green =

-      png_ptr->background.blue =

-      png_ptr->background.gray = png_get_uint_16(buf);

-   }

-   else

-   {

-      png_ptr->background.red = png_get_uint_16(buf);

-      png_ptr->background.green = png_get_uint_16(buf + 2);

-      png_ptr->background.blue = png_get_uint_16(buf + 4);

-   }

-

-   png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));

+    {

+        png_warning(png_ptr, "Missing PLTE before bKGD");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD))

+    {

+        png_warning(png_ptr, "Duplicate bKGD chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+        truelen = 1;

+    else if(png_ptr->color_type & PNG_COLOR_MASK_COLOR)

+        truelen = 6;

+    else

+        truelen = 2;

+

+    if(length != truelen)

+    {

+        png_warning(png_ptr, "Incorrect bKGD chunk length");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    png_crc_read(png_ptr, buf, truelen);

+    if(png_crc_finish(png_ptr, 0))

+        return;

+

+    /* We convert the index value into RGB components so that we can allow

+     * arbitrary RGB values for background when we have transparency, and

+     * so it is easy to determine the RGB values of the background color

+     * from the info_ptr struct. */

+    if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+    {

+        png_ptr->background.index = buf[0];

+        if(info_ptr && info_ptr->num_palette)

+        {

+            if(buf[0] >= info_ptr->num_palette)

+            {

+                png_warning(png_ptr, "Incorrect bKGD chunk index value");

+                return;

+            }

+            png_ptr->background.red =

+                (png_uint_16)png_ptr->palette[buf[0]].red;

+            png_ptr->background.green =

+                (png_uint_16)png_ptr->palette[buf[0]].green;

+            png_ptr->background.blue =

+                (png_uint_16)png_ptr->palette[buf[0]].blue;

+        }

+    }

+    else if(!(png_ptr->color_type & PNG_COLOR_MASK_COLOR))  /* GRAY */

+    {

+        png_ptr->background.red =

+            png_ptr->background.green =

+                png_ptr->background.blue =

+                    png_ptr->background.gray = png_get_uint_16(buf);

+    }

+    else

+    {

+        png_ptr->background.red = png_get_uint_16(buf);

+        png_ptr->background.green = png_get_uint_16(buf + 2);

+        png_ptr->background.blue = png_get_uint_16(buf + 4);

+    }

+

+    png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));

 }

 #endif

 

@@ -1493,53 +1503,53 @@ png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   unsigned int num, i;

-   png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];

-

-   png_debug(1, "in png_handle_hIST");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before hIST");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid hIST after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (!(png_ptr->mode & PNG_HAVE_PLTE))

-   {

-      png_warning(png_ptr, "Missing PLTE before hIST");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST))

-   {

-      png_warning(png_ptr, "Duplicate hIST chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   num = length / 2 ;

-   if (num != (unsigned int) png_ptr->num_palette || num >

-      (unsigned int) PNG_MAX_PALETTE_LENGTH)

-   {

-      png_warning(png_ptr, "Incorrect hIST chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   for (i = 0; i < num; i++)

-   {

-      png_byte buf[2];

-

-      png_crc_read(png_ptr, buf, 2);

-      readbuf[i] = png_get_uint_16(buf);

-   }

-

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   png_set_hIST(png_ptr, info_ptr, readbuf);

+    unsigned int num, i;

+    png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];

+

+    png_debug(1, "in png_handle_hIST");

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before hIST");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid hIST after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(!(png_ptr->mode & PNG_HAVE_PLTE))

+    {

+        png_warning(png_ptr, "Missing PLTE before hIST");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST))

+    {

+        png_warning(png_ptr, "Duplicate hIST chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    num = length / 2 ;

+    if(num != (unsigned int) png_ptr->num_palette || num >

+       (unsigned int) PNG_MAX_PALETTE_LENGTH)

+    {

+        png_warning(png_ptr, "Incorrect hIST chunk length");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

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

+    {

+        png_byte buf[2];

+

+        png_crc_read(png_ptr, buf, 2);

+        readbuf[i] = png_get_uint_16(buf);

+    }

+

+    if(png_crc_finish(png_ptr, 0))

+        return;

+

+    png_set_hIST(png_ptr, info_ptr, readbuf);

 }

 #endif

 

@@ -1547,42 +1557,42 @@ png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_byte buf[9];

-   png_uint_32 res_x, res_y;

-   int unit_type;

-

-   png_debug(1, "in png_handle_pHYs");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before pHYs");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid pHYs after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))

-   {

-      png_warning(png_ptr, "Duplicate pHYs chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (length != 9)

-   {

-      png_warning(png_ptr, "Incorrect pHYs chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 9);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   res_x = png_get_uint_32(buf);

-   res_y = png_get_uint_32(buf + 4);

-   unit_type = buf[8];

-   png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);

+    png_byte buf[9];

+    png_uint_32 res_x, res_y;

+    int unit_type;

+

+    png_debug(1, "in png_handle_pHYs");

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before pHYs");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid pHYs after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))

+    {

+        png_warning(png_ptr, "Duplicate pHYs chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    if(length != 9)

+    {

+        png_warning(png_ptr, "Incorrect pHYs chunk length");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    png_crc_read(png_ptr, buf, 9);

+    if(png_crc_finish(png_ptr, 0))

+        return;

+

+    res_x = png_get_uint_32(buf);

+    res_y = png_get_uint_32(buf + 4);

+    unit_type = buf[8];

+    png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);

 }

 #endif

 

@@ -1590,42 +1600,42 @@ png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_byte buf[9];

-   png_int_32 offset_x, offset_y;

-   int unit_type;

-

-   png_debug(1, "in png_handle_oFFs");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before oFFs");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid oFFs after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))

-   {

-      png_warning(png_ptr, "Duplicate oFFs chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (length != 9)

-   {

-      png_warning(png_ptr, "Incorrect oFFs chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 9);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   offset_x = png_get_int_32(buf);

-   offset_y = png_get_int_32(buf + 4);

-   unit_type = buf[8];

-   png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);

+    png_byte buf[9];

+    png_int_32 offset_x, offset_y;

+    int unit_type;

+

+    png_debug(1, "in png_handle_oFFs");

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before oFFs");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid oFFs after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))

+    {

+        png_warning(png_ptr, "Duplicate oFFs chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    if(length != 9)

+    {

+        png_warning(png_ptr, "Incorrect oFFs chunk length");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    png_crc_read(png_ptr, buf, 9);

+    if(png_crc_finish(png_ptr, 0))

+        return;

+

+    offset_x = png_get_int_32(buf);

+    offset_y = png_get_int_32(buf + 4);

+    unit_type = buf[8];

+    png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);

 }

 #endif

 

@@ -1634,132 +1644,132 @@ png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_int_32 X0, X1;

-   png_byte type, nparams;

-   png_charp buf, units, endptr;

-   png_charpp params;

-   png_size_t slength;

-   int i;

-

-   png_debug(1, "in png_handle_pCAL");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before pCAL");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid pCAL after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL))

-   {

-      png_warning(png_ptr, "Duplicate pCAL chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)",

-      length + 1);

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

-   if (png_ptr->chunkdata == NULL)

-     {

-       png_warning(png_ptr, "No memory for pCAL purpose");

-       return;

-     }

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-

-   if (png_crc_finish(png_ptr, 0))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */

-

-   png_debug(3, "Finding end of pCAL purpose string");

-   for (buf = png_ptr->chunkdata; *buf; buf++)

-      /* Empty loop */ ;

-

-   endptr = png_ptr->chunkdata + slength;

-

-   /* We need to have at least 12 bytes after the purpose string

-      in order to get the parameter information. */

-   if (endptr <= buf + 12)

-   {

-      png_warning(png_ptr, "Invalid pCAL data");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_debug(3, "Reading pCAL X0, X1, type, nparams, and units");

-   X0 = png_get_int_32((png_bytep)buf+1);

-   X1 = png_get_int_32((png_bytep)buf+5);

-   type = buf[9];

-   nparams = buf[10];

-   units = buf + 11;

-

-   png_debug(3, "Checking pCAL equation type and number of parameters");

-   /* Check that we have the right number of parameters for known

-      equation types. */

-   if ((type == PNG_EQUATION_LINEAR && nparams != 2) ||

+    png_int_32 X0, X1;

+    png_byte type, nparams;

+    png_charp buf, units, endptr;

+    png_charpp params;

+    png_size_t slength;

+    int i;

+

+    png_debug(1, "in png_handle_pCAL");

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before pCAL");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid pCAL after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL))

+    {

+        png_warning(png_ptr, "Duplicate pCAL chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)",

+               length + 1);

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

+    if(png_ptr->chunkdata == NULL)

+    {

+        png_warning(png_ptr, "No memory for pCAL purpose");

+        return;

+    }

+    slength = (png_size_t)length;

+    png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

+

+    if(png_crc_finish(png_ptr, 0))

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+

+    png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */

+

+    png_debug(3, "Finding end of pCAL purpose string");

+    for(buf = png_ptr->chunkdata; *buf; buf++)

+        /* Empty loop */ ;

+

+    endptr = png_ptr->chunkdata + slength;

+

+    /* We need to have at least 12 bytes after the purpose string

+       in order to get the parameter information. */

+    if(endptr <= buf + 12)

+    {

+        png_warning(png_ptr, "Invalid pCAL data");

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+

+    png_debug(3, "Reading pCAL X0, X1, type, nparams, and units");

+    X0 = png_get_int_32((png_bytep)buf + 1);

+    X1 = png_get_int_32((png_bytep)buf + 5);

+    type = buf[9];

+    nparams = buf[10];

+    units = buf + 11;

+

+    png_debug(3, "Checking pCAL equation type and number of parameters");

+    /* Check that we have the right number of parameters for known

+       equation types. */

+    if((type == PNG_EQUATION_LINEAR && nparams != 2) ||

        (type == PNG_EQUATION_BASE_E && nparams != 3) ||

        (type == PNG_EQUATION_ARBITRARY && nparams != 3) ||

        (type == PNG_EQUATION_HYPERBOLIC && nparams != 4))

-   {

-      png_warning(png_ptr, "Invalid pCAL parameters for equation type");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-   else if (type >= PNG_EQUATION_LAST)

-   {

-      png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");

-   }

-

-   for (buf = units; *buf; buf++)

-      /* Empty loop to move past the units string. */ ;

-

-   png_debug(3, "Allocating pCAL parameters array");

-   params = (png_charpp)png_malloc_warn(png_ptr,

-      (png_size_t)(nparams * png_sizeof(png_charp)));

-   if (params == NULL)

-     {

-       png_free(png_ptr, png_ptr->chunkdata);

-       png_ptr->chunkdata = NULL;

-       png_warning(png_ptr, "No memory for pCAL params");

-       return;

-     }

-

-   /* Get pointers to the start of each parameter string. */

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

-   {

-      buf++; /* Skip the null string terminator from previous parameter. */

-

-      png_debug1(3, "Reading pCAL parameter %d", i);

-      for (params[i] = buf; buf <= endptr && *buf != 0x00; buf++)

-         /* Empty loop to move past each parameter string */ ;

-

-      /* Make sure we haven't run out of data yet */

-      if (buf > endptr)

-      {

-         png_warning(png_ptr, "Invalid pCAL data");

-         png_free(png_ptr, png_ptr->chunkdata);

-         png_ptr->chunkdata = NULL;

-         png_free(png_ptr, params);

-         return;

-      }

-   }

-

-   png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,

-      units, params);

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-   png_free(png_ptr, params);

+    {

+        png_warning(png_ptr, "Invalid pCAL parameters for equation type");

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+    else if(type >= PNG_EQUATION_LAST)

+    {

+        png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");

+    }

+

+    for(buf = units; *buf; buf++)

+        /* Empty loop to move past the units string. */ ;

+

+    png_debug(3, "Allocating pCAL parameters array");

+    params = (png_charpp)png_malloc_warn(png_ptr,

+                                         (png_size_t)(nparams * png_sizeof(png_charp)));

+    if(params == NULL)

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        png_warning(png_ptr, "No memory for pCAL params");

+        return;

+    }

+

+    /* Get pointers to the start of each parameter string. */

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

+    {

+        buf++; /* Skip the null string terminator from previous parameter. */

+

+        png_debug1(3, "Reading pCAL parameter %d", i);

+        for(params[i] = buf; buf <= endptr && *buf != 0x00; buf++)

+            /* Empty loop to move past each parameter string */ ;

+

+        /* Make sure we haven't run out of data yet */

+        if(buf > endptr)

+        {

+            png_warning(png_ptr, "Invalid pCAL data");

+            png_free(png_ptr, png_ptr->chunkdata);

+            png_ptr->chunkdata = NULL;

+            png_free(png_ptr, params);

+            return;

+        }

+    }

+

+    png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,

+                 units, params);

+

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = NULL;

+    png_free(png_ptr, params);

 }

 #endif

 

@@ -1768,140 +1778,140 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_charp ep;

+    png_charp ep;

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   double width, height;

-   png_charp vp;

+    double width, height;

+    png_charp vp;

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   png_charp swidth, sheight;

-#endif

-#endif

-   png_size_t slength;

-

-   png_debug(1, "in png_handle_sCAL");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before sCAL");

-   else if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      png_warning(png_ptr, "Invalid sCAL after IDAT");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL))

-   {

-      png_warning(png_ptr, "Duplicate sCAL chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)",

-      length + 1);

-   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

-   if (png_ptr->chunkdata == NULL)

-   {

-      png_warning(png_ptr, "Out of memory while processing sCAL chunk");

-      return;

-   }

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-

-   if (png_crc_finish(png_ptr, 0))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */

-

-   ep = png_ptr->chunkdata + 1;        /* Skip unit byte */

+    png_charp swidth, sheight;

+#endif

+#endif

+    png_size_t slength;

+

+    png_debug(1, "in png_handle_sCAL");

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before sCAL");

+    else if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        png_warning(png_ptr, "Invalid sCAL after IDAT");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+    else if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL))

+    {

+        png_warning(png_ptr, "Duplicate sCAL chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)",

+               length + 1);

+    png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

+    if(png_ptr->chunkdata == NULL)

+    {

+        png_warning(png_ptr, "Out of memory while processing sCAL chunk");

+        return;

+    }

+    slength = (png_size_t)length;

+    png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

+

+    if(png_crc_finish(png_ptr, 0))

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+

+    png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */

+

+    ep = png_ptr->chunkdata + 1;        /* Skip unit byte */

 

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   width = png_strtod(png_ptr, ep, &vp);

-   if (*vp)

-   {

-      png_warning(png_ptr, "malformed width string in sCAL chunk");

-      return;

-   }

+    width = png_strtod(png_ptr, ep, &vp);

+    if(*vp)

+    {

+        png_warning(png_ptr, "malformed width string in sCAL chunk");

+        return;

+    }

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);

-   if (swidth == NULL)

-   {

-      png_warning(png_ptr, "Out of memory while processing sCAL chunk width");

-      return;

-   }

-   png_memcpy(swidth, ep, png_strlen(ep));

+    swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);

+    if(swidth == NULL)

+    {

+        png_warning(png_ptr, "Out of memory while processing sCAL chunk width");

+        return;

+    }

+    png_memcpy(swidth, ep, png_strlen(ep));

 #endif

 #endif

 

-   for (ep = png_ptr->chunkdata; *ep; ep++)

-      /* Empty loop */ ;

-   ep++;

+    for(ep = png_ptr->chunkdata; *ep; ep++)

+        /* Empty loop */ ;

+    ep++;

 

-   if (png_ptr->chunkdata + slength < ep)

-   {

-      png_warning(png_ptr, "Truncated sCAL chunk");

+    if(png_ptr->chunkdata + slength < ep)

+    {

+        png_warning(png_ptr, "Truncated sCAL chunk");

 #if defined(PNG_FIXED_POINT_SUPPORTED) && \

     !defined(PNG_FLOATING_POINT_SUPPORTED)

-      png_free(png_ptr, swidth);

+        png_free(png_ptr, swidth);

 #endif

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

 

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   height = png_strtod(png_ptr, ep, &vp);

-   if (*vp)

-   {

-      png_warning(png_ptr, "malformed height string in sCAL chunk");

-      return;

-   }

+    height = png_strtod(png_ptr, ep, &vp);

+    if(*vp)

+    {

+        png_warning(png_ptr, "malformed height string in sCAL chunk");

+        return;

+    }

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);

-   if (sheight == NULL)

-   {

-      png_warning(png_ptr, "Out of memory while processing sCAL chunk height");

-      return;

-   }

-   png_memcpy(sheight, ep, png_strlen(ep));

+    sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);

+    if(sheight == NULL)

+    {

+        png_warning(png_ptr, "Out of memory while processing sCAL chunk height");

+        return;

+    }

+    png_memcpy(sheight, ep, png_strlen(ep));

 #endif

 #endif

 

-   if (png_ptr->chunkdata + slength < ep

+    if(png_ptr->chunkdata + slength < ep

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-      || width <= 0. || height <= 0.

+       || width <= 0. || height <= 0.

 #endif

       )

-   {

-      png_warning(png_ptr, "Invalid sCAL data");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

+    {

+        png_warning(png_ptr, "Invalid sCAL data");

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

 #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)

-      png_free(png_ptr, swidth);

-      png_free(png_ptr, sheight);

+        png_free(png_ptr, swidth);

+        png_free(png_ptr, sheight);

 #endif

-      return;

-   }

+        return;

+    }

 

 

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   png_set_sCAL(png_ptr, info_ptr, png_ptr->chunkdata[0], width, height);

+    png_set_sCAL(png_ptr, info_ptr, png_ptr->chunkdata[0], width, height);

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], swidth, sheight);

+    png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], swidth, sheight);

 #endif

 #endif

 

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = NULL;

 #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)

-   png_free(png_ptr, swidth);

-   png_free(png_ptr, sheight);

+    png_free(png_ptr, swidth);

+    png_free(png_ptr, sheight);

 #endif

 }

 #endif

@@ -1910,42 +1920,42 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_byte buf[7];

-   png_time mod_time;

-

-   png_debug(1, "in png_handle_tIME");

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Out of place tIME chunk");

-   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME))

-   {

-      png_warning(png_ptr, "Duplicate tIME chunk");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   if (png_ptr->mode & PNG_HAVE_IDAT)

-      png_ptr->mode |= PNG_AFTER_IDAT;

-

-   if (length != 7)

-   {

-      png_warning(png_ptr, "Incorrect tIME chunk length");

-      png_crc_finish(png_ptr, length);

-      return;

-   }

-

-   png_crc_read(png_ptr, buf, 7);

-   if (png_crc_finish(png_ptr, 0))

-      return;

-

-   mod_time.second = buf[6];

-   mod_time.minute = buf[5];

-   mod_time.hour = buf[4];

-   mod_time.day = buf[3];

-   mod_time.month = buf[2];

-   mod_time.year = png_get_uint_16(buf);

-

-   png_set_tIME(png_ptr, info_ptr, &mod_time);

+    png_byte buf[7];

+    png_time mod_time;

+

+    png_debug(1, "in png_handle_tIME");

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Out of place tIME chunk");

+    else if(info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME))

+    {

+        png_warning(png_ptr, "Duplicate tIME chunk");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    if(png_ptr->mode & PNG_HAVE_IDAT)

+        png_ptr->mode |= PNG_AFTER_IDAT;

+

+    if(length != 7)

+    {

+        png_warning(png_ptr, "Incorrect tIME chunk length");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+

+    png_crc_read(png_ptr, buf, 7);

+    if(png_crc_finish(png_ptr, 0))

+        return;

+

+    mod_time.second = buf[6];

+    mod_time.minute = buf[5];

+    mod_time.hour = buf[4];

+    mod_time.day = buf[3];

+    mod_time.month = buf[2];

+    mod_time.year = png_get_uint_16(buf);

+

+    png_set_tIME(png_ptr, info_ptr, &mod_time);

 }

 #endif

 

@@ -1954,101 +1964,101 @@ png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_textp text_ptr;

-   png_charp key;

-   png_charp text;

-   png_uint_32 skip = 0;

-   png_size_t slength;

-   int ret;

+    png_textp text_ptr;

+    png_charp key;

+    png_charp text;

+    png_uint_32 skip = 0;

+    png_size_t slength;

+    int ret;

 

-   png_debug(1, "in png_handle_tEXt");

+    png_debug(1, "in png_handle_tEXt");

 

 #ifdef PNG_USER_LIMITS_SUPPORTED

-   if (png_ptr->user_chunk_cache_max != 0)

-   {

-      if (png_ptr->user_chunk_cache_max == 1)

-      {

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      if (--png_ptr->user_chunk_cache_max == 1)

-      {

-         png_warning(png_ptr, "No space in chunk cache for tEXt");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-   }

-#endif

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before tEXt");

-

-   if (png_ptr->mode & PNG_HAVE_IDAT)

-      png_ptr->mode |= PNG_AFTER_IDAT;

+    if(png_ptr->user_chunk_cache_max != 0)

+    {

+        if(png_ptr->user_chunk_cache_max == 1)

+        {

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+        if(--png_ptr->user_chunk_cache_max == 1)

+        {

+            png_warning(png_ptr, "No space in chunk cache for tEXt");

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+    }

+#endif

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before tEXt");

+

+    if(png_ptr->mode & PNG_HAVE_IDAT)

+        png_ptr->mode |= PNG_AFTER_IDAT;

 

 #ifdef PNG_MAX_MALLOC_64K

-   if (length > (png_uint_32)65535L)

-   {

-      png_warning(png_ptr, "tEXt chunk too large to fit in memory");

-      skip = length - (png_uint_32)65535L;

-      length = (png_uint_32)65535L;

-   }

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-

-   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

-   if (png_ptr->chunkdata == NULL)

-   {

-     png_warning(png_ptr, "No memory to process text chunk");

-     return;

-   }

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-

-   if (png_crc_finish(png_ptr, skip))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   key = png_ptr->chunkdata;

-

-   key[slength] = 0x00;

-

-   for (text = key; *text; text++)

-      /* Empty loop to find end of key */ ;

-

-   if (text != key + slength)

-      text++;

-

-   text_ptr = (png_textp)png_malloc_warn(png_ptr,

-      png_sizeof(png_text));

-   if (text_ptr == NULL)

-   {

-     png_warning(png_ptr, "Not enough memory to process text chunk");

-     png_free(png_ptr, png_ptr->chunkdata);

-     png_ptr->chunkdata = NULL;

-     return;

-   }

-   text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;

-   text_ptr->key = key;

+    if(length > (png_uint_32)65535L)

+    {

+        png_warning(png_ptr, "tEXt chunk too large to fit in memory");

+        skip = length - (png_uint_32)65535L;

+        length = (png_uint_32)65535L;

+    }

+#endif

+

+    png_free(png_ptr, png_ptr->chunkdata);

+

+    png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

+    if(png_ptr->chunkdata == NULL)

+    {

+        png_warning(png_ptr, "No memory to process text chunk");

+        return;

+    }

+    slength = (png_size_t)length;

+    png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

+

+    if(png_crc_finish(png_ptr, skip))

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+

+    key = png_ptr->chunkdata;

+

+    key[slength] = 0x00;

+

+    for(text = key; *text; text++)

+        /* Empty loop to find end of key */ ;

+

+    if(text != key + slength)

+        text++;

+

+    text_ptr = (png_textp)png_malloc_warn(png_ptr,

+                                          png_sizeof(png_text));

+    if(text_ptr == NULL)

+    {

+        png_warning(png_ptr, "Not enough memory to process text chunk");

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+    text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;

+    text_ptr->key = key;

 #ifdef PNG_iTXt_SUPPORTED

-   text_ptr->lang = NULL;

-   text_ptr->lang_key = NULL;

-   text_ptr->itxt_length = 0;

+    text_ptr->lang = NULL;

+    text_ptr->lang_key = NULL;

+    text_ptr->itxt_length = 0;

 #endif

-   text_ptr->text = text;

-   text_ptr->text_length = png_strlen(text);

+    text_ptr->text = text;

+    text_ptr->text_length = png_strlen(text);

 

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

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

 

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-   png_free(png_ptr, text_ptr);

-   if (ret)

-     png_warning(png_ptr, "Insufficient memory to process text chunk");

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = NULL;

+    png_free(png_ptr, text_ptr);

+    if(ret)

+        png_warning(png_ptr, "Insufficient memory to process text chunk");

 }

 #endif

 

@@ -2057,118 +2067,118 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_textp text_ptr;

-   png_charp text;

-   int comp_type;

-   int ret;

-   png_size_t slength, prefix_len, data_len;

+    png_textp text_ptr;

+    png_charp text;

+    int comp_type;

+    int ret;

+    png_size_t slength, prefix_len, data_len;

 

-   png_debug(1, "in png_handle_zTXt");

+    png_debug(1, "in png_handle_zTXt");

 

 #ifdef PNG_USER_LIMITS_SUPPORTED

-   if (png_ptr->user_chunk_cache_max != 0)

-   {

-      if (png_ptr->user_chunk_cache_max == 1)

-      {

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      if (--png_ptr->user_chunk_cache_max == 1)

-      {

-         png_warning(png_ptr, "No space in chunk cache for zTXt");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-   }

-#endif

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before zTXt");

-

-   if (png_ptr->mode & PNG_HAVE_IDAT)

-      png_ptr->mode |= PNG_AFTER_IDAT;

+    if(png_ptr->user_chunk_cache_max != 0)

+    {

+        if(png_ptr->user_chunk_cache_max == 1)

+        {

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+        if(--png_ptr->user_chunk_cache_max == 1)

+        {

+            png_warning(png_ptr, "No space in chunk cache for zTXt");

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+    }

+#endif

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before zTXt");

+

+    if(png_ptr->mode & PNG_HAVE_IDAT)

+        png_ptr->mode |= PNG_AFTER_IDAT;

 

 #ifdef PNG_MAX_MALLOC_64K

-   /* We will no doubt have problems with chunks even half this size, but

-      there is no hard and fast rule to tell us where to stop. */

-   if (length > (png_uint_32)65535L)

-   {

-     png_warning(png_ptr, "zTXt chunk too large to fit in memory");

-     png_crc_finish(png_ptr, length);

-     return;

-   }

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

-   if (png_ptr->chunkdata == NULL)

-   {

-     png_warning(png_ptr, "Out of memory processing zTXt chunk");

-     return;

-   }

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-   if (png_crc_finish(png_ptr, 0))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00;

-

-   for (text = png_ptr->chunkdata; *text; text++)

-      /* Empty loop */ ;

-

-   /* zTXt must have some text after the chunkdataword */

-   if (text >= png_ptr->chunkdata + slength - 2)

-   {

-      png_warning(png_ptr, "Truncated zTXt chunk");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-   else

-   {

-       comp_type = *(++text);

-       if (comp_type != PNG_TEXT_COMPRESSION_zTXt)

-       {

-          png_warning(png_ptr, "Unknown compression type in zTXt chunk");

-          comp_type = PNG_TEXT_COMPRESSION_zTXt;

-       }

-       text++;        /* Skip the compression_method byte */

-   }

-   prefix_len = text - png_ptr->chunkdata;

-

-   png_decompress_chunk(png_ptr, comp_type,

-     (png_size_t)length, prefix_len, &data_len);

-

-   text_ptr = (png_textp)png_malloc_warn(png_ptr,

-      png_sizeof(png_text));

-   if (text_ptr == NULL)

-   {

-     png_warning(png_ptr, "Not enough memory to process zTXt chunk");

-     png_free(png_ptr, png_ptr->chunkdata);

-     png_ptr->chunkdata = NULL;

-     return;

-   }

-   text_ptr->compression = comp_type;

-   text_ptr->key = png_ptr->chunkdata;

+    /* We will no doubt have problems with chunks even half this size, but

+       there is no hard and fast rule to tell us where to stop. */

+    if(length > (png_uint_32)65535L)

+    {

+        png_warning(png_ptr, "zTXt chunk too large to fit in memory");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+#endif

+

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

+    if(png_ptr->chunkdata == NULL)

+    {

+        png_warning(png_ptr, "Out of memory processing zTXt chunk");

+        return;

+    }

+    slength = (png_size_t)length;

+    png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

+    if(png_crc_finish(png_ptr, 0))

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+

+    png_ptr->chunkdata[slength] = 0x00;

+

+    for(text = png_ptr->chunkdata; *text; text++)

+        /* Empty loop */ ;

+

+    /* zTXt must have some text after the chunkdataword */

+    if(text >= png_ptr->chunkdata + slength - 2)

+    {

+        png_warning(png_ptr, "Truncated zTXt chunk");

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+    else

+    {

+        comp_type = *(++text);

+        if(comp_type != PNG_TEXT_COMPRESSION_zTXt)

+        {

+            png_warning(png_ptr, "Unknown compression type in zTXt chunk");

+            comp_type = PNG_TEXT_COMPRESSION_zTXt;

+        }

+        text++;        /* Skip the compression_method byte */

+    }

+    prefix_len = text - png_ptr->chunkdata;

+

+    png_decompress_chunk(png_ptr, comp_type,

+                         (png_size_t)length, prefix_len, &data_len);

+

+    text_ptr = (png_textp)png_malloc_warn(png_ptr,

+                                          png_sizeof(png_text));

+    if(text_ptr == NULL)

+    {

+        png_warning(png_ptr, "Not enough memory to process zTXt chunk");

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+    text_ptr->compression = comp_type;

+    text_ptr->key = png_ptr->chunkdata;

 #ifdef PNG_iTXt_SUPPORTED

-   text_ptr->lang = NULL;

-   text_ptr->lang_key = NULL;

-   text_ptr->itxt_length = 0;

+    text_ptr->lang = NULL;

+    text_ptr->lang_key = NULL;

+    text_ptr->itxt_length = 0;

 #endif

-   text_ptr->text = png_ptr->chunkdata + prefix_len;

-   text_ptr->text_length = data_len;

+    text_ptr->text = png_ptr->chunkdata + prefix_len;

+    text_ptr->text_length = data_len;

 

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

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

 

-   png_free(png_ptr, text_ptr);

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-   if (ret)

-     png_error(png_ptr, "Insufficient memory to store zTXt chunk");

+    png_free(png_ptr, text_ptr);

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = NULL;

+    if(ret)

+        png_error(png_ptr, "Insufficient memory to store zTXt chunk");

 }

 #endif

 

@@ -2177,144 +2187,144 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_textp text_ptr;

-   png_charp key, lang, text, lang_key;

-   int comp_flag;

-   int comp_type = 0;

-   int ret;

-   png_size_t slength, prefix_len, data_len;

+    png_textp text_ptr;

+    png_charp key, lang, text, lang_key;

+    int comp_flag;

+    int comp_type = 0;

+    int ret;

+    png_size_t slength, prefix_len, data_len;

 

-   png_debug(1, "in png_handle_iTXt");

+    png_debug(1, "in png_handle_iTXt");

 

 #ifdef PNG_USER_LIMITS_SUPPORTED

-   if (png_ptr->user_chunk_cache_max != 0)

-   {

-      if (png_ptr->user_chunk_cache_max == 1)

-      {

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      if (--png_ptr->user_chunk_cache_max == 1)

-      {

-         png_warning(png_ptr, "No space in chunk cache for iTXt");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-   }

-#endif

-

-   if (!(png_ptr->mode & PNG_HAVE_IHDR))

-      png_error(png_ptr, "Missing IHDR before iTXt");

-

-   if (png_ptr->mode & PNG_HAVE_IDAT)

-      png_ptr->mode |= PNG_AFTER_IDAT;

+    if(png_ptr->user_chunk_cache_max != 0)

+    {

+        if(png_ptr->user_chunk_cache_max == 1)

+        {

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+        if(--png_ptr->user_chunk_cache_max == 1)

+        {

+            png_warning(png_ptr, "No space in chunk cache for iTXt");

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+    }

+#endif

+

+    if(!(png_ptr->mode & PNG_HAVE_IHDR))

+        png_error(png_ptr, "Missing IHDR before iTXt");

+

+    if(png_ptr->mode & PNG_HAVE_IDAT)

+        png_ptr->mode |= PNG_AFTER_IDAT;

 

 #ifdef PNG_MAX_MALLOC_64K

-   /* We will no doubt have problems with chunks even half this size, but

-      there is no hard and fast rule to tell us where to stop. */

-   if (length > (png_uint_32)65535L)

-   {

-     png_warning(png_ptr, "iTXt chunk too large to fit in memory");

-     png_crc_finish(png_ptr, length);

-     return;

-   }

-#endif

-

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

-   if (png_ptr->chunkdata == NULL)

-   {

-     png_warning(png_ptr, "No memory to process iTXt chunk");

-     return;

-   }

-   slength = (png_size_t)length;

-   png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

-   if (png_crc_finish(png_ptr, 0))

-   {

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   png_ptr->chunkdata[slength] = 0x00;

-

-   for (lang = png_ptr->chunkdata; *lang; lang++)

-      /* Empty loop */ ;

-   lang++;        /* Skip NUL separator */

-

-   /* iTXt must have a language tag (possibly empty), two compression bytes,

-    * translated keyword (possibly empty), and possibly some text after the

-    * keyword

-    */

-

-   if (lang >= png_ptr->chunkdata + slength - 3)

-   {

-      png_warning(png_ptr, "Truncated iTXt chunk");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-   else

-   {

-       comp_flag = *lang++;

-       comp_type = *lang++;

-   }

-

-   for (lang_key = lang; *lang_key; lang_key++)

-      /* Empty loop */ ;

-   lang_key++;        /* Skip NUL separator */

-

-   if (lang_key >= png_ptr->chunkdata + slength)

-   {

-      png_warning(png_ptr, "Truncated iTXt chunk");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   for (text = lang_key; *text; text++)

-      /* Empty loop */ ;

-   text++;        /* Skip NUL separator */

-   if (text >= png_ptr->chunkdata + slength)

-   {

-      png_warning(png_ptr, "Malformed iTXt chunk");

-      png_free(png_ptr, png_ptr->chunkdata);

-      png_ptr->chunkdata = NULL;

-      return;

-   }

-

-   prefix_len = text - png_ptr->chunkdata;

-

-   key=png_ptr->chunkdata;

-   if (comp_flag)

-       png_decompress_chunk(png_ptr, comp_type,

-         (size_t)length, prefix_len, &data_len);

-   else

-       data_len = png_strlen(png_ptr->chunkdata + prefix_len);

-   text_ptr = (png_textp)png_malloc_warn(png_ptr,

-      png_sizeof(png_text));

-   if (text_ptr == NULL)

-   {

-     png_warning(png_ptr, "Not enough memory to process iTXt chunk");

-     png_free(png_ptr, png_ptr->chunkdata);

-     png_ptr->chunkdata = NULL;

-     return;

-   }

-   text_ptr->compression = (int)comp_flag + 1;

-   text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);

-   text_ptr->lang = png_ptr->chunkdata + (lang - key);

-   text_ptr->itxt_length = data_len;

-   text_ptr->text_length = 0;

-   text_ptr->key = png_ptr->chunkdata;

-   text_ptr->text = png_ptr->chunkdata + prefix_len;

-

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

-

-   png_free(png_ptr, text_ptr);

-   png_free(png_ptr, png_ptr->chunkdata);

-   png_ptr->chunkdata = NULL;

-   if (ret)

-     png_error(png_ptr, "Insufficient memory to store iTXt chunk");

+    /* We will no doubt have problems with chunks even half this size, but

+       there is no hard and fast rule to tell us where to stop. */

+    if(length > (png_uint_32)65535L)

+    {

+        png_warning(png_ptr, "iTXt chunk too large to fit in memory");

+        png_crc_finish(png_ptr, length);

+        return;

+    }

+#endif

+

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

+    if(png_ptr->chunkdata == NULL)

+    {

+        png_warning(png_ptr, "No memory to process iTXt chunk");

+        return;

+    }

+    slength = (png_size_t)length;

+    png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);

+    if(png_crc_finish(png_ptr, 0))

+    {

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+

+    png_ptr->chunkdata[slength] = 0x00;

+

+    for(lang = png_ptr->chunkdata; *lang; lang++)

+        /* Empty loop */ ;

+    lang++;        /* Skip NUL separator */

+

+    /* iTXt must have a language tag (possibly empty), two compression bytes,

+     * translated keyword (possibly empty), and possibly some text after the

+     * keyword

+     */

+

+    if(lang >= png_ptr->chunkdata + slength - 3)

+    {

+        png_warning(png_ptr, "Truncated iTXt chunk");

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+    else

+    {

+        comp_flag = *lang++;

+        comp_type = *lang++;

+    }

+

+    for(lang_key = lang; *lang_key; lang_key++)

+        /* Empty loop */ ;

+    lang_key++;        /* Skip NUL separator */

+

+    if(lang_key >= png_ptr->chunkdata + slength)

+    {

+        png_warning(png_ptr, "Truncated iTXt chunk");

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+

+    for(text = lang_key; *text; text++)

+        /* Empty loop */ ;

+    text++;        /* Skip NUL separator */

+    if(text >= png_ptr->chunkdata + slength)

+    {

+        png_warning(png_ptr, "Malformed iTXt chunk");

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+

+    prefix_len = text - png_ptr->chunkdata;

+

+    key = png_ptr->chunkdata;

+    if(comp_flag)

+        png_decompress_chunk(png_ptr, comp_type,

+                             (size_t)length, prefix_len, &data_len);

+    else

+        data_len = png_strlen(png_ptr->chunkdata + prefix_len);

+    text_ptr = (png_textp)png_malloc_warn(png_ptr,

+                                          png_sizeof(png_text));

+    if(text_ptr == NULL)

+    {

+        png_warning(png_ptr, "Not enough memory to process iTXt chunk");

+        png_free(png_ptr, png_ptr->chunkdata);

+        png_ptr->chunkdata = NULL;

+        return;

+    }

+    text_ptr->compression = (int)comp_flag + 1;

+    text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);

+    text_ptr->lang = png_ptr->chunkdata + (lang - key);

+    text_ptr->itxt_length = data_len;

+    text_ptr->text_length = 0;

+    text_ptr->key = png_ptr->chunkdata;

+    text_ptr->text = png_ptr->chunkdata + prefix_len;

+

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

+

+    png_free(png_ptr, text_ptr);

+    png_free(png_ptr, png_ptr->chunkdata);

+    png_ptr->chunkdata = NULL;

+    if(ret)

+        png_error(png_ptr, "Insufficient memory to store iTXt chunk");

 }

 #endif

 

@@ -2326,110 +2336,110 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

 {

-   png_uint_32 skip = 0;

+    png_uint_32 skip = 0;

 

-   png_debug(1, "in png_handle_unknown");

+    png_debug(1, "in png_handle_unknown");

 

 #ifdef PNG_USER_LIMITS_SUPPORTED

-   if (png_ptr->user_chunk_cache_max != 0)

-   {

-      if (png_ptr->user_chunk_cache_max == 1)

-      {

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-      if (--png_ptr->user_chunk_cache_max == 1)

-      {

-         png_warning(png_ptr, "No space in chunk cache for unknown chunk");

-         png_crc_finish(png_ptr, length);

-         return;

-      }

-   }

-#endif

-

-   if (png_ptr->mode & PNG_HAVE_IDAT)

-   {

-      PNG_IDAT;

-      if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))  /* Not an IDAT */

-         png_ptr->mode |= PNG_AFTER_IDAT;

-   }

-

-   if (!(png_ptr->chunk_name[0] & 0x20))

-   {

+    if(png_ptr->user_chunk_cache_max != 0)

+    {

+        if(png_ptr->user_chunk_cache_max == 1)

+        {

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+        if(--png_ptr->user_chunk_cache_max == 1)

+        {

+            png_warning(png_ptr, "No space in chunk cache for unknown chunk");

+            png_crc_finish(png_ptr, length);

+            return;

+        }

+    }

+#endif

+

+    if(png_ptr->mode & PNG_HAVE_IDAT)

+    {

+        PNG_IDAT;

+        if(png_memcmp(png_ptr->chunk_name, png_IDAT, 4))   /* Not an IDAT */

+            png_ptr->mode |= PNG_AFTER_IDAT;

+    }

+

+    if(!(png_ptr->chunk_name[0] & 0x20))

+    {

 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-      if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

+        if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

            PNG_HANDLE_CHUNK_ALWAYS

 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED

            && png_ptr->read_user_chunk_fn == NULL

 #endif

-        )

+          )

 #endif

-          png_chunk_error(png_ptr, "unknown critical chunk");

-   }

+            png_chunk_error(png_ptr, "unknown critical chunk");

+    }

 

 #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

-   if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)

+    if((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)

 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED

        || (png_ptr->read_user_chunk_fn != NULL)

 #endif

-        )

-   {

+      )

+    {

 #ifdef PNG_MAX_MALLOC_64K

-       if (length > (png_uint_32)65535L)

-       {

-           png_warning(png_ptr, "unknown chunk too large to fit in memory");

-           skip = length - (png_uint_32)65535L;

-           length = (png_uint_32)65535L;

-       }

-#endif

-       png_memcpy((png_charp)png_ptr->unknown_chunk.name,

-                  (png_charp)png_ptr->chunk_name,

-                  png_sizeof(png_ptr->unknown_chunk.name));

-       png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1]

-           = '\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, length);

-         png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);

-       }

+        if(length > (png_uint_32)65535L)

+        {

+            png_warning(png_ptr, "unknown chunk too large to fit in memory");

+            skip = length - (png_uint_32)65535L;

+            length = (png_uint_32)65535L;

+        }

+#endif

+        png_memcpy((png_charp)png_ptr->unknown_chunk.name,

+                   (png_charp)png_ptr->chunk_name,

+                   png_sizeof(png_ptr->unknown_chunk.name));

+        png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1]

+        = '\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, length);

+            png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);

+        }

 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED

-       if (png_ptr->read_user_chunk_fn != NULL)

-       {

-          /* Callback to user unknown chunk handler */

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

+        if(png_ptr->read_user_chunk_fn != NULL)

+        {

+            /* Callback to user unknown chunk handler */

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

 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-                if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

-                     PNG_HANDLE_CHUNK_ALWAYS)

+                    if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

+                       PNG_HANDLE_CHUNK_ALWAYS)

 #endif

-                   png_chunk_error(png_ptr, "unknown critical chunk");

-             png_set_unknown_chunks(png_ptr, info_ptr,

-               &png_ptr->unknown_chunk, 1);

-          }

-       }

-       else

+                        png_chunk_error(png_ptr, "unknown critical chunk");

+                png_set_unknown_chunks(png_ptr, info_ptr,

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

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

+        skip = length;

 

-   png_crc_finish(png_ptr, skip);

+    png_crc_finish(png_ptr, skip);

 

 #ifndef PNG_READ_USER_CHUNKS_SUPPORTED

-   info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */

+    info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */

 #endif

 }

 

@@ -2444,12 +2454,12 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 void /* PRIVATE */

 png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)

 {

-   png_debug(1, "in png_check_chunk_name");

-   if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) ||

+    png_debug(1, "in png_check_chunk_name");

+    if(isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) ||

        isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3]))

-   {

-      png_chunk_error(png_ptr, "invalid chunk type");

-   }

+    {

+        png_chunk_error(png_ptr, "invalid chunk type");

+    }

 }

 

 /* Combines the row recently read in with the existing pixels in the

@@ -2466,18 +2476,18 @@ png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
 void /* PRIVATE */

 png_combine_row(png_structp png_ptr, png_bytep row, int mask)

 {

-   png_debug(1, "in png_combine_row");

-   if (mask == 0xff)

-   {

-      png_memcpy(row, png_ptr->row_buf + 1,

-         PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));

-   }

-   else

-   {

-      switch (png_ptr->row_info.pixel_depth)

-      {

-         case 1:

-         {

+    png_debug(1, "in png_combine_row");

+    if(mask == 0xff)

+    {

+        png_memcpy(row, png_ptr->row_buf + 1,

+                   PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));

+    }

+    else

+    {

+        switch(png_ptr->row_info.pixel_depth)

+        {

+        case 1:

+        {

             png_bytep sp = png_ptr->row_buf + 1;

             png_bytep dp = row;

             int s_inc, s_start, s_end;

@@ -2487,7 +2497,7 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
             png_uint_32 row_width = png_ptr->width;

 

 #ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (png_ptr->transformations & PNG_PACKSWAP)

+            if(png_ptr->transformations & PNG_PACKSWAP)

             {

                 s_start = 0;

                 s_end = 7;

@@ -2503,35 +2513,35 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
 

             shift = s_start;

 

-            for (i = 0; i < row_width; i++)

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

             {

-               if (m & mask)

-               {

-                  int value;

-

-                  value = (*sp >> shift) & 0x01;

-                  *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);

-                  *dp |= (png_byte)(value << shift);

-               }

-

-               if (shift == s_end)

-               {

-                  shift = s_start;

-                  sp++;

-                  dp++;

-               }

-               else

-                  shift += s_inc;

-

-               if (m == 1)

-                  m = 0x80;

-               else

-                  m >>= 1;

+                if(m & mask)

+                {

+                    int value;

+

+                    value = (*sp >> shift) & 0x01;

+                    *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);

+                    *dp |= (png_byte)(value << shift);

+                }

+

+                if(shift == s_end)

+                {

+                    shift = s_start;

+                    sp++;

+                    dp++;

+                }

+                else

+                    shift += s_inc;

+

+                if(m == 1)

+                    m = 0x80;

+                else

+                    m >>= 1;

             }

             break;

-         }

-         case 2:

-         {

+        }

+        case 2:

+        {

             png_bytep sp = png_ptr->row_buf + 1;

             png_bytep dp = row;

             int s_start, s_end, s_inc;

@@ -2542,48 +2552,48 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
             int value;

 

 #ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (png_ptr->transformations & PNG_PACKSWAP)

+            if(png_ptr->transformations & PNG_PACKSWAP)

             {

-               s_start = 0;

-               s_end = 6;

-               s_inc = 2;

+                s_start = 0;

+                s_end = 6;

+                s_inc = 2;

             }

             else

 #endif

             {

-               s_start = 6;

-               s_end = 0;

-               s_inc = -2;

+                s_start = 6;

+                s_end = 0;

+                s_inc = -2;

             }

 

             shift = s_start;

 

-            for (i = 0; i < row_width; i++)

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

             {

-               if (m & mask)

-               {

-                  value = (*sp >> shift) & 0x03;

-                  *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

-                  *dp |= (png_byte)(value << shift);

-               }

-

-               if (shift == s_end)

-               {

-                  shift = s_start;

-                  sp++;

-                  dp++;

-               }

-               else

-                  shift += s_inc;

-               if (m == 1)

-                  m = 0x80;

-               else

-                  m >>= 1;

+                if(m & mask)

+                {

+                    value = (*sp >> shift) & 0x03;

+                    *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

+                    *dp |= (png_byte)(value << shift);

+                }

+

+                if(shift == s_end)

+                {

+                    shift = s_start;

+                    sp++;

+                    dp++;

+                }

+                else

+                    shift += s_inc;

+                if(m == 1)

+                    m = 0x80;

+                else

+                    m >>= 1;

             }

             break;

-         }

-         case 4:

-         {

+        }

+        case 4:

+        {

             png_bytep sp = png_ptr->row_buf + 1;

             png_bytep dp = row;

             int s_start, s_end, s_inc;

@@ -2594,47 +2604,47 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
             int value;

 

 #ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (png_ptr->transformations & PNG_PACKSWAP)

+            if(png_ptr->transformations & PNG_PACKSWAP)

             {

-               s_start = 0;

-               s_end = 4;

-               s_inc = 4;

+                s_start = 0;

+                s_end = 4;

+                s_inc = 4;

             }

             else

 #endif

             {

-               s_start = 4;

-               s_end = 0;

-               s_inc = -4;

+                s_start = 4;

+                s_end = 0;

+                s_inc = -4;

             }

             shift = s_start;

 

-            for (i = 0; i < row_width; i++)

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

             {

-               if (m & mask)

-               {

-                  value = (*sp >> shift) & 0xf;

-                  *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

-                  *dp |= (png_byte)(value << shift);

-               }

-

-               if (shift == s_end)

-               {

-                  shift = s_start;

-                  sp++;

-                  dp++;

-               }

-               else

-                  shift += s_inc;

-               if (m == 1)

-                  m = 0x80;

-               else

-                  m >>= 1;

+                if(m & mask)

+                {

+                    value = (*sp >> shift) & 0xf;

+                    *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

+                    *dp |= (png_byte)(value << shift);

+                }

+

+                if(shift == s_end)

+                {

+                    shift = s_start;

+                    sp++;

+                    dp++;

+                }

+                else

+                    shift += s_inc;

+                if(m == 1)

+                    m = 0x80;

+                else

+                    m >>= 1;

             }

             break;

-         }

-         default:

-         {

+        }

+        default:

+        {

             png_bytep sp = png_ptr->row_buf + 1;

             png_bytep dp = row;

             png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

@@ -2643,25 +2653,25 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
             png_byte m = 0x80;

 

 

-            for (i = 0; i < row_width; i++)

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

             {

-               if (m & mask)

-               {

-                  png_memcpy(dp, sp, pixel_bytes);

-               }

-

-               sp += pixel_bytes;

-               dp += pixel_bytes;

-

-               if (m == 1)

-                  m = 0x80;

-               else

-                  m >>= 1;

+                if(m & mask)

+                {

+                    png_memcpy(dp, sp, pixel_bytes);

+                }

+

+                sp += pixel_bytes;

+                dp += pixel_bytes;

+

+                if(m == 1)

+                    m = 0x80;

+                else

+                    m >>= 1;

             }

             break;

-         }

-      }

-   }

+        }

+        }

+    }

 }

 

 #ifdef PNG_READ_INTERLACING_SUPPORTED

@@ -2672,25 +2682,25 @@ void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
 void /* PRIVATE */

 png_do_read_interlace(png_structp png_ptr)

 {

-   png_row_infop row_info = &(png_ptr->row_info);

-   png_bytep row = png_ptr->row_buf + 1;

-   int pass = png_ptr->pass;

-   png_uint_32 transformations = png_ptr->transformations;

-   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */

-   /* Offset to next interlace block */

-   PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

-

-   png_debug(1, "in png_do_read_interlace");

-   if (row != NULL && row_info != NULL)

-   {

-      png_uint_32 final_width;

-

-      final_width = row_info->width * png_pass_inc[pass];

-

-      switch (row_info->pixel_depth)

-      {

-         case 1:

-         {

+    png_row_infop row_info = &(png_ptr->row_info);

+    png_bytep row = png_ptr->row_buf + 1;

+    int pass = png_ptr->pass;

+    png_uint_32 transformations = png_ptr->transformations;

+    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */

+    /* Offset to next interlace block */

+    PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+

+    png_debug(1, "in png_do_read_interlace");

+    if(row != NULL && row_info != NULL)

+    {

+        png_uint_32 final_width;

+

+        final_width = row_info->width * png_pass_inc[pass];

+

+        switch(row_info->pixel_depth)

+        {

+        case 1:

+        {

             png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3);

             png_bytep dp = row + (png_size_t)((final_width - 1) >> 3);

             int sshift, dshift;

@@ -2701,7 +2711,7 @@ png_do_read_interlace(png_structp png_ptr)
             int j;

 

 #ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (transformations & PNG_PACKSWAP)

+            if(transformations & PNG_PACKSWAP)

             {

                 sshift = (int)((row_info->width + 7) & 0x07);

                 dshift = (int)((final_width + 7) & 0x07);

@@ -2719,33 +2729,33 @@ png_do_read_interlace(png_structp png_ptr)
                 s_inc = 1;

             }

 

-            for (i = 0; i < row_info->width; i++)

+            for(i = 0; i < row_info->width; i++)

             {

-               v = (png_byte)((*sp >> sshift) & 0x01);

-               for (j = 0; j < jstop; j++)

-               {

-                  *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);

-                  *dp |= (png_byte)(v << dshift);

-                  if (dshift == s_end)

-                  {

-                     dshift = s_start;

-                     dp--;

-                  }

-                  else

-                     dshift += s_inc;

-               }

-               if (sshift == s_end)

-               {

-                  sshift = s_start;

-                  sp--;

-               }

-               else

-                  sshift += s_inc;

+                v = (png_byte)((*sp >> sshift) & 0x01);

+                for(j = 0; j < jstop; j++)

+                {

+                    *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);

+                    *dp |= (png_byte)(v << dshift);

+                    if(dshift == s_end)

+                    {

+                        dshift = s_start;

+                        dp--;

+                    }

+                    else

+                        dshift += s_inc;

+                }

+                if(sshift == s_end)

+                {

+                    sshift = s_start;

+                    sp--;

+                }

+                else

+                    sshift += s_inc;

             }

             break;

-         }

-         case 2:

-         {

+        }

+        case 2:

+        {

             png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2);

             png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2);

             int sshift, dshift;

@@ -2754,54 +2764,54 @@ png_do_read_interlace(png_structp png_ptr)
             png_uint_32 i;

 

 #ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (transformations & PNG_PACKSWAP)

+            if(transformations & PNG_PACKSWAP)

             {

-               sshift = (int)(((row_info->width + 3) & 0x03) << 1);

-               dshift = (int)(((final_width + 3) & 0x03) << 1);

-               s_start = 6;

-               s_end = 0;

-               s_inc = -2;

+                sshift = (int)(((row_info->width + 3) & 0x03) << 1);

+                dshift = (int)(((final_width + 3) & 0x03) << 1);

+                s_start = 6;

+                s_end = 0;

+                s_inc = -2;

             }

             else

 #endif

             {

-               sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1);

-               dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1);

-               s_start = 0;

-               s_end = 6;

-               s_inc = 2;

+                sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1);

+                dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1);

+                s_start = 0;

+                s_end = 6;

+                s_inc = 2;

             }

 

-            for (i = 0; i < row_info->width; i++)

+            for(i = 0; i < row_info->width; i++)

             {

-               png_byte v;

-               int j;

-

-               v = (png_byte)((*sp >> sshift) & 0x03);

-               for (j = 0; j < jstop; j++)

-               {

-                  *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);

-                  *dp |= (png_byte)(v << dshift);

-                  if (dshift == s_end)

-                  {

-                     dshift = s_start;

-                     dp--;

-                  }

-                  else

-                     dshift += s_inc;

-               }

-               if (sshift == s_end)

-               {

-                  sshift = s_start;

-                  sp--;

-               }

-               else

-                  sshift += s_inc;

+                png_byte v;

+                int j;

+

+                v = (png_byte)((*sp >> sshift) & 0x03);

+                for(j = 0; j < jstop; j++)

+                {

+                    *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);

+                    *dp |= (png_byte)(v << dshift);

+                    if(dshift == s_end)

+                    {

+                        dshift = s_start;

+                        dp--;

+                    }

+                    else

+                        dshift += s_inc;

+                }

+                if(sshift == s_end)

+                {

+                    sshift = s_start;

+                    sp--;

+                }

+                else

+                    sshift += s_inc;

             }

             break;

-         }

-         case 4:

-         {

+        }

+        case 4:

+        {

             png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1);

             png_bytep dp = row + (png_size_t)((final_width - 1) >> 1);

             int sshift, dshift;

@@ -2810,167 +2820,167 @@ png_do_read_interlace(png_structp png_ptr)
             int jstop = png_pass_inc[pass];

 

 #ifdef PNG_READ_PACKSWAP_SUPPORTED

-            if (transformations & PNG_PACKSWAP)

+            if(transformations & PNG_PACKSWAP)

             {

-               sshift = (int)(((row_info->width + 1) & 0x01) << 2);

-               dshift = (int)(((final_width + 1) & 0x01) << 2);

-               s_start = 4;

-               s_end = 0;

-               s_inc = -4;

+                sshift = (int)(((row_info->width + 1) & 0x01) << 2);

+                dshift = (int)(((final_width + 1) & 0x01) << 2);

+                s_start = 4;

+                s_end = 0;

+                s_inc = -4;

             }

             else

 #endif

             {

-               sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2);

-               dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2);

-               s_start = 0;

-               s_end = 4;

-               s_inc = 4;

+                sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2);

+                dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2);

+                s_start = 0;

+                s_end = 4;

+                s_inc = 4;

             }

 

-            for (i = 0; i < row_info->width; i++)

+            for(i = 0; i < row_info->width; i++)

             {

-               png_byte v = (png_byte)((*sp >> sshift) & 0xf);

-               int j;

-

-               for (j = 0; j < jstop; j++)

-               {

-                  *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);

-                  *dp |= (png_byte)(v << dshift);

-                  if (dshift == s_end)

-                  {

-                     dshift = s_start;

-                     dp--;

-                  }

-                  else

-                     dshift += s_inc;

-               }

-               if (sshift == s_end)

-               {

-                  sshift = s_start;

-                  sp--;

-               }

-               else

-                  sshift += s_inc;

+                png_byte v = (png_byte)((*sp >> sshift) & 0xf);

+                int j;

+

+                for(j = 0; j < jstop; j++)

+                {

+                    *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);

+                    *dp |= (png_byte)(v << dshift);

+                    if(dshift == s_end)

+                    {

+                        dshift = s_start;

+                        dp--;

+                    }

+                    else

+                        dshift += s_inc;

+                }

+                if(sshift == s_end)

+                {

+                    sshift = s_start;

+                    sp--;

+                }

+                else

+                    sshift += s_inc;

             }

             break;

-         }

-         default:

-         {

+        }

+        default:

+        {

             png_size_t pixel_bytes = (row_info->pixel_depth >> 3);

             png_bytep sp = row + (png_size_t)(row_info->width - 1)

-                * pixel_bytes;

+                           * pixel_bytes;

             png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes;

 

             int jstop = png_pass_inc[pass];

             png_uint_32 i;

 

-            for (i = 0; i < row_info->width; i++)

+            for(i = 0; i < row_info->width; i++)

             {

-               png_byte v[8];

-               int j;

-

-               png_memcpy(v, sp, pixel_bytes);

-               for (j = 0; j < jstop; j++)

-               {

-                  png_memcpy(dp, v, pixel_bytes);

-                  dp -= pixel_bytes;

-               }

-               sp -= pixel_bytes;

+                png_byte v[8];

+                int j;

+

+                png_memcpy(v, sp, pixel_bytes);

+                for(j = 0; j < jstop; j++)

+                {

+                    png_memcpy(dp, v, pixel_bytes);

+                    dp -= pixel_bytes;

+                }

+                sp -= pixel_bytes;

             }

             break;

-         }

-      }

-      row_info->width = final_width;

-      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width);

-   }

+        }

+        }

+        row_info->width = final_width;

+        row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width);

+    }

 #ifndef PNG_READ_PACKSWAP_SUPPORTED

-   transformations = transformations; /* Silence compiler warning */

+    transformations = transformations; /* Silence compiler warning */

 #endif

 }

 #endif /* PNG_READ_INTERLACING_SUPPORTED */

 

 void /* PRIVATE */

 png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,

-   png_bytep prev_row, int filter)

+                    png_bytep prev_row, int filter)

 {

-   png_debug(1, "in png_read_filter_row");

-   png_debug2(2, "row = %lu, filter = %d", png_ptr->row_number, filter);

-   switch (filter)

-   {

-      case PNG_FILTER_VALUE_NONE:

-         break;

-      case PNG_FILTER_VALUE_SUB:

-      {

-         png_uint_32 i;

-         png_uint_32 istop = row_info->rowbytes;

-         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

-         png_bytep rp = row + bpp;

-         png_bytep lp = row;

-

-         for (i = bpp; i < istop; i++)

-         {

+    png_debug(1, "in png_read_filter_row");

+    png_debug2(2, "row = %lu, filter = %d", png_ptr->row_number, filter);

+    switch(filter)

+    {

+    case PNG_FILTER_VALUE_NONE:

+        break;

+    case PNG_FILTER_VALUE_SUB:

+    {

+        png_uint_32 i;

+        png_uint_32 istop = row_info->rowbytes;

+        png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+        png_bytep rp = row + bpp;

+        png_bytep lp = row;

+

+        for(i = bpp; i < istop; i++)

+        {

             *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);

             rp++;

-         }

-         break;

-      }

-      case PNG_FILTER_VALUE_UP:

-      {

-         png_uint_32 i;

-         png_uint_32 istop = row_info->rowbytes;

-         png_bytep rp = row;

-         png_bytep pp = prev_row;

-

-         for (i = 0; i < istop; i++)

-         {

+        }

+        break;

+    }

+    case PNG_FILTER_VALUE_UP:

+    {

+        png_uint_32 i;

+        png_uint_32 istop = row_info->rowbytes;

+        png_bytep rp = row;

+        png_bytep pp = prev_row;

+

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

+        {

             *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);

             rp++;

-         }

-         break;

-      }

-      case PNG_FILTER_VALUE_AVG:

-      {

-         png_uint_32 i;

-         png_bytep rp = row;

-         png_bytep pp = prev_row;

-         png_bytep lp = row;

-         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

-         png_uint_32 istop = row_info->rowbytes - bpp;

-

-         for (i = 0; i < bpp; i++)

-         {

+        }

+        break;

+    }

+    case PNG_FILTER_VALUE_AVG:

+    {

+        png_uint_32 i;

+        png_bytep rp = row;

+        png_bytep pp = prev_row;

+        png_bytep lp = row;

+        png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+        png_uint_32 istop = row_info->rowbytes - bpp;

+

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

+        {

             *rp = (png_byte)(((int)(*rp) +

-               ((int)(*pp++) / 2 )) & 0xff);

+                              ((int)(*pp++) / 2)) & 0xff);

             rp++;

-         }

+        }

 

-         for (i = 0; i < istop; i++)

-         {

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

+        {

             *rp = (png_byte)(((int)(*rp) +

-               (int)(*pp++ + *lp++) / 2 ) & 0xff);

+                              (int)(*pp++ + *lp++) / 2) & 0xff);

             rp++;

-         }

-         break;

-      }

-      case PNG_FILTER_VALUE_PAETH:

-      {

-         png_uint_32 i;

-         png_bytep rp = row;

-         png_bytep pp = prev_row;

-         png_bytep lp = row;

-         png_bytep cp = prev_row;

-         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

-         png_uint_32 istop=row_info->rowbytes - bpp;

-

-         for (i = 0; i < bpp; i++)

-         {

+        }

+        break;

+    }

+    case PNG_FILTER_VALUE_PAETH:

+    {

+        png_uint_32 i;

+        png_bytep rp = row;

+        png_bytep pp = prev_row;

+        png_bytep lp = row;

+        png_bytep cp = prev_row;

+        png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+        png_uint_32 istop = row_info->rowbytes - bpp;

+

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

+        {

             *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);

             rp++;

-         }

+        }

 

-         for (i = 0; i < istop; i++)   /* Use leftover rp,pp */

-         {

+        for(i = 0; i < istop; i++)    /* Use leftover rp,pp */

+        {

             int a, b, c, pa, pb, pc, p;

 

             a = *lp++;

@@ -3003,14 +3013,14 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
 

             *rp = (png_byte)(((int)(*rp) + p) & 0xff);

             rp++;

-         }

-         break;

-      }

-      default:

-         png_warning(png_ptr, "Ignoring bad adaptive filter type");

-         *row = 0;

-         break;

-   }

+        }

+        break;

+    }

+    default:

+        png_warning(png_ptr, "Ignoring bad adaptive filter type");

+        *row = 0;

+        break;

+    }

 }

 

 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED

@@ -3018,125 +3028,126 @@ void /* PRIVATE */
 png_read_finish_row(png_structp png_ptr)

 {

 #ifdef PNG_READ_INTERLACING_SUPPORTED

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

-   PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+    /* Start of interlace block */

+    PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

 

-   /* Offset to next interlace block */

-   PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+    /* Offset to next interlace block */

+    PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

 

-   /* Start of interlace block in the y direction */

-   PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

+    /* Start of interlace block in the y direction */

+    PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

 

-   /* Offset to next interlace block in the y direction */

-   PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

+    /* Offset to next interlace block in the y direction */

+    PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

 #endif /* PNG_READ_INTERLACING_SUPPORTED */

 

-   png_debug(1, "in png_read_finish_row");

-   png_ptr->row_number++;

-   if (png_ptr->row_number < png_ptr->num_rows)

-      return;

+    png_debug(1, "in png_read_finish_row");

+    png_ptr->row_number++;

+    if(png_ptr->row_number < png_ptr->num_rows)

+        return;

 

 #ifdef PNG_READ_INTERLACING_SUPPORTED

-   if (png_ptr->interlaced)

-   {

-      png_ptr->row_number = 0;

-      png_memset(png_ptr->prev_row, 0,

-         png_ptr->rowbytes + 1);

-      do

-      {

-         png_ptr->pass++;

-         if (png_ptr->pass >= 7)

-            break;

-         png_ptr->iwidth = (png_ptr->width +

-            png_pass_inc[png_ptr->pass] - 1 -

-            png_pass_start[png_ptr->pass]) /

-            png_pass_inc[png_ptr->pass];

-

-         if (!(png_ptr->transformations & PNG_INTERLACE))

-         {

-            png_ptr->num_rows = (png_ptr->height +

-               png_pass_yinc[png_ptr->pass] - 1 -

-               png_pass_ystart[png_ptr->pass]) /

-               png_pass_yinc[png_ptr->pass];

-            if (!(png_ptr->num_rows))

-               continue;

-         }

-         else  /* if (png_ptr->transformations & PNG_INTERLACE) */

-            break;

-      } while (png_ptr->iwidth == 0);

+    if(png_ptr->interlaced)

+    {

+        png_ptr->row_number = 0;

+        png_memset(png_ptr->prev_row, 0,

+                   png_ptr->rowbytes + 1);

+        do

+        {

+            png_ptr->pass++;

+            if(png_ptr->pass >= 7)

+                break;

+            png_ptr->iwidth = (png_ptr->width +

+                               png_pass_inc[png_ptr->pass] - 1 -

+                               png_pass_start[png_ptr->pass]) /

+                              png_pass_inc[png_ptr->pass];

+

+            if(!(png_ptr->transformations & PNG_INTERLACE))

+            {

+                png_ptr->num_rows = (png_ptr->height +

+                                     png_pass_yinc[png_ptr->pass] - 1 -

+                                     png_pass_ystart[png_ptr->pass]) /

+                                    png_pass_yinc[png_ptr->pass];

+                if(!(png_ptr->num_rows))

+                    continue;

+            }

+            else  /* if (png_ptr->transformations & PNG_INTERLACE) */

+                break;

+        }

+        while(png_ptr->iwidth == 0);

 

-      if (png_ptr->pass < 7)

-         return;

-   }

+        if(png_ptr->pass < 7)

+            return;

+    }

 #endif /* PNG_READ_INTERLACING_SUPPORTED */

 

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

-   {

-      PNG_IDAT;

-      char extra;

-      int ret;

-

-      png_ptr->zstream.next_out = (Byte *)&extra;

-      png_ptr->zstream.avail_out = (uInt)1;

-      for (;;)

-      {

-         if (!(png_ptr->zstream.avail_in))

-         {

-            while (!png_ptr->idat_size)

+    if(!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

+    {

+        PNG_IDAT;

+        char extra;

+        int ret;

+

+        png_ptr->zstream.next_out = (Byte *)&extra;

+        png_ptr->zstream.avail_out = (uInt)1;

+        for(;;)

+        {

+            if(!(png_ptr->zstream.avail_in))

             {

-               png_byte chunk_length[4];

-

-               png_crc_finish(png_ptr, 0);

-

-               png_read_data(png_ptr, chunk_length, 4);

-               png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);

-               png_reset_crc(png_ptr);

-               png_crc_read(png_ptr, png_ptr->chunk_name, 4);

-               if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

-                  png_error(png_ptr, "Not enough image data");

+                while(!png_ptr->idat_size)

+                {

+                    png_byte chunk_length[4];

+

+                    png_crc_finish(png_ptr, 0);

+

+                    png_read_data(png_ptr, chunk_length, 4);

+                    png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);

+                    png_reset_crc(png_ptr);

+                    png_crc_read(png_ptr, png_ptr->chunk_name, 4);

+                    if(png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+                        png_error(png_ptr, "Not enough image data");

+

+                }

+                png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;

+                png_ptr->zstream.next_in = png_ptr->zbuf;

+                if(png_ptr->zbuf_size > png_ptr->idat_size)

+                    png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;

+                png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);

+                png_ptr->idat_size -= png_ptr->zstream.avail_in;

+            }

+            ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

+            if(ret == Z_STREAM_END)

+            {

+                if(!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||

+                   png_ptr->idat_size)

+                    png_warning(png_ptr, "Extra compressed data");

+                png_ptr->mode |= PNG_AFTER_IDAT;

+                png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

+                break;

+            }

+            if(ret != Z_OK)

+                png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :

+                          "Decompression Error");

 

+            if(!(png_ptr->zstream.avail_out))

+            {

+                png_warning(png_ptr, "Extra compressed data");

+                png_ptr->mode |= PNG_AFTER_IDAT;

+                png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

+                break;

             }

-            png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;

-            png_ptr->zstream.next_in = png_ptr->zbuf;

-            if (png_ptr->zbuf_size > png_ptr->idat_size)

-               png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;

-            png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);

-            png_ptr->idat_size -= png_ptr->zstream.avail_in;

-         }

-         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

-         if (ret == Z_STREAM_END)

-         {

-            if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||

-               png_ptr->idat_size)

-               png_warning(png_ptr, "Extra compressed data");

-            png_ptr->mode |= PNG_AFTER_IDAT;

-            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

-            break;

-         }

-         if (ret != Z_OK)

-            png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :

-                      "Decompression Error");

-

-         if (!(png_ptr->zstream.avail_out))

-         {

-            png_warning(png_ptr, "Extra compressed data");

-            png_ptr->mode |= PNG_AFTER_IDAT;

-            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

-            break;

-         }

 

-      }

-      png_ptr->zstream.avail_out = 0;

-   }

+        }

+        png_ptr->zstream.avail_out = 0;

+    }

 

-   if (png_ptr->idat_size || png_ptr->zstream.avail_in)

-      png_warning(png_ptr, "Extra compression data");

+    if(png_ptr->idat_size || png_ptr->zstream.avail_in)

+        png_warning(png_ptr, "Extra compression data");

 

-   inflateReset(&png_ptr->zstream);

+    inflateReset(&png_ptr->zstream);

 

-   png_ptr->mode |= PNG_AFTER_IDAT;

+    png_ptr->mode |= PNG_AFTER_IDAT;

 }

 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */

 

@@ -3144,213 +3155,213 @@ void /* PRIVATE */
 png_read_start_row(png_structp png_ptr)

 {

 #ifdef PNG_READ_INTERLACING_SUPPORTED

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

-   PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+    /* Start of interlace block */

+    PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

 

-   /* Offset to next interlace block */

-   PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+    /* Offset to next interlace block */

+    PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

 

-   /* Start of interlace block in the y direction */

-   PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

+    /* Start of interlace block in the y direction */

+    PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

 

-   /* Offset to next interlace block in the y direction */

-   PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

+    /* Offset to next interlace block in the y direction */

+    PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

 #endif

 

-   int max_pixel_depth;

-   png_size_t row_bytes;

+    int max_pixel_depth;

+    png_size_t row_bytes;

 

-   png_debug(1, "in png_read_start_row");

-   png_ptr->zstream.avail_in = 0;

-   png_init_read_transformations(png_ptr);

+    png_debug(1, "in png_read_start_row");

+    png_ptr->zstream.avail_in = 0;

+    png_init_read_transformations(png_ptr);

 #ifdef PNG_READ_INTERLACING_SUPPORTED

-   if (png_ptr->interlaced)

-   {

-      if (!(png_ptr->transformations & PNG_INTERLACE))

-         png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -

-            png_pass_ystart[0]) / png_pass_yinc[0];

-      else

-         png_ptr->num_rows = png_ptr->height;

-

-      png_ptr->iwidth = (png_ptr->width +

-         png_pass_inc[png_ptr->pass] - 1 -

-         png_pass_start[png_ptr->pass]) /

-         png_pass_inc[png_ptr->pass];

-   }

-   else

+    if(png_ptr->interlaced)

+    {

+        if(!(png_ptr->transformations & PNG_INTERLACE))

+            png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -

+                                 png_pass_ystart[0]) / png_pass_yinc[0];

+        else

+            png_ptr->num_rows = png_ptr->height;

+

+        png_ptr->iwidth = (png_ptr->width +

+                           png_pass_inc[png_ptr->pass] - 1 -

+                           png_pass_start[png_ptr->pass]) /

+                          png_pass_inc[png_ptr->pass];

+    }

+    else

 #endif /* PNG_READ_INTERLACING_SUPPORTED */

-   {

-      png_ptr->num_rows = png_ptr->height;

-      png_ptr->iwidth = png_ptr->width;

-   }

-   max_pixel_depth = png_ptr->pixel_depth;

+    {

+        png_ptr->num_rows = png_ptr->height;

+        png_ptr->iwidth = png_ptr->width;

+    }

+    max_pixel_depth = png_ptr->pixel_depth;

 

 #ifdef PNG_READ_PACK_SUPPORTED

-   if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)

-      max_pixel_depth = 8;

+    if((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)

+        max_pixel_depth = 8;

 #endif

 

 #ifdef PNG_READ_EXPAND_SUPPORTED

-   if (png_ptr->transformations & PNG_EXPAND)

-   {

-      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      {

-         if (png_ptr->num_trans)

-            max_pixel_depth = 32;

-         else

-            max_pixel_depth = 24;

-      }

-      else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

-      {

-         if (max_pixel_depth < 8)

-            max_pixel_depth = 8;

-         if (png_ptr->num_trans)

-            max_pixel_depth *= 2;

-      }

-      else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

-      {

-         if (png_ptr->num_trans)

-         {

-            max_pixel_depth *= 4;

-            max_pixel_depth /= 3;

-         }

-      }

-   }

+    if(png_ptr->transformations & PNG_EXPAND)

+    {

+        if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+        {

+            if(png_ptr->num_trans)

+                max_pixel_depth = 32;

+            else

+                max_pixel_depth = 24;

+        }

+        else if(png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

+        {

+            if(max_pixel_depth < 8)

+                max_pixel_depth = 8;

+            if(png_ptr->num_trans)

+                max_pixel_depth *= 2;

+        }

+        else if(png_ptr->color_type == PNG_COLOR_TYPE_RGB)

+        {

+            if(png_ptr->num_trans)

+            {

+                max_pixel_depth *= 4;

+                max_pixel_depth /= 3;

+            }

+        }

+    }

 #endif

 

 #ifdef PNG_READ_FILLER_SUPPORTED

-   if (png_ptr->transformations & (PNG_FILLER))

-   {

-      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-         max_pixel_depth = 32;

-      else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

-      {

-         if (max_pixel_depth <= 8)

-            max_pixel_depth = 16;

-         else

-            max_pixel_depth = 32;

-      }

-      else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

-      {

-         if (max_pixel_depth <= 32)

+    if(png_ptr->transformations & (PNG_FILLER))

+    {

+        if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

             max_pixel_depth = 32;

-         else

-            max_pixel_depth = 64;

-      }

-   }

+        else if(png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

+        {

+            if(max_pixel_depth <= 8)

+                max_pixel_depth = 16;

+            else

+                max_pixel_depth = 32;

+        }

+        else if(png_ptr->color_type == PNG_COLOR_TYPE_RGB)

+        {

+            if(max_pixel_depth <= 32)

+                max_pixel_depth = 32;

+            else

+                max_pixel_depth = 64;

+        }

+    }

 #endif

 

 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

-   if (png_ptr->transformations & PNG_GRAY_TO_RGB)

-   {

-      if (

+    if(png_ptr->transformations & PNG_GRAY_TO_RGB)

+    {

+        if(

 #ifdef PNG_READ_EXPAND_SUPPORTED

-        (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||

+            (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||

 #endif

 #ifdef PNG_READ_FILLER_SUPPORTED

-        (png_ptr->transformations & (PNG_FILLER)) ||

+            (png_ptr->transformations & (PNG_FILLER)) ||

 #endif

-        png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         if (max_pixel_depth <= 16)

-            max_pixel_depth = 32;

-         else

-            max_pixel_depth = 64;

-      }

-      else

-      {

-         if (max_pixel_depth <= 8)

-           {

-             if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-               max_pixel_depth = 32;

-             else

-               max_pixel_depth = 24;

-           }

-         else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-            max_pixel_depth = 64;

-         else

-            max_pixel_depth = 48;

-      }

-   }

+            png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+        {

+            if(max_pixel_depth <= 16)

+                max_pixel_depth = 32;

+            else

+                max_pixel_depth = 64;

+        }

+        else

+        {

+            if(max_pixel_depth <= 8)

+            {

+                if(png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+                    max_pixel_depth = 32;

+                else

+                    max_pixel_depth = 24;

+            }

+            else if(png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+                max_pixel_depth = 64;

+            else

+                max_pixel_depth = 48;

+        }

+    }

 #endif

 

 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \

 defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)

-   if (png_ptr->transformations & PNG_USER_TRANSFORM)

-     {

-       int user_pixel_depth = png_ptr->user_transform_depth*

-         png_ptr->user_transform_channels;

-       if (user_pixel_depth > max_pixel_depth)

-         max_pixel_depth=user_pixel_depth;

-     }

-#endif

-

-   /* Align the width on the next larger 8 pixels.  Mainly used

-    * for interlacing

-    */

-   row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));

-   /* Calculate the maximum bytes needed, adding a byte and a pixel

-    * for safety's sake

-    */

-   row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) +

-      1 + ((max_pixel_depth + 7) >> 3);

+    if(png_ptr->transformations & PNG_USER_TRANSFORM)

+    {

+        int user_pixel_depth = png_ptr->user_transform_depth *

+                               png_ptr->user_transform_channels;

+        if(user_pixel_depth > max_pixel_depth)

+            max_pixel_depth = user_pixel_depth;

+    }

+#endif

+

+    /* Align the width on the next larger 8 pixels.  Mainly used

+     * for interlacing

+     */

+    row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));

+    /* Calculate the maximum bytes needed, adding a byte and a pixel

+     * for safety's sake

+     */

+    row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) +

+                1 + ((max_pixel_depth + 7) >> 3);

 #ifdef PNG_MAX_MALLOC_64K

-   if (row_bytes > (png_uint_32)65536L)

-      png_error(png_ptr, "This image requires a row greater than 64KB");

+    if(row_bytes > (png_uint_32)65536L)

+        png_error(png_ptr, "This image requires a row greater than 64KB");

 #endif

 

-   if (row_bytes + 48 > png_ptr->old_big_row_buf_size)

-   {

-     png_free(png_ptr, png_ptr->big_row_buf);

-     if (png_ptr->interlaced)

-        png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,

-            row_bytes + 48);

-     else

-        png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr,

-            row_bytes + 48);

-     png_ptr->old_big_row_buf_size = row_bytes + 48;

+    if(row_bytes + 48 > png_ptr->old_big_row_buf_size)

+    {

+        png_free(png_ptr, png_ptr->big_row_buf);

+        if(png_ptr->interlaced)

+            png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,

+                                   row_bytes + 48);

+        else

+            png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr,

+                                   row_bytes + 48);

+        png_ptr->old_big_row_buf_size = row_bytes + 48;

 

 #ifdef PNG_ALIGNED_MEMORY_SUPPORTED

-     /* Use 16-byte aligned memory for row_buf with at least 16 bytes

-      * of padding before and after row_buf.

-      */

-     png_ptr->row_buf = png_ptr->big_row_buf + 32

-         - (((png_alloc_size_t)&(png_ptr->big_row_buf[0]) + 15) % 16);

-     png_ptr->old_big_row_buf_size = row_bytes + 48;

+        /* Use 16-byte aligned memory for row_buf with at least 16 bytes

+         * of padding before and after row_buf.

+         */

+        png_ptr->row_buf = png_ptr->big_row_buf + 32

+                           - (((png_alloc_size_t) & (png_ptr->big_row_buf[0]) + 15) % 16);

+        png_ptr->old_big_row_buf_size = row_bytes + 48;

 #else

-     /* Use 32 bytes of padding before and 16 bytes after row_buf. */

-     png_ptr->row_buf = png_ptr->big_row_buf + 32;

+        /* Use 32 bytes of padding before and 16 bytes after row_buf. */

+        png_ptr->row_buf = png_ptr->big_row_buf + 32;

 #endif

-     png_ptr->old_big_row_buf_size = row_bytes + 48;

-   }

+        png_ptr->old_big_row_buf_size = row_bytes + 48;

+    }

 

 #ifdef PNG_MAX_MALLOC_64K

-   if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)

-      png_error(png_ptr, "This image requires a row greater than 64KB");

-#endif

-   if ((png_uint_32)png_ptr->rowbytes > (png_uint_32)(PNG_SIZE_MAX - 1))

-      png_error(png_ptr, "Row has too many bytes to allocate in memory");

-

-   if (png_ptr->rowbytes + 1 > png_ptr->old_prev_row_size)

-   {

-      png_free(png_ptr, png_ptr->prev_row);

-      png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(

-        png_ptr->rowbytes + 1));

-      png_ptr->old_prev_row_size = png_ptr->rowbytes + 1;

-   }

-

-   png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);

-

-   png_debug1(3, "width = %lu,", png_ptr->width);

-   png_debug1(3, "height = %lu,", png_ptr->height);

-   png_debug1(3, "iwidth = %lu,", png_ptr->iwidth);

-   png_debug1(3, "num_rows = %lu,", png_ptr->num_rows);

-   png_debug1(3, "rowbytes = %lu,", png_ptr->rowbytes);

-   png_debug1(3, "irowbytes = %lu",

-       PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1);

-

-   png_ptr->flags |= PNG_FLAG_ROW_INIT;

+    if((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)

+        png_error(png_ptr, "This image requires a row greater than 64KB");

+#endif

+    if((png_uint_32)png_ptr->rowbytes > (png_uint_32)(PNG_SIZE_MAX - 1))

+        png_error(png_ptr, "Row has too many bytes to allocate in memory");

+

+    if(png_ptr->rowbytes + 1 > png_ptr->old_prev_row_size)

+    {

+        png_free(png_ptr, png_ptr->prev_row);

+        png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(

+                                png_ptr->rowbytes + 1));

+        png_ptr->old_prev_row_size = png_ptr->rowbytes + 1;

+    }

+

+    png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);

+

+    png_debug1(3, "width = %lu,", png_ptr->width);

+    png_debug1(3, "height = %lu,", png_ptr->height);

+    png_debug1(3, "iwidth = %lu,", png_ptr->iwidth);

+    png_debug1(3, "num_rows = %lu,", png_ptr->num_rows);

+    png_debug1(3, "rowbytes = %lu,", png_ptr->rowbytes);

+    png_debug1(3, "irowbytes = %lu",

+               PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1);

+

+    png_ptr->flags |= PNG_FLAG_ROW_INIT;

 }

 #endif /* PNG_READ_SUPPORTED */

diff --git a/src/libpng/pngset.c b/src/libpng/pngset.c
index 90ef1b4cf..a9fdaf92c 100644
--- a/src/libpng/pngset.c
+++ b/src/libpng/pngset.c
@@ -25,13 +25,13 @@
 void PNGAPI

 png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)

 {

-   png_debug1(1, "in %s storage function", "bKGD");

+    png_debug1(1, "in %s storage function", "bKGD");

 

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

-      return;

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

+        return;

 

-   png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));

-   info_ptr->valid |= PNG_INFO_bKGD;

+    png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));

+    info_ptr->valid |= PNG_INFO_bKGD;

 }

 #endif

 

@@ -39,73 +39,73 @@ png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
 #ifdef PNG_FLOATING_POINT_SUPPORTED

 void PNGAPI

 png_set_cHRM(png_structp png_ptr, png_infop info_ptr,

-   double white_x, double white_y, double red_x, double red_y,

-   double green_x, double green_y, double blue_x, double blue_y)

+             double white_x, double white_y, double red_x, double red_y,

+             double green_x, double green_y, double blue_x, double blue_y)

 {

-   png_debug1(1, "in %s storage function", "cHRM");

-

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

-      return;

-

-   info_ptr->x_white = (float)white_x;

-   info_ptr->y_white = (float)white_y;

-   info_ptr->x_red   = (float)red_x;

-   info_ptr->y_red   = (float)red_y;

-   info_ptr->x_green = (float)green_x;

-   info_ptr->y_green = (float)green_y;

-   info_ptr->x_blue  = (float)blue_x;

-   info_ptr->y_blue  = (float)blue_y;

+    png_debug1(1, "in %s storage function", "cHRM");

+

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

+        return;

+

+    info_ptr->x_white = (float)white_x;

+    info_ptr->y_white = (float)white_y;

+    info_ptr->x_red   = (float)red_x;

+    info_ptr->y_red   = (float)red_y;

+    info_ptr->x_green = (float)green_x;

+    info_ptr->y_green = (float)green_y;

+    info_ptr->x_blue  = (float)blue_x;

+    info_ptr->y_blue  = (float)blue_y;

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);

-   info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);

-   info_ptr->int_x_red   = (png_fixed_point)(  red_x*100000.+0.5);

-   info_ptr->int_y_red   = (png_fixed_point)(  red_y*100000.+0.5);

-   info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);

-   info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);

-   info_ptr->int_x_blue  = (png_fixed_point)( blue_x*100000.+0.5);

-   info_ptr->int_y_blue  = (png_fixed_point)( blue_y*100000.+0.5);

+    info_ptr->int_x_white = (png_fixed_point)(white_x * 100000. + 0.5);

+    info_ptr->int_y_white = (png_fixed_point)(white_y * 100000. + 0.5);

+    info_ptr->int_x_red   = (png_fixed_point)(red_x * 100000. + 0.5);

+    info_ptr->int_y_red   = (png_fixed_point)(red_y * 100000. + 0.5);

+    info_ptr->int_x_green = (png_fixed_point)(green_x * 100000. + 0.5);

+    info_ptr->int_y_green = (png_fixed_point)(green_y * 100000. + 0.5);

+    info_ptr->int_x_blue  = (png_fixed_point)(blue_x * 100000. + 0.5);

+    info_ptr->int_y_blue  = (png_fixed_point)(blue_y * 100000. + 0.5);

 #endif

-   info_ptr->valid |= PNG_INFO_cHRM;

+    info_ptr->valid |= PNG_INFO_cHRM;

 }

 #endif /* PNG_FLOATING_POINT_SUPPORTED */

 

 #ifdef PNG_FIXED_POINT_SUPPORTED

 void PNGAPI

 png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,

-   png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,

-   png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,

-   png_fixed_point blue_x, png_fixed_point blue_y)

+                   png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,

+                   png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,

+                   png_fixed_point blue_x, png_fixed_point blue_y)

 {

-   png_debug1(1, "in %s storage function", "cHRM fixed");

+    png_debug1(1, "in %s storage function", "cHRM fixed");

 

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

-      return;

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

+        return;

 

 #ifdef PNG_CHECK_cHRM_SUPPORTED

-   if (png_check_cHRM_fixed(png_ptr,

-      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y))

+    if(png_check_cHRM_fixed(png_ptr,

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

+    {

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

 #endif /* PNG_cHRM_SUPPORTED */

@@ -115,65 +115,65 @@ png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
 void PNGAPI

 png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)

 {

-   double png_gamma;

-

-   png_debug1(1, "in %s storage function", "gAMA");

-

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

-      return;

-

-   /* Check for overflow */

-   if (file_gamma > 21474.83)

-   {

-      png_warning(png_ptr, "Limiting gamma to 21474.83");

-      png_gamma=21474.83;

-   }

-   else

-      png_gamma = file_gamma;

-   info_ptr->gamma = (float)png_gamma;

+    double png_gamma;

+

+    png_debug1(1, "in %s storage function", "gAMA");

+

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

+        return;

+

+    /* Check for overflow */

+    if(file_gamma > 21474.83)

+    {

+        png_warning(png_ptr, "Limiting gamma to 21474.83");

+        png_gamma = 21474.83;

+    }

+    else

+        png_gamma = file_gamma;

+    info_ptr->gamma = (float)png_gamma;

 #ifdef PNG_FIXED_POINT_SUPPORTED

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

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

 #endif

-   info_ptr->valid |= PNG_INFO_gAMA;

-   if (png_gamma == 0.0)

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

+    info_ptr->valid |= PNG_INFO_gAMA;

+    if(png_gamma == 0.0)

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

 }

 #endif

 void PNGAPI

 png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point

-   int_gamma)

+                   int_gamma)

 {

-   png_fixed_point png_gamma;

-

-   png_debug1(1, "in %s storage function", "gAMA");

-

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

-      return;

-

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

-   }

-   else

-   {

-      if (int_gamma < 0)

-      {

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

-         png_gamma = 0;

-      }

-      else

-         png_gamma = int_gamma;

-   }

+    png_fixed_point png_gamma;

+

+    png_debug1(1, "in %s storage function", "gAMA");

+

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

+        return;

+

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

+    }

+    else

+    {

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

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

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   info_ptr->int_gamma = png_gamma;

+    info_ptr->int_gamma = png_gamma;

 #endif

-   info_ptr->valid |= PNG_INFO_gAMA;

-   if (png_gamma == 0)

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

+    info_ptr->valid |= PNG_INFO_gAMA;

+    if(png_gamma == 0)

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

 }

 #endif

 

@@ -181,172 +181,172 @@ png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
 void PNGAPI

 png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)

 {

-   int i;

+    int i;

 

-   png_debug1(1, "in %s storage function", "hIST");

+    png_debug1(1, "in %s storage function", "hIST");

 

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

-      return;

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

+        return;

 

-   if (info_ptr->num_palette == 0 || info_ptr->num_palette

+    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_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);

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

-   }

-

-   for (i = 0; i < info_ptr->num_palette; i++)

-      png_ptr->hist[i] = hist[i];

-   info_ptr->hist = png_ptr->hist;

-   info_ptr->valid |= PNG_INFO_hIST;

-

-   info_ptr->free_me |= PNG_FREE_HIST;

+    {

+        png_warning(png_ptr,

+                    "Invalid palette size, hIST allocation skipped");

+        return;

+    }

+

+    png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);

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

+    }

+

+    for(i = 0; i < info_ptr->num_palette; i++)

+        png_ptr->hist[i] = hist[i];

+    info_ptr->hist = png_ptr->hist;

+    info_ptr->valid |= PNG_INFO_hIST;

+

+    info_ptr->free_me |= PNG_FREE_HIST;

 }

 #endif

 

 void PNGAPI

 png_set_IHDR(png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 width, png_uint_32 height, int bit_depth,

-   int color_type, int interlace_type, int compression_type,

-   int filter_type)

+             png_uint_32 width, png_uint_32 height, int bit_depth,

+             int color_type, int interlace_type, int compression_type,

+             int filter_type)

 {

-   png_debug1(1, "in %s storage function", "IHDR");

-

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

-      return;

-

-   info_ptr->width = width;

-   info_ptr->height = height;

-   info_ptr->bit_depth = (png_byte)bit_depth;

-   info_ptr->color_type = (png_byte)color_type;

-   info_ptr->compression_type = (png_byte)compression_type;

-   info_ptr->filter_type = (png_byte)filter_type;

-   info_ptr->interlace_type = (png_byte)interlace_type;

-

-   png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,

-       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,

-       info_ptr->compression_type, info_ptr->filter_type);

-

-   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      info_ptr->channels = 1;

-   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)

-      info_ptr->channels = 3;

-   else

-      info_ptr->channels = 1;

-   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)

-      info_ptr->channels++;

-   info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);

-

-   /* Check for potential overflow */

-   if (width > (PNG_UINT_32_MAX

-                 >> 3)      /* 8-byte RGBA pixels */

-                 - 64       /* bigrowbuf hack */

-                 - 1        /* filter byte */

-                 - 7*8      /* rounding of width to multiple of 8 pixels */

-                 - 8)       /* extra max_pixel_depth pad */

-      info_ptr->rowbytes = 0;

-   else

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

+    png_debug1(1, "in %s storage function", "IHDR");

+

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

+        return;

+

+    info_ptr->width = width;

+    info_ptr->height = height;

+    info_ptr->bit_depth = (png_byte)bit_depth;

+    info_ptr->color_type = (png_byte)color_type;

+    info_ptr->compression_type = (png_byte)compression_type;

+    info_ptr->filter_type = (png_byte)filter_type;

+    info_ptr->interlace_type = (png_byte)interlace_type;

+

+    png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height,

+                   info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,

+                   info_ptr->compression_type, info_ptr->filter_type);

+

+    if(info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+        info_ptr->channels = 1;

+    else if(info_ptr->color_type & PNG_COLOR_MASK_COLOR)

+        info_ptr->channels = 3;

+    else

+        info_ptr->channels = 1;

+    if(info_ptr->color_type & PNG_COLOR_MASK_ALPHA)

+        info_ptr->channels++;

+    info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);

+

+    /* Check for potential overflow */

+    if(width > (PNG_UINT_32_MAX

+                >> 3)      /* 8-byte RGBA pixels */

+       - 64       /* bigrowbuf hack */

+       - 1        /* filter byte */

+       - 7 * 8    /* rounding of width to multiple of 8 pixels */

+       - 8)       /* extra max_pixel_depth pad */

+        info_ptr->rowbytes = 0;

+    else

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

 }

 

 #ifdef PNG_oFFs_SUPPORTED

 void PNGAPI

 png_set_oFFs(png_structp png_ptr, png_infop info_ptr,

-   png_int_32 offset_x, png_int_32 offset_y, int unit_type)

+             png_int_32 offset_x, png_int_32 offset_y, int unit_type)

 {

-   png_debug1(1, "in %s storage function", "oFFs");

+    png_debug1(1, "in %s storage function", "oFFs");

 

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

-      return;

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

+        return;

 

-   info_ptr->x_offset = offset_x;

-   info_ptr->y_offset = offset_y;

-   info_ptr->offset_unit_type = (png_byte)unit_type;

-   info_ptr->valid |= PNG_INFO_oFFs;

+    info_ptr->x_offset = offset_x;

+    info_ptr->y_offset = offset_y;

+    info_ptr->offset_unit_type = (png_byte)unit_type;

+    info_ptr->valid |= PNG_INFO_oFFs;

 }

 #endif

 

 #ifdef PNG_pCAL_SUPPORTED

 void PNGAPI

 png_set_pCAL(png_structp png_ptr, png_infop info_ptr,

-   png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,

-   png_charp units, png_charpp params)

+             png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,

+             png_charp units, png_charpp params)

 {

-   png_size_t length;

-   int i;

-

-   png_debug1(1, "in %s storage function", "pCAL");

-

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

-      return;

-

-   length = png_strlen(purpose) + 1;

-   png_debug1(3, "allocating purpose for info (%lu bytes)",

-     (unsigned long)length);

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

-   if (info_ptr->pcal_purpose == NULL)

-   {

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

-      return;

-   }

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

-

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

-   info_ptr->pcal_X0 = X0;

-   info_ptr->pcal_X1 = X1;

-   info_ptr->pcal_type = (png_byte)type;

-   info_ptr->pcal_nparams = (png_byte)nparams;

-

-   length = png_strlen(units) + 1;

-   png_debug1(3, "allocating units for info (%lu bytes)",

-     (unsigned long)length);

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

-   if (info_ptr->pcal_units == NULL)

-   {

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

-      return;

-   }

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

-

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

-      (png_size_t)((nparams + 1) * png_sizeof(png_charp)));

-   if (info_ptr->pcal_params == NULL)

-   {

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

-      return;

-   }

-

-   png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp));

-

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

-   {

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

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

-        (unsigned long)length);

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

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

-      {

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

-         return;

-      }

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

-   }

-

-   info_ptr->valid |= PNG_INFO_pCAL;

-   info_ptr->free_me |= PNG_FREE_PCAL;

+    png_size_t length;

+    int i;

+

+    png_debug1(1, "in %s storage function", "pCAL");

+

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

+        return;

+

+    length = png_strlen(purpose) + 1;

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

+               (unsigned long)length);

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

+    if(info_ptr->pcal_purpose == NULL)

+    {

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

+        return;

+    }

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

+

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

+    info_ptr->pcal_X0 = X0;

+    info_ptr->pcal_X1 = X1;

+    info_ptr->pcal_type = (png_byte)type;

+    info_ptr->pcal_nparams = (png_byte)nparams;

+

+    length = png_strlen(units) + 1;

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

+               (unsigned long)length);

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

+    if(info_ptr->pcal_units == NULL)

+    {

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

+        return;

+    }

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

+

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

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

+    if(info_ptr->pcal_params == NULL)

+    {

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

+        return;

+    }

+

+    png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp));

+

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

+    {

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

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

+                   (unsigned long)length);

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

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

+        {

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

+            return;

+        }

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

+    }

+

+    info_ptr->valid |= PNG_INFO_pCAL;

+    info_ptr->free_me |= PNG_FREE_PCAL;

 }

 #endif

 

@@ -356,59 +356,59 @@ void PNGAPI
 png_set_sCAL(png_structp png_ptr, png_infop info_ptr,

              int unit, double width, double height)

 {

-   png_debug1(1, "in %s storage function", "sCAL");

+    png_debug1(1, "in %s storage function", "sCAL");

 

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

-      return;

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

+        return;

 

-   info_ptr->scal_unit = (png_byte)unit;

-   info_ptr->scal_pixel_width = width;

-   info_ptr->scal_pixel_height = height;

+    info_ptr->scal_unit = (png_byte)unit;

+    info_ptr->scal_pixel_width = width;

+    info_ptr->scal_pixel_height = height;

 

-   info_ptr->valid |= PNG_INFO_sCAL;

+    info_ptr->valid |= PNG_INFO_sCAL;

 }

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

 void PNGAPI

 png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,

-             int unit, png_charp swidth, png_charp sheight)

+               int unit, png_charp swidth, png_charp sheight)

 {

-   png_size_t length;

-

-   png_debug1(1, "in %s storage function", "sCAL");

-

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

-      return;

-

-   info_ptr->scal_unit = (png_byte)unit;

-

-   length = png_strlen(swidth) + 1;

-   png_debug1(3, "allocating unit for info (%u bytes)",

-      (unsigned int)length);

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

-   if (info_ptr->scal_s_width == NULL)

-   {

-      png_warning(png_ptr,

-         "Memory allocation failed while processing sCAL");

-      return;

-   }

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

-

-   length = png_strlen(sheight) + 1;

-   png_debug1(3, "allocating unit for info (%u bytes)",

-      (unsigned int)length);

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

-   if (info_ptr->scal_s_height == NULL)

-   {

-      png_free (png_ptr, info_ptr->scal_s_width);

-      info_ptr->scal_s_width = NULL;

-      png_warning(png_ptr,

-         "Memory allocation failed while processing sCAL");

-      return;

-   }

-   png_memcpy(info_ptr->scal_s_height, sheight, length);

-   info_ptr->valid |= PNG_INFO_sCAL;

-   info_ptr->free_me |= PNG_FREE_SCAL;

+    png_size_t length;

+

+    png_debug1(1, "in %s storage function", "sCAL");

+

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

+        return;

+

+    info_ptr->scal_unit = (png_byte)unit;

+

+    length = png_strlen(swidth) + 1;

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

+               (unsigned int)length);

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

+    if(info_ptr->scal_s_width == NULL)

+    {

+        png_warning(png_ptr,

+                    "Memory allocation failed while processing sCAL");

+        return;

+    }

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

+

+    length = png_strlen(sheight) + 1;

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

+               (unsigned int)length);

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

+    if(info_ptr->scal_s_height == NULL)

+    {

+        png_free(png_ptr, info_ptr->scal_s_width);

+        info_ptr->scal_s_width = NULL;

+        png_warning(png_ptr,

+                    "Memory allocation failed while processing sCAL");

+        return;

+    }

+    png_memcpy(info_ptr->scal_s_height, sheight, length);

+    info_ptr->valid |= PNG_INFO_sCAL;

+    info_ptr->free_me |= PNG_FREE_SCAL;

 }

 #endif

 #endif

@@ -417,74 +417,74 @@ png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
 #ifdef PNG_pHYs_SUPPORTED

 void PNGAPI

 png_set_pHYs(png_structp png_ptr, png_infop info_ptr,

-   png_uint_32 res_x, png_uint_32 res_y, int unit_type)

+             png_uint_32 res_x, png_uint_32 res_y, int unit_type)

 {

-   png_debug1(1, "in %s storage function", "pHYs");

+    png_debug1(1, "in %s storage function", "pHYs");

 

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

-      return;

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

+        return;

 

-   info_ptr->x_pixels_per_unit = res_x;

-   info_ptr->y_pixels_per_unit = res_y;

-   info_ptr->phys_unit_type = (png_byte)unit_type;

-   info_ptr->valid |= PNG_INFO_pHYs;

+    info_ptr->x_pixels_per_unit = res_x;

+    info_ptr->y_pixels_per_unit = res_y;

+    info_ptr->phys_unit_type = (png_byte)unit_type;

+    info_ptr->valid |= PNG_INFO_pHYs;

 }

 #endif

 

 void PNGAPI

 png_set_PLTE(png_structp png_ptr, png_infop info_ptr,

-   png_colorp palette, int num_palette)

+             png_colorp palette, int num_palette)

 {

 

-   png_debug1(1, "in %s storage function", "PLTE");

-

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

-      return;

-

-   if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)

-   {

-      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-         png_error(png_ptr, "Invalid palette length");

-      else

-      {

-         png_warning(png_ptr, "Invalid palette length");

-         return;

-      }

-   }

-

-   /* It may not actually be necessary to set png_ptr->palette here;

-    * we do it for backward compatibility with the way the png_handle_tRNS

-    * function used to do the allocation.

-    */

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

-

-   /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead

-    * of num_palette entries, in case of an invalid PNG file that has

-    * too-large sample values.

-    */

-   png_ptr->palette = (png_colorp)png_calloc(png_ptr,

-      PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));

-   png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));

-   info_ptr->palette = png_ptr->palette;

-   info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;

-

-   info_ptr->free_me |= PNG_FREE_PLTE;

-

-   info_ptr->valid |= PNG_INFO_PLTE;

+    png_debug1(1, "in %s storage function", "PLTE");

+

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

+        return;

+

+    if(num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)

+    {

+        if(info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+            png_error(png_ptr, "Invalid palette length");

+        else

+        {

+            png_warning(png_ptr, "Invalid palette length");

+            return;

+        }

+    }

+

+    /* It may not actually be necessary to set png_ptr->palette here;

+     * we do it for backward compatibility with the way the png_handle_tRNS

+     * function used to do the allocation.

+     */

+    png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);

+

+    /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead

+     * of num_palette entries, in case of an invalid PNG file that has

+     * too-large sample values.

+     */

+    png_ptr->palette = (png_colorp)png_calloc(png_ptr,

+                       PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));

+    png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));

+    info_ptr->palette = png_ptr->palette;

+    info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;

+

+    info_ptr->free_me |= PNG_FREE_PLTE;

+

+    info_ptr->valid |= PNG_INFO_PLTE;

 }

 

 #ifdef PNG_sBIT_SUPPORTED

 void PNGAPI

 png_set_sBIT(png_structp png_ptr, png_infop info_ptr,

-   png_color_8p sig_bit)

+             png_color_8p sig_bit)

 {

-   png_debug1(1, "in %s storage function", "sBIT");

+    png_debug1(1, "in %s storage function", "sBIT");

 

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

-      return;

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

+        return;

 

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

-   info_ptr->valid |= PNG_INFO_sBIT;

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

+    info_ptr->valid |= PNG_INFO_sBIT;

 }

 #endif

 

@@ -492,81 +492,81 @@ png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
 void PNGAPI

 png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)

 {

-   png_debug1(1, "in %s storage function", "sRGB");

+    png_debug1(1, "in %s storage function", "sRGB");

 

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

-      return;

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

+        return;

 

-   info_ptr->srgb_intent = (png_byte)intent;

-   info_ptr->valid |= PNG_INFO_sRGB;

+    info_ptr->srgb_intent = (png_byte)intent;

+    info_ptr->valid |= PNG_INFO_sRGB;

 }

 

 void PNGAPI

 png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,

-   int intent)

+                           int intent)

 {

 #ifdef PNG_gAMA_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   float file_gamma;

+    float file_gamma;

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   png_fixed_point int_file_gamma;

+    png_fixed_point int_file_gamma;

 #endif

 #endif

 #ifdef PNG_cHRM_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;

+    float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;

 #endif

-   png_fixed_point 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_fixed_point 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

-   png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");

+    png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");

 

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

-      return;

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

+        return;

 

-   png_set_sRGB(png_ptr, info_ptr, intent);

+    png_set_sRGB(png_ptr, info_ptr, intent);

 

 #ifdef PNG_gAMA_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   file_gamma = (float).45455;

-   png_set_gAMA(png_ptr, info_ptr, file_gamma);

+    file_gamma = (float).45455;

+    png_set_gAMA(png_ptr, info_ptr, file_gamma);

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   int_file_gamma = 45455L;

-   png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);

+    int_file_gamma = 45455L;

+    png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);

 #endif

 #endif

 

 #ifdef PNG_cHRM_SUPPORTED

-   int_white_x = 31270L;

-   int_white_y = 32900L;

-   int_red_x   = 64000L;

-   int_red_y   = 33000L;

-   int_green_x = 30000L;

-   int_green_y = 60000L;

-   int_blue_x  = 15000L;

-   int_blue_y  =  6000L;

+    int_white_x = 31270L;

+    int_white_y = 32900L;

+    int_red_x   = 64000L;

+    int_red_y   = 33000L;

+    int_green_x = 30000L;

+    int_green_y = 60000L;

+    int_blue_x  = 15000L;

+    int_blue_y  =  6000L;

 

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   white_x = (float).3127;

-   white_y = (float).3290;

-   red_x   = (float).64;

-   red_y   = (float).33;

-   green_x = (float).30;

-   green_y = (float).60;

-   blue_x  = (float).15;

-   blue_y  = (float).06;

+    white_x = (float).3127;

+    white_y = (float).3290;

+    red_x   = (float).64;

+    red_y   = (float).33;

+    green_x = (float).30;

+    green_y = (float).60;

+    blue_x  = (float).15;

+    blue_y  = (float).06;

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

+    png_set_cHRM(png_ptr, info_ptr,

+                 white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);

 #endif

 #endif /* cHRM */

 }

@@ -579,44 +579,44 @@ png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
              png_charp name, int compression_type,

              png_charp profile, png_uint_32 proflen)

 {

-   png_charp new_iccp_name;

-   png_charp new_iccp_profile;

-   png_uint_32 length;

+    png_charp new_iccp_name;

+    png_charp new_iccp_profile;

+    png_uint_32 length;

 

-   png_debug1(1, "in %s storage function", "iCCP");

+    png_debug1(1, "in %s storage function", "iCCP");

 

-   if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)

-      return;

+    if(png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)

+        return;

 

-   length = png_strlen(name)+1;

-   new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);

-   if (new_iccp_name == NULL)

-   {

+    length = png_strlen(name) + 1;

+    new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);

+    if(new_iccp_name == NULL)

+    {

         png_warning(png_ptr, "Insufficient memory to process iCCP chunk");

-      return;

-   }

-   png_memcpy(new_iccp_name, name, length);

-   new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);

-   if (new_iccp_profile == NULL)

-   {

-      png_free (png_ptr, new_iccp_name);

-      png_warning(png_ptr,

-          "Insufficient memory to process iCCP profile");

-      return;

-   }

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

-

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

-

-   info_ptr->iccp_proflen = proflen;

-   info_ptr->iccp_name = new_iccp_name;

-   info_ptr->iccp_profile = new_iccp_profile;

-   /* Compression is always zero but is here so the API and info structure

-    * does not have to change if we introduce multiple compression types

-    */

-   info_ptr->iccp_compression = (png_byte)compression_type;

-   info_ptr->free_me |= PNG_FREE_ICCP;

-   info_ptr->valid |= PNG_INFO_iCCP;

+        return;

+    }

+    png_memcpy(new_iccp_name, name, length);

+    new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);

+    if(new_iccp_profile == NULL)

+    {

+        png_free(png_ptr, new_iccp_name);

+        png_warning(png_ptr,

+                    "Insufficient memory to process iCCP profile");

+        return;

+    }

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

+

+    png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);

+

+    info_ptr->iccp_proflen = proflen;

+    info_ptr->iccp_name = new_iccp_name;

+    info_ptr->iccp_profile = new_iccp_profile;

+    /* Compression is always zero but is here so the API and info structure

+     * does not have to change if we introduce multiple compression types

+     */

+    info_ptr->iccp_compression = (png_byte)compression_type;

+    info_ptr->free_me |= PNG_FREE_ICCP;

+    info_ptr->valid |= PNG_INFO_iCCP;

 }

 #endif

 

@@ -625,173 +625,173 @@ void PNGAPI
 png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,

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

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

 }

 

 int /* PRIVATE */

 png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,

                int num_text)

 {

-   int i;

-

-   png_debug1(1, "in %s storage function", ((png_ptr == NULL ||

-      png_ptr->chunk_name[0] == '\0') ?

-      "text" : (png_const_charp)png_ptr->chunk_name));

-

-   if (png_ptr == NULL || info_ptr == NULL || num_text == 0)

-      return(0);

-

-   /* Make sure we have enough space in the "text" array in info_struct

-    * to hold all of the incoming text_ptr objects.

-    */

-   if (info_ptr->num_text + num_text > info_ptr->max_text)

-   {

-      if (info_ptr->text != NULL)

-      {

-         png_textp old_text;

-         int old_max;

-

-         old_max = info_ptr->max_text;

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

-         old_text = info_ptr->text;

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

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

-         if (info_ptr->text == NULL)

-         {

+    int i;

+

+    png_debug1(1, "in %s storage function", ((png_ptr == NULL ||

+               png_ptr->chunk_name[0] == '\0') ?

+               "text" : (png_const_charp)png_ptr->chunk_name));

+

+    if(png_ptr == NULL || info_ptr == NULL || num_text == 0)

+        return(0);

+

+    /* Make sure we have enough space in the "text" array in info_struct

+     * to hold all of the incoming text_ptr objects.

+     */

+    if(info_ptr->num_text + num_text > info_ptr->max_text)

+    {

+        if(info_ptr->text != NULL)

+        {

+            png_textp old_text;

+            int old_max;

+

+            old_max = info_ptr->max_text;

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

+            old_text = info_ptr->text;

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

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

+            if(info_ptr->text == NULL)

+            {

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

-            return(1);

-         }

-         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *

-            png_sizeof(png_text)));

-         png_free(png_ptr, old_text);

-      }

-      else

-      {

-         info_ptr->max_text = num_text + 8;

-         info_ptr->num_text = 0;

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

-         info_ptr->free_me |= PNG_FREE_TEXT;

-      }

-      png_debug1(3, "allocated %d entries for info_ptr->text",

-         info_ptr->max_text);

-   }

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

-   {

-      png_size_t text_length, key_len;

-      png_size_t lang_len, lang_key_len;

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

-

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

-          continue;

-

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

-

-      if (text_ptr[i].compression <= 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

+        }

+        else

+        {

+            info_ptr->max_text = num_text + 8;

+            info_ptr->num_text = 0;

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

+            info_ptr->free_me |= PNG_FREE_TEXT;

+        }

+        png_debug1(3, "allocated %d entries for info_ptr->text",

+                   info_ptr->max_text);

+    }

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

+    {

+        png_size_t text_length, key_len;

+        png_size_t lang_len, lang_key_len;

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

+

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

+            continue;

+

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

+

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

+        {

             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

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

+        }

 #else /* PNG_iTXt_SUPPORTED */

-      {

-         png_warning(png_ptr, "iTXt chunk not supported");

-         continue;

-      }

+        {

+            png_warning(png_ptr, "iTXt chunk not supported");

+            continue;

+        }

 #endif

 

-      if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')

-      {

-         text_length = 0;

+        if(text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')

+        {

+            text_length = 0;

 #ifdef PNG_iTXt_SUPPORTED

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

-            textp->compression = PNG_ITXT_COMPRESSION_NONE;

-         else

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

+                textp->compression = PNG_ITXT_COMPRESSION_NONE;

+            else

 #endif

-            textp->compression = PNG_TEXT_COMPRESSION_NONE;

-      }

-

-      else

-      {

-         text_length = png_strlen(text_ptr[i].text);

-         textp->compression = text_ptr[i].compression;

-      }

-

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

-         (png_size_t)

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

-      if (textp->key == NULL)

-         return(1);

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

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

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

+                textp->compression = PNG_TEXT_COMPRESSION_NONE;

+        }

+

+        else

+        {

+            text_length = png_strlen(text_ptr[i].text);

+            textp->compression = text_ptr[i].compression;

+        }

+

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

+                                                (png_size_t)

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

+        if(textp->key == NULL)

+            return(1);

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

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

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

 #ifdef PNG_iTXt_SUPPORTED

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

-      {

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

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

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

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

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

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

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

-      }

-      else

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

+        {

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

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

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

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

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

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

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

+        }

+        else

 #endif

-      {

+        {

 #ifdef PNG_iTXt_SUPPORTED

-         textp->lang=NULL;

-         textp->lang_key=NULL;

+            textp->lang = NULL;

+            textp->lang_key = NULL;

 #endif

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

-      }

-      if (text_length)

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

-            (png_size_t)(text_length));

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

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

+        }

+        if(text_length)

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

+                       (png_size_t)(text_length));

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

 

 #ifdef PNG_iTXt_SUPPORTED

-      if (textp->compression > 0)

-      {

-         textp->text_length = 0;

-         textp->itxt_length = text_length;

-      }

-      else

+        if(textp->compression > 0)

+        {

+            textp->text_length = 0;

+            textp->itxt_length = text_length;

+        }

+        else

 #endif

 

-      {

-         textp->text_length = text_length;

+        {

+            textp->text_length = text_length;

 #ifdef PNG_iTXt_SUPPORTED

-         textp->itxt_length = 0;

+            textp->itxt_length = 0;

 #endif

-      }

-      info_ptr->num_text++;

-      png_debug1(3, "transferred text chunk %d", info_ptr->num_text);

-   }

-   return(0);

+        }

+        info_ptr->num_text++;

+        png_debug1(3, "transferred text chunk %d", info_ptr->num_text);

+    }

+    return(0);

 }

 #endif

 

@@ -799,66 +799,66 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
 void PNGAPI

 png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)

 {

-   png_debug1(1, "in %s storage function", "tIME");

+    png_debug1(1, "in %s storage function", "tIME");

 

-   if (png_ptr == NULL || info_ptr == NULL ||

+    if(png_ptr == NULL || info_ptr == NULL ||

        (png_ptr->mode & PNG_WROTE_tIME))

-      return;

+        return;

 

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

-   info_ptr->valid |= PNG_INFO_tIME;

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

+    info_ptr->valid |= PNG_INFO_tIME;

 }

 #endif

 

 #ifdef PNG_tRNS_SUPPORTED

 void PNGAPI

 png_set_tRNS(png_structp png_ptr, png_infop info_ptr,

-   png_bytep trans_alpha, int num_trans, png_color_16p trans_color)

+             png_bytep trans_alpha, int num_trans, png_color_16p trans_color)

 {

-   png_debug1(1, "in %s storage function", "tRNS");

-

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

-      return;

-

-   if (trans_alpha != NULL)

-   {

-       /* It may not actually be necessary to set png_ptr->trans_alpha here;

-        * we do it for backward compatibility with the way the png_handle_tRNS

-        * function used to do the allocation.

-        */

-

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

-

-       /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */

-       png_ptr->trans_alpha = info_ptr->trans_alpha = (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_alpha, trans_alpha, (png_size_t)num_trans);

-   }

-

-   if (trans_color != NULL)

-   {

-      int sample_max = (1 << info_ptr->bit_depth);

-      if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&

-          (int)trans_color->gray > sample_max) ||

-          (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_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;

-   }

-

-   info_ptr->num_trans = (png_uint_16)num_trans;

-   if (num_trans != 0)

-   {

-      info_ptr->valid |= PNG_INFO_tRNS;

-      info_ptr->free_me |= PNG_FREE_TRNS;

-   }

+    png_debug1(1, "in %s storage function", "tRNS");

+

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

+        return;

+

+    if(trans_alpha != NULL)

+    {

+        /* It may not actually be necessary to set png_ptr->trans_alpha here;

+         * we do it for backward compatibility with the way the png_handle_tRNS

+         * function used to do the allocation.

+         */

+

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

+

+        /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */

+        png_ptr->trans_alpha = info_ptr->trans_alpha = (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_alpha, trans_alpha, (png_size_t)num_trans);

+    }

+

+    if(trans_color != NULL)

+    {

+        int sample_max = (1 << info_ptr->bit_depth);

+        if((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&

+            (int)trans_color->gray > sample_max) ||

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

+    }

+

+    info_ptr->num_trans = (png_uint_16)num_trans;

+    if(num_trans != 0)

+    {

+        info_ptr->valid |= PNG_INFO_tRNS;

+        info_ptr->free_me |= PNG_FREE_TRNS;

+    }

 }

 #endif

 

@@ -874,205 +874,205 @@ png_set_sPLT(png_structp png_ptr,
  *                   added.

  */

 {

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

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

-

-   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,

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

-   }

-

-   info_ptr->splt_palettes = np;

-   info_ptr->splt_palettes_num += nentries;

-   info_ptr->valid |= PNG_INFO_sPLT;

-   info_ptr->free_me |= PNG_FREE_SPLT;

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

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

+

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

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

+    }

+

+    info_ptr->splt_palettes = np;

+    info_ptr->splt_palettes_num += nentries;

+    info_ptr->valid |= PNG_INFO_sPLT;

+    info_ptr->free_me |= PNG_FREE_SPLT;

 }

 #endif /* PNG_sPLT_SUPPORTED */

 

 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

 void PNGAPI

 png_set_unknown_chunks(png_structp png_ptr,

-   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)

+                       png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)

 {

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

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

-   info_ptr->unknown_chunks = NULL;

-

-   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((png_charp)to->name, (png_charp)from->name,

-          png_sizeof(from->name));

-      to->name[png_sizeof(to->name)-1] = '\0';

-      to->size = from->size;

-      /* Note our location in the read or write sequence */

-      to->location = (png_byte)(png_ptr->mode & 0xff);

-

-      if (from->size == 0)

-         to->data=NULL;

-      else

-      {

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

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

-   info_ptr->free_me |= PNG_FREE_UNKN;

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

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

+    info_ptr->unknown_chunks = NULL;

+

+    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((png_charp)to->name, (png_charp)from->name,

+                   png_sizeof(from->name));

+        to->name[png_sizeof(to->name)-1] = '\0';

+        to->size = from->size;

+        /* Note our location in the read or write sequence */

+        to->location = (png_byte)(png_ptr->mode & 0xff);

+

+        if(from->size == 0)

+            to->data = NULL;

+        else

+        {

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

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

+    info_ptr->free_me |= PNG_FREE_UNKN;

 }

 void PNGAPI

 png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,

-   int chunk, int location)

+                               int chunk, int location)

 {

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

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

        (int)info_ptr->unknown_chunks_num)

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

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

 }

 #endif

 

 

 #ifdef PNG_MNG_FEATURES_SUPPORTED

 png_uint_32 PNGAPI

-png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)

+png_permit_mng_features(png_structp png_ptr, png_uint_32 mng_features)

 {

-   png_debug(1, "in png_permit_mng_features");

+    png_debug(1, "in png_permit_mng_features");

 

-   if (png_ptr == NULL)

-      return (png_uint_32)0;

-   png_ptr->mng_features_permitted =

-     (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);

-   return (png_uint_32)png_ptr->mng_features_permitted;

+    if(png_ptr == NULL)

+        return (png_uint_32)0;

+    png_ptr->mng_features_permitted =

+        (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);

+    return (png_uint_32)png_ptr->mng_features_permitted;

 }

 #endif

 

 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

 void PNGAPI

 png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep

-   chunk_list, int num_chunks)

+                            chunk_list, int num_chunks)

 {

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

-      else

-         png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;

-

-      if (keep == PNG_HANDLE_CHUNK_ALWAYS)

-         png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;

-      else

-         png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;

-      return;

-   }

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

-   png_ptr->free_me |= PNG_FREE_LIST;

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

+        else

+            png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;

+

+        if(keep == PNG_HANDLE_CHUNK_ALWAYS)

+            png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;

+        else

+            png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;

+        return;

+    }

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

+    png_ptr->free_me |= PNG_FREE_LIST;

 }

 #endif

 

 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED

 void PNGAPI

 png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,

-   png_user_chunk_ptr read_user_chunk_fn)

+                           png_user_chunk_ptr read_user_chunk_fn)

 {

-   png_debug(1, "in png_set_read_user_chunk_fn");

+    png_debug(1, "in png_set_read_user_chunk_fn");

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

-   png_ptr->read_user_chunk_fn = read_user_chunk_fn;

-   png_ptr->user_chunk_ptr = user_chunk_ptr;

+    png_ptr->read_user_chunk_fn = read_user_chunk_fn;

+    png_ptr->user_chunk_ptr = user_chunk_ptr;

 }

 #endif

 

@@ -1080,25 +1080,25 @@ png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
 void PNGAPI

 png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)

 {

-   png_debug1(1, "in %s storage function", "rows");

+    png_debug1(1, "in %s storage function", "rows");

 

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

-      return;

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

+        return;

 

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

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

-   info_ptr->row_pointers = row_pointers;

-   if (row_pointers)

-      info_ptr->valid |= PNG_INFO_IDAT;

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

+        png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);

+    info_ptr->row_pointers = row_pointers;

+    if(row_pointers)

+        info_ptr->valid |= PNG_INFO_IDAT;

 }

 #endif

 

 void PNGAPI

 png_set_compression_buffer_size(png_structp png_ptr,

-    png_size_t size)

+                                png_size_t size)

 {

-    if (png_ptr == NULL)

-       return;

+    if(png_ptr == NULL)

+        return;

     png_free(png_ptr, png_ptr->zbuf);

     png_ptr->zbuf_size = size;

     png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);

@@ -1109,8 +1109,8 @@ png_set_compression_buffer_size(png_structp png_ptr,
 void PNGAPI

 png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)

 {

-   if (png_ptr && info_ptr)

-      info_ptr->valid &= ~mask;

+    if(png_ptr && info_ptr)

+        info_ptr->valid &= ~mask;

 }

 

 

@@ -1118,36 +1118,36 @@ png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
 #ifdef PNG_SET_USER_LIMITS_SUPPORTED

 /* This function was added to libpng 1.2.6 */

 void PNGAPI

-png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,

-    png_uint_32 user_height_max)

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

+png_set_chunk_cache_max(png_structp png_ptr,

+                        png_uint_32 user_chunk_cache_max)

 {

-    if (png_ptr)

-       png_ptr->user_chunk_cache_max = user_chunk_cache_max;

+    if(png_ptr)

+        png_ptr->user_chunk_cache_max = user_chunk_cache_max;

 }

 

 /* This function was added to libpng 1.4.1 */

 void PNGAPI

-png_set_chunk_malloc_max (png_structp png_ptr,

-   png_alloc_size_t user_chunk_malloc_max)

+png_set_chunk_malloc_max(png_structp png_ptr,

+                         png_alloc_size_t user_chunk_malloc_max)

 {

-    if (png_ptr)

-       png_ptr->user_chunk_malloc_max =

-          (png_size_t)user_chunk_malloc_max;

+    if(png_ptr)

+        png_ptr->user_chunk_malloc_max =

+            (png_size_t)user_chunk_malloc_max;

 }

 #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */

 

@@ -1156,12 +1156,12 @@ png_set_chunk_malloc_max (png_structp png_ptr,
 void PNGAPI

 png_set_benign_errors(png_structp png_ptr, int allowed)

 {

-   png_debug(1, "in png_set_benign_errors");

+    png_debug(1, "in png_set_benign_errors");

 

-   if (allowed)

-      png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;

-   else

-      png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN;

+    if(allowed)

+        png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;

+    else

+        png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN;

 }

 #endif /* PNG_BENIGN_ERRORS_SUPPORTED */

 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

diff --git a/src/libpng/pngtest.c b/src/libpng/pngtest.c
index 91f7e376d..196453be0 100644
--- a/src/libpng/pngtest.c
+++ b/src/libpng/pngtest.c
@@ -39,7 +39,7 @@
 #  define FCLOSE(file) fclose(file)

 

 #ifndef PNG_STDIO_SUPPORTED

-     typedef FILE                * png_FILE_p;

+typedef FILE                * png_FILE_p;

 #endif

 

 /* Makes pngtest verbose so we can find problems (needs to be before png.h) */

@@ -102,21 +102,21 @@ read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);
 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

@@ -124,9 +124,9 @@ write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);
 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");

 }

 

 

@@ -141,8 +141,8 @@ 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)

-      ++filters_used[*(data - 1)];

+    if(png_ptr != NULL && row_info != NULL)

+        ++filters_used[*(data - 1)];

 }

 #endif

 

@@ -158,95 +158,95 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data);
 void

 count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)

 {

-   png_bytep dp = data;

-   if (png_ptr == NULL)return;

-

-   /* Contents of 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_bytep dp = data;

+    if(png_ptr == NULL)return;

+

+    /* Contents of 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)

+     */

 

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

+    if(row_info->color_type == 0 || row_info->color_type == 3)

     {

-       int pos = 0;

-       png_uint_32 n, nstop;

-       for (n = 0, nstop=row_info->width; n<nstop; n++)

-       {

-          if (row_info->bit_depth == 1)

-          {

-             if (((*dp << pos++ ) & 0x80) == 0)

-                zero_samples++;

-             if (pos == 8)

-             {

-                pos = 0;

-                dp++;

-             }

-          }

-          if (row_info->bit_depth == 2)

-          {

-             if (((*dp << (pos+=2)) & 0xc0) == 0)

-                zero_samples++;

-             if (pos == 8)

-             {

-                pos = 0;

-                dp++;

-             }

-          }

-          if (row_info->bit_depth == 4)

-          {

-             if (((*dp << (pos+=4)) & 0xf0) == 0)

-                zero_samples++;

-             if (pos == 8)

-             {

-                pos = 0;

-                dp++;

-             }

-          }

-          if (row_info->bit_depth == 8)

-             if (*dp++ == 0)

-                zero_samples++;

-          if (row_info->bit_depth == 16)

-          {

-             if ((*dp | *(dp+1)) == 0)

-                zero_samples++;

-             dp+=2;

-          }

-       }

+        int pos = 0;

+        png_uint_32 n, nstop;

+        for(n = 0, nstop = row_info->width; n < nstop; n++)

+        {

+            if(row_info->bit_depth == 1)

+            {

+                if(((*dp << pos++) & 0x80) == 0)

+                    zero_samples++;

+                if(pos == 8)

+                {

+                    pos = 0;

+                    dp++;

+                }

+            }

+            if(row_info->bit_depth == 2)

+            {

+                if(((*dp << (pos += 2)) & 0xc0) == 0)

+                    zero_samples++;

+                if(pos == 8)

+                {

+                    pos = 0;

+                    dp++;

+                }

+            }

+            if(row_info->bit_depth == 4)

+            {

+                if(((*dp << (pos += 4)) & 0xf0) == 0)

+                    zero_samples++;

+                if(pos == 8)

+                {

+                    pos = 0;

+                    dp++;

+                }

+            }

+            if(row_info->bit_depth == 8)

+                if(*dp++ == 0)

+                    zero_samples++;

+            if(row_info->bit_depth == 16)

+            {

+                if((*dp | *(dp + 1)) == 0)

+                    zero_samples++;

+                dp += 2;

+            }

+        }

     }

     else /* Other color types */

     {

-       png_uint_32 n, nstop;

-       int channel;

-       int color_channels = row_info->channels;

-       if (row_info->color_type > 3)color_channels--;

-

-       for (n = 0, nstop=row_info->width; n<nstop; n++)

-       {

-          for (channel = 0; channel < color_channels; channel++)

-          {

-             if (row_info->bit_depth == 8)

-                if (*dp++ == 0)

-                   zero_samples++;

-             if (row_info->bit_depth == 16)

-             {

-                if ((*dp | *(dp+1)) == 0)

-                   zero_samples++;

-                dp+=2;

-             }

-          }

-          if (row_info->color_type > 3)

-          {

-             dp++;

-             if (row_info->bit_depth == 16)

+        png_uint_32 n, nstop;

+        int channel;

+        int color_channels = row_info->channels;

+        if(row_info->color_type > 3)color_channels--;

+

+        for(n = 0, nstop = row_info->width; n < nstop; n++)

+        {

+            for(channel = 0; channel < color_channels; channel++)

+            {

+                if(row_info->bit_depth == 8)

+                    if(*dp++ == 0)

+                        zero_samples++;

+                if(row_info->bit_depth == 16)

+                {

+                    if((*dp | *(dp + 1)) == 0)

+                        zero_samples++;

+                    dp += 2;

+                }

+            }

+            if(row_info->color_type > 3)

+            {

                 dp++;

-          }

-       }

+                if(row_info->bit_depth == 16)

+                    dp++;

+            }

+        }

     }

 }

 #endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */

@@ -267,22 +267,22 @@ static int wrote_question = 0;
 static void

 pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   png_size_t check = 0;

-   png_voidp io_ptr;

-

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

-    */

-   io_ptr = png_get_io_ptr(png_ptr);

-   if (io_ptr != NULL)

-   {

-      check = fread(data, 1, length, (png_FILE_p)io_ptr);

-   }

-

-   if (check != length)

-   {

-      png_error(png_ptr, "Read Error!");

-   }

+    png_size_t check = 0;

+    png_voidp io_ptr;

+

+    /* 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.

+     */

+    io_ptr = png_get_io_ptr(png_ptr);

+    if(io_ptr != NULL)

+    {

+        check = fread(data, 1, length, (png_FILE_p)io_ptr);

+    }

+

+    if(check != length)

+    {

+        png_error(png_ptr, "Read Error!");

+    }

 }

 #else

 /* This is the model-independent version. Since the standard I/O library

@@ -296,39 +296,39 @@ pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 static void

 pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   png_size_t check;

-   png_byte *n_data;

-   png_FILE_p io_ptr;

-

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

-   if ((png_bytep)n_data == data)

-   {

-      check = fread(n_data, 1, length, io_ptr);

-   }

-   else

-   {

-      png_byte buf[NEAR_BUF_SIZE];

-      png_size_t read, remaining, err;

-      check = 0;

-      remaining = length;

-      do

-      {

-         read = MIN(NEAR_BUF_SIZE, remaining);

-         err = fread(buf, 1, 1, io_ptr);

-         png_memcpy(data, buf, read); /* Copy far buffer to near buffer */

-         if (err != read)

-            break;

-         else

-            check += err;

-         data += read;

-         remaining -= read;

-      }

-      while (remaining != 0);

-   }

-   if (check != length)

-      png_error(png_ptr, "read Error");

+    png_size_t check;

+    png_byte *n_data;

+    png_FILE_p io_ptr;

+

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

+    if((png_bytep)n_data == data)

+    {

+        check = fread(n_data, 1, length, io_ptr);

+    }

+    else

+    {

+        png_byte buf[NEAR_BUF_SIZE];

+        png_size_t read, remaining, err;

+        check = 0;

+        remaining = length;

+        do

+        {

+            read = MIN(NEAR_BUF_SIZE, remaining);

+            err = fread(buf, 1, 1, io_ptr);

+            png_memcpy(data, buf, read); /* Copy far buffer to near buffer */

+            if(err != read)

+                break;

+            else

+                check += err;

+            data += read;

+            remaining -= read;

+        }

+        while(remaining != 0);

+    }

+    if(check != length)

+        png_error(png_ptr, "read Error");

 }

 #endif /* USE_FAR_KEYWORD */

 

@@ -336,8 +336,8 @@ pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 static void

 pngtest_flush(png_structp png_ptr)

 {

-   /* Do nothing; fflush() is said to be just a waste of energy. */

-   png_ptr = png_ptr;  /* Stifle compiler warning */

+    /* Do nothing; fflush() is said to be just a waste of energy. */

+    png_ptr = png_ptr;  /* Stifle compiler warning */

 }

 #endif

 

@@ -350,13 +350,13 @@ pngtest_flush(png_structp png_ptr)
 static void

 pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   png_size_t check;

+    png_size_t check;

 

-   check = fwrite(data, 1, length, (png_FILE_p)png_ptr->io_ptr);

-   if (check != length)

-   {

-      png_error(png_ptr, "Write Error");

-   }

+    check = fwrite(data, 1, length, (png_FILE_p)png_ptr->io_ptr);

+    if(check != length)

+    {

+        png_error(png_ptr, "Write Error");

+    }

 }

 #else

 /* This is the model-independent version. Since the standard I/O library

@@ -370,41 +370,41 @@ pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 static void

 pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   png_size_t check;

-   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */

-   png_FILE_p io_ptr;

-

-   /* Check if data really is near. If so, use usual code. */

-   near_data = (png_byte *)CVT_PTR_NOCHECK(data);

-   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

-   if ((png_bytep)near_data == data)

-   {

-      check = fwrite(near_data, 1, length, io_ptr);

-   }

-   else

-   {

-      png_byte buf[NEAR_BUF_SIZE];

-      png_size_t written, remaining, err;

-      check = 0;

-      remaining = length;

-      do

-      {

-         written = MIN(NEAR_BUF_SIZE, remaining);

-         png_memcpy(buf, data, written); /* Copy far buffer to near buffer */

-         err = fwrite(buf, 1, written, io_ptr);

-         if (err != written)

-            break;

-         else

-            check += err;

-         data += written;

-         remaining -= written;

-      }

-      while (remaining != 0);

-   }

-   if (check != length)

-   {

-      png_error(png_ptr, "Write Error");

-   }

+    png_size_t check;

+    png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */

+    png_FILE_p io_ptr;

+

+    /* Check if data really is near. If so, use usual code. */

+    near_data = (png_byte *)CVT_PTR_NOCHECK(data);

+    io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

+    if((png_bytep)near_data == data)

+    {

+        check = fwrite(near_data, 1, length, io_ptr);

+    }

+    else

+    {

+        png_byte buf[NEAR_BUF_SIZE];

+        png_size_t written, remaining, err;

+        check = 0;

+        remaining = length;

+        do

+        {

+            written = MIN(NEAR_BUF_SIZE, remaining);

+            png_memcpy(buf, data, written); /* Copy far buffer to near buffer */

+            err = fwrite(buf, 1, written, io_ptr);

+            if(err != written)

+                break;

+            else

+                check += err;

+            data += written;

+            remaining -= written;

+        }

+        while(remaining != 0);

+    }

+    if(check != length)

+    {

+        png_error(png_ptr, "Write Error");

+    }

 }

 #endif /* USE_FAR_KEYWORD */

 

@@ -416,13 +416,13 @@ pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 static void

 pngtest_warning(png_structp png_ptr, png_const_charp message)

 {

-   PNG_CONST char *name = "UNKNOWN (ERROR!)";

-   char *test;

-   test = png_get_error_ptr(png_ptr);

-   if (test == NULL)

-     fprintf(STDERR, "%s: libpng warning: %s\n", name, message);

-   else

-     fprintf(STDERR, "%s: libpng warning: %s\n", test, message);

+    PNG_CONST char *name = "UNKNOWN (ERROR!)";

+    char *test;

+    test = png_get_error_ptr(png_ptr);

+    if(test == NULL)

+        fprintf(STDERR, "%s: libpng warning: %s\n", name, message);

+    else

+        fprintf(STDERR, "%s: libpng warning: %s\n", test, message);

 }

 

 /* This is the default error handling function.  Note that replacements for

@@ -433,10 +433,10 @@ pngtest_warning(png_structp png_ptr, png_const_charp message)
 static void

 pngtest_error(png_structp png_ptr, png_const_charp message)

 {

-   pngtest_warning(png_ptr, message);

-   /* We can return because png_error calls the default handler, which is

-    * actually OK in this case.

-    */

+    pngtest_warning(png_ptr, message);

+    /* We can return because png_error calls the default handler, which is

+     * actually OK in this case.

+     */

 }

 #endif /* !PNG_STDIO_SUPPORTED */

 /* END of code to validate stdio-free compilation */

@@ -455,9 +455,9 @@ pngtest_error(png_structp png_ptr, png_const_charp message)
  */

 typedef struct memory_information

 {

-   png_alloc_size_t          size;

-   png_voidp                 pointer;

-   struct memory_information FAR *next;

+    png_alloc_size_t          size;

+    png_voidp                 pointer;

+    struct memory_information FAR *next;

 } memory_information;

 typedef memory_information FAR *memory_infop;

 

@@ -468,103 +468,103 @@ static int total_allocation = 0;
 static int num_allocations = 0;

 

 png_voidp png_debug_malloc

-   PNGARG((png_structp png_ptr, png_alloc_size_t size));

+PNGARG((png_structp png_ptr, png_alloc_size_t size));

 void png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr));

 

 png_voidp

 png_debug_malloc(png_structp png_ptr, png_alloc_size_t size)

 {

 

-   /* png_malloc has already tested for NULL; png_create_struct calls

-    * png_debug_malloc directly, with png_ptr == NULL which is OK

-    */

-

-   if (size == 0)

-      return (NULL);

-

-   /* This calls the library allocator twice, once to get the requested

-      buffer and once to get a new free list entry. */

-   {

-      /* Disable malloc_fn and free_fn */

-      memory_infop pinfo;

-      png_set_mem_fn(png_ptr, NULL, NULL, NULL);

-      pinfo = (memory_infop)png_malloc(png_ptr,

-         png_sizeof(*pinfo));

-      pinfo->size = size;

-      current_allocation += size;

-      total_allocation += size;

-      num_allocations ++;

-      if (current_allocation > maximum_allocation)

-         maximum_allocation = current_allocation;

-      pinfo->pointer = png_malloc(png_ptr, size);

-      /* Restore malloc_fn and free_fn */

-      png_set_mem_fn(png_ptr,

-          NULL, png_debug_malloc, png_debug_free);

-      if (size != 0 && pinfo->pointer == NULL)

-      {

-         current_allocation -= size;

-         total_allocation -= size;

-         png_error(png_ptr,

-           "out of memory in pngtest->png_debug_malloc");

-      }

-      pinfo->next = pinformation;

-      pinformation = pinfo;

-      /* Make sure the caller isn't assuming zeroed memory. */

-      png_memset(pinfo->pointer, 0xdd, pinfo->size);

-      if (verbose)

-         printf("png_malloc %lu bytes at %x\n", (unsigned long)size,

-            pinfo->pointer);

-      return (png_voidp)(pinfo->pointer);

-   }

+    /* png_malloc has already tested for NULL; png_create_struct calls

+     * png_debug_malloc directly, with png_ptr == NULL which is OK

+     */

+

+    if(size == 0)

+        return (NULL);

+

+    /* This calls the library allocator twice, once to get the requested

+       buffer and once to get a new free list entry. */

+    {

+        /* Disable malloc_fn and free_fn */

+        memory_infop pinfo;

+        png_set_mem_fn(png_ptr, NULL, NULL, NULL);

+        pinfo = (memory_infop)png_malloc(png_ptr,

+                                         png_sizeof(*pinfo));

+        pinfo->size = size;

+        current_allocation += size;

+        total_allocation += size;

+        num_allocations ++;

+        if(current_allocation > maximum_allocation)

+            maximum_allocation = current_allocation;

+        pinfo->pointer = png_malloc(png_ptr, size);

+        /* Restore malloc_fn and free_fn */

+        png_set_mem_fn(png_ptr,

+                       NULL, png_debug_malloc, png_debug_free);

+        if(size != 0 && pinfo->pointer == NULL)

+        {

+            current_allocation -= size;

+            total_allocation -= size;

+            png_error(png_ptr,

+                      "out of memory in pngtest->png_debug_malloc");

+        }

+        pinfo->next = pinformation;

+        pinformation = pinfo;

+        /* Make sure the caller isn't assuming zeroed memory. */

+        png_memset(pinfo->pointer, 0xdd, pinfo->size);

+        if(verbose)

+            printf("png_malloc %lu bytes at %x\n", (unsigned long)size,

+                   pinfo->pointer);

+        return (png_voidp)(pinfo->pointer);

+    }

 }

 

 /* Free a pointer.  It is removed from the list at the same time. */

 void

 png_debug_free(png_structp png_ptr, png_voidp ptr)

 {

-   if (png_ptr == NULL)

-      fprintf(STDERR, "NULL pointer to png_debug_free.\n");

-   if (ptr == 0)

-   {

+    if(png_ptr == NULL)

+        fprintf(STDERR, "NULL pointer to png_debug_free.\n");

+    if(ptr == 0)

+    {

 #if 0 /* This happens all the time. */

-      fprintf(STDERR, "WARNING: freeing NULL pointer\n");

-#endif

-      return;

-   }

-

-   /* Unlink the element from the list. */

-   {

-      memory_infop FAR *ppinfo = &pinformation;

-      for (;;)

-      {

-         memory_infop pinfo = *ppinfo;

-         if (pinfo->pointer == ptr)

-         {

-            *ppinfo = pinfo->next;

-            current_allocation -= pinfo->size;

-            if (current_allocation < 0)

-               fprintf(STDERR, "Duplicate free of memory\n");

-            /* We must free the list element too, but first kill

-               the memory that is to be freed. */

-            png_memset(ptr, 0x55, pinfo->size);

-            png_free_default(png_ptr, pinfo);

-            pinfo = NULL;

-            break;

-         }

-         if (pinfo->next == NULL)

-         {

-            fprintf(STDERR, "Pointer %x not found\n", (unsigned int)ptr);

-            break;

-         }

-         ppinfo = &pinfo->next;

-      }

-   }

-

-   /* Finally free the data. */

-   if (verbose)

-      printf("Freeing %x\n", ptr);

-   png_free_default(png_ptr, ptr);

-   ptr = NULL;

+        fprintf(STDERR, "WARNING: freeing NULL pointer\n");

+#endif

+        return;

+    }

+

+    /* Unlink the element from the list. */

+    {

+        memory_infop FAR *ppinfo = &pinformation;

+        for(;;)

+        {

+            memory_infop pinfo = *ppinfo;

+            if(pinfo->pointer == ptr)

+            {

+                *ppinfo = pinfo->next;

+                current_allocation -= pinfo->size;

+                if(current_allocation < 0)

+                    fprintf(STDERR, "Duplicate free of memory\n");

+                /* We must free the list element too, but first kill

+                   the memory that is to be freed. */

+                png_memset(ptr, 0x55, pinfo->size);

+                png_free_default(png_ptr, pinfo);

+                pinfo = NULL;

+                break;

+            }

+            if(pinfo->next == NULL)

+            {

+                fprintf(STDERR, "Pointer %x not found\n", (unsigned int)ptr);

+                break;

+            }

+            ppinfo = &pinfo->next;

+        }

+    }

+

+    /* Finally free the data. */

+    if(verbose)

+        printf("Freeing %x\n", ptr);

+    png_free_default(png_ptr, ptr);

+    ptr = NULL;

 }

 #endif /* PNG_USER_MEM_SUPPORTED && PNG_DEBUG */

 /* END of code to test memory allocation/deallocation */

@@ -578,60 +578,60 @@ chunk used in ImageMagick to store "virtual page" size).  */
 

 static png_uint_32 user_chunk_data[4];

 

-    /* 0: sTER mode + 1

-     * 1: vpAg width

-     * 2: vpAg height

-     * 3: vpAg units

-     */

+/* 0: sTER mode + 1

+ * 1: vpAg width

+ * 2: vpAg height

+ * 3: vpAg units

+ */

 

 static int read_user_chunk_callback(png_struct *png_ptr,

-   png_unknown_chunkp chunk)

+                                    png_unknown_chunkp chunk)

 {

-   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

-    *

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

+    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

+     *

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

+    {

+        /* Found sTER chunk */

+        if(chunk->size != 1)

             return (-1); /* Error return */

-         if (chunk->data[0] != 0 && chunk->data[0] != 1)

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

-      }

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

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

+        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

@@ -641,729 +641,732 @@ static int read_user_chunk_callback(png_struct *png_ptr,
 int

 test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)

 {

-   static png_FILE_p fpin;

-   static png_FILE_p fpout;  /* "static" prevents setjmp corruption */

-   png_structp read_ptr;

-   png_infop read_info_ptr, end_info_ptr;

+    static png_FILE_p fpin;

+    static png_FILE_p fpout;  /* "static" prevents setjmp corruption */

+    png_structp read_ptr;

+    png_infop read_info_ptr, end_info_ptr;

 #ifdef PNG_WRITE_SUPPORTED

-   png_structp write_ptr;

-   png_infop write_info_ptr;

-   png_infop write_end_info_ptr;

+    png_structp write_ptr;

+    png_infop write_info_ptr;

+    png_infop write_end_info_ptr;

 #else

-   png_structp write_ptr = NULL;

-   png_infop write_info_ptr = NULL;

-   png_infop write_end_info_ptr = NULL;

-#endif

-   png_bytep row_buf;

-   png_uint_32 y;

-   png_uint_32 width, height;

-   int num_pass, pass;

-   int bit_depth, color_type;

+    png_structp write_ptr = NULL;

+    png_infop write_info_ptr = NULL;

+    png_infop write_end_info_ptr = NULL;

+#endif

+    png_bytep row_buf;

+    png_uint_32 y;

+    png_uint_32 width, height;

+    int num_pass, pass;

+    int bit_depth, color_type;

 #ifdef PNG_SETJMP_SUPPORTED

 #ifdef USE_FAR_KEYWORD

-   jmp_buf jmpbuf;

+    jmp_buf jmpbuf;

 #endif

 #endif

 

-   char inbuf[256], outbuf[256];

+    char inbuf[256], outbuf[256];

 

-   row_buf = NULL;

+    row_buf = NULL;

 

-   if ((fpin = fopen(inname, "rb")) == NULL)

-   {

-      fprintf(STDERR, "Could not find input file %s\n", inname);

-      return (1);

-   }

+    if((fpin = fopen(inname, "rb")) == NULL)

+    {

+        fprintf(STDERR, "Could not find input file %s\n", inname);

+        return (1);

+    }

 

-   if ((fpout = fopen(outname, "wb")) == NULL)

-   {

-      fprintf(STDERR, "Could not open output file %s\n", outname);

-      FCLOSE(fpin);

-      return (1);

-   }

+    if((fpout = fopen(outname, "wb")) == NULL)

+    {

+        fprintf(STDERR, "Could not open output file %s\n", outname);

+        FCLOSE(fpin);

+        return (1);

+    }

 

-   png_debug(0, "Allocating read and write structures");

+    png_debug(0, "Allocating read and write structures");

 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-   read_ptr =

-      png_create_read_struct_2(PNG_LIBPNG_VER_STRING, NULL,

-      NULL, NULL, NULL,

-      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);

+    read_ptr =

+        png_create_read_struct_2(PNG_LIBPNG_VER_STRING, NULL,

+                                 NULL, NULL, NULL,

+                                 (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);

 #else

-   read_ptr =

-      png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

+    read_ptr =

+        png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

 #endif

 #ifndef PNG_STDIO_SUPPORTED

-   png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error,

-       pngtest_warning);

+    png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error,

+                     pngtest_warning);

 #endif

 

 #ifdef 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

 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-   write_ptr =

-      png_create_write_struct_2(PNG_LIBPNG_VER_STRING, NULL,

-      NULL, NULL, NULL, png_debug_malloc, png_debug_free);

+    write_ptr =

+        png_create_write_struct_2(PNG_LIBPNG_VER_STRING, NULL,

+                                  NULL, NULL, NULL, png_debug_malloc, png_debug_free);

 #else

-   write_ptr =

-      png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

+    write_ptr =

+        png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

 #endif

 #ifndef PNG_STDIO_SUPPORTED

-   png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error,

-       pngtest_warning);

+    png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error,

+                     pngtest_warning);

 #endif

 #endif

-   png_debug(0, "Allocating read_info, write_info and end_info structures");

-   read_info_ptr = png_create_info_struct(read_ptr);

-   end_info_ptr = png_create_info_struct(read_ptr);

+    png_debug(0, "Allocating read_info, write_info and end_info structures");

+    read_info_ptr = png_create_info_struct(read_ptr);

+    end_info_ptr = png_create_info_struct(read_ptr);

 #ifdef PNG_WRITE_SUPPORTED

-   write_info_ptr = png_create_info_struct(write_ptr);

-   write_end_info_ptr = png_create_info_struct(write_ptr);

+    write_info_ptr = png_create_info_struct(write_ptr);

+    write_end_info_ptr = png_create_info_struct(write_ptr);

 #endif

 

 #ifdef PNG_SETJMP_SUPPORTED

-   png_debug(0, "Setting jmpbuf for read struct");

+    png_debug(0, "Setting jmpbuf for read struct");

 #ifdef USE_FAR_KEYWORD

-   if (setjmp(jmpbuf))

+    if(setjmp(jmpbuf))

 #else

-   if (setjmp(png_jmpbuf(read_ptr)))

+    if(setjmp(png_jmpbuf(read_ptr)))

 #endif

-   {

-      fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);

-      png_free(read_ptr, row_buf);

-      row_buf = NULL;

-      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

+    {

+        fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);

+        png_free(read_ptr, row_buf);

+        row_buf = NULL;

+        png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

 #ifdef PNG_WRITE_SUPPORTED

-      png_destroy_info_struct(write_ptr, &write_end_info_ptr);

-      png_destroy_write_struct(&write_ptr, &write_info_ptr);

+        png_destroy_info_struct(write_ptr, &write_end_info_ptr);

+        png_destroy_write_struct(&write_ptr, &write_info_ptr);

 #endif

-      FCLOSE(fpin);

-      FCLOSE(fpout);

-      return (1);

-   }

+        FCLOSE(fpin);

+        FCLOSE(fpout);

+        return (1);

+    }

 #ifdef USE_FAR_KEYWORD

-   png_memcpy(png_jmpbuf(read_ptr), jmpbuf, png_sizeof(jmp_buf));

+    png_memcpy(png_jmpbuf(read_ptr), jmpbuf, png_sizeof(jmp_buf));

 #endif

 

 #ifdef PNG_WRITE_SUPPORTED

-   png_debug(0, "Setting jmpbuf for write struct");

+    png_debug(0, "Setting jmpbuf for write struct");

 #ifdef USE_FAR_KEYWORD

-   if (setjmp(jmpbuf))

+    if(setjmp(jmpbuf))

 #else

-   if (setjmp(png_jmpbuf(write_ptr)))

+    if(setjmp(png_jmpbuf(write_ptr)))

 #endif

-   {

-      fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);

-      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

-      png_destroy_info_struct(write_ptr, &write_end_info_ptr);

+    {

+        fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);

+        png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

+        png_destroy_info_struct(write_ptr, &write_end_info_ptr);

 #ifdef PNG_WRITE_SUPPORTED

-      png_destroy_write_struct(&write_ptr, &write_info_ptr);

+        png_destroy_write_struct(&write_ptr, &write_info_ptr);

 #endif

-      FCLOSE(fpin);

-      FCLOSE(fpout);

-      return (1);

-   }

+        FCLOSE(fpin);

+        FCLOSE(fpout);

+        return (1);

+    }

 #ifdef USE_FAR_KEYWORD

-   png_memcpy(png_jmpbuf(write_ptr), jmpbuf, png_sizeof(jmp_buf));

+    png_memcpy(png_jmpbuf(write_ptr), jmpbuf, png_sizeof(jmp_buf));

 #endif

 #endif

 #endif

 

-   png_debug(0, "Initializing input and output streams");

+    png_debug(0, "Initializing input and output streams");

 #ifdef PNG_STDIO_SUPPORTED

-   png_init_io(read_ptr, fpin);

+    png_init_io(read_ptr, fpin);

 #  ifdef PNG_WRITE_SUPPORTED

-   png_init_io(write_ptr, fpout);

+    png_init_io(write_ptr, fpout);

 #  endif

 #else

-   png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);

+    png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);

 #  ifdef PNG_WRITE_SUPPORTED

-   png_set_write_fn(write_ptr, (png_voidp)fpout,  pngtest_write_data,

+    png_set_write_fn(write_ptr, (png_voidp)fpout,  pngtest_write_data,

 #    ifdef PNG_WRITE_FLUSH_SUPPORTED

-      pngtest_flush);

+                     pngtest_flush);

 #    else

-      NULL);

+    NULL);

 #    endif

 #  endif

 #endif

-   if (status_dots_requested == 1)

-   {

+    if(status_dots_requested == 1)

+    {

 #ifdef PNG_WRITE_SUPPORTED

-      png_set_write_status_fn(write_ptr, write_row_callback);

+        png_set_write_status_fn(write_ptr, write_row_callback);

 #endif

-      png_set_read_status_fn(read_ptr, read_row_callback);

-   }

-   else

-   {

+        png_set_read_status_fn(read_ptr, read_row_callback);

+    }

+    else

+    {

 #ifdef PNG_WRITE_SUPPORTED

-      png_set_write_status_fn(write_ptr, NULL);

+        png_set_write_status_fn(write_ptr, NULL);

 #endif

-      png_set_read_status_fn(read_ptr, NULL);

-   }

+        png_set_read_status_fn(read_ptr, NULL);

+    }

 

 #ifdef 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

 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-   zero_samples = 0;

-   png_set_write_user_transform_fn(write_ptr, count_zero_samples);

+    zero_samples = 0;

+    png_set_write_user_transform_fn(write_ptr, count_zero_samples);

 #endif

 

 #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

 #  ifndef PNG_HANDLE_CHUNK_ALWAYS

 #    define PNG_HANDLE_CHUNK_ALWAYS       3

 #  endif

-   png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,

-      NULL, 0);

+    png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,

+                                NULL, 0);

 #endif

 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

 #  ifndef PNG_HANDLE_CHUNK_IF_SAFE

 #    define PNG_HANDLE_CHUNK_IF_SAFE      2

 #  endif

-   png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_IF_SAFE,

-      NULL, 0);

+    png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_IF_SAFE,

+                                NULL, 0);

 #endif

 

-   png_debug(0, "Reading info struct");

-   png_read_info(read_ptr, read_info_ptr);

+    png_debug(0, "Reading info struct");

+    png_read_info(read_ptr, read_info_ptr);

 

-   png_debug(0, "Transferring info struct");

-   {

-      int interlace_type, compression_type, filter_type;

+    png_debug(0, "Transferring info struct");

+    {

+        int interlace_type, compression_type, filter_type;

 

-      if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,

-          &color_type, &interlace_type, &compression_type, &filter_type))

-      {

-         png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,

+        if(png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,

+                        &color_type, &interlace_type, &compression_type, &filter_type))

+        {

+            png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

-            color_type, interlace_type, compression_type, filter_type);

+                         color_type, interlace_type, compression_type, filter_type);

 #else

-            color_type, PNG_INTERLACE_NONE, compression_type, filter_type);

+                         color_type, PNG_INTERLACE_NONE, compression_type, filter_type);

 #endif

-      }

-   }

+        }

+    }

 #ifdef PNG_FIXED_POINT_SUPPORTED

 #ifdef PNG_cHRM_SUPPORTED

-   {

-      png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x,

-         blue_y;

-      if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y,

-         &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y))

-      {

-         png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,

-            red_y, green_x, green_y, blue_x, blue_y);

-      }

-   }

+    {

+        png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x,

+                        blue_y;

+        if(png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y,

+                              &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y))

+        {

+            png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,

+                               red_y, green_x, green_y, blue_x, blue_y);

+        }

+    }

 #endif

 #ifdef PNG_gAMA_SUPPORTED

-   {

-      png_fixed_point gamma;

+    {

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

-   }

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

 #ifdef PNG_FLOATING_POINT_SUPPORTED

 #ifdef PNG_cHRM_SUPPORTED

-   {

-      double white_x, white_y, red_x, red_y, green_x, green_y, blue_x,

-         blue_y;

-      if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,

-         &red_y, &green_x, &green_y, &blue_x, &blue_y))

-      {

-         png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,

-            red_y, green_x, green_y, blue_x, blue_y);

-      }

-   }

+    {

+        double white_x, white_y, red_x, red_y, green_x, green_y, blue_x,

+               blue_y;

+        if(png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,

+                        &red_y, &green_x, &green_y, &blue_x, &blue_y))

+        {

+            png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,

+                         red_y, green_x, green_y, blue_x, blue_y);

+        }

+    }

 #endif

 #ifdef PNG_gAMA_SUPPORTED

-   {

-      double gamma;

+    {

+        double gamma;

 

-      if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))

-         png_set_gAMA(write_ptr, write_info_ptr, gamma);

-   }

+        if(png_get_gAMA(read_ptr, read_info_ptr, &gamma))

+            png_set_gAMA(write_ptr, write_info_ptr, gamma);

+    }

 #endif

 #endif /* Floating point */

 #endif /* Fixed point */

 #ifdef PNG_iCCP_SUPPORTED

-   {

-      png_charp name;

-      png_charp profile;

-      png_uint_32 proflen;

-      int compression_type;

-

-      if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,

-                      &profile, &proflen))

-      {

-         png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,

-                      profile, proflen);

-      }

-   }

+    {

+        png_charp name;

+        png_charp profile;

+        png_uint_32 proflen;

+        int compression_type;

+

+        if(png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,

+                        &profile, &proflen))

+        {

+            png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,

+                         profile, proflen);

+        }

+    }

 #endif

 #ifdef PNG_sRGB_SUPPORTED

-   {

-      int intent;

+    {

+        int intent;

 

-      if (png_get_sRGB(read_ptr, read_info_ptr, &intent))

-         png_set_sRGB(write_ptr, write_info_ptr, intent);

-   }

+        if(png_get_sRGB(read_ptr, read_info_ptr, &intent))

+            png_set_sRGB(write_ptr, write_info_ptr, intent);

+    }

 #endif

-   {

-      png_colorp palette;

-      int num_palette;

+    {

+        png_colorp palette;

+        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(png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette))

+            png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);

+    }

 #ifdef PNG_bKGD_SUPPORTED

-   {

-      png_color_16p background;

+    {

+        png_color_16p background;

 

-      if (png_get_bKGD(read_ptr, read_info_ptr, &background))

-      {

-         png_set_bKGD(write_ptr, write_info_ptr, background);

-      }

-   }

+        if(png_get_bKGD(read_ptr, read_info_ptr, &background))

+        {

+            png_set_bKGD(write_ptr, write_info_ptr, background);

+        }

+    }

 #endif

 #ifdef PNG_hIST_SUPPORTED

-   {

-      png_uint_16p hist;

+    {

+        png_uint_16p hist;

 

-      if (png_get_hIST(read_ptr, read_info_ptr, &hist))

-         png_set_hIST(write_ptr, write_info_ptr, hist);

-   }

+        if(png_get_hIST(read_ptr, read_info_ptr, &hist))

+            png_set_hIST(write_ptr, write_info_ptr, hist);

+    }

 #endif

 #ifdef PNG_oFFs_SUPPORTED

-   {

-      png_int_32 offset_x, offset_y;

-      int unit_type;

-

-      if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,

-          &unit_type))

-      {

-         png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);

-      }

-   }

+    {

+        png_int_32 offset_x, offset_y;

+        int unit_type;

+

+        if(png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,

+                        &unit_type))

+        {

+            png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);

+        }

+    }

 #endif

 #ifdef PNG_pCAL_SUPPORTED

-   {

-      png_charp purpose, units;

-      png_charpp params;

-      png_int_32 X0, X1;

-      int type, nparams;

-

-      if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,

-         &nparams, &units, &params))

-      {

-         png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,

-            nparams, units, params);

-      }

-   }

+    {

+        png_charp purpose, units;

+        png_charpp params;

+        png_int_32 X0, X1;

+        int type, nparams;

+

+        if(png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,

+                        &nparams, &units, &params))

+        {

+            png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,

+                         nparams, units, params);

+        }

+    }

 #endif

 #ifdef PNG_pHYs_SUPPORTED

-   {

-      png_uint_32 res_x, res_y;

-      int unit_type;

+    {

+        png_uint_32 res_x, res_y;

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

-   }

+        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

 #ifdef PNG_sBIT_SUPPORTED

-   {

-      png_color_8p sig_bit;

+    {

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

-   }

+        if(png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))

+            png_set_sBIT(write_ptr, write_info_ptr, sig_bit);

+    }

 #endif

 #ifdef PNG_sCAL_SUPPORTED

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-   {

-      int unit;

-      double scal_width, scal_height;

-

-      if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,

-         &scal_height))

-      {

-         png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);

-      }

-   }

+    {

+        int unit;

+        double scal_width, scal_height;

+

+        if(png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,

+                        &scal_height))

+        {

+            png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);

+        }

+    }

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

-   {

-      int unit;

-      png_charp scal_width, scal_height;

-

-      if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,

-          &scal_height))

-      {

-         png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width,

-             scal_height);

-      }

-   }

+    {

+        int unit;

+        png_charp scal_width, scal_height;

+

+        if(png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,

+                          &scal_height))

+        {

+            png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width,

+                           scal_height);

+        }

+    }

 #endif

 #endif

 #endif

 #ifdef PNG_TEXT_SUPPORTED

-   {

-      png_textp text_ptr;

-      int num_text;

-

-      if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)

-      {

-         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text);

-         png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);

-      }

-   }

+    {

+        png_textp text_ptr;

+        int num_text;

+

+        if(png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)

+        {

+            png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text);

+            png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);

+        }

+    }

 #endif

 #ifdef PNG_tIME_SUPPORTED

-   {

-      png_timep mod_time;

+    {

+        png_timep mod_time;

 

-      if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))

-      {

-         png_set_tIME(write_ptr, write_info_ptr, mod_time);

+        if(png_get_tIME(read_ptr, read_info_ptr, &mod_time))

+        {

+            png_set_tIME(write_ptr, write_info_ptr, mod_time);

 #ifdef 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.

-          */

-         png_memcpy(tIME_string,

-                    png_convert_to_rfc1123(read_ptr, mod_time),

-                    png_sizeof(tIME_string));

-         tIME_string[png_sizeof(tIME_string) - 1] = '\0';

-         tIME_chunk_present++;

+            /* 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.

+             */

+            png_memcpy(tIME_string,

+                       png_convert_to_rfc1123(read_ptr, mod_time),

+                       png_sizeof(tIME_string));

+            tIME_string[png_sizeof(tIME_string) - 1] = '\0';

+            tIME_chunk_present++;

 #endif /* PNG_TIME_RFC1123_SUPPORTED */

-      }

-   }

+        }

+    }

 #endif

 #ifdef PNG_tRNS_SUPPORTED

-   {

-      png_bytep trans_alpha;

-      int num_trans;

-      png_color_16p trans_color;

-

-      if (png_get_tRNS(read_ptr, read_info_ptr, &trans_alpha, &num_trans,

-         &trans_color))

-      {

-         int sample_max = (1 << bit_depth);

-         /* libpng doesn't reject a tRNS chunk with out-of-range samples */

-         if (!((color_type == PNG_COLOR_TYPE_GRAY &&

-             (int)trans_color->gray > sample_max) ||

-             (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_alpha, num_trans,

-               trans_color);

-      }

-   }

+    {

+        png_bytep trans_alpha;

+        int num_trans;

+        png_color_16p trans_color;

+

+        if(png_get_tRNS(read_ptr, read_info_ptr, &trans_alpha, &num_trans,

+                        &trans_color))

+        {

+            int sample_max = (1 << bit_depth);

+            /* libpng doesn't reject a tRNS chunk with out-of-range samples */

+            if(!((color_type == PNG_COLOR_TYPE_GRAY &&

+                  (int)trans_color->gray > sample_max) ||

+                 (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_alpha, num_trans,

+                             trans_color);

+        }

+    }

 #endif

 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   {

-      png_unknown_chunkp unknowns;

-      int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr,

-         &unknowns);

-      if (num_unknowns)

-      {

-         png_size_t i;

-         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.

-          */

-         for (i = 0; i < (png_size_t)num_unknowns; i++)

-           png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,

-             unknowns[i].location);

-      }

-   }

+    {

+        png_unknown_chunkp unknowns;

+        int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr,

+                           &unknowns);

+        if(num_unknowns)

+        {

+            png_size_t i;

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

+             */

+            for(i = 0; i < (png_size_t)num_unknowns; i++)

+                png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,

+                                               unknowns[i].location);

+        }

+    }

 #endif

 

 #ifdef PNG_WRITE_SUPPORTED

-   png_debug(0, "Writing info struct");

+    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(write_ptr, write_info_ptr);

+    /* If we wanted, we could write info in two steps:

+     * png_write_info_before_PLTE(write_ptr, write_info_ptr);

+     */

+    png_write_info(write_ptr, write_info_ptr);

 

 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED

-   if (user_chunk_data[0] != 0)

-   {

-      png_byte png_sTER[5] = {115,  84,  69,  82, '\0'};

+    if(user_chunk_data[0] != 0)

+    {

+        png_byte png_sTER[5] = {115,  84,  69,  82, '\0'};

 

-      unsigned char

+        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 (user_chunk_data[1] != 0 || user_chunk_data[2] != 0)

-   {

-      png_byte png_vpAg[5] = {118, 112,  65, 103, '\0'};

-

-      unsigned char

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

+

+        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

 #endif

 

 #ifdef SINGLE_ROWBUF_ALLOC

-   png_debug(0, "Allocating row buffer...");

-   row_buf = (png_bytep)png_malloc(read_ptr,

-      png_get_rowbytes(read_ptr, read_info_ptr));

-   png_debug1(0, "0x%08lx", (unsigned long)row_buf);

+    png_debug(0, "Allocating row buffer...");

+    row_buf = (png_bytep)png_malloc(read_ptr,

+                                    png_get_rowbytes(read_ptr, read_info_ptr));

+    png_debug1(0, "0x%08lx", (unsigned long)row_buf);

 #endif /* SINGLE_ROWBUF_ALLOC */

-   png_debug(0, "Writing row data");

+    png_debug(0, "Writing row data");

 

 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \

   defined(PNG_WRITE_INTERLACING_SUPPORTED)

-   num_pass = png_set_interlace_handling(read_ptr);

+    num_pass = png_set_interlace_handling(read_ptr);

 #  ifdef PNG_WRITE_SUPPORTED

-   png_set_interlace_handling(write_ptr);

+    png_set_interlace_handling(write_ptr);

 #  endif

 #else

-   num_pass = 1;

+    num_pass = 1;

 #endif

 

 #ifdef PNGTEST_TIMING

-   t_stop = (float)clock();

-   t_misc += (t_stop - t_start);

-   t_start = t_stop;

-#endif

-   for (pass = 0; pass < num_pass; pass++)

-   {

-      png_debug1(0, "Writing row data for pass %d", pass);

-      for (y = 0; y < height; y++)

-      {

+    t_stop = (float)clock();

+    t_misc += (t_stop - t_start);

+    t_start = t_stop;

+#endif

+    for(pass = 0;

+        pass < num_pass;

+        pass++)

+    {

+        png_debug1(0, "Writing row data for pass %d", pass);

+        for(y = 0; y < height; y++)

+        {

 #ifndef SINGLE_ROWBUF_ALLOC

-         png_debug2(0, "Allocating row buffer (pass %d, y = %ld)...", pass, y);

-         row_buf = (png_bytep)png_malloc(read_ptr,

-            png_get_rowbytes(read_ptr, read_info_ptr));

-         png_debug2(0, "0x%08lx (%ld bytes)", (unsigned long)row_buf,

-            png_get_rowbytes(read_ptr, read_info_ptr));

+            png_debug2(0, "Allocating row buffer (pass %d, y = %ld)...", pass, y);

+            row_buf = (png_bytep)png_malloc(read_ptr,

+                                            png_get_rowbytes(read_ptr, read_info_ptr));

+            png_debug2(0, "0x%08lx (%ld bytes)", (unsigned long)row_buf,

+                       png_get_rowbytes(read_ptr, read_info_ptr));

 #endif /* !SINGLE_ROWBUF_ALLOC */

-         png_read_rows(read_ptr, (png_bytepp)&row_buf, NULL, 1);

+            png_read_rows(read_ptr, (png_bytepp)&row_buf, NULL, 1);

 

 #ifdef PNG_WRITE_SUPPORTED

 #ifdef PNGTEST_TIMING

-         t_stop = (float)clock();

-         t_decode += (t_stop - t_start);

-         t_start = t_stop;

+            t_stop = (float)clock();

+            t_decode += (t_stop - t_start);

+            t_start = t_stop;

 #endif

-         png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);

+            png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);

 #ifdef PNGTEST_TIMING

-         t_stop = (float)clock();

-         t_encode += (t_stop - t_start);

-         t_start = t_stop;

+            t_stop = (float)clock();

+            t_encode += (t_stop - t_start);

+            t_start = t_stop;

 #endif

 #endif /* PNG_WRITE_SUPPORTED */

 

 #ifndef SINGLE_ROWBUF_ALLOC

-         png_debug2(0, "Freeing row buffer (pass %d, y = %ld)", pass, y);

-         png_free(read_ptr, row_buf);

-         row_buf = NULL;

+            png_debug2(0, "Freeing row buffer (pass %d, y = %ld)", pass, y);

+            png_free(read_ptr, row_buf);

+            row_buf = NULL;

 #endif /* !SINGLE_ROWBUF_ALLOC */

-      }

-   }

+        }

+    }

 

 #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

-   png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);

+    png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);

 #endif

 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);

+    png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);

 #endif

 

-   png_debug(0, "Reading and writing end_info data");

+    png_debug(0, "Reading and writing end_info data");

 

-   png_read_end(read_ptr, end_info_ptr);

+    png_read_end(read_ptr, end_info_ptr);

 #ifdef PNG_TEXT_SUPPORTED

-   {

-      png_textp text_ptr;

-      int num_text;

-

-      if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0)

-      {

-         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text);

-         png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text);

-      }

-   }

+    {

+        png_textp text_ptr;

+        int num_text;

+

+        if(png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0)

+        {

+            png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text);

+            png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text);

+        }

+    }

 #endif

 #ifdef PNG_tIME_SUPPORTED

-   {

-      png_timep mod_time;

+    {

+        png_timep mod_time;

 

-      if (png_get_tIME(read_ptr, end_info_ptr, &mod_time))

-      {

-         png_set_tIME(write_ptr, write_end_info_ptr, mod_time);

+        if(png_get_tIME(read_ptr, end_info_ptr, &mod_time))

+        {

+            png_set_tIME(write_ptr, write_end_info_ptr, mod_time);

 #ifdef 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 */

-         png_memcpy(tIME_string,

-                    png_convert_to_rfc1123(read_ptr, mod_time),

-                    png_sizeof(tIME_string));

-         tIME_string[png_sizeof(tIME_string) - 1] = '\0';

-         tIME_chunk_present++;

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

+            png_memcpy(tIME_string,

+                       png_convert_to_rfc1123(read_ptr, mod_time),

+                       png_sizeof(tIME_string));

+            tIME_string[png_sizeof(tIME_string) - 1] = '\0';

+            tIME_chunk_present++;

 #endif /* PNG_TIME_RFC1123_SUPPORTED */

-      }

-   }

+        }

+    }

 #endif

 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   {

-      png_unknown_chunkp unknowns;

-      int num_unknowns;

-      num_unknowns = (int)png_get_unknown_chunks(read_ptr, end_info_ptr,

-         &unknowns);

-      if (num_unknowns)

-      {

-         png_size_t i;

-         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.

-          */

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

-      }

-   }

+    {

+        png_unknown_chunkp unknowns;

+        int num_unknowns;

+        num_unknowns = (int)png_get_unknown_chunks(read_ptr, end_info_ptr,

+                       &unknowns);

+        if(num_unknowns)

+        {

+            png_size_t i;

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

+             */

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

+        }

+    }

 #endif

 #ifdef PNG_WRITE_SUPPORTED

-   png_write_end(write_ptr, write_end_info_ptr);

+    png_write_end(write_ptr, write_end_info_ptr);

 #endif

 

 #ifdef PNG_EASY_ACCESS_SUPPORTED

-   if (verbose)

-   {

-      png_uint_32 iwidth, iheight;

-      iwidth = png_get_image_width(write_ptr, write_info_ptr);

-      iheight = png_get_image_height(write_ptr, write_info_ptr);

-      fprintf(STDERR, "\n Image width = %lu, height = %lu\n",

-         (unsigned long)iwidth, (unsigned long)iheight);

-   }

+    if(verbose)

+    {

+        png_uint_32 iwidth, iheight;

+        iwidth = png_get_image_width(write_ptr, write_info_ptr);

+        iheight = png_get_image_height(write_ptr, write_info_ptr);

+        fprintf(STDERR, "\n Image width = %lu, height = %lu\n",

+                (unsigned long)iwidth, (unsigned long)iheight);

+    }

 #endif

 

-   png_debug(0, "Destroying data structs");

+    png_debug(0, "Destroying data structs");

 #ifdef SINGLE_ROWBUF_ALLOC

-   png_debug(1, "destroying row_buf for read_ptr");

-   png_free(read_ptr, row_buf);

-   row_buf = NULL;

+    png_debug(1, "destroying row_buf for read_ptr");

+    png_free(read_ptr, row_buf);

+    row_buf = NULL;

 #endif /* SINGLE_ROWBUF_ALLOC */

-   png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr");

-   png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

+    png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr");

+    png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

 #ifdef PNG_WRITE_SUPPORTED

-   png_debug(1, "destroying write_end_info_ptr");

-   png_destroy_info_struct(write_ptr, &write_end_info_ptr);

-   png_debug(1, "destroying write_ptr, write_info_ptr");

-   png_destroy_write_struct(&write_ptr, &write_info_ptr);

-#endif

-   png_debug(0, "Destruction complete.");

-

-   FCLOSE(fpin);

-   FCLOSE(fpout);

-

-   png_debug(0, "Opening files for comparison");

-   if ((fpin = fopen(inname, "rb")) == NULL)

-   {

-      fprintf(STDERR, "Could not find file %s\n", inname);

-      return (1);

-   }

-

-   if ((fpout = fopen(outname, "rb")) == NULL)

-   {

-      fprintf(STDERR, "Could not find file %s\n", outname);

-      FCLOSE(fpin);

-      return (1);

-   }

-

-   for (;;)

-   {

-      png_size_t num_in, num_out;

-

-         num_in = fread(inbuf, 1, 1, fpin);

-         num_out = fread(outbuf, 1, 1, fpout);

-

-      if (num_in != num_out)

-      {

-         fprintf(STDERR, "\nFiles %s and %s are of a different size\n",

-                 inname, outname);

-         if (wrote_question == 0)

-         {

-            fprintf(STDERR,

-         "   Was %s written with the same maximum IDAT chunk size (%d bytes),",

-              inname, PNG_ZBUF_SIZE);

-            fprintf(STDERR,

-              "\n   filtering heuristic (libpng default), compression");

-            fprintf(STDERR,

-              " level (zlib default),\n   and zlib version (%s)?\n\n",

-              ZLIB_VERSION);

-            wrote_question = 1;

-         }

-         FCLOSE(fpin);

-         FCLOSE(fpout);

-         return (0);

-      }

-

-      if (!num_in)

-         break;

-

-      if (png_memcmp(inbuf, outbuf, num_in))

-      {

-         fprintf(STDERR, "\nFiles %s and %s are different\n", inname, outname);

-         if (wrote_question == 0)

-         {

-            fprintf(STDERR,

-         "   Was %s written with the same maximum IDAT chunk size (%d bytes),",

-                 inname, PNG_ZBUF_SIZE);

-            fprintf(STDERR,

-              "\n   filtering heuristic (libpng default), compression");

-            fprintf(STDERR,

-              " level (zlib default),\n   and zlib version (%s)?\n\n",

-              ZLIB_VERSION);

-            wrote_question = 1;

-         }

-         FCLOSE(fpin);

-         FCLOSE(fpout);

-         return (0);

-      }

-   }

-

-   FCLOSE(fpin);

-   FCLOSE(fpout);

-

-   return (0);

+    png_debug(1, "destroying write_end_info_ptr");

+    png_destroy_info_struct(write_ptr, &write_end_info_ptr);

+    png_debug(1, "destroying write_ptr, write_info_ptr");

+    png_destroy_write_struct(&write_ptr, &write_info_ptr);

+#endif

+    png_debug(0, "Destruction complete.");

+

+    FCLOSE(fpin);

+    FCLOSE(fpout);

+

+    png_debug(0, "Opening files for comparison");

+    if((fpin = fopen(inname, "rb")) == NULL)

+    {

+        fprintf(STDERR, "Could not find file %s\n", inname);

+        return (1);

+    }

+

+    if((fpout = fopen(outname, "rb")) == NULL)

+    {

+        fprintf(STDERR, "Could not find file %s\n", outname);

+        FCLOSE(fpin);

+        return (1);

+    }

+

+    for(;;

+       )

+    {

+        png_size_t num_in, num_out;

+

+        num_in = fread(inbuf, 1, 1, fpin);

+        num_out = fread(outbuf, 1, 1, fpout);

+

+        if(num_in != num_out)

+        {

+            fprintf(STDERR, "\nFiles %s and %s are of a different size\n",

+                    inname, outname);

+            if(wrote_question == 0)

+            {

+                fprintf(STDERR,

+                        "   Was %s written with the same maximum IDAT chunk size (%d bytes),",

+                        inname, PNG_ZBUF_SIZE);

+                fprintf(STDERR,

+                        "\n   filtering heuristic (libpng default), compression");

+                fprintf(STDERR,

+                        " level (zlib default),\n   and zlib version (%s)?\n\n",

+                        ZLIB_VERSION);

+                wrote_question = 1;

+            }

+            FCLOSE(fpin);

+            FCLOSE(fpout);

+            return (0);

+        }

+

+        if(!num_in)

+            break;

+

+        if(png_memcmp(inbuf, outbuf, num_in))

+        {

+            fprintf(STDERR, "\nFiles %s and %s are different\n", inname, outname);

+            if(wrote_question == 0)

+            {

+                fprintf(STDERR,

+                        "   Was %s written with the same maximum IDAT chunk size (%d bytes),",

+                        inname, PNG_ZBUF_SIZE);

+                fprintf(STDERR,

+                        "\n   filtering heuristic (libpng default), compression");

+                fprintf(STDERR,

+                        " level (zlib default),\n   and zlib version (%s)?\n\n",

+                        ZLIB_VERSION);

+                wrote_question = 1;

+            }

+            FCLOSE(fpin);

+            FCLOSE(fpout);

+            return (0);

+        }

+    }

+

+    FCLOSE(fpin);

+    FCLOSE(fpout);

+

+    return (0);

 }

 

 /* Input and output filenames */

@@ -1378,252 +1381,252 @@ static PNG_CONST char *outname = "pngout.png";
 int

 main(int argc, char *argv[])

 {

-   int multiple = 0;

-   int ierror = 0;

-

-   fprintf(STDERR, "\n Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);

-   fprintf(STDERR, "   with zlib   version %s\n", ZLIB_VERSION);

-   fprintf(STDERR, "%s", png_get_copyright(NULL));

-   /* Show the version of libpng used in building the library */

-   fprintf(STDERR, " library (%lu):%s",

-      (unsigned long)png_access_version_number(),

-      png_get_header_version(NULL));

-   /* Show the version of libpng used in building the application */

-   fprintf(STDERR, " pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER,

-      PNG_HEADER_VERSION_STRING);

-   fprintf(STDERR, " sizeof(png_struct)=%ld, sizeof(png_info)=%ld\n",

-                    (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

-    */

+    int multiple = 0;

+    int ierror = 0;

+

+    fprintf(STDERR, "\n Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);

+    fprintf(STDERR, "   with zlib   version %s\n", ZLIB_VERSION);

+    fprintf(STDERR, "%s", png_get_copyright(NULL));

+    /* Show the version of libpng used in building the library */

+    fprintf(STDERR, " library (%lu):%s",

+            (unsigned long)png_access_version_number(),

+            png_get_header_version(NULL));

+    /* Show the version of libpng used in building the application */

+    fprintf(STDERR, " pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER,

+            PNG_HEADER_VERSION_STRING);

+    fprintf(STDERR, " sizeof(png_struct)=%ld, sizeof(png_info)=%ld\n",

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

+     */

 #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)

-      fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");

+    fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");

 #endif

-   /* I think the following can happen. */

+    /* I think the following can happen. */

 #if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)

-      fprintf(STDERR, " NOTE: libpng compiled for max 64k, zlib not\n");

-#endif

-

-   if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))

-   {

-      fprintf(STDERR,

-         "Warning: versions are different between png.h and png.c\n");

-      fprintf(STDERR, "  png.h version: %s\n", PNG_LIBPNG_VER_STRING);

-      fprintf(STDERR, "  png.c version: %s\n\n", png_libpng_ver);

-      ++ierror;

-   }

-

-   if (argc > 1)

-   {

-      if (strcmp(argv[1], "-m") == 0)

-      {

-         multiple = 1;

-         status_dots_requested = 0;

-      }

-      else if (strcmp(argv[1], "-mv") == 0 ||

-               strcmp(argv[1], "-vm") == 0 )

-      {

-         multiple = 1;

-         verbose = 1;

-         status_dots_requested = 1;

-      }

-      else if (strcmp(argv[1], "-v") == 0)

-      {

-         verbose = 1;

-         status_dots_requested = 1;

-         inname = argv[2];

-      }

-      else

-      {

-         inname = argv[1];

-         status_dots_requested = 0;

-      }

-   }

-

-   if (!multiple && argc == 3 + verbose)

-     outname = argv[2 + verbose];

-

-   if ((!multiple && argc > 3 + verbose) || (multiple && argc < 2))

-   {

-     fprintf(STDERR,

-       "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",

-        argv[0], argv[0]);

-     fprintf(STDERR,

-       "  reads/writes one PNG file (without -m) or multiple files (-m)\n");

-     fprintf(STDERR,

-       "  with -m %s is used as a temporary file\n", outname);

-     exit(1);

-   }

-

-   if (multiple)

-   {

-      int i;

+    fprintf(STDERR, " NOTE: libpng compiled for max 64k, zlib not\n");

+#endif

+

+    if(strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))

+    {

+        fprintf(STDERR,

+                "Warning: versions are different between png.h and png.c\n");

+        fprintf(STDERR, "  png.h version: %s\n", PNG_LIBPNG_VER_STRING);

+        fprintf(STDERR, "  png.c version: %s\n\n", png_libpng_ver);

+        ++ierror;

+    }

+

+    if(argc > 1)

+    {

+        if(strcmp(argv[1], "-m") == 0)

+        {

+            multiple = 1;

+            status_dots_requested = 0;

+        }

+        else if(strcmp(argv[1], "-mv") == 0 ||

+                strcmp(argv[1], "-vm") == 0)

+        {

+            multiple = 1;

+            verbose = 1;

+            status_dots_requested = 1;

+        }

+        else if(strcmp(argv[1], "-v") == 0)

+        {

+            verbose = 1;

+            status_dots_requested = 1;

+            inname = argv[2];

+        }

+        else

+        {

+            inname = argv[1];

+            status_dots_requested = 0;

+        }

+    }

+

+    if(!multiple && argc == 3 + verbose)

+        outname = argv[2 + verbose];

+

+    if((!multiple && argc > 3 + verbose) || (multiple && argc < 2))

+    {

+        fprintf(STDERR,

+                "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",

+                argv[0], argv[0]);

+        fprintf(STDERR,

+                "  reads/writes one PNG file (without -m) or multiple files (-m)\n");

+        fprintf(STDERR,

+                "  with -m %s is used as a temporary file\n", outname);

+        exit(1);

+    }

+

+    if(multiple)

+    {

+        int i;

 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-      int allocation_now = current_allocation;

-#endif

-      for (i=2; i<argc; ++i)

-      {

-         int kerror;

-         fprintf(STDERR, "\n Testing %s:", argv[i]);

-         kerror = test_one_file(argv[i], outname);

-         if (kerror == 0)

-         {

+        int allocation_now = current_allocation;

+#endif

+        for(i = 2; i < argc; ++i)

+        {

+            int kerror;

+            fprintf(STDERR, "\n Testing %s:", argv[i]);

+            kerror = test_one_file(argv[i], outname);

+            if(kerror == 0)

+            {

 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-            int k;

+                int k;

 #endif

 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-            fprintf(STDERR, "\n PASS (%lu zero samples)\n",

-               (unsigned long)zero_samples);

+                fprintf(STDERR, "\n PASS (%lu zero samples)\n",

+                        (unsigned long)zero_samples);

 #else

-            fprintf(STDERR, " PASS\n");

+                fprintf(STDERR, " PASS\n");

 #endif

 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-            for (k = 0; k<256; k++)

-               if (filters_used[k])

-                  fprintf(STDERR, " Filter %d was used %lu times\n",

-                     k, (unsigned long)filters_used[k]);

+                for(k = 0; k < 256; k++)

+                    if(filters_used[k])

+                        fprintf(STDERR, " Filter %d was used %lu times\n",

+                                k, (unsigned long)filters_used[k]);

 #endif

 #ifdef PNG_TIME_RFC1123_SUPPORTED

-         if (tIME_chunk_present != 0)

-            fprintf(STDERR, " tIME = %s\n", tIME_string);

-         tIME_chunk_present = 0;

+                if(tIME_chunk_present != 0)

+                    fprintf(STDERR, " tIME = %s\n", tIME_string);

+                tIME_chunk_present = 0;

 #endif /* PNG_TIME_RFC1123_SUPPORTED */

-         }

-         else

-         {

-            fprintf(STDERR, " FAIL\n");

-            ierror += kerror;

-         }

+            }

+            else

+            {

+                fprintf(STDERR, " FAIL\n");

+                ierror += kerror;

+            }

 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-         if (allocation_now != current_allocation)

-            fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",

-               current_allocation - allocation_now);

-         if (current_allocation != 0)

-         {

-            memory_infop pinfo = pinformation;

-

-            fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",

-               current_allocation);

-            while (pinfo != NULL)

+            if(allocation_now != current_allocation)

+                fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",

+                        current_allocation - allocation_now);

+            if(current_allocation != 0)

             {

-               fprintf(STDERR, " %lu bytes at %x\n",

-                 (unsigned long)pinfo->size,

-                 (unsigned int) pinfo->pointer);

-               pinfo = pinfo->next;

+                memory_infop pinfo = pinformation;

+

+                fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",

+                        current_allocation);

+                while(pinfo != NULL)

+                {

+                    fprintf(STDERR, " %lu bytes at %x\n",

+                            (unsigned long)pinfo->size,

+                            (unsigned int) pinfo->pointer);

+                    pinfo = pinfo->next;

+                }

             }

-         }

 #endif

-      }

+        }

 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-         fprintf(STDERR, " Current memory allocation: %10d bytes\n",

-            current_allocation);

-         fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",

-            maximum_allocation);

-         fprintf(STDERR, " Total   memory allocation: %10d bytes\n",

-            total_allocation);

-         fprintf(STDERR, "     Number of allocations: %10d\n",

-            num_allocations);

-#endif

-   }

-   else

-   {

-      int i;

-      for (i = 0; i<3; ++i)

-      {

-         int kerror;

+        fprintf(STDERR, " Current memory allocation: %10d bytes\n",

+                current_allocation);

+        fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",

+                maximum_allocation);

+        fprintf(STDERR, " Total   memory allocation: %10d bytes\n",

+                total_allocation);

+        fprintf(STDERR, "     Number of allocations: %10d\n",

+                num_allocations);

+#endif

+    }

+    else

+    {

+        int i;

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

+        {

+            int kerror;

 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-         int allocation_now = current_allocation;

-#endif

-         if (i == 1) status_dots_requested = 1;

-         else if (verbose == 0)status_dots_requested = 0;

-         if (i == 0 || verbose == 1 || ierror != 0)

-            fprintf(STDERR, "\n Testing %s:", inname);

-         kerror = test_one_file(inname, outname);

-         if (kerror == 0)

-         {

-            if (verbose == 1 || i == 2)

+            int allocation_now = current_allocation;

+#endif

+            if(i == 1) status_dots_requested = 1;

+            else if(verbose == 0)status_dots_requested = 0;

+            if(i == 0 || verbose == 1 || ierror != 0)

+                fprintf(STDERR, "\n Testing %s:", inname);

+            kerror = test_one_file(inname, outname);

+            if(kerror == 0)

             {

+                if(verbose == 1 || i == 2)

+                {

 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-                int k;

+                    int k;

 #endif

 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-                fprintf(STDERR, "\n PASS (%lu zero samples)\n",

-                   (unsigned long)zero_samples);

+                    fprintf(STDERR, "\n PASS (%lu zero samples)\n",

+                            (unsigned long)zero_samples);

 #else

-                fprintf(STDERR, " PASS\n");

+                    fprintf(STDERR, " PASS\n");

 #endif

 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED

-                for (k = 0; k<256; k++)

-                   if (filters_used[k])

-                      fprintf(STDERR, " Filter %d was used %lu times\n",

-                         k, (unsigned long)filters_used[k]);

+                    for(k = 0; k < 256; k++)

+                        if(filters_used[k])

+                            fprintf(STDERR, " Filter %d was used %lu times\n",

+                                    k, (unsigned long)filters_used[k]);

 #endif

 #ifdef PNG_TIME_RFC1123_SUPPORTED

-             if (tIME_chunk_present != 0)

-                fprintf(STDERR, " tIME = %s\n", tIME_string);

+                    if(tIME_chunk_present != 0)

+                        fprintf(STDERR, " tIME = %s\n", tIME_string);

 #endif /* PNG_TIME_RFC1123_SUPPORTED */

+                }

+            }

+            else

+            {

+                if(verbose == 0 && i != 2)

+                    fprintf(STDERR, "\n Testing %s:", inname);

+                fprintf(STDERR, " FAIL\n");

+                ierror += kerror;

             }

-         }

-         else

-         {

-            if (verbose == 0 && i != 2)

-               fprintf(STDERR, "\n Testing %s:", inname);

-            fprintf(STDERR, " FAIL\n");

-            ierror += kerror;

-         }

 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-         if (allocation_now != current_allocation)

-             fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",

-               current_allocation - allocation_now);

-         if (current_allocation != 0)

-         {

-             memory_infop pinfo = pinformation;

-

-             fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",

-                current_allocation);

-             while (pinfo != NULL)

-             {

-                fprintf(STDERR, " %lu bytes at %x\n",

-                   (unsigned long)pinfo->size, (unsigned int)pinfo->pointer);

-                pinfo = pinfo->next;

-             }

-          }

-#endif

-       }

+            if(allocation_now != current_allocation)

+                fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",

+                        current_allocation - allocation_now);

+            if(current_allocation != 0)

+            {

+                memory_infop pinfo = pinformation;

+

+                fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",

+                        current_allocation);

+                while(pinfo != NULL)

+                {

+                    fprintf(STDERR, " %lu bytes at %x\n",

+                            (unsigned long)pinfo->size, (unsigned int)pinfo->pointer);

+                    pinfo = pinfo->next;

+                }

+            }

+#endif

+        }

 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

-       fprintf(STDERR, " Current memory allocation: %10d bytes\n",

-          current_allocation);

-       fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",

-          maximum_allocation);

-       fprintf(STDERR, " Total   memory allocation: %10d bytes\n",

-          total_allocation);

-       fprintf(STDERR, "     Number of allocations: %10d\n",

-            num_allocations);

+        fprintf(STDERR, " Current memory allocation: %10d bytes\n",

+                current_allocation);

+        fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",

+                maximum_allocation);

+        fprintf(STDERR, " Total   memory allocation: %10d bytes\n",

+                total_allocation);

+        fprintf(STDERR, "     Number of allocations: %10d\n",

+                num_allocations);

 #endif

-   }

+    }

 

 #ifdef PNGTEST_TIMING

-   t_stop = (float)clock();

-   t_misc += (t_stop - t_start);

-   t_start = t_stop;

-   fprintf(STDERR, " CPU time used = %.3f seconds",

-      (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC);

-   fprintf(STDERR, " (decoding %.3f,\n",

-      t_decode/(float)CLOCKS_PER_SEC);

-   fprintf(STDERR, "        encoding %.3f ,",

-      t_encode/(float)CLOCKS_PER_SEC);

-   fprintf(STDERR, " other %.3f seconds)\n\n",

-      t_misc/(float)CLOCKS_PER_SEC);

-#endif

-

-   if (ierror == 0)

-      fprintf(STDERR, " libpng passes test\n");

-   else

-      fprintf(STDERR, " libpng FAILS test\n");

-   return (int)(ierror != 0);

+    t_stop = (float)clock();

+    t_misc += (t_stop - t_start);

+    t_start = t_stop;

+    fprintf(STDERR, " CPU time used = %.3f seconds",

+            (t_misc + t_decode + t_encode) / (float)CLOCKS_PER_SEC);

+    fprintf(STDERR, " (decoding %.3f,\n",

+            t_decode / (float)CLOCKS_PER_SEC);

+    fprintf(STDERR, "        encoding %.3f ,",

+            t_encode / (float)CLOCKS_PER_SEC);

+    fprintf(STDERR, " other %.3f seconds)\n\n",

+            t_misc / (float)CLOCKS_PER_SEC);

+#endif

+

+    if(ierror == 0)

+        fprintf(STDERR, " libpng passes test\n");

+    else

+        fprintf(STDERR, " libpng FAILS test\n");

+    return (int)(ierror != 0);

 }

 

 /* Generate a compiler error if there is an old png.h in the search path. */

diff --git a/src/libpng/pngtrans.c b/src/libpng/pngtrans.c
index 5b6e5fba4..63e3d90d5 100644
--- a/src/libpng/pngtrans.c
+++ b/src/libpng/pngtrans.c
@@ -21,11 +21,11 @@
 void PNGAPI

 png_set_bgr(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_bgr");

+    png_debug(1, "in png_set_bgr");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_BGR;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->transformations |= PNG_BGR;

 }

 #endif

 

@@ -34,12 +34,12 @@ png_set_bgr(png_structp png_ptr)
 void PNGAPI

 png_set_swap(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_swap");

+    png_debug(1, "in png_set_swap");

 

-   if (png_ptr == NULL)

-      return;

-   if (png_ptr->bit_depth == 16)

-      png_ptr->transformations |= PNG_SWAP_BYTES;

+    if(png_ptr == NULL)

+        return;

+    if(png_ptr->bit_depth == 16)

+        png_ptr->transformations |= PNG_SWAP_BYTES;

 }

 #endif

 

@@ -48,15 +48,15 @@ png_set_swap(png_structp png_ptr)
 void PNGAPI

 png_set_packing(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_packing");

-

-   if (png_ptr == NULL)

-      return;

-   if (png_ptr->bit_depth < 8)

-   {

-      png_ptr->transformations |= PNG_PACK;

-      png_ptr->usr_bit_depth = 8;

-   }

+    png_debug(1, "in png_set_packing");

+

+    if(png_ptr == NULL)

+        return;

+    if(png_ptr->bit_depth < 8)

+    {

+        png_ptr->transformations |= PNG_PACK;

+        png_ptr->usr_bit_depth = 8;

+    }

 }

 #endif

 

@@ -65,12 +65,12 @@ png_set_packing(png_structp png_ptr)
 void PNGAPI

 png_set_packswap(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_packswap");

+    png_debug(1, "in png_set_packswap");

 

-   if (png_ptr == NULL)

-      return;

-   if (png_ptr->bit_depth < 8)

-      png_ptr->transformations |= PNG_PACKSWAP;

+    if(png_ptr == NULL)

+        return;

+    if(png_ptr->bit_depth < 8)

+        png_ptr->transformations |= PNG_PACKSWAP;

 }

 #endif

 

@@ -78,12 +78,12 @@ png_set_packswap(png_structp png_ptr)
 void PNGAPI

 png_set_shift(png_structp png_ptr, png_color_8p true_bits)

 {

-   png_debug(1, "in png_set_shift");

+    png_debug(1, "in png_set_shift");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_SHIFT;

-   png_ptr->shift = *true_bits;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->transformations |= PNG_SHIFT;

+    png_ptr->shift = *true_bits;

 }

 #endif

 

@@ -92,15 +92,15 @@ png_set_shift(png_structp png_ptr, png_color_8p true_bits)
 int PNGAPI

 png_set_interlace_handling(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_interlace handling");

+    png_debug(1, "in png_set_interlace handling");

 

-   if (png_ptr && png_ptr->interlaced)

-   {

-      png_ptr->transformations |= PNG_INTERLACE;

-      return (7);

-   }

+    if(png_ptr && png_ptr->interlaced)

+    {

+        png_ptr->transformations |= PNG_INTERLACE;

+        return (7);

+    }

 

-   return (1);

+    return (1);

 }

 #endif

 

@@ -113,46 +113,46 @@ png_set_interlace_handling(png_structp png_ptr)
 void PNGAPI

 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;

-   png_ptr->transformations |= PNG_FILLER;

-   png_ptr->filler = (png_uint_16)filler;

-   if (filler_loc == PNG_FILLER_AFTER)

-      png_ptr->flags |= PNG_FLAG_FILLER_AFTER;

-   else

-      png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;

-

-   /* This should probably go in the "do_read_filler" routine.

-    * I attempted to do that in libpng-1.0.1a but that caused problems

-    * so I restored it in libpng-1.0.2a

-   */

-

-   if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

-   {

-      png_ptr->usr_channels = 4;

-   }

-

-   /* Also I added this in libpng-1.0.2a (what happens when we expand

-    * a less-than-8-bit grayscale to GA? */

-

-   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)

-   {

-      png_ptr->usr_channels = 2;

-   }

+    png_debug(1, "in png_set_filler");

+

+    if(png_ptr == NULL)

+        return;

+    png_ptr->transformations |= PNG_FILLER;

+    png_ptr->filler = (png_uint_16)filler;

+    if(filler_loc == PNG_FILLER_AFTER)

+        png_ptr->flags |= PNG_FLAG_FILLER_AFTER;

+    else

+        png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;

+

+    /* This should probably go in the "do_read_filler" routine.

+     * I attempted to do that in libpng-1.0.1a but that caused problems

+     * so I restored it in libpng-1.0.2a

+    */

+

+    if(png_ptr->color_type == PNG_COLOR_TYPE_RGB)

+    {

+        png_ptr->usr_channels = 4;

+    }

+

+    /* Also I added this in libpng-1.0.2a (what happens when we expand

+     * a less-than-8-bit grayscale to GA? */

+

+    if(png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)

+    {

+        png_ptr->usr_channels = 2;

+    }

 }

 

 /* Added to libpng-1.2.7 */

 void PNGAPI

 png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)

 {

-   png_debug(1, "in png_set_add_alpha");

+    png_debug(1, "in png_set_add_alpha");

 

-   if (png_ptr == NULL)

-      return;

-   png_set_filler(png_ptr, filler, filler_loc);

-   png_ptr->transformations |= PNG_ADD_ALPHA;

+    if(png_ptr == NULL)

+        return;

+    png_set_filler(png_ptr, filler, filler_loc);

+    png_ptr->transformations |= PNG_ADD_ALPHA;

 }

 

 #endif

@@ -162,11 +162,11 @@ png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
 void PNGAPI

 png_set_swap_alpha(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_swap_alpha");

+    png_debug(1, "in png_set_swap_alpha");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_SWAP_ALPHA;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->transformations |= PNG_SWAP_ALPHA;

 }

 #endif

 

@@ -175,11 +175,11 @@ png_set_swap_alpha(png_structp png_ptr)
 void PNGAPI

 png_set_invert_alpha(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_invert_alpha");

+    png_debug(1, "in png_set_invert_alpha");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_INVERT_ALPHA;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->transformations |= PNG_INVERT_ALPHA;

 }

 #endif

 

@@ -187,61 +187,61 @@ png_set_invert_alpha(png_structp png_ptr)
 void PNGAPI

 png_set_invert_mono(png_structp png_ptr)

 {

-   png_debug(1, "in png_set_invert_mono");

+    png_debug(1, "in png_set_invert_mono");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_INVERT_MONO;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->transformations |= PNG_INVERT_MONO;

 }

 

 /* Invert monochrome grayscale data */

 void /* PRIVATE */

 png_do_invert(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_invert");

-

-  /* This test removed from libpng version 1.0.13 and 1.2.0:

-   *   if (row_info->bit_depth == 1 &&

-   */

-   if (row_info->color_type == PNG_COLOR_TYPE_GRAY)

-   {

-      png_bytep rp = row;

-      png_uint_32 i;

-      png_uint_32 istop = row_info->rowbytes;

-

-      for (i = 0; i < istop; i++)

-      {

-         *rp = (png_byte)(~(*rp));

-         rp++;

-      }

-   }

-   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

-      row_info->bit_depth == 8)

-   {

-      png_bytep rp = row;

-      png_uint_32 i;

-      png_uint_32 istop = row_info->rowbytes;

-

-      for (i = 0; i < istop; i+=2)

-      {

-         *rp = (png_byte)(~(*rp));

-         rp+=2;

-      }

-   }

-   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

-      row_info->bit_depth == 16)

-   {

-      png_bytep rp = row;

-      png_uint_32 i;

-      png_uint_32 istop = row_info->rowbytes;

-

-      for (i = 0; i < istop; i+=4)

-      {

-         *rp = (png_byte)(~(*rp));

-         *(rp+1) = (png_byte)(~(*(rp+1)));

-         rp+=4;

-      }

-   }

+    png_debug(1, "in png_do_invert");

+

+    /* This test removed from libpng version 1.0.13 and 1.2.0:

+     *   if (row_info->bit_depth == 1 &&

+     */

+    if(row_info->color_type == PNG_COLOR_TYPE_GRAY)

+    {

+        png_bytep rp = row;

+        png_uint_32 i;

+        png_uint_32 istop = row_info->rowbytes;

+

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

+        {

+            *rp = (png_byte)(~(*rp));

+            rp++;

+        }

+    }

+    else if(row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

+            row_info->bit_depth == 8)

+    {

+        png_bytep rp = row;

+        png_uint_32 i;

+        png_uint_32 istop = row_info->rowbytes;

+

+        for(i = 0; i < istop; i += 2)

+        {

+            *rp = (png_byte)(~(*rp));

+            rp += 2;

+        }

+    }

+    else if(row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

+            row_info->bit_depth == 16)

+    {

+        png_bytep rp = row;

+        png_uint_32 i;

+        png_uint_32 istop = row_info->rowbytes;

+

+        for(i = 0; i < istop; i += 4)

+        {

+            *rp = (png_byte)(~(*rp));

+            *(rp + 1) = (png_byte)(~(*(rp + 1)));

+            rp += 4;

+        }

+    }

 }

 #endif

 

@@ -250,156 +250,159 @@ png_do_invert(png_row_infop row_info, png_bytep row)
 void /* PRIVATE */

 png_do_swap(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_swap");

-

-   if (

-       row_info->bit_depth == 16)

-   {

-      png_bytep rp = row;

-      png_uint_32 i;

-      png_uint_32 istop= row_info->width * row_info->channels;

-

-      for (i = 0; i < istop; i++, rp += 2)

-      {

-         png_byte t = *rp;

-         *rp = *(rp + 1);

-         *(rp + 1) = t;

-      }

-   }

+    png_debug(1, "in png_do_swap");

+

+    if(

+        row_info->bit_depth == 16)

+    {

+        png_bytep rp = row;

+        png_uint_32 i;

+        png_uint_32 istop = row_info->width * row_info->channels;

+

+        for(i = 0; i < istop; i++, rp += 2)

+        {

+            png_byte t = *rp;

+            *rp = *(rp + 1);

+            *(rp + 1) = t;

+        }

+    }

 }

 #endif

 

 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)

-static PNG_CONST png_byte onebppswaptable[256] = {

-   0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,

-   0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,

-   0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,

-   0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,

-   0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,

-   0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,

-   0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,

-   0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,

-   0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,

-   0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,

-   0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,

-   0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,

-   0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,

-   0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,

-   0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,

-   0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,

-   0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,

-   0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,

-   0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,

-   0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,

-   0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,

-   0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,

-   0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,

-   0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,

-   0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,

-   0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,

-   0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,

-   0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,

-   0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,

-   0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,

-   0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,

-   0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF

+static PNG_CONST png_byte onebppswaptable[256] =

+{

+    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,

+    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,

+    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,

+    0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,

+    0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,

+    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,

+    0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,

+    0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,

+    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,

+    0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,

+    0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,

+    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,

+    0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,

+    0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,

+    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,

+    0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,

+    0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,

+    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,

+    0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,

+    0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,

+    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,

+    0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,

+    0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,

+    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,

+    0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,

+    0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,

+    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,

+    0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,

+    0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,

+    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,

+    0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,

+    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF

 };

 

-static PNG_CONST png_byte twobppswaptable[256] = {

-   0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,

-   0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,

-   0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,

-   0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,

-   0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,

-   0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,

-   0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,

-   0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,

-   0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,

-   0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,

-   0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,

-   0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,

-   0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,

-   0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,

-   0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,

-   0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,

-   0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,

-   0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,

-   0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,

-   0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,

-   0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,

-   0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,

-   0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,

-   0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,

-   0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,

-   0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,

-   0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,

-   0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,

-   0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,

-   0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,

-   0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,

-   0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF

+static PNG_CONST png_byte twobppswaptable[256] =

+{

+    0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,

+    0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,

+    0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,

+    0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,

+    0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,

+    0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,

+    0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,

+    0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,

+    0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,

+    0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,

+    0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,

+    0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,

+    0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,

+    0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,

+    0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,

+    0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,

+    0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,

+    0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,

+    0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,

+    0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,

+    0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,

+    0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,

+    0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,

+    0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,

+    0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,

+    0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,

+    0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,

+    0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,

+    0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,

+    0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,

+    0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,

+    0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF

 };

 

-static PNG_CONST png_byte fourbppswaptable[256] = {

-   0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,

-   0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,

-   0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,

-   0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,

-   0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,

-   0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,

-   0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,

-   0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,

-   0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,

-   0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,

-   0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,

-   0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,

-   0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,

-   0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,

-   0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,

-   0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,

-   0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,

-   0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,

-   0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,

-   0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,

-   0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,

-   0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,

-   0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,

-   0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,

-   0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,

-   0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,

-   0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,

-   0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,

-   0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,

-   0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,

-   0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,

-   0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF

+static PNG_CONST png_byte fourbppswaptable[256] =

+{

+    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,

+    0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,

+    0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,

+    0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,

+    0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,

+    0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,

+    0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,

+    0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,

+    0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,

+    0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,

+    0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,

+    0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,

+    0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,

+    0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,

+    0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,

+    0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,

+    0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,

+    0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,

+    0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,

+    0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,

+    0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,

+    0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,

+    0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,

+    0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,

+    0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,

+    0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,

+    0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,

+    0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,

+    0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,

+    0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,

+    0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,

+    0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF

 };

 

 /* Swaps pixel packing order within bytes */

 void /* PRIVATE */

 png_do_packswap(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_packswap");

-

-   if (

-       row_info->bit_depth < 8)

-   {

-      png_bytep rp, end, table;

-

-      end = row + row_info->rowbytes;

-

-      if (row_info->bit_depth == 1)

-         table = (png_bytep)onebppswaptable;

-      else if (row_info->bit_depth == 2)

-         table = (png_bytep)twobppswaptable;

-      else if (row_info->bit_depth == 4)

-         table = (png_bytep)fourbppswaptable;

-      else

-         return;

-

-      for (rp = row; rp < end; rp++)

-         *rp = table[*rp];

-   }

+    png_debug(1, "in png_do_packswap");

+

+    if(

+        row_info->bit_depth < 8)

+    {

+        png_bytep rp, end, table;

+

+        end = row + row_info->rowbytes;

+

+        if(row_info->bit_depth == 1)

+            table = (png_bytep)onebppswaptable;

+        else if(row_info->bit_depth == 2)

+            table = (png_bytep)twobppswaptable;

+        else if(row_info->bit_depth == 4)

+            table = (png_bytep)fourbppswaptable;

+        else

+            return;

+

+        for(rp = row; rp < end; rp++)

+            *rp = table[*rp];

+    }

 }

 #endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */

 

@@ -409,154 +412,157 @@ png_do_packswap(png_row_infop row_info, png_bytep row)
 void /* PRIVATE */

 png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)

 {

-   png_debug(1, "in png_do_strip_filler");

-

-   {

-      png_bytep sp=row;

-      png_bytep dp=row;

-      png_uint_32 row_width=row_info->width;

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

-      {

-         if (row_info->bit_depth == 8)

-         {

-            /* This converts from RGBX or RGBA to RGB */

-            if (flags & PNG_FLAG_FILLER_AFTER)

-            {

-               dp+=3; sp+=4;

-               for (i = 1; i < row_width; i++)

-               {

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  sp++;

-               }

-            }

-            /* This converts from XRGB or ARGB to RGB */

-            else

-            {

-               for (i = 0; i < row_width; i++)

-               {

-                  sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-               }

-            }

-            row_info->pixel_depth = 24;

-            row_info->rowbytes = row_width * 3;

-         }

-         else /* if (row_info->bit_depth == 16) */

-         {

-            if (flags & PNG_FLAG_FILLER_AFTER)

+    png_debug(1, "in png_do_strip_filler");

+

+    {

+        png_bytep sp = row;

+        png_bytep dp = row;

+        png_uint_32 row_width = row_info->width;

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

+        {

+            if(row_info->bit_depth == 8)

             {

-               /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */

-               sp += 8; dp += 6;

-               for (i = 1; i < row_width; i++)

-               {

-                  /* This could be (although png_memcpy is probably slower):

-                  png_memcpy(dp, sp, 6);

-                  sp += 8;

-                  dp += 6;

-                  */

-

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  sp += 2;

-               }

+                /* This converts from RGBX or RGBA to RGB */

+                if(flags & PNG_FLAG_FILLER_AFTER)

+                {

+                    dp += 3;

+                    sp += 4;

+                    for(i = 1; i < row_width; i++)

+                    {

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        sp++;

+                    }

+                }

+                /* This converts from XRGB or ARGB to RGB */

+                else

+                {

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

+                    {

+                        sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                    }

+                }

+                row_info->pixel_depth = 24;

+                row_info->rowbytes = row_width * 3;

             }

-            else

+            else /* if (row_info->bit_depth == 16) */

             {

-               /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */

-               for (i = 0; i < row_width; i++)

-               {

-                  /* This could be (although png_memcpy is probably slower):

-                  png_memcpy(dp, sp, 6);

-                  sp += 8;

-                  dp += 6;

-                  */

-

-                  sp+=2;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-               }

+                if(flags & PNG_FLAG_FILLER_AFTER)

+                {

+                    /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */

+                    sp += 8;

+                    dp += 6;

+                    for(i = 1; i < row_width; i++)

+                    {

+                        /* This could be (although png_memcpy is probably slower):

+                        png_memcpy(dp, sp, 6);

+                        sp += 8;

+                        dp += 6;

+                        */

+

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        sp += 2;

+                    }

+                }

+                else

+                {

+                    /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */

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

+                    {

+                        /* This could be (although png_memcpy is probably slower):

+                        png_memcpy(dp, sp, 6);

+                        sp += 8;

+                        dp += 6;

+                        */

+

+                        sp += 2;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                    }

+                }

+                row_info->pixel_depth = 48;

+                row_info->rowbytes = row_width * 6;

             }

-            row_info->pixel_depth = 48;

-            row_info->rowbytes = row_width * 6;

-         }

-         row_info->channels = 3;

-      }

-      else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||

-         (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

-         (flags & PNG_FLAG_STRIP_ALPHA))) &&

-          row_info->channels == 2)

-      {

-         if (row_info->bit_depth == 8)

-         {

-            /* This converts from GX or GA to G */

-            if (flags & PNG_FLAG_FILLER_AFTER)

+            row_info->channels = 3;

+        }

+        else if((row_info->color_type == PNG_COLOR_TYPE_GRAY ||

+                 (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

+                  (flags & PNG_FLAG_STRIP_ALPHA))) &&

+                row_info->channels == 2)

+        {

+            if(row_info->bit_depth == 8)

             {

-               for (i = 0; i < row_width; i++)

-               {

-                  *dp++ = *sp++;

-                  sp++;

-               }

+                /* This converts from GX or GA to G */

+                if(flags & PNG_FLAG_FILLER_AFTER)

+                {

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

+                    {

+                        *dp++ = *sp++;

+                        sp++;

+                    }

+                }

+                /* This converts from XG or AG to G */

+                else

+                {

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

+                    {

+                        sp++;

+                        *dp++ = *sp++;

+                    }

+                }

+                row_info->pixel_depth = 8;

+                row_info->rowbytes = row_width;

             }

-            /* This converts from XG or AG to G */

-            else

+            else /* if (row_info->bit_depth == 16) */

             {

-               for (i = 0; i < row_width; i++)

-               {

-                  sp++;

-                  *dp++ = *sp++;

-               }

+                if(flags & PNG_FLAG_FILLER_AFTER)

+                {

+                    /* This converts from GGXX or GGAA to GG */

+                    sp += 4;

+                    dp += 2;

+                    for(i = 1; i < row_width; i++)

+                    {

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                        sp += 2;

+                    }

+                }

+                else

+                {

+                    /* This converts from XXGG or AAGG to GG */

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

+                    {

+                        sp += 2;

+                        *dp++ = *sp++;

+                        *dp++ = *sp++;

+                    }

+                }

+                row_info->pixel_depth = 16;

+                row_info->rowbytes = row_width * 2;

             }

-            row_info->pixel_depth = 8;

-            row_info->rowbytes = row_width;

-         }

-         else /* if (row_info->bit_depth == 16) */

-         {

-            if (flags & PNG_FLAG_FILLER_AFTER)

-            {

-               /* This converts from GGXX or GGAA to GG */

-               sp += 4; dp += 2;

-               for (i = 1; i < row_width; i++)

-               {

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-                  sp += 2;

-               }

-            }

-            else

-            {

-               /* This converts from XXGG or AAGG to GG */

-               for (i = 0; i < row_width; i++)

-               {

-                  sp += 2;

-                  *dp++ = *sp++;

-                  *dp++ = *sp++;

-               }

-            }

-            row_info->pixel_depth = 16;

-            row_info->rowbytes = row_width * 2;

-         }

-         row_info->channels = 1;

-      }

-      if (flags & PNG_FLAG_STRIP_ALPHA)

-        row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;

-   }

+            row_info->channels = 1;

+        }

+        if(flags & PNG_FLAG_STRIP_ALPHA)

+            row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;

+    }

 }

 #endif

 

@@ -565,73 +571,73 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
 void /* PRIVATE */

 png_do_bgr(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_bgr");

-

-   if (

-       (row_info->color_type & PNG_COLOR_MASK_COLOR))

-   {

-      png_uint_32 row_width = row_info->width;

-      if (row_info->bit_depth == 8)

-      {

-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-         {

-            png_bytep rp;

-            png_uint_32 i;

-

-            for (i = 0, rp = row; i < row_width; i++, rp += 3)

+    png_debug(1, "in png_do_bgr");

+

+    if(

+        (row_info->color_type & PNG_COLOR_MASK_COLOR))

+    {

+        png_uint_32 row_width = row_info->width;

+        if(row_info->bit_depth == 8)

+        {

+            if(row_info->color_type == PNG_COLOR_TYPE_RGB)

             {

-               png_byte save = *rp;

-               *rp = *(rp + 2);

-               *(rp + 2) = save;

+                png_bytep rp;

+                png_uint_32 i;

+

+                for(i = 0, rp = row; i < row_width; i++, rp += 3)

+                {

+                    png_byte save = *rp;

+                    *rp = *(rp + 2);

+                    *(rp + 2) = save;

+                }

             }

-         }

-         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-         {

-            png_bytep rp;

-            png_uint_32 i;

-

-            for (i = 0, rp = row; i < row_width; i++, rp += 4)

+            else if(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

             {

-               png_byte save = *rp;

-               *rp = *(rp + 2);

-               *(rp + 2) = save;

+                png_bytep rp;

+                png_uint_32 i;

+

+                for(i = 0, rp = row; i < row_width; i++, rp += 4)

+                {

+                    png_byte save = *rp;

+                    *rp = *(rp + 2);

+                    *(rp + 2) = save;

+                }

             }

-         }

-      }

-      else if (row_info->bit_depth == 16)

-      {

-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

-         {

-            png_bytep rp;

-            png_uint_32 i;

-

-            for (i = 0, rp = row; i < row_width; i++, rp += 6)

+        }

+        else if(row_info->bit_depth == 16)

+        {

+            if(row_info->color_type == PNG_COLOR_TYPE_RGB)

             {

-               png_byte save = *rp;

-               *rp = *(rp + 4);

-               *(rp + 4) = save;

-               save = *(rp + 1);

-               *(rp + 1) = *(rp + 5);

-               *(rp + 5) = save;

+                png_bytep rp;

+                png_uint_32 i;

+

+                for(i = 0, rp = row; i < row_width; i++, rp += 6)

+                {

+                    png_byte save = *rp;

+                    *rp = *(rp + 4);

+                    *(rp + 4) = save;

+                    save = *(rp + 1);

+                    *(rp + 1) = *(rp + 5);

+                    *(rp + 5) = save;

+                }

             }

-         }

-         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-         {

-            png_bytep rp;

-            png_uint_32 i;

-

-            for (i = 0, rp = row; i < row_width; i++, rp += 8)

+            else if(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

             {

-               png_byte save = *rp;

-               *rp = *(rp + 4);

-               *(rp + 4) = save;

-               save = *(rp + 1);

-               *(rp + 1) = *(rp + 5);

-               *(rp + 5) = save;

+                png_bytep rp;

+                png_uint_32 i;

+

+                for(i = 0, rp = row; i < row_width; i++, rp += 8)

+                {

+                    png_byte save = *rp;

+                    *rp = *(rp + 4);

+                    *(rp + 4) = save;

+                    save = *(rp + 1);

+                    *(rp + 1) = *(rp + 5);

+                    *(rp + 5) = save;

+                }

             }

-         }

-      }

-   }

+        }

+    }

 }

 #endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */

 

@@ -639,20 +645,20 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

 void PNGAPI

 png_set_user_transform_info(png_structp png_ptr, png_voidp

-   user_transform_ptr, int user_transform_depth, int user_transform_channels)

+                            user_transform_ptr, int user_transform_depth, int user_transform_channels)

 {

-   png_debug(1, "in png_set_user_transform_info");

+    png_debug(1, "in png_set_user_transform_info");

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED

-   png_ptr->user_transform_ptr = user_transform_ptr;

-   png_ptr->user_transform_depth = (png_byte)user_transform_depth;

-   png_ptr->user_transform_channels = (png_byte)user_transform_channels;

+    png_ptr->user_transform_ptr = user_transform_ptr;

+    png_ptr->user_transform_depth = (png_byte)user_transform_depth;

+    png_ptr->user_transform_channels = (png_byte)user_transform_channels;

 #else

-   if (user_transform_ptr || user_transform_depth || user_transform_channels)

-      png_warning(png_ptr,

-        "This version of libpng does not support user transform info");

+    if(user_transform_ptr || user_transform_depth || user_transform_channels)

+        png_warning(png_ptr,

+                    "This version of libpng does not support user transform info");

 #endif

 }

 #endif

@@ -665,12 +671,12 @@ png_set_user_transform_info(png_structp png_ptr, png_voidp
 png_voidp PNGAPI

 png_get_user_transform_ptr(png_structp png_ptr)

 {

-   if (png_ptr == NULL)

-      return (NULL);

+    if(png_ptr == NULL)

+        return (NULL);

 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED

-   return ((png_voidp)png_ptr->user_transform_ptr);

+    return ((png_voidp)png_ptr->user_transform_ptr);

 #else

-   return (NULL);

+    return (NULL);

 #endif

 }

 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

diff --git a/src/libpng/pngwio.c b/src/libpng/pngwio.c
index b02d2ec95..28e5afff4 100644
--- a/src/libpng/pngwio.c
+++ b/src/libpng/pngwio.c
@@ -33,10 +33,10 @@
 void /* PRIVATE */

 png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   if (png_ptr->write_data_fn != NULL )

-      (*(png_ptr->write_data_fn))(png_ptr, data, length);

-   else

-      png_error(png_ptr, "Call to NULL write function");

+    if(png_ptr->write_data_fn != NULL)

+        (*(png_ptr->write_data_fn))(png_ptr, data, length);

+    else

+        png_error(png_ptr, "Call to NULL write function");

 }

 

 #ifdef PNG_STDIO_SUPPORTED

@@ -49,13 +49,13 @@ png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 void PNGAPI

 png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   png_uint_32 check;

+    png_uint_32 check;

 

-   if (png_ptr == NULL)

-      return;

-   check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));

-   if (check != length)

-      png_error(png_ptr, "Write Error");

+    if(png_ptr == NULL)

+        return;

+    check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));

+    if(check != length)

+        png_error(png_ptr, "Write Error");

 }

 #else

 /* This is the model-independent version. Since the standard I/O library

@@ -69,43 +69,43 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 void PNGAPI

 png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   png_uint_32 check;

-   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */

-   png_FILE_p io_ptr;

-

-   if (png_ptr == NULL)

-      return;

-   /* Check if data really is near. If so, use usual code. */

-   near_data = (png_byte *)CVT_PTR_NOCHECK(data);

-   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

-   if ((png_bytep)near_data == data)

-   {

-      check = fwrite(near_data, 1, length, io_ptr);

-   }

-   else

-   {

-      png_byte buf[NEAR_BUF_SIZE];

-      png_size_t written, remaining, err;

-      check = 0;

-      remaining = length;

-      do

-      {

-         written = MIN(NEAR_BUF_SIZE, remaining);

-         png_memcpy(buf, data, written); /* Copy far buffer to near buffer */

-         err = fwrite(buf, 1, written, io_ptr);

-         if (err != written)

-            break;

-

-         else

-            check += err;

-

-         data += written;

-         remaining -= written;

-      }

-      while (remaining != 0);

-   }

-   if (check != length)

-      png_error(png_ptr, "Write Error");

+    png_uint_32 check;

+    png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */

+    png_FILE_p io_ptr;

+

+    if(png_ptr == NULL)

+        return;

+    /* Check if data really is near. If so, use usual code. */

+    near_data = (png_byte *)CVT_PTR_NOCHECK(data);

+    io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

+    if((png_bytep)near_data == data)

+    {

+        check = fwrite(near_data, 1, length, io_ptr);

+    }

+    else

+    {

+        png_byte buf[NEAR_BUF_SIZE];

+        png_size_t written, remaining, err;

+        check = 0;

+        remaining = length;

+        do

+        {

+            written = MIN(NEAR_BUF_SIZE, remaining);

+            png_memcpy(buf, data, written); /* Copy far buffer to near buffer */

+            err = fwrite(buf, 1, written, io_ptr);

+            if(err != written)

+                break;

+

+            else

+                check += err;

+

+            data += written;

+            remaining -= written;

+        }

+        while(remaining != 0);

+    }

+    if(check != length)

+        png_error(png_ptr, "Write Error");

 }

 

 #endif

@@ -119,19 +119,19 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 void /* PRIVATE */

 png_flush(png_structp png_ptr)

 {

-   if (png_ptr->output_flush_fn != NULL)

-      (*(png_ptr->output_flush_fn))(png_ptr);

+    if(png_ptr->output_flush_fn != NULL)

+        (*(png_ptr->output_flush_fn))(png_ptr);

 }

 

 #ifdef PNG_STDIO_SUPPORTED

 void PNGAPI

 png_default_flush(png_structp png_ptr)

 {

-   png_FILE_p io_ptr;

-   if (png_ptr == NULL)

-      return;

-   io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));

-   fflush(io_ptr);

+    png_FILE_p io_ptr;

+    if(png_ptr == NULL)

+        return;

+    io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));

+    fflush(io_ptr);

 }

 #endif

 #endif

@@ -167,74 +167,74 @@ png_default_flush(png_structp png_ptr)
  */

 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)

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

+    png_ptr->io_ptr = io_ptr;

 

 #ifdef PNG_STDIO_SUPPORTED

-   if (write_data_fn != NULL)

-      png_ptr->write_data_fn = write_data_fn;

+    if(write_data_fn != NULL)

+        png_ptr->write_data_fn = write_data_fn;

 

-   else

-      png_ptr->write_data_fn = png_default_write_data;

+    else

+        png_ptr->write_data_fn = png_default_write_data;

 #else

-   png_ptr->write_data_fn = write_data_fn;

+    png_ptr->write_data_fn = write_data_fn;

 #endif

 

 #ifdef PNG_WRITE_FLUSH_SUPPORTED

 #ifdef PNG_STDIO_SUPPORTED

-   if (output_flush_fn != NULL)

-      png_ptr->output_flush_fn = output_flush_fn;

+    if(output_flush_fn != NULL)

+        png_ptr->output_flush_fn = output_flush_fn;

 

-   else

-      png_ptr->output_flush_fn = png_default_flush;

+    else

+        png_ptr->output_flush_fn = png_default_flush;

 #else

-   png_ptr->output_flush_fn = output_flush_fn;

+    png_ptr->output_flush_fn = output_flush_fn;

 #endif

 #endif /* PNG_WRITE_FLUSH_SUPPORTED */

 

-   /* It is an error to read while writing a png file */

-   if (png_ptr->read_data_fn != NULL)

-   {

-      png_ptr->read_data_fn = NULL;

-      png_warning(png_ptr,

-         "Attempted to set both read_data_fn and write_data_fn in");

-      png_warning(png_ptr,

-         "the same structure.  Resetting read_data_fn to NULL");

-   }

+    /* It is an error to read while writing a png file */

+    if(png_ptr->read_data_fn != NULL)

+    {

+        png_ptr->read_data_fn = NULL;

+        png_warning(png_ptr,

+                    "Attempted to set both read_data_fn and write_data_fn in");

+        png_warning(png_ptr,

+                    "the same structure.  Resetting read_data_fn to NULL");

+    }

 }

 

 #ifdef USE_FAR_KEYWORD

 #ifdef _MSC_VER

 void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)

 {

-   void *near_ptr;

-   void FAR *far_ptr;

-   FP_OFF(near_ptr) = FP_OFF(ptr);

-   far_ptr = (void FAR *)near_ptr;

+    void *near_ptr;

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

+    if(check != 0)

+        if(FP_SEG(ptr) != FP_SEG(far_ptr))

+            png_error(png_ptr, "segment lost in conversion");

 

-   return(near_ptr);

+    return(near_ptr);

 }

 #  else

 void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)

 {

-   void *near_ptr;

-   void FAR *far_ptr;

-   near_ptr = (void FAR *)ptr;

-   far_ptr = (void FAR *)near_ptr;

+    void *near_ptr;

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

+    if(check != 0)

+        if(far_ptr != ptr)

+            png_error(png_ptr, "segment lost in conversion");

 

-   return(near_ptr);

+    return(near_ptr);

 }

 #   endif

 #   endif

diff --git a/src/libpng/pngwrite.c b/src/libpng/pngwrite.c
index 75bfe18d9..5a198ee5a 100644
--- a/src/libpng/pngwrite.c
+++ b/src/libpng/pngwrite.c
@@ -29,279 +29,279 @@
 void PNGAPI

 png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)

 {

-   png_debug(1, "in png_write_info_before_PLTE");

-

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

-      return;

-   if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))

-   {

-   /* Write PNG signature */

-   png_write_sig(png_ptr);

+    png_debug(1, "in png_write_info_before_PLTE");

+

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

+        return;

+    if(!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))

+    {

+        /* Write PNG signature */

+        png_write_sig(png_ptr);

 #ifdef PNG_MNG_FEATURES_SUPPORTED

-   if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) && \

-      (png_ptr->mng_features_permitted))

-   {

-      png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");

-      png_ptr->mng_features_permitted = 0;

-   }

-#endif

-   /* Write IHDR information. */

-   png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,

-      info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,

-      info_ptr->filter_type,

+        if((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) && \

+           (png_ptr->mng_features_permitted))

+        {

+            png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");

+            png_ptr->mng_features_permitted = 0;

+        }

+#endif

+        /* Write IHDR information. */

+        png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,

+                       info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,

+                       info_ptr->filter_type,

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

-      info_ptr->interlace_type);

+                       info_ptr->interlace_type);

 #else

-      0);

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

+         */

 #ifdef PNG_WRITE_gAMA_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_gAMA)

-   {

+        if(info_ptr->valid & PNG_INFO_gAMA)

+        {

 #  ifdef PNG_FLOATING_POINT_SUPPORTED

-      png_write_gAMA(png_ptr, info_ptr->gamma);

+            png_write_gAMA(png_ptr, info_ptr->gamma);

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

-      png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma);

+            png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma);

 #  endif

 #endif

-   }

+        }

 #endif

 #ifdef PNG_WRITE_sRGB_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_sRGB)

-      png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);

+        if(info_ptr->valid & PNG_INFO_sRGB)

+            png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);

 #endif

 #ifdef PNG_WRITE_iCCP_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_iCCP)

-      png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,

-                     info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);

+        if(info_ptr->valid & PNG_INFO_iCCP)

+            png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,

+                           info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);

 #endif

 #ifdef PNG_WRITE_sBIT_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_sBIT)

-      png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);

+        if(info_ptr->valid & PNG_INFO_sBIT)

+            png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);

 #endif

 #ifdef PNG_WRITE_cHRM_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_cHRM)

-   {

+        if(info_ptr->valid & PNG_INFO_cHRM)

+        {

 #ifdef PNG_FLOATING_POINT_SUPPORTED

-      png_write_cHRM(png_ptr,

-         info_ptr->x_white, info_ptr->y_white,

-         info_ptr->x_red, info_ptr->y_red,

-         info_ptr->x_green, info_ptr->y_green,

-         info_ptr->x_blue, info_ptr->y_blue);

+            png_write_cHRM(png_ptr,

+                           info_ptr->x_white, info_ptr->y_white,

+                           info_ptr->x_red, info_ptr->y_red,

+                           info_ptr->x_green, info_ptr->y_green,

+                           info_ptr->x_blue, info_ptr->y_blue);

 #else

 #  ifdef PNG_FIXED_POINT_SUPPORTED

-      png_write_cHRM_fixed(png_ptr,

-         info_ptr->int_x_white, info_ptr->int_y_white,

-         info_ptr->int_x_red, info_ptr->int_y_red,

-         info_ptr->int_x_green, info_ptr->int_y_green,

-         info_ptr->int_x_blue, info_ptr->int_y_blue);

+            png_write_cHRM_fixed(png_ptr,

+                                 info_ptr->int_x_white, info_ptr->int_y_white,

+                                 info_ptr->int_x_red, info_ptr->int_y_red,

+                                 info_ptr->int_x_green, info_ptr->int_y_green,

+                                 info_ptr->int_x_blue, info_ptr->int_y_blue);

 #  endif

 #endif

-   }

+        }

 #endif

 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   if (info_ptr->unknown_chunks_num)

-   {

-      png_unknown_chunk *up;

-

-      png_debug(5, "writing extra chunks");

-

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

-            !(up->location & PNG_HAVE_IDAT) &&

-            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

-            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

-         {

-            if (up->size == 0)

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

-   }

+        if(info_ptr->unknown_chunks_num)

+        {

+            png_unknown_chunk *up;

+

+            png_debug(5, "writing extra chunks");

+

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

+                   !(up->location & PNG_HAVE_IDAT) &&

+                   ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

+                    (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

+                {

+                    if(up->size == 0)

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

+    }

 }

 

 void PNGAPI

 png_write_info(png_structp png_ptr, png_infop info_ptr)

 {

 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

-   int i;

+    int i;

 #endif

 

-   png_debug(1, "in png_write_info");

+    png_debug(1, "in png_write_info");

 

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

-      return;

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

+        return;

 

-   png_write_info_before_PLTE(png_ptr, info_ptr);

+    png_write_info_before_PLTE(png_ptr, info_ptr);

 

-   if (info_ptr->valid & PNG_INFO_PLTE)

-      png_write_PLTE(png_ptr, info_ptr->palette,

-         (png_uint_32)info_ptr->num_palette);

-   else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-      png_error(png_ptr, "Valid palette required for paletted images");

+    if(info_ptr->valid & PNG_INFO_PLTE)

+        png_write_PLTE(png_ptr, info_ptr->palette,

+                       (png_uint_32)info_ptr->num_palette);

+    else if(info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+        png_error(png_ptr, "Valid palette required for paletted images");

 

 #ifdef PNG_WRITE_tRNS_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_tRNS)

-   {

+    if(info_ptr->valid & PNG_INFO_tRNS)

+    {

 #ifdef 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_alpha[j] = (png_byte)(255 - info_ptr->trans_alpha[j]);

-      }

-#endif

-      png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),

-         info_ptr->num_trans, info_ptr->color_type);

-   }

+        /* 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_alpha[j] = (png_byte)(255 - info_ptr->trans_alpha[j]);

+        }

+#endif

+        png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),

+                       info_ptr->num_trans, info_ptr->color_type);

+    }

 #endif

 #ifdef PNG_WRITE_bKGD_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_bKGD)

-      png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);

+    if(info_ptr->valid & PNG_INFO_bKGD)

+        png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);

 #endif

 #ifdef PNG_WRITE_hIST_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_hIST)

-      png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);

+    if(info_ptr->valid & PNG_INFO_hIST)

+        png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);

 #endif

 #ifdef PNG_WRITE_oFFs_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_oFFs)

-      png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,

-         info_ptr->offset_unit_type);

+    if(info_ptr->valid & PNG_INFO_oFFs)

+        png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,

+                       info_ptr->offset_unit_type);

 #endif

 #ifdef PNG_WRITE_pCAL_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_pCAL)

-      png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,

-         info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,

-         info_ptr->pcal_units, info_ptr->pcal_params);

+    if(info_ptr->valid & PNG_INFO_pCAL)

+        png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,

+                       info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,

+                       info_ptr->pcal_units, info_ptr->pcal_params);

 #endif

 

 #ifdef PNG_sCAL_SUPPORTED

-   if (info_ptr->valid & PNG_INFO_sCAL)

+    if(info_ptr->valid & PNG_INFO_sCAL)

 #ifdef PNG_WRITE_sCAL_SUPPORTED

 #if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)

-      png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,

-          info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);

+        png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,

+                       info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);

 #else /* !FLOATING_POINT */

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

+        png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,

+                         info_ptr->scal_s_width, info_ptr->scal_s_height);

 #endif /* FIXED_POINT */

 #endif /* FLOATING_POINT */

 #else  /* !WRITE_sCAL */

-      png_warning(png_ptr,

-          "png_write_sCAL not supported; sCAL chunk not written");

+        png_warning(png_ptr,

+                    "png_write_sCAL not supported; sCAL chunk not written");

 #endif /* WRITE_sCAL */

 #endif /* sCAL */

 

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

+    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 /* pHYs */

 

 #ifdef 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;

-   }

+    if(info_ptr->valid & PNG_INFO_tIME)

+    {

+        png_write_tIME(png_ptr, &(info_ptr->mod_time));

+        png_ptr->mode |= PNG_WROTE_tIME;

+    }

 #endif /* tIME */

 

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

+    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 /* sPLT */

 

 #ifdef PNG_WRITE_TEXT_SUPPORTED

-   /* Check to see if we need to write text chunks */

-   for (i = 0; i < info_ptr->num_text; i++)

-   {

-      png_debug2(2, "Writing header text chunk %d, type %d", i,

-         info_ptr->text[i].compression);

-      /* An internationalized chunk? */

-      if (info_ptr->text[i].compression > 0)

-      {

+    /* Check to see if we need to write text chunks */

+    for(i = 0; i < info_ptr->num_text; i++)

+    {

+        png_debug2(2, "Writing header text chunk %d, type %d", i,

+                   info_ptr->text[i].compression);

+        /* An internationalized chunk? */

+        if(info_ptr->text[i].compression > 0)

+        {

 #ifdef 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");

-#endif

-          /* Mark this chunk as written */

-          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

-      }

-      /* If we want a compressed text chunk */

-      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)

-      {

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

+        }

+        /* If we want a compressed text chunk */

+        else if(info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)

+        {

 #ifdef PNG_WRITE_zTXt_SUPPORTED

-         /* Write compressed chunk */

-         png_write_zTXt(png_ptr, info_ptr->text[i].key,

-            info_ptr->text[i].text, 0,

-            info_ptr->text[i].compression);

+            /* Write compressed chunk */

+            png_write_zTXt(png_ptr, info_ptr->text[i].key,

+                           info_ptr->text[i].text, 0,

+                           info_ptr->text[i].compression);

 #else

-         png_warning(png_ptr, "Unable to write compressed text");

+            png_warning(png_ptr, "Unable to write compressed text");

 #endif

-         /* Mark this chunk as written */

-         info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

-      }

-      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

-      {

+            /* Mark this chunk as written */

+            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

+        }

+        else if(info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

+        {

 #ifdef PNG_WRITE_tEXt_SUPPORTED

-         /* Write uncompressed chunk */

-         png_write_tEXt(png_ptr, info_ptr->text[i].key,

-                         info_ptr->text[i].text,

-                         0);

-         /* Mark this chunk as written */

-         info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

+            /* Write uncompressed chunk */

+            png_write_tEXt(png_ptr, info_ptr->text[i].key,

+                           info_ptr->text[i].text,

+                           0);

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

+            /* Can't get here */

+            png_warning(png_ptr, "Unable to write uncompressed text");

 #endif

-      }

-   }

+        }

+    }

 #endif /* tEXt */

 

 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   if (info_ptr->unknown_chunks_num)

-   {

-      png_unknown_chunk *up;

-

-      png_debug(5, "writing extra chunks");

-

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

-            !(up->location & PNG_HAVE_IDAT) &&

-            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

-            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

-         {

-            png_write_chunk(png_ptr, up->name, up->data, up->size);

-         }

-      }

-   }

+    if(info_ptr->unknown_chunks_num)

+    {

+        png_unknown_chunk *up;

+

+        png_debug(5, "writing extra chunks");

+

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

+               !(up->location & PNG_HAVE_IDAT) &&

+               ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

+                (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

+            {

+                png_write_chunk(png_ptr, up->name, up->data, up->size);

+            }

+        }

+    }

 #endif

 }

 

@@ -313,114 +313,114 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
 void PNGAPI

 png_write_end(png_structp png_ptr, png_infop info_ptr)

 {

-   png_debug(1, "in png_write_end");

+    png_debug(1, "in png_write_end");

 

-   if (png_ptr == NULL)

-      return;

-   if (!(png_ptr->mode & PNG_HAVE_IDAT))

-      png_error(png_ptr, "No IDATs written into file");

+    if(png_ptr == NULL)

+        return;

+    if(!(png_ptr->mode & PNG_HAVE_IDAT))

+        png_error(png_ptr, "No IDATs written into file");

 

-   /* See if user wants us to write information chunks */

-   if (info_ptr != NULL)

-   {

+    /* See if user wants us to write information chunks */

+    if(info_ptr != NULL)

+    {

 #ifdef PNG_WRITE_TEXT_SUPPORTED

-      int i; /* local index variable */

+        int i; /* local index variable */

 #endif

 #ifdef PNG_WRITE_tIME_SUPPORTED

-      /* Check to see if user has supplied a time chunk */

-      if ((info_ptr->valid & PNG_INFO_tIME) &&

-         !(png_ptr->mode & PNG_WROTE_tIME))

-         png_write_tIME(png_ptr, &(info_ptr->mod_time));

+        /* Check to see if user has supplied a time chunk */

+        if((info_ptr->valid & PNG_INFO_tIME) &&

+           !(png_ptr->mode & PNG_WROTE_tIME))

+            png_write_tIME(png_ptr, &(info_ptr->mod_time));

 #endif

 #ifdef PNG_WRITE_TEXT_SUPPORTED

-      /* Loop through comment chunks */

-      for (i = 0; i < info_ptr->num_text; i++)

-      {

-         png_debug2(2, "Writing trailer text chunk %d, type %d", i,

-            info_ptr->text[i].compression);

-         /* An internationalized chunk? */

-         if (info_ptr->text[i].compression > 0)

-         {

+        /* Loop through comment chunks */

+        for(i = 0; i < info_ptr->num_text; i++)

+        {

+            png_debug2(2, "Writing trailer text chunk %d, type %d", i,

+                       info_ptr->text[i].compression);

+            /* An internationalized chunk? */

+            if(info_ptr->text[i].compression > 0)

+            {

 #ifdef 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;

-         }

-         else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)

-         {

+                /* 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)

+            {

 #ifdef PNG_WRITE_zTXt_SUPPORTED

-            /* Write compressed chunk */

-            png_write_zTXt(png_ptr, info_ptr->text[i].key,

-               info_ptr->text[i].text, 0,

-               info_ptr->text[i].compression);

+                /* Write compressed chunk */

+                png_write_zTXt(png_ptr, info_ptr->text[i].key,

+                               info_ptr->text[i].text, 0,

+                               info_ptr->text[i].compression);

 #else

-            png_warning(png_ptr, "Unable to write compressed text");

+                png_warning(png_ptr, "Unable to write compressed text");

 #endif

-            /* Mark this chunk as written */

-            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

-         }

-         else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

-         {

+                /* Mark this chunk as written */

+                info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

+            }

+            else if(info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

+            {

 #ifdef PNG_WRITE_tEXt_SUPPORTED

-            /* Write uncompressed chunk */

-            png_write_tEXt(png_ptr, info_ptr->text[i].key,

-               info_ptr->text[i].text, 0);

+                /* Write uncompressed chunk */

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

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

-         }

-      }

+                /* Mark this chunk as written */

+                info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

+            }

+        }

 #endif

 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

-   if (info_ptr->unknown_chunks_num)

-   {

-      png_unknown_chunk *up;

-

-      png_debug(5, "writing extra chunks");

-

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

-            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

-            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

-         {

-            png_write_chunk(png_ptr, up->name, up->data, up->size);

-         }

-      }

-   }

-#endif

-   }

-

-   png_ptr->mode |= PNG_AFTER_IDAT;

-

-   /* Write end of PNG file */

-   png_write_IEND(png_ptr);

-   /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,

-    * and restored again in libpng-1.2.30, may cause some applications that

-    * do not set png_ptr->output_flush_fn to crash.  If your application

-    * experiences a problem, please try building libpng with

-    * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to

-    * png-mng-implement at lists.sf.net .

-    */

+        if(info_ptr->unknown_chunks_num)

+        {

+            png_unknown_chunk *up;

+

+            png_debug(5, "writing extra chunks");

+

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

+                   ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

+                    (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

+                {

+                    png_write_chunk(png_ptr, up->name, up->data, up->size);

+                }

+            }

+        }

+#endif

+    }

+

+    png_ptr->mode |= PNG_AFTER_IDAT;

+

+    /* Write end of PNG file */

+    png_write_IEND(png_ptr);

+    /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,

+     * and restored again in libpng-1.2.30, may cause some applications that

+     * do not set png_ptr->output_flush_fn to crash.  If your application

+     * experiences a problem, please try building libpng with

+     * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to

+     * png-mng-implement at lists.sf.net .

+     */

 #ifdef PNG_WRITE_FLUSH_SUPPORTED

 #  ifdef PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED

-   png_flush(png_ptr);

+    png_flush(png_ptr);

 #  endif

 #endif

 }

@@ -430,169 +430,170 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
 void PNGAPI

 png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)

 {

-   png_debug(1, "in png_convert_from_struct_tm");

-

-   ptime->year = (png_uint_16)(1900 + ttime->tm_year);

-   ptime->month = (png_byte)(ttime->tm_mon + 1);

-   ptime->day = (png_byte)ttime->tm_mday;

-   ptime->hour = (png_byte)ttime->tm_hour;

-   ptime->minute = (png_byte)ttime->tm_min;

-   ptime->second = (png_byte)ttime->tm_sec;

+    png_debug(1, "in png_convert_from_struct_tm");

+

+    ptime->year = (png_uint_16)(1900 + ttime->tm_year);

+    ptime->month = (png_byte)(ttime->tm_mon + 1);

+    ptime->day = (png_byte)ttime->tm_mday;

+    ptime->hour = (png_byte)ttime->tm_hour;

+    ptime->minute = (png_byte)ttime->tm_min;

+    ptime->second = (png_byte)ttime->tm_sec;

 }

 

 void PNGAPI

 png_convert_from_time_t(png_timep ptime, time_t ttime)

 {

-   struct tm *tbuf;

+    struct tm *tbuf;

 

-   png_debug(1, "in png_convert_from_time_t");

+    png_debug(1, "in png_convert_from_time_t");

 

-   tbuf = gmtime(&ttime);

-   png_convert_from_struct_tm(ptime, tbuf);

+    tbuf = gmtime(&ttime);

+    png_convert_from_struct_tm(ptime, tbuf);

 }

 #endif

 

 /* Initialize png_ptr structure, and allocate any memory needed */

 png_structp PNGAPI

 png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn)

+                        png_error_ptr error_fn, png_error_ptr warn_fn)

 {

 #ifdef PNG_USER_MEM_SUPPORTED

-   return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,

-      warn_fn, NULL, NULL, NULL));

+    return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,

+                                      warn_fn, NULL, NULL, NULL));

 }

 

 /* Alternate initialize png_ptr structure, and allocate any memory needed */

 png_structp PNGAPI

 png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,

-   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

-   png_malloc_ptr malloc_fn, png_free_ptr free_fn)

+                          png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

+                          png_malloc_ptr malloc_fn, png_free_ptr free_fn)

 {

 #endif /* PNG_USER_MEM_SUPPORTED */

-   volatile int png_cleanup_needed = 0;

+    volatile int png_cleanup_needed = 0;

 #ifdef PNG_SETJMP_SUPPORTED

-   volatile

+    volatile

 #endif

-   png_structp png_ptr;

+    png_structp png_ptr;

 #ifdef PNG_SETJMP_SUPPORTED

 #ifdef USE_FAR_KEYWORD

-   jmp_buf jmpbuf;

+    jmp_buf jmpbuf;

 #endif

 #endif

-   int i;

+    int i;

 

-   png_debug(1, "in png_create_write_struct");

+    png_debug(1, "in png_create_write_struct");

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,

-      (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);

+    png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,

+              (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);

 #else

-   png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

+    png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

 #endif /* PNG_USER_MEM_SUPPORTED */

-   if (png_ptr == NULL)

-      return (NULL);

+    if(png_ptr == NULL)

+        return (NULL);

 

-   /* Added at libpng-1.2.6 */

+    /* Added at libpng-1.2.6 */

 #ifdef PNG_SET_USER_LIMITS_SUPPORTED

-   png_ptr->user_width_max = PNG_USER_WIDTH_MAX;

-   png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;

+    png_ptr->user_width_max = PNG_USER_WIDTH_MAX;

+    png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;

 #endif

 

 #ifdef PNG_SETJMP_SUPPORTED

-/* Applications that neglect to set up their own setjmp() and then

-   encounter a png_error() will longjmp here.  Since the jmpbuf is

-   then meaningless we abort instead of returning. */

+    /* Applications that neglect to set up their own setjmp() and then

+       encounter a png_error() will longjmp here.  Since the jmpbuf is

+       then meaningless we abort instead of returning. */

 #ifdef USE_FAR_KEYWORD

-   if (setjmp(jmpbuf))

+    if(setjmp(jmpbuf))

 #else

-   if (setjmp(png_jmpbuf(png_ptr))) /* sets longjmp to match setjmp */

+    if(setjmp(png_jmpbuf(png_ptr)))  /* sets longjmp to match setjmp */

 #endif

 #ifdef USE_FAR_KEYWORD

-   png_memcpy(png_jmpbuf(png_ptr), jmpbuf, png_sizeof(jmp_buf));

+        png_memcpy(png_jmpbuf(png_ptr), jmpbuf, png_sizeof(jmp_buf));

 #endif

-      PNG_ABORT();

+    PNG_ABORT();

 #endif

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);

+    png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);

 #endif /* PNG_USER_MEM_SUPPORTED */

-   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

-

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

-   }

-

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

-     {

-#ifdef PNG_STDIO_SUPPORTED

-        char msg[80];

-        if (user_png_ver)

+    png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

+

+    if(user_png_ver)

+    {

+        i = 0;

+        do

         {

-           png_snprintf(msg, 80,

-              "Application was compiled with png.h from libpng-%.20s",

-              user_png_ver);

-           png_warning(png_ptr, msg);

+            if(user_png_ver[i] != png_libpng_ver[i])

+                png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

         }

-        png_snprintf(msg, 80,

-           "Application  is  running with png.c from libpng-%.20s",

-           png_libpng_ver);

-        png_warning(png_ptr, msg);

+        while(png_libpng_ver[i++]);

+    }

+

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

+        {

+#ifdef PNG_STDIO_SUPPORTED

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

 #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_cleanup_needed = 1;

-     }

-   }

-

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

-   }

-   if (png_cleanup_needed)

-   {

-       /* Clean up PNG structure and deallocate any memory. */

-       png_free(png_ptr, png_ptr->zbuf);

-       png_ptr->zbuf = NULL;

+            png_warning(png_ptr,

+                        "Incompatible libpng version in application and library");

+            png_cleanup_needed = 1;

+        }

+    }

+

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

+    }

+    if(png_cleanup_needed)

+    {

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

+    png_set_write_fn(png_ptr, NULL, NULL, NULL);

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,

-      1, NULL, NULL);

+    png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,

+                              1, NULL, NULL);

 #endif

 

-   return (png_ptr);

+    return (png_ptr);

 }

 

 

@@ -603,21 +604,21 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
  */

 void PNGAPI

 png_write_rows(png_structp png_ptr, png_bytepp row,

-   png_uint_32 num_rows)

+               png_uint_32 num_rows)

 {

-   png_uint_32 i; /* row counter */

-   png_bytepp rp; /* row pointer */

+    png_uint_32 i; /* row counter */

+    png_bytepp rp; /* row pointer */

 

-   png_debug(1, "in png_write_rows");

+    png_debug(1, "in png_write_rows");

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

-   /* Loop through the rows */

-   for (i = 0, rp = row; i < num_rows; i++, rp++)

-   {

-      png_write_row(png_ptr, *rp);

-   }

+    /* Loop through the rows */

+    for(i = 0, rp = row; i < num_rows; i++, rp++)

+    {

+        png_write_row(png_ptr, *rp);

+    }

 }

 

 /* Write the image.  You only need to call this function once, even

@@ -626,210 +627,210 @@ png_write_rows(png_structp png_ptr, png_bytepp row,
 void PNGAPI

 png_write_image(png_structp png_ptr, png_bytepp image)

 {

-   png_uint_32 i; /* row index */

-   int pass, num_pass; /* pass variables */

-   png_bytepp rp; /* points to current row */

+    png_uint_32 i; /* row index */

+    int pass, num_pass; /* pass variables */

+    png_bytepp rp; /* points to current row */

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

-   png_debug(1, "in png_write_image");

+    png_debug(1, "in png_write_image");

 

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   /* Initialize interlace handling.  If image is not interlaced,

-    * this will set pass to 1

-    */

-   num_pass = png_set_interlace_handling(png_ptr);

+    /* Initialize interlace handling.  If image is not interlaced,

+     * this will set pass to 1

+     */

+    num_pass = png_set_interlace_handling(png_ptr);

 #else

-   num_pass = 1;

-#endif

-   /* Loop through passes */

-   for (pass = 0; pass < num_pass; pass++)

-   {

-      /* Loop through image */

-      for (i = 0, rp = image; i < png_ptr->height; i++, rp++)

-      {

-         png_write_row(png_ptr, *rp);

-      }

-   }

+    num_pass = 1;

+#endif

+    /* Loop through passes */

+    for(pass = 0; pass < num_pass; pass++)

+    {

+        /* Loop through image */

+        for(i = 0, rp = image; i < png_ptr->height; i++, rp++)

+        {

+            png_write_row(png_ptr, *rp);

+        }

+    }

 }

 

 /* Called by user to write a row of image data */

 void PNGAPI

 png_write_row(png_structp png_ptr, png_bytep row)

 {

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

-   png_debug2(1, "in png_write_row (row %ld, pass %d)",

-      png_ptr->row_number, png_ptr->pass);

+    png_debug2(1, "in png_write_row (row %ld, pass %d)",

+               png_ptr->row_number, png_ptr->pass);

 

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

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

 

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

-   }

+        png_write_start_row(png_ptr);

+    }

 

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   /* If interlaced and not interested in row, return */

-   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

-   {

-      switch (png_ptr->pass)

-      {

-         case 0:

-            if (png_ptr->row_number & 0x07)

+    /* If interlaced and not interested in row, return */

+    if(png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

+    {

+        switch(png_ptr->pass)

+        {

+        case 0:

+            if(png_ptr->row_number & 0x07)

             {

-               png_write_finish_row(png_ptr);

-               return;

+                png_write_finish_row(png_ptr);

+                return;

             }

             break;

-         case 1:

-            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)

+        case 1:

+            if((png_ptr->row_number & 0x07) || png_ptr->width < 5)

             {

-               png_write_finish_row(png_ptr);

-               return;

+                png_write_finish_row(png_ptr);

+                return;

             }

             break;

-         case 2:

-            if ((png_ptr->row_number & 0x07) != 4)

+        case 2:

+            if((png_ptr->row_number & 0x07) != 4)

             {

-               png_write_finish_row(png_ptr);

-               return;

+                png_write_finish_row(png_ptr);

+                return;

             }

             break;

-         case 3:

-            if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)

+        case 3:

+            if((png_ptr->row_number & 0x03) || png_ptr->width < 3)

             {

-               png_write_finish_row(png_ptr);

-               return;

+                png_write_finish_row(png_ptr);

+                return;

             }

             break;

-         case 4:

-            if ((png_ptr->row_number & 0x03) != 2)

+        case 4:

+            if((png_ptr->row_number & 0x03) != 2)

             {

-               png_write_finish_row(png_ptr);

-               return;

+                png_write_finish_row(png_ptr);

+                return;

             }

             break;

-         case 5:

-            if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)

+        case 5:

+            if((png_ptr->row_number & 0x01) || png_ptr->width < 2)

             {

-               png_write_finish_row(png_ptr);

-               return;

+                png_write_finish_row(png_ptr);

+                return;

             }

             break;

-         case 6:

-            if (!(png_ptr->row_number & 0x01))

+        case 6:

+            if(!(png_ptr->row_number & 0x01))

             {

-               png_write_finish_row(png_ptr);

-               return;

+                png_write_finish_row(png_ptr);

+                return;

             }

             break;

-      }

-   }

+        }

+    }

 #endif

 

-   /* Set up row info for transformations */

-   png_ptr->row_info.color_type = png_ptr->color_type;

-   png_ptr->row_info.width = png_ptr->usr_width;

-   png_ptr->row_info.channels = png_ptr->usr_channels;

-   png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;

-   png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *

-      png_ptr->row_info.channels);

+    /* Set up row info for transformations */

+    png_ptr->row_info.color_type = png_ptr->color_type;

+    png_ptr->row_info.width = png_ptr->usr_width;

+    png_ptr->row_info.channels = png_ptr->usr_channels;

+    png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;

+    png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *

+                                    png_ptr->row_info.channels);

 

-   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

-      png_ptr->row_info.width);

+    png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

+                                 png_ptr->row_info.width);

 

-   png_debug1(3, "row_info->color_type = %d", png_ptr->row_info.color_type);

-   png_debug1(3, "row_info->width = %lu", png_ptr->row_info.width);

-   png_debug1(3, "row_info->channels = %d", png_ptr->row_info.channels);

-   png_debug1(3, "row_info->bit_depth = %d", png_ptr->row_info.bit_depth);

-   png_debug1(3, "row_info->pixel_depth = %d", png_ptr->row_info.pixel_depth);

-   png_debug1(3, "row_info->rowbytes = %lu", png_ptr->row_info.rowbytes);

+    png_debug1(3, "row_info->color_type = %d", png_ptr->row_info.color_type);

+    png_debug1(3, "row_info->width = %lu", png_ptr->row_info.width);

+    png_debug1(3, "row_info->channels = %d", png_ptr->row_info.channels);

+    png_debug1(3, "row_info->bit_depth = %d", png_ptr->row_info.bit_depth);

+    png_debug1(3, "row_info->pixel_depth = %d", png_ptr->row_info.pixel_depth);

+    png_debug1(3, "row_info->rowbytes = %lu", png_ptr->row_info.rowbytes);

 

-   /* Copy user's row into buffer, leaving room for filter byte. */

-   png_memcpy(png_ptr->row_buf + 1, row, png_ptr->row_info.rowbytes);

+    /* Copy user's row into buffer, leaving room for filter byte. */

+    png_memcpy(png_ptr->row_buf + 1, row, png_ptr->row_info.rowbytes);

 

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

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

-      if (!(png_ptr->row_info.width))

-      {

-         png_write_finish_row(png_ptr);

-         return;

-      }

-   }

-#endif

-

-   /* Handle other transformations */

-   if (png_ptr->transformations)

-      png_do_write_transformations(png_ptr);

+    /* 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 ... */

+        if(!(png_ptr->row_info.width))

+        {

+            png_write_finish_row(png_ptr);

+            return;

+        }

+    }

+#endif

+

+    /* Handle other transformations */

+    if(png_ptr->transformations)

+        png_do_write_transformations(png_ptr);

 

 #ifdef PNG_MNG_FEATURES_SUPPORTED

-   /* Write filter_method 64 (intrapixel differencing) only if

-    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

-    * 2. Libpng did not write a PNG signature (this filter_method is only

-    *    used in PNG datastreams that are embedded in MNG datastreams) and

-    * 3. The application called png_permit_mng_features with a mask that

-    *    included PNG_FLAG_MNG_FILTER_64 and

-    * 4. The filter_method is 64 and

-    * 5. The color_type is RGB or RGBA

-    */

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

-      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

-   {

-      /* Intrapixel differencing */

-      png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);

-   }

-#endif

-

-   /* Find a filter if necessary, filter the row and write it out. */

-   png_write_find_filter(png_ptr, &(png_ptr->row_info));

-

-   if (png_ptr->write_row_fn != NULL)

-      (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

+    /* Write filter_method 64 (intrapixel differencing) only if

+     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

+     * 2. Libpng did not write a PNG signature (this filter_method is only

+     *    used in PNG datastreams that are embedded in MNG datastreams) and

+     * 3. The application called png_permit_mng_features with a mask that

+     *    included PNG_FLAG_MNG_FILTER_64 and

+     * 4. The filter_method is 64 and

+     * 5. The color_type is RGB or RGBA

+     */

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

+       (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

+    {

+        /* Intrapixel differencing */

+        png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    }

+#endif

+

+    /* Find a filter if necessary, filter the row and write it out. */

+    png_write_find_filter(png_ptr, &(png_ptr->row_info));

+

+    if(png_ptr->write_row_fn != NULL)

+        (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

 }

 

 #ifdef PNG_WRITE_FLUSH_SUPPORTED

@@ -837,66 +838,67 @@ png_write_row(png_structp png_ptr, png_bytep row)
 void PNGAPI

 png_set_flush(png_structp png_ptr, int nrows)

 {

-   png_debug(1, "in png_set_flush");

+    png_debug(1, "in png_set_flush");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);

+    if(png_ptr == NULL)

+        return;

+    png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);

 }

 

 /* Flush the current output buffers now */

 void PNGAPI

 png_write_flush(png_structp png_ptr)

 {

-   int wrote_IDAT;

-

-   png_debug(1, "in png_write_flush");

-

-   if (png_ptr == NULL)

-      return;

-   /* We have already written out all of the data */

-   if (png_ptr->row_number >= png_ptr->num_rows)

-      return;

-

-   do

-   {

-      int ret;

-

-      /* Compress the data */

-      ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);

-      wrote_IDAT = 0;

-

-      /* Check for compression errors */

-      if (ret != Z_OK)

-      {

-         if (png_ptr->zstream.msg != NULL)

-            png_error(png_ptr, png_ptr->zstream.msg);

-         else

-            png_error(png_ptr, "zlib error");

-      }

-

-      if (!(png_ptr->zstream.avail_out))

-      {

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

-         wrote_IDAT = 1;

-      }

-   } while(wrote_IDAT == 1);

-

-   /* If there is any data left to be output, write it into a new IDAT */

-   if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)

-   {

-      /* Write the IDAT and reset the zlib output buffer */

-      png_write_IDAT(png_ptr, png_ptr->zbuf,

-                     png_ptr->zbuf_size - png_ptr->zstream.avail_out);

-      png_ptr->zstream.next_out = png_ptr->zbuf;

-      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-   }

-   png_ptr->flush_rows = 0;

-   png_flush(png_ptr);

+    int wrote_IDAT;

+

+    png_debug(1, "in png_write_flush");

+

+    if(png_ptr == NULL)

+        return;

+    /* We have already written out all of the data */

+    if(png_ptr->row_number >= png_ptr->num_rows)

+        return;

+

+    do

+    {

+        int ret;

+

+        /* Compress the data */

+        ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);

+        wrote_IDAT = 0;

+

+        /* Check for compression errors */

+        if(ret != Z_OK)

+        {

+            if(png_ptr->zstream.msg != NULL)

+                png_error(png_ptr, png_ptr->zstream.msg);

+            else

+                png_error(png_ptr, "zlib error");

+        }

+

+        if(!(png_ptr->zstream.avail_out))

+        {

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

+            wrote_IDAT = 1;

+        }

+    }

+    while(wrote_IDAT == 1);

+

+    /* If there is any data left to be output, write it into a new IDAT */

+    if(png_ptr->zbuf_size != png_ptr->zstream.avail_out)

+    {

+        /* Write the IDAT and reset the zlib output buffer */

+        png_write_IDAT(png_ptr, png_ptr->zbuf,

+                       png_ptr->zbuf_size - png_ptr->zstream.avail_out);

+        png_ptr->zstream.next_out = png_ptr->zbuf;

+        png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+    }

+    png_ptr->flush_rows = 0;

+    png_flush(png_ptr);

 }

 #endif /* PNG_WRITE_FLUSH_SUPPORTED */

 

@@ -904,70 +906,70 @@ png_write_flush(png_structp png_ptr)
 void PNGAPI

 png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)

 {

-   png_structp png_ptr = NULL;

-   png_infop info_ptr = NULL;

+    png_structp png_ptr = NULL;

+    png_infop info_ptr = NULL;

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_free_ptr free_fn = NULL;

-   png_voidp mem_ptr = NULL;

+    png_free_ptr free_fn = NULL;

+    png_voidp mem_ptr = NULL;

 #endif

 

-   png_debug(1, "in png_destroy_write_struct");

+    png_debug(1, "in png_destroy_write_struct");

 

-   if (png_ptr_ptr != NULL)

-   {

-      png_ptr = *png_ptr_ptr;

+    if(png_ptr_ptr != NULL)

+    {

+        png_ptr = *png_ptr_ptr;

 #ifdef PNG_USER_MEM_SUPPORTED

-      free_fn = png_ptr->free_fn;

-      mem_ptr = png_ptr->mem_ptr;

+        free_fn = png_ptr->free_fn;

+        mem_ptr = png_ptr->mem_ptr;

 #endif

-   }

+    }

 

 #ifdef PNG_USER_MEM_SUPPORTED

-   if (png_ptr != NULL)

-   {

-      free_fn = png_ptr->free_fn;

-      mem_ptr = png_ptr->mem_ptr;

-   }

+    if(png_ptr != NULL)

+    {

+        free_fn = png_ptr->free_fn;

+        mem_ptr = png_ptr->mem_ptr;

+    }

 #endif

 

-   if (info_ptr_ptr != NULL)

-      info_ptr = *info_ptr_ptr;

+    if(info_ptr_ptr != NULL)

+        info_ptr = *info_ptr_ptr;

 

-   if (info_ptr != NULL)

-   {

-      if (png_ptr != NULL)

-      {

-        png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

+    if(info_ptr != NULL)

+    {

+        if(png_ptr != NULL)

+        {

+            png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

 

 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

-        if (png_ptr->num_chunk_list)

-        {

-           png_free(png_ptr, png_ptr->chunk_list);

-           png_ptr->num_chunk_list = 0;

-        }

+            if(png_ptr->num_chunk_list)

+            {

+                png_free(png_ptr, png_ptr->chunk_list);

+                png_ptr->num_chunk_list = 0;

+            }

 #endif

-      }

+        }

 

 #ifdef PNG_USER_MEM_SUPPORTED

-      png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,

-         (png_voidp)mem_ptr);

+        png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,

+                             (png_voidp)mem_ptr);

 #else

-      png_destroy_struct((png_voidp)info_ptr);

+        png_destroy_struct((png_voidp)info_ptr);

 #endif

-      *info_ptr_ptr = NULL;

-   }

+        *info_ptr_ptr = NULL;

+    }

 

-   if (png_ptr != NULL)

-   {

-      png_write_destroy(png_ptr);

+    if(png_ptr != NULL)

+    {

+        png_write_destroy(png_ptr);

 #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

-      *png_ptr_ptr = NULL;

-   }

+        *png_ptr_ptr = NULL;

+    }

 }

 

 

@@ -976,66 +978,66 @@ void /* PRIVATE */
 png_write_destroy(png_structp png_ptr)

 {

 #ifdef PNG_SETJMP_SUPPORTED

-   jmp_buf tmp_jmp; /* Save jump buffer */

+    jmp_buf tmp_jmp; /* Save jump buffer */

 #endif

-   png_error_ptr error_fn;

-   png_error_ptr warning_fn;

-   png_voidp error_ptr;

+    png_error_ptr error_fn;

+    png_error_ptr warning_fn;

+    png_voidp error_ptr;

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_free_ptr free_fn;

+    png_free_ptr free_fn;

 #endif

 

-   png_debug(1, "in png_write_destroy");

+    png_debug(1, "in png_write_destroy");

 

-   /* Free any memory zlib uses */

-   deflateEnd(&png_ptr->zstream);

+    /* Free any memory zlib uses */

+    deflateEnd(&png_ptr->zstream);

 

-   /* Free our memory.  png_free checks NULL for us. */

-   png_free(png_ptr, png_ptr->zbuf);

-   png_free(png_ptr, png_ptr->row_buf);

+    /* Free our memory.  png_free checks NULL for us. */

+    png_free(png_ptr, png_ptr->zbuf);

+    png_free(png_ptr, png_ptr->row_buf);

 #ifdef PNG_WRITE_FILTER_SUPPORTED

-   png_free(png_ptr, png_ptr->prev_row);

-   png_free(png_ptr, png_ptr->sub_row);

-   png_free(png_ptr, png_ptr->up_row);

-   png_free(png_ptr, png_ptr->avg_row);

-   png_free(png_ptr, png_ptr->paeth_row);

+    png_free(png_ptr, png_ptr->prev_row);

+    png_free(png_ptr, png_ptr->sub_row);

+    png_free(png_ptr, png_ptr->up_row);

+    png_free(png_ptr, png_ptr->avg_row);

+    png_free(png_ptr, png_ptr->paeth_row);

 #endif

 

 #ifdef PNG_TIME_RFC1123_SUPPORTED

-   png_free(png_ptr, png_ptr->time_buffer);

+    png_free(png_ptr, png_ptr->time_buffer);

 #endif

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   png_free(png_ptr, png_ptr->prev_filters);

-   png_free(png_ptr, png_ptr->filter_weights);

-   png_free(png_ptr, png_ptr->inv_filter_weights);

-   png_free(png_ptr, png_ptr->filter_costs);

-   png_free(png_ptr, png_ptr->inv_filter_costs);

+    png_free(png_ptr, png_ptr->prev_filters);

+    png_free(png_ptr, png_ptr->filter_weights);

+    png_free(png_ptr, png_ptr->inv_filter_weights);

+    png_free(png_ptr, png_ptr->filter_costs);

+    png_free(png_ptr, png_ptr->inv_filter_costs);

 #endif

 

 #ifdef PNG_SETJMP_SUPPORTED

-   /* Reset structure */

-   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));

+    /* Reset structure */

+    png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));

 #endif

 

-   error_fn = png_ptr->error_fn;

-   warning_fn = png_ptr->warning_fn;

-   error_ptr = png_ptr->error_ptr;

+    error_fn = png_ptr->error_fn;

+    warning_fn = png_ptr->warning_fn;

+    error_ptr = png_ptr->error_ptr;

 #ifdef PNG_USER_MEM_SUPPORTED

-   free_fn = png_ptr->free_fn;

+    free_fn = png_ptr->free_fn;

 #endif

 

-   png_memset(png_ptr, 0, png_sizeof(png_struct));

+    png_memset(png_ptr, 0, png_sizeof(png_struct));

 

-   png_ptr->error_fn = error_fn;

-   png_ptr->warning_fn = warning_fn;

-   png_ptr->error_ptr = error_ptr;

+    png_ptr->error_fn = error_fn;

+    png_ptr->warning_fn = warning_fn;

+    png_ptr->error_ptr = error_ptr;

 #ifdef PNG_USER_MEM_SUPPORTED

-   png_ptr->free_fn = free_fn;

+    png_ptr->free_fn = free_fn;

 #endif

 

 #ifdef PNG_SETJMP_SUPPORTED

-   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));

+    png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));

 #endif

 }

 

@@ -1043,113 +1045,122 @@ png_write_destroy(png_structp png_ptr)
 void PNGAPI

 png_set_filter(png_structp png_ptr, int method, int filters)

 {

-   png_debug(1, "in png_set_filter");

+    png_debug(1, "in png_set_filter");

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 #ifdef PNG_MNG_FEATURES_SUPPORTED

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

-      (method == PNG_INTRAPIXEL_DIFFERENCING))

-         method = PNG_FILTER_TYPE_BASE;

-#endif

-   if (method == PNG_FILTER_TYPE_BASE)

-   {

-      switch (filters & (PNG_ALL_FILTERS | 0x07))

-      {

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

+       (method == PNG_INTRAPIXEL_DIFFERENCING))

+        method = PNG_FILTER_TYPE_BASE;

+#endif

+    if(method == PNG_FILTER_TYPE_BASE)

+    {

+        switch(filters & (PNG_ALL_FILTERS | 0x07))

+        {

 #ifdef PNG_WRITE_FILTER_SUPPORTED

-         case 5:

-         case 6:

-         case 7: png_warning(png_ptr, "Unknown row filter for method 0");

+        case 5:

+        case 6:

+        case 7:

+            png_warning(png_ptr, "Unknown row filter for method 0");

 #endif /* PNG_WRITE_FILTER_SUPPORTED */

-         case PNG_FILTER_VALUE_NONE:

-              png_ptr->do_filter = PNG_FILTER_NONE; break;

+        case PNG_FILTER_VALUE_NONE:

+            png_ptr->do_filter = PNG_FILTER_NONE;

+            break;

 #ifdef PNG_WRITE_FILTER_SUPPORTED

-         case PNG_FILTER_VALUE_SUB:

-              png_ptr->do_filter = PNG_FILTER_SUB; break;

-         case PNG_FILTER_VALUE_UP:

-              png_ptr->do_filter = PNG_FILTER_UP; break;

-         case PNG_FILTER_VALUE_AVG:

-              png_ptr->do_filter = PNG_FILTER_AVG; break;

-         case PNG_FILTER_VALUE_PAETH:

-              png_ptr->do_filter = PNG_FILTER_PAETH; break;

-         default: png_ptr->do_filter = (png_byte)filters; break;

+        case PNG_FILTER_VALUE_SUB:

+            png_ptr->do_filter = PNG_FILTER_SUB;

+            break;

+        case PNG_FILTER_VALUE_UP:

+            png_ptr->do_filter = PNG_FILTER_UP;

+            break;

+        case PNG_FILTER_VALUE_AVG:

+            png_ptr->do_filter = PNG_FILTER_AVG;

+            break;

+        case PNG_FILTER_VALUE_PAETH:

+            png_ptr->do_filter = PNG_FILTER_PAETH;

+            break;

+        default:

+            png_ptr->do_filter = (png_byte)filters;

+            break;

 #else

-         default: png_warning(png_ptr, "Unknown row filter for method 0");

+        default:

+            png_warning(png_ptr, "Unknown row filter for method 0");

 #endif /* PNG_WRITE_FILTER_SUPPORTED */

-      }

-

-      /* If we have allocated the row_buf, this means we have already started

-       * with the image and we should have allocated all of the filter buffers

-       * that have been selected.  If prev_row isn't already allocated, then

-       * it is too late to start using the filters that need it, since we

-       * will be missing the data in the previous row.  If an application

-       * wants to start and stop using particular filters during compression,

-       * it should start out with all of the filters, and then add and

-       * remove them after the start of compression.

-       */

-      if (png_ptr->row_buf != NULL)

-      {

+        }

+

+        /* If we have allocated the row_buf, this means we have already started

+         * with the image and we should have allocated all of the filter buffers

+         * that have been selected.  If prev_row isn't already allocated, then

+         * it is too late to start using the filters that need it, since we

+         * will be missing the data in the previous row.  If an application

+         * wants to start and stop using particular filters during compression,

+         * it should start out with all of the filters, and then add and

+         * remove them after the start of compression.

+         */

+        if(png_ptr->row_buf != NULL)

+        {

 #ifdef PNG_WRITE_FILTER_SUPPORTED

-         if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)

-         {

-            png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,

-              (png_ptr->rowbytes + 1));

-            png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;

-         }

-

-         if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)

-         {

-            if (png_ptr->prev_row == NULL)

-            {

-               png_warning(png_ptr, "Can't add Up filter after starting");

-               png_ptr->do_filter &= ~PNG_FILTER_UP;

-            }

-            else

+            if((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)

             {

-               png_ptr->up_row = (png_bytep)png_malloc(png_ptr,

-                  (png_ptr->rowbytes + 1));

-               png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;

+                png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,

+                                   (png_ptr->rowbytes + 1));

+                png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;

             }

-         }

 

-         if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)

-         {

-            if (png_ptr->prev_row == NULL)

+            if((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)

             {

-               png_warning(png_ptr, "Can't add Average filter after starting");

-               png_ptr->do_filter &= ~PNG_FILTER_AVG;

+                if(png_ptr->prev_row == NULL)

+                {

+                    png_warning(png_ptr, "Can't add Up filter after starting");

+                    png_ptr->do_filter &= ~PNG_FILTER_UP;

+                }

+                else

+                {

+                    png_ptr->up_row = (png_bytep)png_malloc(png_ptr,

+                                                            (png_ptr->rowbytes + 1));

+                    png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;

+                }

             }

-            else

-            {

-               png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,

-                  (png_ptr->rowbytes + 1));

-               png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;

-            }

-         }

 

-         if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&

-             png_ptr->paeth_row == NULL)

-         {

-            if (png_ptr->prev_row == NULL)

+            if((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)

             {

-               png_warning(png_ptr, "Can't add Paeth filter after starting");

-               png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);

+                if(png_ptr->prev_row == NULL)

+                {

+                    png_warning(png_ptr, "Can't add Average filter after starting");

+                    png_ptr->do_filter &= ~PNG_FILTER_AVG;

+                }

+                else

+                {

+                    png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,

+                                       (png_ptr->rowbytes + 1));

+                    png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;

+                }

             }

-            else

+

+            if((png_ptr->do_filter & PNG_FILTER_PAETH) &&

+               png_ptr->paeth_row == NULL)

             {

-               png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,

-                  (png_ptr->rowbytes + 1));

-               png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;

+                if(png_ptr->prev_row == NULL)

+                {

+                    png_warning(png_ptr, "Can't add Paeth filter after starting");

+                    png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);

+                }

+                else

+                {

+                    png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,

+                                         (png_ptr->rowbytes + 1));

+                    png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;

+                }

             }

-         }

 

-         if (png_ptr->do_filter == PNG_NO_FILTERS)

+            if(png_ptr->do_filter == PNG_NO_FILTERS)

 #endif /* PNG_WRITE_FILTER_SUPPORTED */

-            png_ptr->do_filter = PNG_FILTER_NONE;

-      }

-   }

-   else

-      png_error(png_ptr, "Unknown custom filter method");

+                png_ptr->do_filter = PNG_FILTER_NONE;

+        }

+    }

+    else

+        png_error(png_ptr, "Unknown custom filter method");

 }

 

 /* This allows us to influence the way in which libpng chooses the "best"

@@ -1162,209 +1173,209 @@ png_set_filter(png_structp png_ptr, int method, int filters)
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED      /* GRR 970116 */

 void PNGAPI

 png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,

-   int num_weights, png_doublep filter_weights,

-   png_doublep filter_costs)

+                          int num_weights, png_doublep filter_weights,

+                          png_doublep filter_costs)

 {

-   int i;

-

-   png_debug(1, "in png_set_filter_heuristics");

-

-   if (png_ptr == NULL)

-      return;

-   if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST)

-   {

-      png_warning(png_ptr, "Unknown filter heuristic method");

-      return;

-   }

-

-   if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT)

-   {

-      heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED;

-   }

-

-   if (num_weights < 0 || filter_weights == NULL ||

-      heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED)

-   {

-      num_weights = 0;

-   }

-

-   png_ptr->num_prev_filters = (png_byte)num_weights;

-   png_ptr->heuristic_method = (png_byte)heuristic_method;

-

-   if (num_weights > 0)

-   {

-      if (png_ptr->prev_filters == NULL)

-      {

-         png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,

-            (png_uint_32)(png_sizeof(png_byte) * num_weights));

-

-         /* To make sure that the weighting starts out fairly */

-         for (i = 0; i < num_weights; i++)

-         {

-            png_ptr->prev_filters[i] = 255;

-         }

-      }

-

-      if (png_ptr->filter_weights == NULL)

-      {

-         png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,

-            (png_uint_32)(png_sizeof(png_uint_16) * num_weights));

-

-         png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,

-            (png_uint_32)(png_sizeof(png_uint_16) * num_weights));

-         for (i = 0; i < num_weights; i++)

-         {

-            png_ptr->inv_filter_weights[i] =

-            png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;

-         }

-      }

-

-      for (i = 0; i < num_weights; i++)

-      {

-         if (filter_weights[i] < 0.0)

-         {

-            png_ptr->inv_filter_weights[i] =

-            png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;

-         }

-         else

-         {

-            png_ptr->inv_filter_weights[i] =

-               (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5);

-            png_ptr->filter_weights[i] =

-               (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5);

-         }

-      }

-   }

-

-   /* If, in the future, there are other filter methods, this would

-    * need to be based on png_ptr->filter.

-    */

-   if (png_ptr->filter_costs == NULL)

-   {

-      png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,

-         (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));

-

-      png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,

-         (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));

-

-      for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)

-      {

-         png_ptr->inv_filter_costs[i] =

-         png_ptr->filter_costs[i] = PNG_COST_FACTOR;

-      }

-   }

-

-   /* Here is where we set the relative costs of the different filters.  We

-    * should take the desired compression level into account when setting

-    * the costs, so that Paeth, for instance, has a high relative cost at low

-    * compression levels, while it has a lower relative cost at higher

-    * compression settings.  The filter types are in order of increasing

-    * relative cost, so it would be possible to do this with an algorithm.

-    */

-   for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)

-   {

-      if (filter_costs == NULL || filter_costs[i] < 0.0)

-      {

-         png_ptr->inv_filter_costs[i] =

-         png_ptr->filter_costs[i] = PNG_COST_FACTOR;

-      }

-      else if (filter_costs[i] >= 1.0)

-      {

-         png_ptr->inv_filter_costs[i] =

-            (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5);

-         png_ptr->filter_costs[i] =

-            (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5);

-      }

-   }

+    int i;

+

+    png_debug(1, "in png_set_filter_heuristics");

+

+    if(png_ptr == NULL)

+        return;

+    if(heuristic_method >= PNG_FILTER_HEURISTIC_LAST)

+    {

+        png_warning(png_ptr, "Unknown filter heuristic method");

+        return;

+    }

+

+    if(heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT)

+    {

+        heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED;

+    }

+

+    if(num_weights < 0 || filter_weights == NULL ||

+       heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED)

+    {

+        num_weights = 0;

+    }

+

+    png_ptr->num_prev_filters = (png_byte)num_weights;

+    png_ptr->heuristic_method = (png_byte)heuristic_method;

+

+    if(num_weights > 0)

+    {

+        if(png_ptr->prev_filters == NULL)

+        {

+            png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,

+                                    (png_uint_32)(png_sizeof(png_byte) * num_weights));

+

+            /* To make sure that the weighting starts out fairly */

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

+            {

+                png_ptr->prev_filters[i] = 255;

+            }

+        }

+

+        if(png_ptr->filter_weights == NULL)

+        {

+            png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,

+                                      (png_uint_32)(png_sizeof(png_uint_16) * num_weights));

+

+            png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,

+                                          (png_uint_32)(png_sizeof(png_uint_16) * num_weights));

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

+            {

+                png_ptr->inv_filter_weights[i] =

+                    png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;

+            }

+        }

+

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

+        {

+            if(filter_weights[i] < 0.0)

+            {

+                png_ptr->inv_filter_weights[i] =

+                    png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;

+            }

+            else

+            {

+                png_ptr->inv_filter_weights[i] =

+                    (png_uint_16)((double)PNG_WEIGHT_FACTOR * filter_weights[i] + 0.5);

+                png_ptr->filter_weights[i] =

+                    (png_uint_16)((double)PNG_WEIGHT_FACTOR / filter_weights[i] + 0.5);

+            }

+        }

+    }

+

+    /* If, in the future, there are other filter methods, this would

+     * need to be based on png_ptr->filter.

+     */

+    if(png_ptr->filter_costs == NULL)

+    {

+        png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,

+                                (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));

+

+        png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,

+                                    (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));

+

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

+        {

+            png_ptr->inv_filter_costs[i] =

+                png_ptr->filter_costs[i] = PNG_COST_FACTOR;

+        }

+    }

+

+    /* Here is where we set the relative costs of the different filters.  We

+     * should take the desired compression level into account when setting

+     * the costs, so that Paeth, for instance, has a high relative cost at low

+     * compression levels, while it has a lower relative cost at higher

+     * compression settings.  The filter types are in order of increasing

+     * relative cost, so it would be possible to do this with an algorithm.

+     */

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

+    {

+        if(filter_costs == NULL || filter_costs[i] < 0.0)

+        {

+            png_ptr->inv_filter_costs[i] =

+                png_ptr->filter_costs[i] = PNG_COST_FACTOR;

+        }

+        else if(filter_costs[i] >= 1.0)

+        {

+            png_ptr->inv_filter_costs[i] =

+                (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5);

+            png_ptr->filter_costs[i] =

+                (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5);

+        }

+    }

 }

 #endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */

 

 void PNGAPI

 png_set_compression_level(png_structp png_ptr, int level)

 {

-   png_debug(1, "in png_set_compression_level");

+    png_debug(1, "in png_set_compression_level");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;

-   png_ptr->zlib_level = level;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;

+    png_ptr->zlib_level = level;

 }

 

 void PNGAPI

 png_set_compression_mem_level(png_structp png_ptr, int mem_level)

 {

-   png_debug(1, "in png_set_compression_mem_level");

+    png_debug(1, "in png_set_compression_mem_level");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;

-   png_ptr->zlib_mem_level = mem_level;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;

+    png_ptr->zlib_mem_level = mem_level;

 }

 

 void PNGAPI

 png_set_compression_strategy(png_structp png_ptr, int strategy)

 {

-   png_debug(1, "in png_set_compression_strategy");

+    png_debug(1, "in png_set_compression_strategy");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;

-   png_ptr->zlib_strategy = strategy;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;

+    png_ptr->zlib_strategy = strategy;

 }

 

 void PNGAPI

 png_set_compression_window_bits(png_structp png_ptr, int window_bits)

 {

-   if (png_ptr == NULL)

-      return;

-   if (window_bits > 15)

-      png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");

-   else if (window_bits < 8)

-      png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");

+    if(png_ptr == NULL)

+        return;

+    if(window_bits > 15)

+        png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");

+    else if(window_bits < 8)

+        png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");

 #ifndef WBITS_8_OK

-   /* Avoid libpng bug with 256-byte windows */

-   if (window_bits == 8)

-     {

-       png_warning(png_ptr, "Compression window is being reset to 512");

-       window_bits = 9;

-     }

-#endif

-   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;

-   png_ptr->zlib_window_bits = window_bits;

+    /* Avoid libpng bug with 256-byte windows */

+    if(window_bits == 8)

+    {

+        png_warning(png_ptr, "Compression window is being reset to 512");

+        window_bits = 9;

+    }

+#endif

+    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;

+    png_ptr->zlib_window_bits = window_bits;

 }

 

 void PNGAPI

 png_set_compression_method(png_structp png_ptr, int method)

 {

-   png_debug(1, "in png_set_compression_method");

-

-   if (png_ptr == NULL)

-      return;

-   if (method != 8)

-      png_warning(png_ptr, "Only compression method 8 is supported by PNG");

-   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;

-   png_ptr->zlib_method = method;

+    png_debug(1, "in png_set_compression_method");

+

+    if(png_ptr == NULL)

+        return;

+    if(method != 8)

+        png_warning(png_ptr, "Only compression method 8 is supported by PNG");

+    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;

+    png_ptr->zlib_method = method;

 }

 

 void PNGAPI

 png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)

 {

-   if (png_ptr == NULL)

-      return;

-   png_ptr->write_row_fn = write_row_fn;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->write_row_fn = write_row_fn;

 }

 

 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

 void PNGAPI

 png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr

-   write_user_transform_fn)

+                                write_user_transform_fn)

 {

-   png_debug(1, "in png_set_write_user_transform_fn");

+    png_debug(1, "in png_set_write_user_transform_fn");

 

-   if (png_ptr == NULL)

-      return;

-   png_ptr->transformations |= PNG_USER_TRANSFORM;

-   png_ptr->write_user_transform_fn = write_user_transform_fn;

+    if(png_ptr == NULL)

+        return;

+    png_ptr->transformations |= PNG_USER_TRANSFORM;

+    png_ptr->write_user_transform_fn = write_user_transform_fn;

 }

 #endif

 

@@ -1374,84 +1385,84 @@ void PNGAPI
 png_write_png(png_structp png_ptr, png_infop info_ptr,

               int transforms, voidp params)

 {

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

-      return;

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

+        return;

 

-   /* Write the file header information. */

-   png_write_info(png_ptr, info_ptr);

+    /* Write the file header information. */

+    png_write_info(png_ptr, info_ptr);

 

-   /* ------ these transformations don't touch the info structure ------- */

+    /* ------ these transformations don't touch the info structure ------- */

 

 #ifdef PNG_WRITE_INVERT_SUPPORTED

-   /* Invert monochrome pixels */

-   if (transforms & PNG_TRANSFORM_INVERT_MONO)

-      png_set_invert_mono(png_ptr);

+    /* Invert monochrome pixels */

+    if(transforms & PNG_TRANSFORM_INVERT_MONO)

+        png_set_invert_mono(png_ptr);

 #endif

 

 #ifdef PNG_WRITE_SHIFT_SUPPORTED

-   /* Shift the pixels up to a legal bit depth and fill in

-    * as appropriate to correctly scale the image.

-    */

-   if ((transforms & PNG_TRANSFORM_SHIFT)

-               && (info_ptr->valid & PNG_INFO_sBIT))

-      png_set_shift(png_ptr, &info_ptr->sig_bit);

+    /* Shift the pixels up to a legal bit depth and fill in

+     * as appropriate to correctly scale the image.

+     */

+    if((transforms & PNG_TRANSFORM_SHIFT)

+       && (info_ptr->valid & PNG_INFO_sBIT))

+        png_set_shift(png_ptr, &info_ptr->sig_bit);

 #endif

 

 #ifdef PNG_WRITE_PACK_SUPPORTED

-   /* Pack pixels into bytes */

-   if (transforms & PNG_TRANSFORM_PACKING)

-       png_set_packing(png_ptr);

+    /* Pack pixels into bytes */

+    if(transforms & PNG_TRANSFORM_PACKING)

+        png_set_packing(png_ptr);

 #endif

 

 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

-   /* Swap location of alpha bytes from ARGB to RGBA */

-   if (transforms & PNG_TRANSFORM_SWAP_ALPHA)

-      png_set_swap_alpha(png_ptr);

+    /* Swap location of alpha bytes from ARGB to RGBA */

+    if(transforms & PNG_TRANSFORM_SWAP_ALPHA)

+        png_set_swap_alpha(png_ptr);

 #endif

 

 #ifdef PNG_WRITE_FILLER_SUPPORTED

-   /* Pack XRGB/RGBX/ARGB/RGBA into * RGB (4 channels -> 3 channels) */

-   if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER)

-      png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);

-   else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE)

-      png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

+    /* Pack XRGB/RGBX/ARGB/RGBA into * RGB (4 channels -> 3 channels) */

+    if(transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER)

+        png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);

+    else if(transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE)

+        png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

 #endif

 

 #ifdef PNG_WRITE_BGR_SUPPORTED

-   /* Flip BGR pixels to RGB */

-   if (transforms & PNG_TRANSFORM_BGR)

-      png_set_bgr(png_ptr);

+    /* Flip BGR pixels to RGB */

+    if(transforms & PNG_TRANSFORM_BGR)

+        png_set_bgr(png_ptr);

 #endif

 

 #ifdef PNG_WRITE_SWAP_SUPPORTED

-   /* Swap bytes of 16-bit files to most significant byte first */

-   if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)

-      png_set_swap(png_ptr);

+    /* Swap bytes of 16-bit files to most significant byte first */

+    if(transforms & PNG_TRANSFORM_SWAP_ENDIAN)

+        png_set_swap(png_ptr);

 #endif

 

 #ifdef PNG_WRITE_PACKSWAP_SUPPORTED

-   /* Swap bits of 1, 2, 4 bit packed pixel formats */

-   if (transforms & PNG_TRANSFORM_PACKSWAP)

-      png_set_packswap(png_ptr);

+    /* Swap bits of 1, 2, 4 bit packed pixel formats */

+    if(transforms & PNG_TRANSFORM_PACKSWAP)

+        png_set_packswap(png_ptr);

 #endif

 

 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

-   /* Invert the alpha channel from opacity to transparency */

-   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)

-      png_set_invert_alpha(png_ptr);

+    /* Invert the alpha channel from opacity to transparency */

+    if(transforms & PNG_TRANSFORM_INVERT_ALPHA)

+        png_set_invert_alpha(png_ptr);

 #endif

 

-   /* ----------------------- end of transformations ------------------- */

+    /* ----------------------- end of transformations ------------------- */

 

-   /* Write the bits */

-   if (info_ptr->valid & PNG_INFO_IDAT)

-       png_write_image(png_ptr, info_ptr->row_pointers);

+    /* Write the bits */

+    if(info_ptr->valid & PNG_INFO_IDAT)

+        png_write_image(png_ptr, info_ptr->row_pointers);

 

-   /* It is REQUIRED to call this to finish writing the rest of the file */

-   png_write_end(png_ptr, info_ptr);

+    /* It is REQUIRED to call this to finish writing the rest of the file */

+    png_write_end(png_ptr, info_ptr);

 

-   transforms = transforms; /* Quiet compiler warnings */

-   params = params;

+    transforms = transforms; /* Quiet compiler warnings */

+    params = params;

 }

 #endif

 #endif /* PNG_WRITE_SUPPORTED */

diff --git a/src/libpng/pngwtran.c b/src/libpng/pngwtran.c
index 9cf095b8c..40f168200 100644
--- a/src/libpng/pngwtran.c
+++ b/src/libpng/pngwtran.c
@@ -22,64 +22,64 @@
 void /* PRIVATE */

 png_do_write_transformations(png_structp png_ptr)

 {

-   png_debug(1, "in png_do_write_transformations");

+    png_debug(1, "in png_do_write_transformations");

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

-   if (png_ptr->transformations & PNG_USER_TRANSFORM)

-      if (png_ptr->write_user_transform_fn != NULL)

-        (*(png_ptr->write_user_transform_fn)) /* User write transform

+    if(png_ptr->transformations & PNG_USER_TRANSFORM)

+        if(png_ptr->write_user_transform_fn != NULL)

+            (*(png_ptr->write_user_transform_fn)) /* User write transform

                                                  function */

-          (png_ptr,                    /* png_ptr */

-           &(png_ptr->row_info),       /* row_info:     */

+            (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->row_buf + 1);      /* start of pixel data for row */

 #endif

 #ifdef PNG_WRITE_FILLER_SUPPORTED

-   if (png_ptr->transformations & PNG_FILLER)

-      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         png_ptr->flags);

+    if(png_ptr->transformations & PNG_FILLER)

+        png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                            png_ptr->flags);

 #endif

 #ifdef PNG_WRITE_PACKSWAP_SUPPORTED

-   if (png_ptr->transformations & PNG_PACKSWAP)

-      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_PACKSWAP)

+        png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 #ifdef PNG_WRITE_PACK_SUPPORTED

-   if (png_ptr->transformations & PNG_PACK)

-      png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         (png_uint_32)png_ptr->bit_depth);

+    if(png_ptr->transformations & PNG_PACK)

+        png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                    (png_uint_32)png_ptr->bit_depth);

 #endif

 #ifdef PNG_WRITE_SWAP_SUPPORTED

-   if (png_ptr->transformations & PNG_SWAP_BYTES)

-      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_SWAP_BYTES)

+        png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 #ifdef PNG_WRITE_SHIFT_SUPPORTED

-   if (png_ptr->transformations & PNG_SHIFT)

-      png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,

-         &(png_ptr->shift));

+    if(png_ptr->transformations & PNG_SHIFT)

+        png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,

+                     &(png_ptr->shift));

 #endif

 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

-   if (png_ptr->transformations & PNG_SWAP_ALPHA)

-      png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_SWAP_ALPHA)

+        png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

-   if (png_ptr->transformations & PNG_INVERT_ALPHA)

-      png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_INVERT_ALPHA)

+        png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 #ifdef PNG_WRITE_BGR_SUPPORTED

-   if (png_ptr->transformations & PNG_BGR)

-      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_BGR)

+        png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 #ifdef PNG_WRITE_INVERT_SUPPORTED

-   if (png_ptr->transformations & PNG_INVERT_MONO)

-      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);

+    if(png_ptr->transformations & PNG_INVERT_MONO)

+        png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);

 #endif

 }

 

@@ -91,15 +91,15 @@ png_do_write_transformations(png_structp png_ptr)
 void /* PRIVATE */

 png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)

 {

-   png_debug(1, "in png_do_pack");

-

-   if (row_info->bit_depth == 8 &&

-      row_info->channels == 1)

-   {

-      switch ((int)bit_depth)

-      {

-         case 1:

-         {

+    png_debug(1, "in png_do_pack");

+

+    if(row_info->bit_depth == 8 &&

+       row_info->channels == 1)

+    {

+        switch((int)bit_depth)

+        {

+        case 1:

+        {

             png_bytep sp, dp;

             int mask, v;

             png_uint_32 i;

@@ -110,27 +110,27 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
             mask = 0x80;

             v = 0;

 

-            for (i = 0; i < row_width; i++)

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

             {

-               if (*sp != 0)

-                  v |= mask;

-               sp++;

-               if (mask > 1)

-                  mask >>= 1;

-               else

-               {

-                  mask = 0x80;

-                  *dp = (png_byte)v;

-                  dp++;

-                  v = 0;

-               }

+                if(*sp != 0)

+                    v |= mask;

+                sp++;

+                if(mask > 1)

+                    mask >>= 1;

+                else

+                {

+                    mask = 0x80;

+                    *dp = (png_byte)v;

+                    dp++;

+                    v = 0;

+                }

             }

-            if (mask != 0x80)

-               *dp = (png_byte)v;

+            if(mask != 0x80)

+                *dp = (png_byte)v;

             break;

-         }

-         case 2:

-         {

+        }

+        case 2:

+        {

             png_bytep sp, dp;

             int shift, v;

             png_uint_32 i;

@@ -140,29 +140,29 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
             dp = row;

             shift = 6;

             v = 0;

-            for (i = 0; i < row_width; i++)

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

             {

-               png_byte value;

-

-               value = (png_byte)(*sp & 0x03);

-               v |= (value << shift);

-               if (shift == 0)

-               {

-                  shift = 6;

-                  *dp = (png_byte)v;

-                  dp++;

-                  v = 0;

-               }

-               else

-                  shift -= 2;

-               sp++;

+                png_byte value;

+

+                value = (png_byte)(*sp & 0x03);

+                v |= (value << shift);

+                if(shift == 0)

+                {

+                    shift = 6;

+                    *dp = (png_byte)v;

+                    dp++;

+                    v = 0;

+                }

+                else

+                    shift -= 2;

+                sp++;

             }

-            if (shift != 6)

-               *dp = (png_byte)v;

+            if(shift != 6)

+                *dp = (png_byte)v;

             break;

-         }

-         case 4:

-         {

+        }

+        case 4:

+        {

             png_bytep sp, dp;

             int shift, v;

             png_uint_32 i;

@@ -172,35 +172,35 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
             dp = row;

             shift = 4;

             v = 0;

-            for (i = 0; i < row_width; i++)

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

             {

-               png_byte value;

-

-               value = (png_byte)(*sp & 0x0f);

-               v |= (value << shift);

-

-               if (shift == 0)

-               {

-                  shift = 4;

-                  *dp = (png_byte)v;

-                  dp++;

-                  v = 0;

-               }

-               else

-                  shift -= 4;

-

-               sp++;

+                png_byte value;

+

+                value = (png_byte)(*sp & 0x0f);

+                v |= (value << shift);

+

+                if(shift == 0)

+                {

+                    shift = 4;

+                    *dp = (png_byte)v;

+                    dp++;

+                    v = 0;

+                }

+                else

+                    shift -= 4;

+

+                sp++;

             }

-            if (shift != 4)

-               *dp = (png_byte)v;

+            if(shift != 4)

+                *dp = (png_byte)v;

             break;

-         }

-      }

-      row_info->bit_depth = (png_byte)bit_depth;

-      row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);

-      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

-         row_info->width);

-   }

+        }

+        }

+        row_info->bit_depth = (png_byte)bit_depth;

+        row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);

+        row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

+                                          row_info->width);

+    }

 }

 #endif

 

@@ -215,120 +215,120 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
 void /* PRIVATE */

 png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)

 {

-   png_debug(1, "in png_do_shift");

-

-   if (

-      row_info->color_type != PNG_COLOR_TYPE_PALETTE)

-   {

-      int shift_start[4], shift_dec[4];

-      int channels = 0;

-

-      if (row_info->color_type & PNG_COLOR_MASK_COLOR)

-      {

-         shift_start[channels] = row_info->bit_depth - bit_depth->red;

-         shift_dec[channels] = bit_depth->red;

-         channels++;

-         shift_start[channels] = row_info->bit_depth - bit_depth->green;

-         shift_dec[channels] = bit_depth->green;

-         channels++;

-         shift_start[channels] = row_info->bit_depth - bit_depth->blue;

-         shift_dec[channels] = bit_depth->blue;

-         channels++;

-      }

-      else

-      {

-         shift_start[channels] = row_info->bit_depth - bit_depth->gray;

-         shift_dec[channels] = bit_depth->gray;

-         channels++;

-      }

-      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)

-      {

-         shift_start[channels] = row_info->bit_depth - bit_depth->alpha;

-         shift_dec[channels] = bit_depth->alpha;

-         channels++;

-      }

-

-      /* With low row depths, could only be grayscale, so one channel */

-      if (row_info->bit_depth < 8)

-      {

-         png_bytep bp = row;

-         png_uint_32 i;

-         png_byte mask;

-         png_uint_32 row_bytes = row_info->rowbytes;

-

-         if (bit_depth->gray == 1 && row_info->bit_depth == 2)

-            mask = 0x55;

-         else if (row_info->bit_depth == 4 && bit_depth->gray == 3)

-            mask = 0x11;

-         else

-            mask = 0xff;

-

-         for (i = 0; i < row_bytes; i++, bp++)

-         {

-            png_uint_16 v;

-            int j;

-

-            v = *bp;

-            *bp = 0;

-            for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])

+    png_debug(1, "in png_do_shift");

+

+    if(

+        row_info->color_type != PNG_COLOR_TYPE_PALETTE)

+    {

+        int shift_start[4], shift_dec[4];

+        int channels = 0;

+

+        if(row_info->color_type & PNG_COLOR_MASK_COLOR)

+        {

+            shift_start[channels] = row_info->bit_depth - bit_depth->red;

+            shift_dec[channels] = bit_depth->red;

+            channels++;

+            shift_start[channels] = row_info->bit_depth - bit_depth->green;

+            shift_dec[channels] = bit_depth->green;

+            channels++;

+            shift_start[channels] = row_info->bit_depth - bit_depth->blue;

+            shift_dec[channels] = bit_depth->blue;

+            channels++;

+        }

+        else

+        {

+            shift_start[channels] = row_info->bit_depth - bit_depth->gray;

+            shift_dec[channels] = bit_depth->gray;

+            channels++;

+        }

+        if(row_info->color_type & PNG_COLOR_MASK_ALPHA)

+        {

+            shift_start[channels] = row_info->bit_depth - bit_depth->alpha;

+            shift_dec[channels] = bit_depth->alpha;

+            channels++;

+        }

+

+        /* With low row depths, could only be grayscale, so one channel */

+        if(row_info->bit_depth < 8)

+        {

+            png_bytep bp = row;

+            png_uint_32 i;

+            png_byte mask;

+            png_uint_32 row_bytes = row_info->rowbytes;

+

+            if(bit_depth->gray == 1 && row_info->bit_depth == 2)

+                mask = 0x55;

+            else if(row_info->bit_depth == 4 && bit_depth->gray == 3)

+                mask = 0x11;

+            else

+                mask = 0xff;

+

+            for(i = 0; i < row_bytes; i++, bp++)

             {

-               if (j > 0)

-                  *bp |= (png_byte)((v << j) & 0xff);

-               else

-                  *bp |= (png_byte)((v >> (-j)) & mask);

+                png_uint_16 v;

+                int j;

+

+                v = *bp;

+                *bp = 0;

+                for(j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])

+                {

+                    if(j > 0)

+                        *bp |= (png_byte)((v << j) & 0xff);

+                    else

+                        *bp |= (png_byte)((v >> (-j)) & mask);

+                }

             }

-         }

-      }

-      else if (row_info->bit_depth == 8)

-      {

-         png_bytep bp = row;

-         png_uint_32 i;

-         png_uint_32 istop = channels * row_info->width;

-

-         for (i = 0; i < istop; i++, bp++)

-         {

-

-            png_uint_16 v;

-            int j;

-            int c = (int)(i%channels);

-

-            v = *bp;

-            *bp = 0;

-            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])

+        }

+        else if(row_info->bit_depth == 8)

+        {

+            png_bytep bp = row;

+            png_uint_32 i;

+            png_uint_32 istop = channels * row_info->width;

+

+            for(i = 0; i < istop; i++, bp++)

             {

-               if (j > 0)

-                  *bp |= (png_byte)((v << j) & 0xff);

-               else

-                  *bp |= (png_byte)((v >> (-j)) & 0xff);

+

+                png_uint_16 v;

+                int j;

+                int c = (int)(i % channels);

+

+                v = *bp;

+                *bp = 0;

+                for(j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])

+                {

+                    if(j > 0)

+                        *bp |= (png_byte)((v << j) & 0xff);

+                    else

+                        *bp |= (png_byte)((v >> (-j)) & 0xff);

+                }

             }

-         }

-      }

-      else

-      {

-         png_bytep bp;

-         png_uint_32 i;

-         png_uint_32 istop = channels * row_info->width;

-

-         for (bp = row, i = 0; i < istop; i++)

-         {

-            int c = (int)(i%channels);

-            png_uint_16 value, v;

-            int j;

-

-            v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));

-            value = 0;

-            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])

+        }

+        else

+        {

+            png_bytep bp;

+            png_uint_32 i;

+            png_uint_32 istop = channels * row_info->width;

+

+            for(bp = row, i = 0; i < istop; i++)

             {

-               if (j > 0)

-                  value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);

-               else

-                  value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);

+                int c = (int)(i % channels);

+                png_uint_16 value, v;

+                int j;

+

+                v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));

+                value = 0;

+                for(j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])

+                {

+                    if(j > 0)

+                        value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);

+                    else

+                        value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);

+                }

+                *bp++ = (png_byte)(value >> 8);

+                *bp++ = (png_byte)(value & 0xff);

             }

-            *bp++ = (png_byte)(value >> 8);

-            *bp++ = (png_byte)(value & 0xff);

-         }

-      }

-   }

+        }

+    }

 }

 #endif

 

@@ -336,85 +336,85 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
 void /* PRIVATE */

 png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_write_swap_alpha");

-

-   {

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-      {

-         /* This converts from ARGB to RGBA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-            for (i = 0, sp = dp = row; i < row_width; i++)

+    png_debug(1, "in png_do_write_swap_alpha");

+

+    {

+        if(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+        {

+            /* This converts from ARGB to RGBA */

+            if(row_info->bit_depth == 8)

             {

-               png_byte save = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = save;

+                png_bytep sp, dp;

+                png_uint_32 i;

+                png_uint_32 row_width = row_info->width;

+                for(i = 0, sp = dp = row; i < row_width; i++)

+                {

+                    png_byte save = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = save;

+                }

             }

-         }

-         /* This converts from AARRGGBB to RRGGBBAA */

-         else

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

+            /* This converts from AARRGGBB to RRGGBBAA */

+            else

             {

-               png_byte save[2];

-               save[0] = *(sp++);

-               save[1] = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = save[0];

-               *(dp++) = save[1];

+                png_bytep sp, dp;

+                png_uint_32 i;

+                png_uint_32 row_width = row_info->width;

+

+                for(i = 0, sp = dp = row; i < row_width; i++)

+                {

+                    png_byte save[2];

+                    save[0] = *(sp++);

+                    save[1] = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = save[0];

+                    *(dp++) = save[1];

+                }

             }

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         /* This converts from AG to GA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

+        }

+        else if(row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+        {

+            /* This converts from AG to GA */

+            if(row_info->bit_depth == 8)

             {

-               png_byte save = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = save;

+                png_bytep sp, dp;

+                png_uint_32 i;

+                png_uint_32 row_width = row_info->width;

+

+                for(i = 0, sp = dp = row; i < row_width; i++)

+                {

+                    png_byte save = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = save;

+                }

             }

-         }

-         /* This converts from AAGG to GGAA */

-         else

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

+            /* This converts from AAGG to GGAA */

+            else

             {

-               png_byte save[2];

-               save[0] = *(sp++);

-               save[1] = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = save[0];

-               *(dp++) = save[1];

+                png_bytep sp, dp;

+                png_uint_32 i;

+                png_uint_32 row_width = row_info->width;

+

+                for(i = 0, sp = dp = row; i < row_width; i++)

+                {

+                    png_byte save[2];

+                    save[0] = *(sp++);

+                    save[1] = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = save[0];

+                    *(dp++) = save[1];

+                }

             }

-         }

-      }

-   }

+        }

+    }

 }

 #endif

 

@@ -422,86 +422,89 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
 void /* PRIVATE */

 png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_write_invert_alpha");

-

-   {

-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

-      {

-         /* This inverts the alpha channel in RGBA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-            for (i = 0, sp = dp = row; i < row_width; i++)

+    png_debug(1, "in png_do_write_invert_alpha");

+

+    {

+        if(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+        {

+            /* This inverts the alpha channel in RGBA */

+            if(row_info->bit_depth == 8)

             {

-               /* Does nothing

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               */

-               sp+=3; dp = sp;

-               *(dp++) = (png_byte)(255 - *(sp++));

+                png_bytep sp, dp;

+                png_uint_32 i;

+                png_uint_32 row_width = row_info->width;

+                for(i = 0, sp = dp = row; i < row_width; i++)

+                {

+                    /* Does nothing

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    */

+                    sp += 3;

+                    dp = sp;

+                    *(dp++) = (png_byte)(255 - *(sp++));

+                }

             }

-         }

-         /* This inverts the alpha channel in RRGGBBAA */

-         else

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

+            /* This inverts the alpha channel in RRGGBBAA */

+            else

             {

-               /* Does nothing

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               */

-               sp+=6; dp = sp;

-               *(dp++) = (png_byte)(255 - *(sp++));

-               *(dp++) = (png_byte)(255 - *(sp++));

+                png_bytep sp, dp;

+                png_uint_32 i;

+                png_uint_32 row_width = row_info->width;

+

+                for(i = 0, sp = dp = row; i < row_width; i++)

+                {

+                    /* Does nothing

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    */

+                    sp += 6;

+                    dp = sp;

+                    *(dp++) = (png_byte)(255 - *(sp++));

+                    *(dp++) = (png_byte)(255 - *(sp++));

+                }

             }

-         }

-      }

-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

-      {

-         /* This inverts the alpha channel in GA */

-         if (row_info->bit_depth == 8)

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

+        }

+        else if(row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+        {

+            /* This inverts the alpha channel in GA */

+            if(row_info->bit_depth == 8)

             {

-               *(dp++) = *(sp++);

-               *(dp++) = (png_byte)(255 - *(sp++));

+                png_bytep sp, dp;

+                png_uint_32 i;

+                png_uint_32 row_width = row_info->width;

+

+                for(i = 0, sp = dp = row; i < row_width; i++)

+                {

+                    *(dp++) = *(sp++);

+                    *(dp++) = (png_byte)(255 - *(sp++));

+                }

             }

-         }

-         /* This inverts the alpha channel in GGAA */

-         else

-         {

-            png_bytep sp, dp;

-            png_uint_32 i;

-            png_uint_32 row_width = row_info->width;

-

-            for (i = 0, sp = dp = row; i < row_width; i++)

+            /* This inverts the alpha channel in GGAA */

+            else

             {

-               /* Does nothing

-               *(dp++) = *(sp++);

-               *(dp++) = *(sp++);

-               */

-               sp+=2; dp = sp;

-               *(dp++) = (png_byte)(255 - *(sp++));

-               *(dp++) = (png_byte)(255 - *(sp++));

+                png_bytep sp, dp;

+                png_uint_32 i;

+                png_uint_32 row_width = row_info->width;

+

+                for(i = 0, sp = dp = row; i < row_width; i++)

+                {

+                    /* Does nothing

+                    *(dp++) = *(sp++);

+                    *(dp++) = *(sp++);

+                    */

+                    sp += 2;

+                    dp = sp;

+                    *(dp++) = (png_byte)(255 - *(sp++));

+                    *(dp++) = (png_byte)(255 - *(sp++));

+                }

             }

-         }

-      }

-   }

+        }

+    }

 }

 #endif

 

@@ -510,57 +513,57 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
 void /* PRIVATE */

 png_do_write_intrapixel(png_row_infop row_info, png_bytep row)

 {

-   png_debug(1, "in png_do_write_intrapixel");

-

-   if (

-       (row_info->color_type & PNG_COLOR_MASK_COLOR))

-   {

-      int bytes_per_pixel;

-      png_uint_32 row_width = row_info->width;

-      if (row_info->bit_depth == 8)

-      {

-         png_bytep rp;

-         png_uint_32 i;

-

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

-

-         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

-         {

-            *(rp)   = (png_byte)((*rp     - *(rp+1))&0xff);

-            *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);

-         }

-      }

-      else if (row_info->bit_depth == 16)

-      {

-         png_bytep rp;

-         png_uint_32 i;

-

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

-

-         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

-         {

-            png_uint_32 s0   = (*(rp  ) << 8) | *(rp+1);

-            png_uint_32 s1   = (*(rp+2) << 8) | *(rp+3);

-            png_uint_32 s2   = (*(rp+4) << 8) | *(rp+5);

-            png_uint_32 red  = (png_uint_32)((s0 - s1) & 0xffffL);

-            png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);

-            *(rp  ) = (png_byte)((red >> 8) & 0xff);

-            *(rp+1) = (png_byte)(red & 0xff);

-            *(rp+4) = (png_byte)((blue >> 8) & 0xff);

-            *(rp+5) = (png_byte)(blue & 0xff);

-         }

-      }

-   }

+    png_debug(1, "in png_do_write_intrapixel");

+

+    if(

+        (row_info->color_type & PNG_COLOR_MASK_COLOR))

+    {

+        int bytes_per_pixel;

+        png_uint_32 row_width = row_info->width;

+        if(row_info->bit_depth == 8)

+        {

+            png_bytep rp;

+            png_uint_32 i;

+

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

+

+            for(i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

+            {

+                *(rp)   = (png_byte)((*rp     - *(rp + 1)) & 0xff);

+                *(rp + 2) = (png_byte)((*(rp + 2) - *(rp + 1)) & 0xff);

+            }

+        }

+        else if(row_info->bit_depth == 16)

+        {

+            png_bytep rp;

+            png_uint_32 i;

+

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

+

+            for(i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

+            {

+                png_uint_32 s0   = (*(rp) << 8) | *(rp + 1);

+                png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);

+                png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);

+                png_uint_32 red  = (png_uint_32)((s0 - s1) & 0xffffL);

+                png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);

+                *(rp) = (png_byte)((red >> 8) & 0xff);

+                *(rp + 1) = (png_byte)(red & 0xff);

+                *(rp + 4) = (png_byte)((blue >> 8) & 0xff);

+                *(rp + 5) = (png_byte)(blue & 0xff);

+            }

+        }

+    }

 }

 #endif /* PNG_MNG_FEATURES_SUPPORTED */

 #endif /* PNG_WRITE_SUPPORTED */

diff --git a/src/libpng/pngwutil.c b/src/libpng/pngwutil.c
index b75c34bfd..42c47943f 100644
--- a/src/libpng/pngwutil.c
+++ b/src/libpng/pngwutil.c
@@ -23,10 +23,10 @@
 void PNGAPI

 png_save_uint_32(png_bytep buf, png_uint_32 i)

 {

-   buf[0] = (png_byte)((i >> 24) & 0xff);

-   buf[1] = (png_byte)((i >> 16) & 0xff);

-   buf[2] = (png_byte)((i >> 8) & 0xff);

-   buf[3] = (png_byte)(i & 0xff);

+    buf[0] = (png_byte)((i >> 24) & 0xff);

+    buf[1] = (png_byte)((i >> 16) & 0xff);

+    buf[2] = (png_byte)((i >> 8) & 0xff);

+    buf[3] = (png_byte)(i & 0xff);

 }

 

 #ifdef PNG_SAVE_INT_32_SUPPORTED

@@ -37,10 +37,10 @@ png_save_uint_32(png_bytep buf, png_uint_32 i)
 void PNGAPI

 png_save_int_32(png_bytep buf, png_int_32 i)

 {

-   buf[0] = (png_byte)((i >> 24) & 0xff);

-   buf[1] = (png_byte)((i >> 16) & 0xff);

-   buf[2] = (png_byte)((i >> 8) & 0xff);

-   buf[3] = (png_byte)(i & 0xff);

+    buf[0] = (png_byte)((i >> 24) & 0xff);

+    buf[1] = (png_byte)((i >> 16) & 0xff);

+    buf[2] = (png_byte)((i >> 8) & 0xff);

+    buf[3] = (png_byte)(i & 0xff);

 }

 #endif

 

@@ -51,8 +51,8 @@ png_save_int_32(png_bytep buf, png_int_32 i)
 void PNGAPI

 png_save_uint_16(png_bytep buf, unsigned int i)

 {

-   buf[0] = (png_byte)((i >> 8) & 0xff);

-   buf[1] = (png_byte)(i & 0xff);

+    buf[0] = (png_byte)((i >> 8) & 0xff);

+    buf[1] = (png_byte)(i & 0xff);

 }

 

 /* Simple function to write the signature.  If we have already written

@@ -64,18 +64,18 @@ png_save_uint_16(png_bytep buf, unsigned int i)
 void PNGAPI

 png_write_sig(png_structp png_ptr)

 {

-   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

+    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

 

 #ifdef PNG_IO_STATE_SUPPORTED

-   /* Inform the I/O callback that the signature is being written */

-   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;

+    /* Inform the I/O callback that the signature is being written */

+    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;

 #endif

 

-   /* Write the rest of the 8 byte signature */

-   png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],

-      (png_size_t)(8 - png_ptr->sig_bytes));

-   if (png_ptr->sig_bytes < 3)

-      png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

+    /* Write the rest of the 8 byte signature */

+    png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],

+                   (png_size_t)(8 - png_ptr->sig_bytes));

+    if(png_ptr->sig_bytes < 3)

+        png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

 }

 

 /* Write a PNG chunk all at once.  The type is an array of ASCII characters

@@ -89,13 +89,13 @@ png_write_sig(png_structp png_ptr)
  */

 void PNGAPI

 png_write_chunk(png_structp png_ptr, png_bytep chunk_name,

-   png_bytep data, png_size_t length)

+                png_bytep data, png_size_t length)

 {

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

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

 }

 

 /* Write the start of a PNG chunk.  The type is the chunk type.

@@ -104,38 +104,38 @@ png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
  */

 void PNGAPI

 png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,

-   png_uint_32 length)

+                      png_uint_32 length)

 {

-   png_byte buf[8];

+    png_byte buf[8];

 

-   png_debug2(0, "Writing %s chunk, length = %lu", chunk_name,

-      (unsigned long)length);

+    png_debug2(0, "Writing %s chunk, length = %lu", chunk_name,

+               (unsigned long)length);

 

-   if (png_ptr == NULL)

-      return;

+    if(png_ptr == NULL)

+        return;

 

 #ifdef PNG_IO_STATE_SUPPORTED

-   /* Inform the I/O callback that the chunk header is being written.

-    * PNG_IO_CHUNK_HDR requires a single I/O call.

-    */

-   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;

+    /* Inform the I/O callback that the chunk header is being written.

+     * PNG_IO_CHUNK_HDR requires a single I/O call.

+     */

+    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;

 #endif

 

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

-   png_memcpy(png_ptr->chunk_name, chunk_name, 4);

-   /* Reset the crc and run it over the chunk name */

-   png_reset_crc(png_ptr);

-   png_calculate_crc(png_ptr, chunk_name, 4);

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

+    png_memcpy(png_ptr->chunk_name, chunk_name, 4);

+    /* Reset the crc and run it over the chunk name */

+    png_reset_crc(png_ptr);

+    png_calculate_crc(png_ptr, chunk_name, 4);

 

 #ifdef PNG_IO_STATE_SUPPORTED

-   /* Inform the I/O callback that chunk data will (possibly) be written.

-    * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.

-    */

-   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA;

+    /* Inform the I/O callback that chunk data will (possibly) be written.

+     * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.

+     */

+    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA;

 #endif

 }

 

@@ -147,38 +147,38 @@ png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
 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;

-   if (data != NULL && length > 0)

-   {

-      png_write_data(png_ptr, data, length);

-      /* Update the CRC after writing the data,

-       * in case that the user I/O routine alters it.

-       */

-      png_calculate_crc(png_ptr, data, length);

-   }

+    /* 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,

+         * in case that the user I/O routine alters it.

+         */

+        png_calculate_crc(png_ptr, data, length);

+    }

 }

 

 /* Finish a chunk started with png_write_chunk_start(). */

 void PNGAPI

 png_write_chunk_end(png_structp png_ptr)

 {

-   png_byte buf[4];

+    png_byte buf[4];

 

-   if (png_ptr == NULL) return;

+    if(png_ptr == NULL) return;

 

 #ifdef PNG_IO_STATE_SUPPORTED

-   /* Inform the I/O callback that the chunk CRC is being written.

-    * PNG_IO_CHUNK_CRC requires a single I/O function call.

-    */

-   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;

+    /* Inform the I/O callback that the chunk CRC is being written.

+     * PNG_IO_CHUNK_CRC requires a single I/O function call.

+     */

+    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;

 #endif

 

-   /* Write the crc in a single operation */

-   png_save_uint_32(buf, png_ptr->crc);

+    /* Write the crc in a single operation */

+    png_save_uint_32(buf, png_ptr->crc);

 

-   png_write_data(png_ptr, buf, (png_size_t)4);

+    png_write_data(png_ptr, buf, (png_size_t)4);

 }

 

 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)

@@ -190,222 +190,224 @@ png_write_chunk_end(png_structp png_ptr)
 

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

 static int /* PRIVATE */

 png_text_compress(png_structp png_ptr,

-        png_charp text, png_size_t text_len, int compression,

-        compression_state *comp)

+                  png_charp text, png_size_t text_len, int compression,

+                  compression_state *comp)

 {

-   int ret;

-

-   comp->num_output_ptr = 0;

-   comp->max_output_ptr = 0;

-   comp->output_ptr = NULL;

-   comp->input = NULL;

-   comp->input_len = 0;

-

-   /* We may just want to pass the text right through */

-   if (compression == PNG_TEXT_COMPRESSION_NONE)

-   {

-       comp->input = text;

-       comp->input_len = text_len;

-       return((int)text_len);

-   }

-

-   if (compression >= PNG_TEXT_COMPRESSION_LAST)

-   {

+    int ret;

+

+    comp->num_output_ptr = 0;

+    comp->max_output_ptr = 0;

+    comp->output_ptr = NULL;

+    comp->input = NULL;

+    comp->input_len = 0;

+

+    /* We may just want to pass the text right through */

+    if(compression == PNG_TEXT_COMPRESSION_NONE)

+    {

+        comp->input = text;

+        comp->input_len = text_len;

+        return((int)text_len);

+    }

+

+    if(compression >= PNG_TEXT_COMPRESSION_LAST)

+    {

 #ifdef PNG_STDIO_SUPPORTED

-      char msg[50];

-      png_snprintf(msg, 50, "Unknown compression type %d", compression);

-      png_warning(png_ptr, msg);

+        char msg[50];

+        png_snprintf(msg, 50, "Unknown compression type %d", compression);

+        png_warning(png_ptr, msg);

 #else

-      png_warning(png_ptr, "Unknown compression type");

+        png_warning(png_ptr, "Unknown compression type");

 #endif

-   }

-

-   /* We can't write the chunk until we find out how much data we have,

-    * which means we need to run the compressor first and save the

-    * output.  This shouldn't be a problem, as the vast majority of

-    * comments should be reasonable, but we will set up an array of

-    * malloc'd pointers to be sure.

-    *

-    * If we knew the application was well behaved, we could simplify this

-    * greatly by assuming we can always malloc an output buffer large

-    * enough to hold the compressed text ((1001 * text_len / 1000) + 12)

-    * and malloc this directly.  The only time this would be a bad idea is

-    * if we can't malloc more than 64K and we have 64K of random input

-    * data, or if the input string is incredibly large (although this

-    * wouldn't cause a failure, just a slowdown due to swapping).

-    */

-

-   /* 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() */

-   do

-   {

-      /* Compress the data */

-      ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);

-      if (ret != Z_OK)

-      {

-         /* Error */

-         if (png_ptr->zstream.msg != NULL)

-            png_error(png_ptr, png_ptr->zstream.msg);

-         else

-            png_error(png_ptr, "zlib error");

-      }

-      /* Check to see if we need more room */

-      if (!(png_ptr->zstream.avail_out))

-      {

-         /* Make sure the output array has room */

-         if (comp->num_output_ptr >= comp->max_output_ptr)

-         {

-            int old_max;

-

-            old_max = comp->max_output_ptr;

-            comp->max_output_ptr = comp->num_output_ptr + 4;

-            if (comp->output_ptr != NULL)

-            {

-               png_charpp old_ptr;

-

-               old_ptr = comp->output_ptr;

-               comp->output_ptr = (png_charpp)png_malloc(png_ptr,

-                  (png_alloc_size_t)

-                  (comp->max_output_ptr * png_sizeof(png_charpp)));

-               png_memcpy(comp->output_ptr, old_ptr, old_max

-                  * png_sizeof(png_charp));

-               png_free(png_ptr, old_ptr);

-            }

+    }

+

+    /* We can't write the chunk until we find out how much data we have,

+     * which means we need to run the compressor first and save the

+     * output.  This shouldn't be a problem, as the vast majority of

+     * comments should be reasonable, but we will set up an array of

+     * malloc'd pointers to be sure.

+     *

+     * If we knew the application was well behaved, we could simplify this

+     * greatly by assuming we can always malloc an output buffer large

+     * enough to hold the compressed text ((1001 * text_len / 1000) + 12)

+     * and malloc this directly.  The only time this would be a bad idea is

+     * if we can't malloc more than 64K and we have 64K of random input

+     * data, or if the input string is incredibly large (although this

+     * wouldn't cause a failure, just a slowdown due to swapping).

+     */

+

+    /* 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() */

+    do

+    {

+        /* Compress the data */

+        ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);

+        if(ret != Z_OK)

+        {

+            /* Error */

+            if(png_ptr->zstream.msg != NULL)

+                png_error(png_ptr, png_ptr->zstream.msg);

             else

-               comp->output_ptr = (png_charpp)png_malloc(png_ptr,

-                  (png_alloc_size_t)

-                  (comp->max_output_ptr * png_sizeof(png_charp)));

-         }

-

-         /* Save the data */

-         comp->output_ptr[comp->num_output_ptr] =

-            (png_charp)png_malloc(png_ptr,

-            (png_alloc_size_t)png_ptr->zbuf_size);

-         png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,

-            png_ptr->zbuf_size);

-         comp->num_output_ptr++;

-

-         /* and reset the buffer */

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

-   } while (png_ptr->zstream.avail_in);

-

-   /* Finish the compression */

-   do

-   {

-      /* Tell zlib we are finished */

-      ret = deflate(&png_ptr->zstream, Z_FINISH);

-

-      if (ret == Z_OK)

-      {

-         /* Check to see if we need more room */

-         if (!(png_ptr->zstream.avail_out))

-         {

-            /* Check to make sure our output array has room */

-            if (comp->num_output_ptr >= comp->max_output_ptr)

+                png_error(png_ptr, "zlib error");

+        }

+        /* Check to see if we need more room */

+        if(!(png_ptr->zstream.avail_out))

+        {

+            /* Make sure the output array has room */

+            if(comp->num_output_ptr >= comp->max_output_ptr)

             {

-               int old_max;

-

-               old_max = comp->max_output_ptr;

-               comp->max_output_ptr = comp->num_output_ptr + 4;

-               if (comp->output_ptr != NULL)

-               {

-                  png_charpp old_ptr;

-

-                  old_ptr = comp->output_ptr;

-                  /* This could be optimized to realloc() */

-                  comp->output_ptr = (png_charpp)png_malloc(png_ptr,

-                     (png_alloc_size_t)(comp->max_output_ptr *

-                     png_sizeof(png_charp)));

-                  png_memcpy(comp->output_ptr, old_ptr,

-                     old_max * png_sizeof(png_charp));

-                  png_free(png_ptr, old_ptr);

-               }

-               else

-                  comp->output_ptr = (png_charpp)png_malloc(png_ptr,

-                     (png_alloc_size_t)(comp->max_output_ptr *

-                     png_sizeof(png_charp)));

+                int old_max;

+

+                old_max = comp->max_output_ptr;

+                comp->max_output_ptr = comp->num_output_ptr + 4;

+                if(comp->output_ptr != NULL)

+                {

+                    png_charpp old_ptr;

+

+                    old_ptr = comp->output_ptr;

+                    comp->output_ptr = (png_charpp)png_malloc(png_ptr,

+                                       (png_alloc_size_t)

+                                       (comp->max_output_ptr * png_sizeof(png_charpp)));

+                    png_memcpy(comp->output_ptr, old_ptr, old_max

+                               * png_sizeof(png_charp));

+                    png_free(png_ptr, old_ptr);

+                }

+                else

+                    comp->output_ptr = (png_charpp)png_malloc(png_ptr,

+                                       (png_alloc_size_t)

+                                       (comp->max_output_ptr * png_sizeof(png_charp)));

             }

 

             /* Save the data */

             comp->output_ptr[comp->num_output_ptr] =

-               (png_charp)png_malloc(png_ptr,

-               (png_alloc_size_t)png_ptr->zbuf_size);

+                (png_charp)png_malloc(png_ptr,

+                                      (png_alloc_size_t)png_ptr->zbuf_size);

             png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,

-               png_ptr->zbuf_size);

+                       png_ptr->zbuf_size);

             comp->num_output_ptr++;

 

-            /* and reset the buffer pointers */

+            /* and reset the buffer */

             png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

             png_ptr->zstream.next_out = png_ptr->zbuf;

-         }

-      }

-      else if (ret != Z_STREAM_END)

-      {

-         /* We got an error */

-         if (png_ptr->zstream.msg != NULL)

-            png_error(png_ptr, png_ptr->zstream.msg);

-         else

-            png_error(png_ptr, "zlib error");

-      }

-   } while (ret != Z_STREAM_END);

-

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

-

-   return((int)text_len);

+        }

+        /* Continue until we don't have any more to compress */

+    }

+    while(png_ptr->zstream.avail_in);

+

+    /* Finish the compression */

+    do

+    {

+        /* Tell zlib we are finished */

+        ret = deflate(&png_ptr->zstream, Z_FINISH);

+

+        if(ret == Z_OK)

+        {

+            /* Check to see if we need more room */

+            if(!(png_ptr->zstream.avail_out))

+            {

+                /* Check to make sure our output array has room */

+                if(comp->num_output_ptr >= comp->max_output_ptr)

+                {

+                    int old_max;

+

+                    old_max = comp->max_output_ptr;

+                    comp->max_output_ptr = comp->num_output_ptr + 4;

+                    if(comp->output_ptr != NULL)

+                    {

+                        png_charpp old_ptr;

+

+                        old_ptr = comp->output_ptr;

+                        /* This could be optimized to realloc() */

+                        comp->output_ptr = (png_charpp)png_malloc(png_ptr,

+                                           (png_alloc_size_t)(comp->max_output_ptr *

+                                                              png_sizeof(png_charp)));

+                        png_memcpy(comp->output_ptr, old_ptr,

+                                   old_max * png_sizeof(png_charp));

+                        png_free(png_ptr, old_ptr);

+                    }

+                    else

+                        comp->output_ptr = (png_charpp)png_malloc(png_ptr,

+                                           (png_alloc_size_t)(comp->max_output_ptr *

+                                                              png_sizeof(png_charp)));

+                }

+

+                /* Save the data */

+                comp->output_ptr[comp->num_output_ptr] =

+                    (png_charp)png_malloc(png_ptr,

+                                          (png_alloc_size_t)png_ptr->zbuf_size);

+                png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,

+                           png_ptr->zbuf_size);

+                comp->num_output_ptr++;

+

+                /* and reset the buffer pointers */

+                png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+                png_ptr->zstream.next_out = png_ptr->zbuf;

+            }

+        }

+        else if(ret != Z_STREAM_END)

+        {

+            /* We got an error */

+            if(png_ptr->zstream.msg != NULL)

+                png_error(png_ptr, png_ptr->zstream.msg);

+            else

+                png_error(png_ptr, "zlib error");

+        }

+    }

+    while(ret != Z_STREAM_END);

+

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

+

+    return((int)text_len);

 }

 

 /* Ship the compressed text out via chunk writes */

 static void /* PRIVATE */

 png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)

 {

-   int i;

-

-   /* Handle the no-compression case */

-   if (comp->input)

-   {

-      png_write_chunk_data(png_ptr, (png_bytep)comp->input,

-                            (png_size_t)comp->input_len);

-      return;

-   }

-

-   /* Write saved output buffers, if any */

-   for (i = 0; i < comp->num_output_ptr; i++)

-   {

-      png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i],

-         (png_size_t)png_ptr->zbuf_size);

-      png_free(png_ptr, comp->output_ptr[i]);

-   }

-   if (comp->max_output_ptr != 0)

-      png_free(png_ptr, comp->output_ptr);

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

-   deflateReset(&png_ptr->zstream);

-   png_ptr->zstream.data_type = Z_BINARY;

+    int i;

+

+    /* Handle the no-compression case */

+    if(comp->input)

+    {

+        png_write_chunk_data(png_ptr, (png_bytep)comp->input,

+                             (png_size_t)comp->input_len);

+        return;

+    }

+

+    /* Write saved output buffers, if any */

+    for(i = 0; i < comp->num_output_ptr; i++)

+    {

+        png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i],

+                             (png_size_t)png_ptr->zbuf_size);

+        png_free(png_ptr, comp->output_ptr[i]);

+    }

+    if(comp->max_output_ptr != 0)

+        png_free(png_ptr, comp->output_ptr);

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

+    deflateReset(&png_ptr->zstream);

+    png_ptr->zstream.data_type = Z_BINARY;

 }

 #endif

 

@@ -415,177 +417,183 @@ png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
  */

 void /* PRIVATE */

 png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,

-   int bit_depth, int color_type, int compression_type, int filter_type,

-   int interlace_type)

+               int bit_depth, int color_type, int compression_type, int filter_type,

+               int interlace_type)

 {

-   PNG_IHDR;

-   int ret;

-

-   png_byte buf[13]; /* Buffer to store the IHDR info */

-

-   png_debug(1, "in png_write_IHDR");

-

-   /* Check that we have valid input data from the application info */

-   switch (color_type)

-   {

-      case PNG_COLOR_TYPE_GRAY:

-         switch (bit_depth)

-         {

-            case 1:

-            case 2:

-            case 4:

-            case 8:

-            case 16: png_ptr->channels = 1; break;

-            default: png_error(png_ptr,

-                         "Invalid bit depth for grayscale image");

-         }

-         break;

-      case PNG_COLOR_TYPE_RGB:

-         if (bit_depth != 8 && bit_depth != 16)

+    PNG_IHDR;

+    int ret;

+

+    png_byte buf[13]; /* Buffer to store the IHDR info */

+

+    png_debug(1, "in png_write_IHDR");

+

+    /* Check that we have valid input data from the application info */

+    switch(color_type)

+    {

+    case PNG_COLOR_TYPE_GRAY:

+        switch(bit_depth)

+        {

+        case 1:

+        case 2:

+        case 4:

+        case 8:

+        case 16:

+            png_ptr->channels = 1;

+            break;

+        default:

+            png_error(png_ptr,

+                      "Invalid bit depth for grayscale image");

+        }

+        break;

+    case PNG_COLOR_TYPE_RGB:

+        if(bit_depth != 8 && bit_depth != 16)

             png_error(png_ptr, "Invalid bit depth for RGB image");

-         png_ptr->channels = 3;

-         break;

-      case PNG_COLOR_TYPE_PALETTE:

-         switch (bit_depth)

-         {

-            case 1:

-            case 2:

-            case 4:

-            case 8: png_ptr->channels = 1; break;

-            default: png_error(png_ptr, "Invalid bit depth for paletted image");

-         }

-         break;

-      case PNG_COLOR_TYPE_GRAY_ALPHA:

-         if (bit_depth != 8 && bit_depth != 16)

+        png_ptr->channels = 3;

+        break;

+    case PNG_COLOR_TYPE_PALETTE:

+        switch(bit_depth)

+        {

+        case 1:

+        case 2:

+        case 4:

+        case 8:

+            png_ptr->channels = 1;

+            break;

+        default:

+            png_error(png_ptr, "Invalid bit depth for paletted image");

+        }

+        break;

+    case PNG_COLOR_TYPE_GRAY_ALPHA:

+        if(bit_depth != 8 && bit_depth != 16)

             png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");

-         png_ptr->channels = 2;

-         break;

-      case PNG_COLOR_TYPE_RGB_ALPHA:

-         if (bit_depth != 8 && bit_depth != 16)

+        png_ptr->channels = 2;

+        break;

+    case PNG_COLOR_TYPE_RGB_ALPHA:

+        if(bit_depth != 8 && bit_depth != 16)

             png_error(png_ptr, "Invalid bit depth for RGBA image");

-         png_ptr->channels = 4;

-         break;

-      default:

-         png_error(png_ptr, "Invalid image color type specified");

-   }

-

-   if (compression_type != PNG_COMPRESSION_TYPE_BASE)

-   {

-      png_warning(png_ptr, "Invalid compression type specified");

-      compression_type = PNG_COMPRESSION_TYPE_BASE;

-   }

-

-   /* Write filter_method 64 (intrapixel differencing) only if

-    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

-    * 2. Libpng did not write a PNG signature (this filter_method is only

-    *    used in PNG datastreams that are embedded in MNG datastreams) and

-    * 3. The application called png_permit_mng_features with a mask that

-    *    included PNG_FLAG_MNG_FILTER_64 and

-    * 4. The filter_method is 64 and

-    * 5. The color_type is RGB or RGBA

-    */

-   if (

+        png_ptr->channels = 4;

+        break;

+    default:

+        png_error(png_ptr, "Invalid image color type specified");

+    }

+

+    if(compression_type != PNG_COMPRESSION_TYPE_BASE)

+    {

+        png_warning(png_ptr, "Invalid compression type specified");

+        compression_type = PNG_COMPRESSION_TYPE_BASE;

+    }

+

+    /* Write filter_method 64 (intrapixel differencing) only if

+     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

+     * 2. Libpng did not write a PNG signature (this filter_method is only

+     *    used in PNG datastreams that are embedded in MNG datastreams) and

+     * 3. The application called png_permit_mng_features with a mask that

+     *    included PNG_FLAG_MNG_FILTER_64 and

+     * 4. The filter_method is 64 and

+     * 5. The color_type is RGB or RGBA

+     */

+    if(

 #ifdef PNG_MNG_FEATURES_SUPPORTED

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

-      ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&

-      (color_type == PNG_COLOR_TYPE_RGB ||

-       color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&

-      (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&

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

+          ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&

+          (color_type == PNG_COLOR_TYPE_RGB ||

+           color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&

+          (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&

 #endif

-      filter_type != PNG_FILTER_TYPE_BASE)

-   {

-      png_warning(png_ptr, "Invalid filter type specified");

-      filter_type = PNG_FILTER_TYPE_BASE;

-   }

+        filter_type != PNG_FILTER_TYPE_BASE)

+    {

+        png_warning(png_ptr, "Invalid filter type specified");

+        filter_type = PNG_FILTER_TYPE_BASE;

+    }

 

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   if (interlace_type != PNG_INTERLACE_NONE &&

-      interlace_type != PNG_INTERLACE_ADAM7)

-   {

-      png_warning(png_ptr, "Invalid interlace type specified");

-      interlace_type = PNG_INTERLACE_ADAM7;

-   }

+    if(interlace_type != PNG_INTERLACE_NONE &&

+       interlace_type != PNG_INTERLACE_ADAM7)

+    {

+        png_warning(png_ptr, "Invalid interlace type specified");

+        interlace_type = PNG_INTERLACE_ADAM7;

+    }

 #else

-   interlace_type=PNG_INTERLACE_NONE;

+    interlace_type = PNG_INTERLACE_NONE;

 #endif

 

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

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

 #ifdef PNG_MNG_FEATURES_SUPPORTED

-   png_ptr->filter_type = (png_byte)filter_type;

+    png_ptr->filter_type = (png_byte)filter_type;

 #endif

-   png_ptr->compression_type = (png_byte)compression_type;

-   png_ptr->width = width;

-   png_ptr->height = height;

-

-   png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);

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

-   /* Set the usr info, so any transformations can modify it */

-   png_ptr->usr_width = png_ptr->width;

-   png_ptr->usr_bit_depth = png_ptr->bit_depth;

-   png_ptr->usr_channels = png_ptr->channels;

-

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

-   buf[9] = (png_byte)color_type;

-   buf[10] = (png_byte)compression_type;

-   buf[11] = (png_byte)filter_type;

-   buf[12] = (png_byte)interlace_type;

-

-   /* Write the chunk */

-   png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);

-

-   /* Initialize zlib with PNG info */

-   png_ptr->zstream.zalloc = png_zalloc;

-   png_ptr->zstream.zfree = png_zfree;

-   png_ptr->zstream.opaque = (voidpf)png_ptr;

-   if (!(png_ptr->do_filter))

-   {

-      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||

-         png_ptr->bit_depth < 8)

-         png_ptr->do_filter = PNG_FILTER_NONE;

-      else

-         png_ptr->do_filter = PNG_ALL_FILTERS;

-   }

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))

-   {

-      if (png_ptr->do_filter != PNG_FILTER_NONE)

-         png_ptr->zlib_strategy = Z_FILTERED;

-      else

-         png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;

-   }

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))

-      png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))

-      png_ptr->zlib_mem_level = 8;

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))

-      png_ptr->zlib_window_bits = 15;

-   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))

-      png_ptr->zlib_method = 8;

-   ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,

-         png_ptr->zlib_method, png_ptr->zlib_window_bits,

-         png_ptr->zlib_mem_level, png_ptr->zlib_strategy);

-   if (ret != Z_OK)

-   {

-      if (ret == Z_VERSION_ERROR) png_error(png_ptr,

-          "zlib failed to initialize compressor -- version error");

-      if (ret == Z_STREAM_ERROR) png_error(png_ptr,

-           "zlib failed to initialize compressor -- stream error");

-      if (ret == Z_MEM_ERROR) png_error(png_ptr,

-           "zlib failed to initialize compressor -- mem error");

-      png_error(png_ptr, "zlib failed to initialize compressor");

-   }

-   png_ptr->zstream.next_out = png_ptr->zbuf;

-   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-   /* libpng is not interested in zstream.data_type */

-   /* Set it to a predefined value, to avoid its evaluation inside zlib */

-   png_ptr->zstream.data_type = Z_BINARY;

-

-   png_ptr->mode = PNG_HAVE_IHDR;

+    png_ptr->compression_type = (png_byte)compression_type;

+    png_ptr->width = width;

+    png_ptr->height = height;

+

+    png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);

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

+    /* Set the usr info, so any transformations can modify it */

+    png_ptr->usr_width = png_ptr->width;

+    png_ptr->usr_bit_depth = png_ptr->bit_depth;

+    png_ptr->usr_channels = png_ptr->channels;

+

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

+    buf[9] = (png_byte)color_type;

+    buf[10] = (png_byte)compression_type;

+    buf[11] = (png_byte)filter_type;

+    buf[12] = (png_byte)interlace_type;

+

+    /* Write the chunk */

+    png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);

+

+    /* Initialize zlib with PNG info */

+    png_ptr->zstream.zalloc = png_zalloc;

+    png_ptr->zstream.zfree = png_zfree;

+    png_ptr->zstream.opaque = (voidpf)png_ptr;

+    if(!(png_ptr->do_filter))

+    {

+        if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||

+           png_ptr->bit_depth < 8)

+            png_ptr->do_filter = PNG_FILTER_NONE;

+        else

+            png_ptr->do_filter = PNG_ALL_FILTERS;

+    }

+    if(!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))

+    {

+        if(png_ptr->do_filter != PNG_FILTER_NONE)

+            png_ptr->zlib_strategy = Z_FILTERED;

+        else

+            png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;

+    }

+    if(!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))

+        png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;

+    if(!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))

+        png_ptr->zlib_mem_level = 8;

+    if(!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))

+        png_ptr->zlib_window_bits = 15;

+    if(!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))

+        png_ptr->zlib_method = 8;

+    ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,

+                       png_ptr->zlib_method, png_ptr->zlib_window_bits,

+                       png_ptr->zlib_mem_level, png_ptr->zlib_strategy);

+    if(ret != Z_OK)

+    {

+        if(ret == Z_VERSION_ERROR) png_error(png_ptr,

+                                                 "zlib failed to initialize compressor -- version error");

+        if(ret == Z_STREAM_ERROR) png_error(png_ptr,

+                                                "zlib failed to initialize compressor -- stream error");

+        if(ret == Z_MEM_ERROR) png_error(png_ptr,

+                                             "zlib failed to initialize compressor -- mem error");

+        png_error(png_ptr, "zlib failed to initialize compressor");

+    }

+    png_ptr->zstream.next_out = png_ptr->zbuf;

+    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+    /* libpng is not interested in zstream.data_type */

+    /* Set it to a predefined value, to avoid its evaluation inside zlib */

+    png_ptr->zstream.data_type = Z_BINARY;

+

+    png_ptr->mode = PNG_HAVE_IHDR;

 }

 

 /* Write the palette.  We are careful not to trust png_color to be in the

@@ -595,131 +603,131 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
 void /* PRIVATE */

 png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)

 {

-   PNG_PLTE;

-   png_uint_32 i;

-   png_colorp pal_ptr;

-   png_byte buf[3];

+    PNG_PLTE;

+    png_uint_32 i;

+    png_colorp pal_ptr;

+    png_byte buf[3];

 

-   png_debug(1, "in png_write_PLTE");

+    png_debug(1, "in png_write_PLTE");

 

-   if ((

+    if((

 #ifdef PNG_MNG_FEATURES_SUPPORTED

-        !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&

+           !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&

 #endif

-        num_pal == 0) || num_pal > 256)

-   {

-     if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

-     {

-        png_error(png_ptr, "Invalid number of colors in palette");

-     }

-     else

-     {

-        png_warning(png_ptr, "Invalid number of colors in palette");

+           num_pal == 0) || num_pal > 256)

+    {

+        if(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+        {

+            png_error(png_ptr, "Invalid number of colors in palette");

+        }

+        else

+        {

+            png_warning(png_ptr, "Invalid number of colors in palette");

+            return;

+        }

+    }

+

+    if(!(png_ptr->color_type & PNG_COLOR_MASK_COLOR))

+    {

+        png_warning(png_ptr,

+                    "Ignoring request to write a PLTE chunk in grayscale PNG");

         return;

-     }

-   }

-

-   if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))

-   {

-      png_warning(png_ptr,

-        "Ignoring request to write a PLTE chunk in grayscale PNG");

-      return;

-   }

+    }

 

-   png_ptr->num_palette = (png_uint_16)num_pal;

-   png_debug1(3, "num_palette = %d", png_ptr->num_palette);

+    png_ptr->num_palette = (png_uint_16)num_pal;

+    png_debug1(3, "num_palette = %d", png_ptr->num_palette);

 

-   png_write_chunk_start(png_ptr, (png_bytep)png_PLTE,

-     (png_uint_32)(num_pal * 3));

+    png_write_chunk_start(png_ptr, (png_bytep)png_PLTE,

+                          (png_uint_32)(num_pal * 3));

 #ifdef PNG_POINTER_INDEXING_SUPPORTED

-   for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)

-   {

-      buf[0] = pal_ptr->red;

-      buf[1] = pal_ptr->green;

-      buf[2] = pal_ptr->blue;

-      png_write_chunk_data(png_ptr, buf, (png_size_t)3);

-   }

+    for(i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)

+    {

+        buf[0] = pal_ptr->red;

+        buf[1] = pal_ptr->green;

+        buf[2] = pal_ptr->blue;

+        png_write_chunk_data(png_ptr, buf, (png_size_t)3);

+    }

 #else

-   /* This is a little slower but some buggy compilers need to do this

-    * instead

-    */

-   pal_ptr=palette;

-   for (i = 0; i < num_pal; i++)

-   {

-      buf[0] = pal_ptr[i].red;

-      buf[1] = pal_ptr[i].green;

-      buf[2] = pal_ptr[i].blue;

-      png_write_chunk_data(png_ptr, buf, (png_size_t)3);

-   }

+    /* This is a little slower but some buggy compilers need to do this

+     * instead

+     */

+    pal_ptr = palette;

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

+    {

+        buf[0] = pal_ptr[i].red;

+        buf[1] = pal_ptr[i].green;

+        buf[2] = pal_ptr[i].blue;

+        png_write_chunk_data(png_ptr, buf, (png_size_t)3);

+    }

 #endif

-   png_write_chunk_end(png_ptr);

-   png_ptr->mode |= PNG_HAVE_PLTE;

+    png_write_chunk_end(png_ptr);

+    png_ptr->mode |= PNG_HAVE_PLTE;

 }

 

 /* Write an IDAT chunk */

 void /* PRIVATE */

 png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)

 {

-   PNG_IDAT;

+    PNG_IDAT;

 

-   png_debug(1, "in png_write_IDAT");

+    png_debug(1, "in png_write_IDAT");

 

-   /* Optimize the CMF field in the zlib stream. */

-   /* This hack of the zlib stream is compliant to the stream specification. */

-   if (!(png_ptr->mode & PNG_HAVE_IDAT) &&

+    /* Optimize the CMF field in the zlib stream. */

+    /* This hack of the zlib stream is compliant to the stream specification. */

+    if(!(png_ptr->mode & PNG_HAVE_IDAT) &&

        png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)

-   {

-      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.

-          */

-         if (length >= 2 &&

-             png_ptr->height < 16384 && png_ptr->width < 16384)

-         {

-            png_uint_32 uncompressed_idat_size = png_ptr->height *

-               ((png_ptr->width *

-               png_ptr->channels * png_ptr->bit_depth + 15) >> 3);

-            unsigned int z_cinfo = z_cmf >> 4;

-            unsigned int half_z_window_size = 1 << (z_cinfo + 7);

-            while (uncompressed_idat_size <= half_z_window_size &&

-                   half_z_window_size >= 256)

-            {

-               z_cinfo--;

-               half_z_window_size >>= 1;

-            }

-            z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);

-            if (data[0] != (png_byte)z_cmf)

+    {

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

+             */

+            if(length >= 2 &&

+               png_ptr->height < 16384 && png_ptr->width < 16384)

             {

-               data[0] = (png_byte)z_cmf;

-               data[1] &= 0xe0;

-               data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f);

+                png_uint_32 uncompressed_idat_size = png_ptr->height *

+                                                     ((png_ptr->width *

+                                                       png_ptr->channels * png_ptr->bit_depth + 15) >> 3);

+                unsigned int z_cinfo = z_cmf >> 4;

+                unsigned int half_z_window_size = 1 << (z_cinfo + 7);

+                while(uncompressed_idat_size <= half_z_window_size &&

+                      half_z_window_size >= 256)

+                {

+                    z_cinfo--;

+                    half_z_window_size >>= 1;

+                }

+                z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);

+                if(data[0] != (png_byte)z_cmf)

+                {

+                    data[0] = (png_byte)z_cmf;

+                    data[1] &= 0xe0;

+                    data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f);

+                }

             }

-         }

-      }

-      else

-         png_error(png_ptr,

-            "Invalid zlib compression method or flags in IDAT");

-   }

-

-   png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length);

-   png_ptr->mode |= PNG_HAVE_IDAT;

+        }

+        else

+            png_error(png_ptr,

+                      "Invalid zlib compression method or flags in IDAT");

+    }

+

+    png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length);

+    png_ptr->mode |= PNG_HAVE_IDAT;

 }

 

 /* Write an IEND chunk */

 void /* PRIVATE */

 png_write_IEND(png_structp png_ptr)

 {

-   PNG_IEND;

+    PNG_IEND;

 

-   png_debug(1, "in png_write_IEND");

+    png_debug(1, "in png_write_IEND");

 

-   png_write_chunk(png_ptr, (png_bytep)png_IEND, NULL,

-     (png_size_t)0);

-   png_ptr->mode |= PNG_HAVE_IEND;

+    png_write_chunk(png_ptr, (png_bytep)png_IEND, NULL,

+                    (png_size_t)0);

+    png_ptr->mode |= PNG_HAVE_IEND;

 }

 

 #ifdef PNG_WRITE_gAMA_SUPPORTED

@@ -728,30 +736,30 @@ png_write_IEND(png_structp png_ptr)
 void /* PRIVATE */

 png_write_gAMA(png_structp png_ptr, double file_gamma)

 {

-   PNG_gAMA;

-   png_uint_32 igamma;

-   png_byte buf[4];

+    PNG_gAMA;

+    png_uint_32 igamma;

+    png_byte buf[4];

 

-   png_debug(1, "in png_write_gAMA");

+    png_debug(1, "in png_write_gAMA");

 

-   /* file_gamma is saved in 1/100,000ths */

-   igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);

-   png_save_uint_32(buf, igamma);

-   png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);

+    /* file_gamma is saved in 1/100,000ths */

+    igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);

+    png_save_uint_32(buf, igamma);

+    png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);

 }

 #endif

 #ifdef PNG_FIXED_POINT_SUPPORTED

 void /* PRIVATE */

 png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)

 {

-   PNG_gAMA;

-   png_byte buf[4];

+    PNG_gAMA;

+    png_byte buf[4];

 

-   png_debug(1, "in png_write_gAMA");

+    png_debug(1, "in png_write_gAMA");

 

-   /* file_gamma is saved in 1/100,000ths */

-   png_save_uint_32(buf, (png_uint_32)file_gamma);

-   png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);

+    /* file_gamma is saved in 1/100,000ths */

+    png_save_uint_32(buf, (png_uint_32)file_gamma);

+    png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);

 }

 #endif

 #endif

@@ -761,16 +769,16 @@ png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
 void /* PRIVATE */

 png_write_sRGB(png_structp png_ptr, int srgb_intent)

 {

-   PNG_sRGB;

-   png_byte buf[1];

+    PNG_sRGB;

+    png_byte buf[1];

 

-   png_debug(1, "in png_write_sRGB");

+    png_debug(1, "in png_write_sRGB");

 

-   if (srgb_intent >= PNG_sRGB_INTENT_LAST)

-         png_warning(png_ptr,

-            "Invalid sRGB rendering intent specified");

-   buf[0]=(png_byte)srgb_intent;

-   png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);

+    if(srgb_intent >= PNG_sRGB_INTENT_LAST)

+        png_warning(png_ptr,

+                    "Invalid sRGB rendering intent specified");

+    buf[0] = (png_byte)srgb_intent;

+    png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);

 }

 #endif

 

@@ -778,78 +786,78 @@ png_write_sRGB(png_structp png_ptr, int srgb_intent)
 /* 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)

+               png_charp profile, int profile_len)

 {

-   PNG_iCCP;

-   png_size_t name_len;

-   png_charp new_name;

-   compression_state comp;

-   int embedded_profile_len = 0;

-

-   png_debug(1, "in png_write_iCCP");

-

-   comp.num_output_ptr = 0;

-   comp.max_output_ptr = 0;

-   comp.output_ptr = NULL;

-   comp.input = NULL;

-   comp.input_len = 0;

-

-   if ((name_len = png_check_keyword(png_ptr, name,

-      &new_name)) == 0)

-      return;

-

-   if (compression_type != PNG_COMPRESSION_TYPE_BASE)

-      png_warning(png_ptr, "Unknown compression type in iCCP chunk");

-

-   if (profile == NULL)

-      profile_len = 0;

-

-   if (profile_len > 3)

-      embedded_profile_len =

-          ((*( (png_bytep)profile    ))<<24) |

-          ((*( (png_bytep)profile + 1))<<16) |

-          ((*( (png_bytep)profile + 2))<< 8) |

-          ((*( (png_bytep)profile + 3))    );

-

-   if (embedded_profile_len < 0)

-   {

-      png_warning(png_ptr,

-        "Embedded profile length in iCCP chunk is negative");

-      png_free(png_ptr, new_name);

-      return;

-   }

-

-   if (profile_len < embedded_profile_len)

-   {

-      png_warning(png_ptr,

-        "Embedded profile length too large in iCCP chunk");

-      png_free(png_ptr, new_name);

-      return;

-   }

-

-   if (profile_len > embedded_profile_len)

-   {

-      png_warning(png_ptr,

-        "Truncating profile to actual length in iCCP chunk");

-      profile_len = embedded_profile_len;

-   }

-

-   if (profile_len)

-      profile_len = png_text_compress(png_ptr, profile,

-        (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);

-

-   /* Make sure we include the NULL after the name and the compression type */

-   png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,

-          (png_uint_32)(name_len + profile_len + 2));

-   new_name[name_len + 1] = 0x00;

-   png_write_chunk_data(png_ptr, (png_bytep)new_name,

-     (png_size_t)(name_len + 2));

-

-   if (profile_len)

-      png_write_compressed_data_out(png_ptr, &comp);

-

-   png_write_chunk_end(png_ptr);

-   png_free(png_ptr, new_name);

+    PNG_iCCP;

+    png_size_t name_len;

+    png_charp new_name;

+    compression_state comp;

+    int embedded_profile_len = 0;

+

+    png_debug(1, "in png_write_iCCP");

+

+    comp.num_output_ptr = 0;

+    comp.max_output_ptr = 0;

+    comp.output_ptr = NULL;

+    comp.input = NULL;

+    comp.input_len = 0;

+

+    if((name_len = png_check_keyword(png_ptr, name,

+                                     &new_name)) == 0)

+        return;

+

+    if(compression_type != PNG_COMPRESSION_TYPE_BASE)

+        png_warning(png_ptr, "Unknown compression type in iCCP chunk");

+

+    if(profile == NULL)

+        profile_len = 0;

+

+    if(profile_len > 3)

+        embedded_profile_len =

+            ((*((png_bytep)profile)) << 24) |

+            ((*((png_bytep)profile + 1)) << 16) |

+            ((*((png_bytep)profile + 2)) << 8) |

+            ((*((png_bytep)profile + 3)));

+

+    if(embedded_profile_len < 0)

+    {

+        png_warning(png_ptr,

+                    "Embedded profile length in iCCP chunk is negative");

+        png_free(png_ptr, new_name);

+        return;

+    }

+

+    if(profile_len < embedded_profile_len)

+    {

+        png_warning(png_ptr,

+                    "Embedded profile length too large in iCCP chunk");

+        png_free(png_ptr, new_name);

+        return;

+    }

+

+    if(profile_len > embedded_profile_len)

+    {

+        png_warning(png_ptr,

+                    "Truncating profile to actual length in iCCP chunk");

+        profile_len = embedded_profile_len;

+    }

+

+    if(profile_len)

+        profile_len = png_text_compress(png_ptr, profile,

+                                        (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);

+

+    /* Make sure we include the NULL after the name and the compression type */

+    png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,

+                          (png_uint_32)(name_len + profile_len + 2));

+    new_name[name_len + 1] = 0x00;

+    png_write_chunk_data(png_ptr, (png_bytep)new_name,

+                         (png_size_t)(name_len + 2));

+

+    if(profile_len)

+        png_write_compressed_data_out(png_ptr, &comp);

+

+    png_write_chunk_end(png_ptr);

+    png_free(png_ptr, new_name);

 }

 #endif

 

@@ -858,77 +866,77 @@ png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
 void /* PRIVATE */

 png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)

 {

-   PNG_sPLT;

-   png_size_t name_len;

-   png_charp new_name;

-   png_byte entrybuf[10];

-   png_size_t entry_size = (spalette->depth == 8 ? 6 : 10);

-   png_size_t palette_size = entry_size * spalette->nentries;

-   png_sPLT_entryp ep;

+    PNG_sPLT;

+    png_size_t name_len;

+    png_charp new_name;

+    png_byte entrybuf[10];

+    png_size_t entry_size = (spalette->depth == 8 ? 6 : 10);

+    png_size_t palette_size = entry_size * spalette->nentries;

+    png_sPLT_entryp ep;

 #ifndef PNG_POINTER_INDEXING_SUPPORTED

-   int i;

+    int i;

 #endif

 

-   png_debug(1, "in png_write_sPLT");

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

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

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

 #ifdef PNG_POINTER_INDEXING_SUPPORTED

-   for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)

-   {

-      if (spalette->depth == 8)

-      {

-          entrybuf[0] = (png_byte)ep->red;

-          entrybuf[1] = (png_byte)ep->green;

-          entrybuf[2] = (png_byte)ep->blue;

-          entrybuf[3] = (png_byte)ep->alpha;

-          png_save_uint_16(entrybuf + 4, ep->frequency);

-      }

-      else

-      {

-          png_save_uint_16(entrybuf + 0, ep->red);

-          png_save_uint_16(entrybuf + 2, ep->green);

-          png_save_uint_16(entrybuf + 4, ep->blue);

-          png_save_uint_16(entrybuf + 6, ep->alpha);

-          png_save_uint_16(entrybuf + 8, ep->frequency);

-      }

-      png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);

-   }

+    for(ep = spalette->entries; ep < spalette->entries + spalette->nentries; ep++)

+    {

+        if(spalette->depth == 8)

+        {

+            entrybuf[0] = (png_byte)ep->red;

+            entrybuf[1] = (png_byte)ep->green;

+            entrybuf[2] = (png_byte)ep->blue;

+            entrybuf[3] = (png_byte)ep->alpha;

+            png_save_uint_16(entrybuf + 4, ep->frequency);

+        }

+        else

+        {

+            png_save_uint_16(entrybuf + 0, ep->red);

+            png_save_uint_16(entrybuf + 2, ep->green);

+            png_save_uint_16(entrybuf + 4, ep->blue);

+            png_save_uint_16(entrybuf + 6, ep->alpha);

+            png_save_uint_16(entrybuf + 8, ep->frequency);

+        }

+        png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);

+    }

 #else

-   ep=spalette->entries;

-   for (i=0; i>spalette->nentries; i++)

-   {

-      if (spalette->depth == 8)

-      {

-          entrybuf[0] = (png_byte)ep[i].red;

-          entrybuf[1] = (png_byte)ep[i].green;

-          entrybuf[2] = (png_byte)ep[i].blue;

-          entrybuf[3] = (png_byte)ep[i].alpha;

-          png_save_uint_16(entrybuf + 4, ep[i].frequency);

-      }

-      else

-      {

-          png_save_uint_16(entrybuf + 0, ep[i].red);

-          png_save_uint_16(entrybuf + 2, ep[i].green);

-          png_save_uint_16(entrybuf + 4, ep[i].blue);

-          png_save_uint_16(entrybuf + 6, ep[i].alpha);

-          png_save_uint_16(entrybuf + 8, ep[i].frequency);

-      }

-      png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);

-   }

+    ep = spalette->entries;

+    for(i = 0; i > spalette->nentries; i++)

+    {

+        if(spalette->depth == 8)

+        {

+            entrybuf[0] = (png_byte)ep[i].red;

+            entrybuf[1] = (png_byte)ep[i].green;

+            entrybuf[2] = (png_byte)ep[i].blue;

+            entrybuf[3] = (png_byte)ep[i].alpha;

+            png_save_uint_16(entrybuf + 4, ep[i].frequency);

+        }

+        else

+        {

+            png_save_uint_16(entrybuf + 0, ep[i].red);

+            png_save_uint_16(entrybuf + 2, ep[i].green);

+            png_save_uint_16(entrybuf + 4, ep[i].blue);

+            png_save_uint_16(entrybuf + 6, ep[i].alpha);

+            png_save_uint_16(entrybuf + 8, ep[i].frequency);

+        }

+        png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);

+    }

 #endif

 

-   png_write_chunk_end(png_ptr);

-   png_free(png_ptr, new_name);

+    png_write_chunk_end(png_ptr);

+    png_free(png_ptr, new_name);

 }

 #endif

 

@@ -937,53 +945,53 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
 void /* PRIVATE */

 png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)

 {

-   PNG_sBIT;

-   png_byte buf[4];

-   png_size_t size;

-

-   png_debug(1, "in png_write_sBIT");

-

-   /* Make sure we don't depend upon the order of PNG_COLOR_8 */

-   if (color_type & PNG_COLOR_MASK_COLOR)

-   {

-      png_byte maxbits;

-

-      maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :

-                png_ptr->usr_bit_depth);

-      if (sbit->red == 0 || sbit->red > maxbits ||

-          sbit->green == 0 || sbit->green > maxbits ||

-          sbit->blue == 0 || sbit->blue > maxbits)

-      {

-         png_warning(png_ptr, "Invalid sBIT depth specified");

-         return;

-      }

-      buf[0] = sbit->red;

-      buf[1] = sbit->green;

-      buf[2] = sbit->blue;

-      size = 3;

-   }

-   else

-   {

-      if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)

-      {

-         png_warning(png_ptr, "Invalid sBIT depth specified");

-         return;

-      }

-      buf[0] = sbit->gray;

-      size = 1;

-   }

-

-   if (color_type & PNG_COLOR_MASK_ALPHA)

-   {

-      if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)

-      {

-         png_warning(png_ptr, "Invalid sBIT depth specified");

-         return;

-      }

-      buf[size++] = sbit->alpha;

-   }

-

-   png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);

+    PNG_sBIT;

+    png_byte buf[4];

+    png_size_t size;

+

+    png_debug(1, "in png_write_sBIT");

+

+    /* Make sure we don't depend upon the order of PNG_COLOR_8 */

+    if(color_type & PNG_COLOR_MASK_COLOR)

+    {

+        png_byte maxbits;

+

+        maxbits = (png_byte)(color_type == PNG_COLOR_TYPE_PALETTE ? 8 :

+                             png_ptr->usr_bit_depth);

+        if(sbit->red == 0 || sbit->red > maxbits ||

+           sbit->green == 0 || sbit->green > maxbits ||

+           sbit->blue == 0 || sbit->blue > maxbits)

+        {

+            png_warning(png_ptr, "Invalid sBIT depth specified");

+            return;

+        }

+        buf[0] = sbit->red;

+        buf[1] = sbit->green;

+        buf[2] = sbit->blue;

+        size = 3;

+    }

+    else

+    {

+        if(sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)

+        {

+            png_warning(png_ptr, "Invalid sBIT depth specified");

+            return;

+        }

+        buf[0] = sbit->gray;

+        size = 1;

+    }

+

+    if(color_type & PNG_COLOR_MASK_ALPHA)

+    {

+        if(sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)

+        {

+            png_warning(png_ptr, "Invalid sBIT depth specified");

+            return;

+        }

+        buf[size++] = sbit->alpha;

+    }

+

+    png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);

 }

 #endif

 

@@ -992,81 +1000,81 @@ png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
 #ifdef PNG_FLOATING_POINT_SUPPORTED

 void /* PRIVATE */

 png_write_cHRM(png_structp png_ptr, double white_x, double white_y,

-   double red_x, double red_y, double green_x, double green_y,

-   double blue_x, double blue_y)

+               double red_x, double red_y, double green_x, double green_y,

+               double blue_x, double blue_y)

 {

-   PNG_cHRM;

-   png_byte buf[32];

+    PNG_cHRM;

+    png_byte buf[32];

 

-   png_fixed_point 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_fixed_point 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_debug(1, "in png_write_cHRM");

+    png_debug(1, "in png_write_cHRM");

 

-   int_white_x = (png_uint_32)(white_x * 100000.0 + 0.5);

-   int_white_y = (png_uint_32)(white_y * 100000.0 + 0.5);

-   int_red_x   = (png_uint_32)(red_x   * 100000.0 + 0.5);

-   int_red_y   = (png_uint_32)(red_y   * 100000.0 + 0.5);

-   int_green_x = (png_uint_32)(green_x * 100000.0 + 0.5);

-   int_green_y = (png_uint_32)(green_y * 100000.0 + 0.5);

-   int_blue_x  = (png_uint_32)(blue_x  * 100000.0 + 0.5);

-   int_blue_y  = (png_uint_32)(blue_y  * 100000.0 + 0.5);

+    int_white_x = (png_uint_32)(white_x * 100000.0 + 0.5);

+    int_white_y = (png_uint_32)(white_y * 100000.0 + 0.5);

+    int_red_x   = (png_uint_32)(red_x   * 100000.0 + 0.5);

+    int_red_y   = (png_uint_32)(red_y   * 100000.0 + 0.5);

+    int_green_x = (png_uint_32)(green_x * 100000.0 + 0.5);

+    int_green_y = (png_uint_32)(green_y * 100000.0 + 0.5);

+    int_blue_x  = (png_uint_32)(blue_x  * 100000.0 + 0.5);

+    int_blue_y  = (png_uint_32)(blue_y  * 100000.0 + 0.5);

 

 #ifdef PNG_CHECK_cHRM_SUPPORTED

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

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

 #endif

-   {

-      /* Each value is saved in 1/100,000ths */

+    {

+        /* 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, 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

 #ifdef PNG_FIXED_POINT_SUPPORTED

 void /* PRIVATE */

 png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,

-   png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,

-   png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,

-   png_fixed_point blue_y)

+                     png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,

+                     png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,

+                     png_fixed_point blue_y)

 {

-   PNG_cHRM;

-   png_byte buf[32];

+    PNG_cHRM;

+    png_byte buf[32];

 

-   png_debug(1, "in png_write_cHRM");

+    png_debug(1, "in png_write_cHRM");

 

-   /* Each value is saved in 1/100,000ths */

+    /* Each value is saved in 1/100,000ths */

 #ifdef PNG_CHECK_cHRM_SUPPORTED

-   if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y,

-      green_x, green_y, blue_x, blue_y))

+    if(png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y,

+                            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

@@ -1075,54 +1083,54 @@ png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
 /* Write the tRNS chunk */

 void /* PRIVATE */

 png_write_tRNS(png_structp png_ptr, png_bytep trans_alpha, png_color_16p tran,

-   int num_trans, int color_type)

+               int num_trans, int color_type)

 {

-   PNG_tRNS;

-   png_byte buf[6];

-

-   png_debug(1, "in png_write_tRNS");

-

-   if (color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)

-      {

-         png_warning(png_ptr, "Invalid number of transparent colors specified");

-         return;

-      }

-      /* Write the chunk out as it is */

-      png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans_alpha,

-        (png_size_t)num_trans);

-   }

-   else if (color_type == PNG_COLOR_TYPE_GRAY)

-   {

-      /* One 16 bit value */

-      if (tran->gray >= (1 << png_ptr->bit_depth))

-      {

-         png_warning(png_ptr,

-           "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");

-         return;

-      }

-      png_save_uint_16(buf, tran->gray);

-      png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);

-   }

-   else if (color_type == PNG_COLOR_TYPE_RGB)

-   {

-      /* Three 16 bit values */

-      png_save_uint_16(buf, tran->red);

-      png_save_uint_16(buf + 2, tran->green);

-      png_save_uint_16(buf + 4, tran->blue);

-      if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))

-      {

-         png_warning(png_ptr,

-           "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");

-         return;

-      }

-      png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);

-   }

-   else

-   {

-      png_warning(png_ptr, "Can't write tRNS with an alpha channel");

-   }

+    PNG_tRNS;

+    png_byte buf[6];

+

+    png_debug(1, "in png_write_tRNS");

+

+    if(color_type == PNG_COLOR_TYPE_PALETTE)

+    {

+        if(num_trans <= 0 || num_trans > (int)png_ptr->num_palette)

+        {

+            png_warning(png_ptr, "Invalid number of transparent colors specified");

+            return;

+        }

+        /* Write the chunk out as it is */

+        png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans_alpha,

+                        (png_size_t)num_trans);

+    }

+    else if(color_type == PNG_COLOR_TYPE_GRAY)

+    {

+        /* One 16 bit value */

+        if(tran->gray >= (1 << png_ptr->bit_depth))

+        {

+            png_warning(png_ptr,

+                        "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");

+            return;

+        }

+        png_save_uint_16(buf, tran->gray);

+        png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);

+    }

+    else if(color_type == PNG_COLOR_TYPE_RGB)

+    {

+        /* Three 16 bit values */

+        png_save_uint_16(buf, tran->red);

+        png_save_uint_16(buf + 2, tran->green);

+        png_save_uint_16(buf + 4, tran->blue);

+        if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))

+        {

+            png_warning(png_ptr,

+                        "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");

+            return;

+        }

+        png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);

+    }

+    else

+    {

+        png_warning(png_ptr, "Can't write tRNS with an alpha channel");

+    }

 }

 #endif

 

@@ -1131,50 +1139,50 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans_alpha, png_color_16p tran,
 void /* PRIVATE */

 png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)

 {

-   PNG_bKGD;

-   png_byte buf[6];

+    PNG_bKGD;

+    png_byte buf[6];

 

-   png_debug(1, "in png_write_bKGD");

+    png_debug(1, "in png_write_bKGD");

 

-   if (color_type == PNG_COLOR_TYPE_PALETTE)

-   {

-      if (

+    if(color_type == PNG_COLOR_TYPE_PALETTE)

+    {

+        if(

 #ifdef PNG_MNG_FEATURES_SUPPORTED

-          (png_ptr->num_palette ||

-          (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&

+            (png_ptr->num_palette ||

+             (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&

 #endif

-         back->index >= png_ptr->num_palette)

-      {

-         png_warning(png_ptr, "Invalid background palette index");

-         return;

-      }

-      buf[0] = back->index;

-      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1);

-   }

-   else if (color_type & PNG_COLOR_MASK_COLOR)

-   {

-      png_save_uint_16(buf, back->red);

-      png_save_uint_16(buf + 2, back->green);

-      png_save_uint_16(buf + 4, back->blue);

-      if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))

-      {

-         png_warning(png_ptr,

-           "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");

-         return;

-      }

-      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6);

-   }

-   else

-   {

-      if (back->gray >= (1 << png_ptr->bit_depth))

-      {

-         png_warning(png_ptr,

-           "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");

-         return;

-      }

-      png_save_uint_16(buf, back->gray);

-      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2);

-   }

+            back->index >= png_ptr->num_palette)

+        {

+            png_warning(png_ptr, "Invalid background palette index");

+            return;

+        }

+        buf[0] = back->index;

+        png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1);

+    }

+    else if(color_type & PNG_COLOR_MASK_COLOR)

+    {

+        png_save_uint_16(buf, back->red);

+        png_save_uint_16(buf + 2, back->green);

+        png_save_uint_16(buf + 4, back->blue);

+        if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))

+        {

+            png_warning(png_ptr,

+                        "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");

+            return;

+        }

+        png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6);

+    }

+    else

+    {

+        if(back->gray >= (1 << png_ptr->bit_depth))

+        {

+            png_warning(png_ptr,

+                        "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");

+            return;

+        }

+        png_save_uint_16(buf, back->gray);

+        png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2);

+    }

 }

 #endif

 

@@ -1183,28 +1191,28 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
 void /* PRIVATE */

 png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)

 {

-   PNG_hIST;

-   int i;

-   png_byte buf[3];

-

-   png_debug(1, "in png_write_hIST");

-

-   if (num_hist > (int)png_ptr->num_palette)

-   {

-      png_debug2(3, "num_hist = %d, num_palette = %d", num_hist,

-         png_ptr->num_palette);

-      png_warning(png_ptr, "Invalid number of histogram entries specified");

-      return;

-   }

-

-   png_write_chunk_start(png_ptr, (png_bytep)png_hIST,

-     (png_uint_32)(num_hist * 2));

-   for (i = 0; i < num_hist; i++)

-   {

-      png_save_uint_16(buf, hist[i]);

-      png_write_chunk_data(png_ptr, buf, (png_size_t)2);

-   }

-   png_write_chunk_end(png_ptr);

+    PNG_hIST;

+    int i;

+    png_byte buf[3];

+

+    png_debug(1, "in png_write_hIST");

+

+    if(num_hist > (int)png_ptr->num_palette)

+    {

+        png_debug2(3, "num_hist = %d, num_palette = %d", num_hist,

+                   png_ptr->num_palette);

+        png_warning(png_ptr, "Invalid number of histogram entries specified");

+        return;

+    }

+

+    png_write_chunk_start(png_ptr, (png_bytep)png_hIST,

+                          (png_uint_32)(num_hist * 2));

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

+    {

+        png_save_uint_16(buf, hist[i]);

+        png_write_chunk_data(png_ptr, buf, (png_size_t)2);

+    }

+    png_write_chunk_end(png_ptr);

 }

 #endif

 

@@ -1223,119 +1231,119 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
 png_size_t /* PRIVATE */

 png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)

 {

-   png_size_t key_len;

-   png_charp kp, dp;

-   int kflag;

-   int kwarn=0;

-

-   png_debug(1, "in png_check_keyword");

-

-   *new_key = NULL;

-

-   if (key == NULL || (key_len = png_strlen(key)) == 0)

-   {

-      png_warning(png_ptr, "zero length keyword");

-      return ((png_size_t)0);

-   }

-

-   png_debug1(2, "Keyword to be checked is '%s'", key);

-

-   *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2));

-   if (*new_key == NULL)

-   {

-      png_warning(png_ptr, "Out of memory while procesing keyword");

-      return ((png_size_t)0);

-   }

-

-   /* Replace non-printing characters with a blank and print a warning */

-   for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)

-   {

-      if ((png_byte)*kp < 0x20 ||

-         ((png_byte)*kp > 0x7E && (png_byte)*kp < 0xA1))

-      {

+    png_size_t key_len;

+    png_charp kp, dp;

+    int kflag;

+    int kwarn = 0;

+

+    png_debug(1, "in png_check_keyword");

+

+    *new_key = NULL;

+

+    if(key == NULL || (key_len = png_strlen(key)) == 0)

+    {

+        png_warning(png_ptr, "zero length keyword");

+        return ((png_size_t)0);

+    }

+

+    png_debug1(2, "Keyword to be checked is '%s'", key);

+

+    *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2));

+    if(*new_key == NULL)

+    {

+        png_warning(png_ptr, "Out of memory while procesing keyword");

+        return ((png_size_t)0);

+    }

+

+    /* Replace non-printing characters with a blank and print a warning */

+    for(kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)

+    {

+        if((png_byte)*kp < 0x20 ||

+           ((png_byte)*kp > 0x7E && (png_byte)*kp < 0xA1))

+        {

 #ifdef PNG_STDIO_SUPPORTED

-         char msg[40];

+            char msg[40];

 

-         png_snprintf(msg, 40,

-           "invalid keyword character 0x%02X", (png_byte)*kp);

-         png_warning(png_ptr, msg);

+            png_snprintf(msg, 40,

+                         "invalid keyword character 0x%02X", (png_byte)*kp);

+            png_warning(png_ptr, msg);

 #else

-         png_warning(png_ptr, "invalid character in keyword");

+            png_warning(png_ptr, "invalid character in keyword");

 #endif

-         *dp = ' ';

-      }

-      else

-      {

-         *dp = *kp;

-      }

-   }

-   *dp = '\0';

-

-   /* Remove any trailing white space. */

-   kp = *new_key + key_len - 1;

-   if (*kp == ' ')

-   {

-      png_warning(png_ptr, "trailing spaces removed from keyword");

-

-      while (*kp == ' ')

-      {

-         *(kp--) = '\0';

-         key_len--;

-      }

-   }

-

-   /* Remove any leading white space. */

-   kp = *new_key;

-   if (*kp == ' ')

-   {

-      png_warning(png_ptr, "leading spaces removed from keyword");

-

-      while (*kp == ' ')

-      {

-         kp++;

-         key_len--;

-      }

-   }

-

-   png_debug1(2, "Checking for multiple internal spaces in '%s'", kp);

-

-   /* Remove multiple internal spaces. */

-   for (kflag = 0, dp = *new_key; *kp != '\0'; kp++)

-   {

-      if (*kp == ' ' && kflag == 0)

-      {

-         *(dp++) = *kp;

-         kflag = 1;

-      }

-      else if (*kp == ' ')

-      {

-         key_len--;

-         kwarn=1;

-      }

-      else

-      {

-         *(dp++) = *kp;

-         kflag = 0;

-      }

-   }

-   *dp = '\0';

-   if (kwarn)

-      png_warning(png_ptr, "extra interior spaces removed from keyword");

-

-   if (key_len == 0)

-   {

-      png_free(png_ptr, *new_key);

-      png_warning(png_ptr, "Zero length keyword");

-   }

-

-   if (key_len > 79)

-   {

-      png_warning(png_ptr, "keyword length must be 1 - 79 characters");

-      (*new_key)[79] = '\0';

-      key_len = 79;

-   }

-

-   return (key_len);

+            *dp = ' ';

+        }

+        else

+        {

+            *dp = *kp;

+        }

+    }

+    *dp = '\0';

+

+    /* Remove any trailing white space. */

+    kp = *new_key + key_len - 1;

+    if(*kp == ' ')

+    {

+        png_warning(png_ptr, "trailing spaces removed from keyword");

+

+        while(*kp == ' ')

+        {

+            *(kp--) = '\0';

+            key_len--;

+        }

+    }

+

+    /* Remove any leading white space. */

+    kp = *new_key;

+    if(*kp == ' ')

+    {

+        png_warning(png_ptr, "leading spaces removed from keyword");

+

+        while(*kp == ' ')

+        {

+            kp++;

+            key_len--;

+        }

+    }

+

+    png_debug1(2, "Checking for multiple internal spaces in '%s'", kp);

+

+    /* Remove multiple internal spaces. */

+    for(kflag = 0, dp = *new_key; *kp != '\0'; kp++)

+    {

+        if(*kp == ' ' && kflag == 0)

+        {

+            *(dp++) = *kp;

+            kflag = 1;

+        }

+        else if(*kp == ' ')

+        {

+            key_len--;

+            kwarn = 1;

+        }

+        else

+        {

+            *(dp++) = *kp;

+            kflag = 0;

+        }

+    }

+    *dp = '\0';

+    if(kwarn)

+        png_warning(png_ptr, "extra interior spaces removed from keyword");

+

+    if(key_len == 0)

+    {

+        png_free(png_ptr, *new_key);

+        png_warning(png_ptr, "Zero length keyword");

+    }

+

+    if(key_len > 79)

+    {

+        png_warning(png_ptr, "keyword length must be 1 - 79 characters");

+        (*new_key)[79] = '\0';

+        key_len = 79;

+    }

+

+    return (key_len);

 }

 #endif

 

@@ -1343,38 +1351,38 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
 /* Write a tEXt chunk */

 void /* PRIVATE */

 png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,

-   png_size_t text_len)

+               png_size_t text_len)

 {

-   PNG_tEXt;

-   png_size_t key_len;

-   png_charp new_key;

-

-   png_debug(1, "in png_write_tEXt");

-

-   if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)

-      return;

-

-   if (text == NULL || *text == '\0')

-      text_len = 0;

-   else

-      text_len = png_strlen(text);

-

-   /* Make sure we include the 0 after the key */

-   png_write_chunk_start(png_ptr, (png_bytep)png_tEXt,

-      (png_uint_32)(key_len + text_len + 1));

-   /*

-    * We leave it to the application to meet PNG-1.0 requirements on the

-    * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of

-    * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.

-    * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.

-    */

-   png_write_chunk_data(png_ptr, (png_bytep)new_key,

-     (png_size_t)(key_len + 1));

-   if (text_len)

-      png_write_chunk_data(png_ptr, (png_bytep)text, (png_size_t)text_len);

-

-   png_write_chunk_end(png_ptr);

-   png_free(png_ptr, new_key);

+    PNG_tEXt;

+    png_size_t key_len;

+    png_charp new_key;

+

+    png_debug(1, "in png_write_tEXt");

+

+    if((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0)

+        return;

+

+    if(text == NULL || *text == '\0')

+        text_len = 0;

+    else

+        text_len = png_strlen(text);

+

+    /* Make sure we include the 0 after the key */

+    png_write_chunk_start(png_ptr, (png_bytep)png_tEXt,

+                          (png_uint_32)(key_len + text_len + 1));

+    /*

+     * We leave it to the application to meet PNG-1.0 requirements on the

+     * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of

+     * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.

+     * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.

+     */

+    png_write_chunk_data(png_ptr, (png_bytep)new_key,

+                         (png_size_t)(key_len + 1));

+    if(text_len)

+        png_write_chunk_data(png_ptr, (png_bytep)text, (png_size_t)text_len);

+

+    png_write_chunk_end(png_ptr);

+    png_free(png_ptr, new_key);

 }

 #endif

 

@@ -1382,57 +1390,57 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
 /* 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)

+               png_size_t text_len, int compression)

 {

-   PNG_zTXt;

-   png_size_t key_len;

-   char buf[1];

-   png_charp new_key;

-   compression_state comp;

-

-   png_debug(1, "in png_write_zTXt");

-

-   comp.num_output_ptr = 0;

-   comp.max_output_ptr = 0;

-   comp.output_ptr = NULL;

-   comp.input = NULL;

-   comp.input_len = 0;

-

-   if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)

-   {

-      png_free(png_ptr, new_key);

-      return;

-   }

-

-   if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE)

-   {

-      png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);

-      png_free(png_ptr, new_key);

-      return;

-   }

-

-   text_len = png_strlen(text);

-

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

-   png_write_chunk_start(png_ptr, (png_bytep)png_zTXt,

-     (png_uint_32)(key_len+text_len + 2));

-   /* Write key */

-   png_write_chunk_data(png_ptr, (png_bytep)new_key,

-     (png_size_t)(key_len + 1));

-   png_free(png_ptr, new_key);

-

-   buf[0] = (png_byte)compression;

-   /* Write compression */

-   png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);

-   /* Write the compressed data */

-   png_write_compressed_data_out(png_ptr, &comp);

-

-   /* Close the chunk */

-   png_write_chunk_end(png_ptr);

+    PNG_zTXt;

+    png_size_t key_len;

+    char buf[1];

+    png_charp new_key;

+    compression_state comp;

+

+    png_debug(1, "in png_write_zTXt");

+

+    comp.num_output_ptr = 0;

+    comp.max_output_ptr = 0;

+    comp.output_ptr = NULL;

+    comp.input = NULL;

+    comp.input_len = 0;

+

+    if((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0)

+    {

+        png_free(png_ptr, new_key);

+        return;

+    }

+

+    if(text == NULL || *text == '\0' || compression == PNG_TEXT_COMPRESSION_NONE)

+    {

+        png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);

+        png_free(png_ptr, new_key);

+        return;

+    }

+

+    text_len = png_strlen(text);

+

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

+    png_write_chunk_start(png_ptr, (png_bytep)png_zTXt,

+                          (png_uint_32)(key_len + text_len + 2));

+    /* Write key */

+    png_write_chunk_data(png_ptr, (png_bytep)new_key,

+                         (png_size_t)(key_len + 1));

+    png_free(png_ptr, new_key);

+

+    buf[0] = (png_byte)compression;

+    /* Write compression */

+    png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);

+    /* Write the compressed data */

+    png_write_compressed_data_out(png_ptr, &comp);

+

+    /* Close the chunk */

+    png_write_chunk_end(png_ptr);

 }

 #endif

 

@@ -1440,86 +1448,86 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
 /* 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)

+               png_charp lang, png_charp lang_key, png_charp text)

 {

-   PNG_iTXt;

-   png_size_t lang_len, key_len, lang_key_len, text_len;

-   png_charp new_lang;

-   png_charp new_key = NULL;

-   png_byte cbuf[2];

-   compression_state comp;

-

-   png_debug(1, "in png_write_iTXt");

-

-   comp.num_output_ptr = 0;

-   comp.max_output_ptr = 0;

-   comp.output_ptr = NULL;

-   comp.input = NULL;

-

-   if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)

-      return;

-

-   if ((lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0)

-   {

-      png_warning(png_ptr, "Empty language field in iTXt chunk");

-      new_lang = NULL;

-      lang_len = 0;

-   }

-

-   if (lang_key == NULL)

-      lang_key_len = 0;

-   else

-      lang_key_len = png_strlen(lang_key);

-

-   if (text == NULL)

-      text_len = 0;

-   else

-      text_len = png_strlen(text);

-

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

-    * and the NULs after the key, lang, and lang_key parts */

-

-   png_write_chunk_start(png_ptr, (png_bytep)png_iTXt,

-          (png_uint_32)(

-        5 /* comp byte, comp flag, terminators for key, lang and lang_key */

-        + key_len

-        + lang_len

-        + lang_key_len

-        + text_len));

-

-   /* We leave it to the application to meet PNG-1.0 requirements on the

-    * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of

-    * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.

-    * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.

-    */

-   png_write_chunk_data(png_ptr, (png_bytep)new_key,

-     (png_size_t)(key_len + 1));

-

-   /* Set the compression flag */

-   if (compression == PNG_ITXT_COMPRESSION_NONE || \

+    PNG_iTXt;

+    png_size_t lang_len, key_len, lang_key_len, text_len;

+    png_charp new_lang;

+    png_charp new_key = NULL;

+    png_byte cbuf[2];

+    compression_state comp;

+

+    png_debug(1, "in png_write_iTXt");

+

+    comp.num_output_ptr = 0;

+    comp.max_output_ptr = 0;

+    comp.output_ptr = NULL;

+    comp.input = NULL;

+

+    if((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0)

+        return;

+

+    if((lang_len = png_check_keyword(png_ptr, lang, &new_lang)) == 0)

+    {

+        png_warning(png_ptr, "Empty language field in iTXt chunk");

+        new_lang = NULL;

+        lang_len = 0;

+    }

+

+    if(lang_key == NULL)

+        lang_key_len = 0;

+    else

+        lang_key_len = png_strlen(lang_key);

+

+    if(text == NULL)

+        text_len = 0;

+    else

+        text_len = png_strlen(text);

+

+    /* 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,

+     * and the NULs after the key, lang, and lang_key parts */

+

+    png_write_chunk_start(png_ptr, (png_bytep)png_iTXt,

+                          (png_uint_32)(

+                              5 /* comp byte, comp flag, terminators for key, lang and lang_key */

+                              + key_len

+                              + lang_len

+                              + lang_key_len

+                              + text_len));

+

+    /* We leave it to the application to meet PNG-1.0 requirements on the

+     * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of

+     * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.

+     * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.

+     */

+    png_write_chunk_data(png_ptr, (png_bytep)new_key,

+                         (png_size_t)(key_len + 1));

+

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

-   cbuf[1] = 0;

-   png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);

-

-   cbuf[0] = 0;

-   png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf),

-     (png_size_t)(lang_len + 1));

-   png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf),

-     (png_size_t)(lang_key_len + 1));

-   png_write_compressed_data_out(png_ptr, &comp);

-

-   png_write_chunk_end(png_ptr);

-   png_free(png_ptr, new_key);

-   png_free(png_ptr, new_lang);

+        cbuf[0] = 0;

+    else /* compression == PNG_ITXT_COMPRESSION_zTXt */

+        cbuf[0] = 1;

+    /* Set the compression method */

+    cbuf[1] = 0;

+    png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);

+

+    cbuf[0] = 0;

+    png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf),

+                         (png_size_t)(lang_len + 1));

+    png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf),

+                         (png_size_t)(lang_key_len + 1));

+    png_write_compressed_data_out(png_ptr, &comp);

+

+    png_write_chunk_end(png_ptr);

+    png_free(png_ptr, new_key);

+    png_free(png_ptr, new_lang);

 }

 #endif

 

@@ -1527,81 +1535,81 @@ png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
 /* 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)

+               int unit_type)

 {

-   PNG_oFFs;

-   png_byte buf[9];

+    PNG_oFFs;

+    png_byte buf[9];

 

-   png_debug(1, "in png_write_oFFs");

+    png_debug(1, "in png_write_oFFs");

 

-   if (unit_type >= PNG_OFFSET_LAST)

-      png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");

+    if(unit_type >= PNG_OFFSET_LAST)

+        png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");

 

-   png_save_int_32(buf, x_offset);

-   png_save_int_32(buf + 4, y_offset);

-   buf[8] = (png_byte)unit_type;

+    png_save_int_32(buf, x_offset);

+    png_save_int_32(buf + 4, y_offset);

+    buf[8] = (png_byte)unit_type;

 

-   png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9);

+    png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9);

 }

 #endif

 #ifdef PNG_WRITE_pCAL_SUPPORTED

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

+               png_int_32 X1, int type, int nparams, png_charp units, png_charpp params)

 {

-   PNG_pCAL;

-   png_size_t purpose_len, units_len, total_len;

-   png_uint_32p params_len;

-   png_byte buf[10];

-   png_charp new_purpose;

-   int i;

-

-   png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);

-

-   if (type >= PNG_EQUATION_LAST)

-      png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");

-

-   purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;

-   png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);

-   units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);

-   png_debug1(3, "pCAL units length = %d", (int)units_len);

-   total_len = purpose_len + units_len + 10;

-

-   params_len = (png_uint_32p)png_malloc(png_ptr,

-      (png_alloc_size_t)(nparams * png_sizeof(png_uint_32)));

-

-   /* Find the length of each parameter, making sure we don't count the

-      null terminator for the last parameter. */

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

-   {

-      params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);

-      png_debug2(3, "pCAL parameter %d length = %lu", i,

-        (unsigned long) params_len[i]);

-      total_len += (png_size_t)params_len[i];

-   }

-

-   png_debug1(3, "pCAL total length = %d", (int)total_len);

-   png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len);

-   png_write_chunk_data(png_ptr, (png_bytep)new_purpose,

-     (png_size_t)purpose_len);

-   png_save_int_32(buf, X0);

-   png_save_int_32(buf + 4, X1);

-   buf[8] = (png_byte)type;

-   buf[9] = (png_byte)nparams;

-   png_write_chunk_data(png_ptr, buf, (png_size_t)10);

-   png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len);

-

-   png_free(png_ptr, new_purpose);

-

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

-   {

-      png_write_chunk_data(png_ptr, (png_bytep)params[i],

-         (png_size_t)params_len[i]);

-   }

-

-   png_free(png_ptr, params_len);

-   png_write_chunk_end(png_ptr);

+    PNG_pCAL;

+    png_size_t purpose_len, units_len, total_len;

+    png_uint_32p params_len;

+    png_byte buf[10];

+    png_charp new_purpose;

+    int i;

+

+    png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);

+

+    if(type >= PNG_EQUATION_LAST)

+        png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");

+

+    purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;

+    png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);

+    units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);

+    png_debug1(3, "pCAL units length = %d", (int)units_len);

+    total_len = purpose_len + units_len + 10;

+

+    params_len = (png_uint_32p)png_malloc(png_ptr,

+                                          (png_alloc_size_t)(nparams * png_sizeof(png_uint_32)));

+

+    /* Find the length of each parameter, making sure we don't count the

+       null terminator for the last parameter. */

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

+    {

+        params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);

+        png_debug2(3, "pCAL parameter %d length = %lu", i,

+                   (unsigned long) params_len[i]);

+        total_len += (png_size_t)params_len[i];

+    }

+

+    png_debug1(3, "pCAL total length = %d", (int)total_len);

+    png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len);

+    png_write_chunk_data(png_ptr, (png_bytep)new_purpose,

+                         (png_size_t)purpose_len);

+    png_save_int_32(buf, X0);

+    png_save_int_32(buf + 4, X1);

+    buf[8] = (png_byte)type;

+    buf[9] = (png_byte)nparams;

+    png_write_chunk_data(png_ptr, buf, (png_size_t)10);

+    png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len);

+

+    png_free(png_ptr, new_purpose);

+

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

+    {

+        png_write_chunk_data(png_ptr, (png_bytep)params[i],

+                             (png_size_t)params_len[i]);

+    }

+

+    png_free(png_ptr, params_len);

+    png_write_chunk_end(png_ptr);

 }

 #endif

 

@@ -1611,48 +1619,48 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
 void /* PRIVATE */

 png_write_sCAL(png_structp png_ptr, int unit, double width, double height)

 {

-   PNG_sCAL;

-   char buf[64];

-   png_size_t total_len;

+    PNG_sCAL;

+    char buf[64];

+    png_size_t total_len;

 

-   png_debug(1, "in png_write_sCAL");

+    png_debug(1, "in png_write_sCAL");

 

-   buf[0] = (char)unit;

-   png_snprintf(buf + 1, 63, "%12.12e", width);

-   total_len = 1 + png_strlen(buf + 1) + 1;

-   png_snprintf(buf + total_len, 64-total_len, "%12.12e", height);

-   total_len += png_strlen(buf + total_len);

+    buf[0] = (char)unit;

+    png_snprintf(buf + 1, 63, "%12.12e", width);

+    total_len = 1 + png_strlen(buf + 1) + 1;

+    png_snprintf(buf + total_len, 64 - total_len, "%12.12e", height);

+    total_len += png_strlen(buf + total_len);

 

-   png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);

-   png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len);

+    png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);

+    png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len);

 }

 #else

 #ifdef PNG_FIXED_POINT_SUPPORTED

 void /* PRIVATE */

 png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,

-   png_charp height)

+                 png_charp height)

 {

-   PNG_sCAL;

-   png_byte buf[64];

-   png_size_t wlen, hlen, total_len;

-

-   png_debug(1, "in png_write_sCAL_s");

-

-   wlen = png_strlen(width);

-   hlen = png_strlen(height);

-   total_len = wlen + hlen + 2;

-   if (total_len > 64)

-   {

-      png_warning(png_ptr, "Can't write sCAL (buffer too small)");

-      return;

-   }

-

-   buf[0] = (png_byte)unit;

-   png_memcpy(buf + 1, width, wlen + 1);      /* Append the '\0' here */

-   png_memcpy(buf + wlen + 2, height, hlen);  /* Do NOT append the '\0' here */

-

-   png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);

-   png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len);

+    PNG_sCAL;

+    png_byte buf[64];

+    png_size_t wlen, hlen, total_len;

+

+    png_debug(1, "in png_write_sCAL_s");

+

+    wlen = png_strlen(width);

+    hlen = png_strlen(height);

+    total_len = wlen + hlen + 2;

+    if(total_len > 64)

+    {

+        png_warning(png_ptr, "Can't write sCAL (buffer too small)");

+        return;

+    }

+

+    buf[0] = (png_byte)unit;

+    png_memcpy(buf + 1, width, wlen + 1);      /* Append the '\0' here */

+    png_memcpy(buf + wlen + 2, height, hlen);  /* Do NOT append the '\0' here */

+

+    png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);

+    png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len);

 }

 #endif

 #endif

@@ -1662,22 +1670,22 @@ png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,
 /* 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,

-   int unit_type)

+               png_uint_32 y_pixels_per_unit,

+               int unit_type)

 {

-   PNG_pHYs;

-   png_byte buf[9];

+    PNG_pHYs;

+    png_byte buf[9];

 

-   png_debug(1, "in png_write_pHYs");

+    png_debug(1, "in png_write_pHYs");

 

-   if (unit_type >= PNG_RESOLUTION_LAST)

-      png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");

+    if(unit_type >= PNG_RESOLUTION_LAST)

+        png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");

 

-   png_save_uint_32(buf, x_pixels_per_unit);

-   png_save_uint_32(buf + 4, y_pixels_per_unit);

-   buf[8] = (png_byte)unit_type;

+    png_save_uint_32(buf, x_pixels_per_unit);

+    png_save_uint_32(buf + 4, y_pixels_per_unit);

+    buf[8] = (png_byte)unit_type;

 

-   png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);

+    png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);

 }

 #endif

 

@@ -1688,27 +1696,27 @@ png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
 void /* PRIVATE */

 png_write_tIME(png_structp png_ptr, png_timep mod_time)

 {

-   PNG_tIME;

-   png_byte buf[7];

+    PNG_tIME;

+    png_byte buf[7];

 

-   png_debug(1, "in png_write_tIME");

+    png_debug(1, "in png_write_tIME");

 

-   if (mod_time->month  > 12 || mod_time->month  < 1 ||

+    if(mod_time->month  > 12 || mod_time->month  < 1 ||

        mod_time->day    > 31 || mod_time->day    < 1 ||

        mod_time->hour   > 23 || mod_time->second > 60)

-   {

-      png_warning(png_ptr, "Invalid time specified for tIME chunk");

-      return;

-   }

-

-   png_save_uint_16(buf, mod_time->year);

-   buf[2] = mod_time->month;

-   buf[3] = mod_time->day;

-   buf[4] = mod_time->hour;

-   buf[5] = mod_time->minute;

-   buf[6] = mod_time->second;

-

-   png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);

+    {

+        png_warning(png_ptr, "Invalid time specified for tIME chunk");

+        return;

+    }

+

+    png_save_uint_16(buf, mod_time->year);

+    buf[2] = mod_time->month;

+    buf[3] = mod_time->day;

+    buf[4] = mod_time->hour;

+    buf[5] = mod_time->minute;

+    buf[6] = mod_time->second;

+

+    png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);

 }

 #endif

 

@@ -1717,97 +1725,97 @@ void /* PRIVATE */
 png_write_start_row(png_structp png_ptr)

 {

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

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

-   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+    /* Start of interlace block */

+    int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

 

-   /* Offset to next interlace block */

-   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

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

-   int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

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

-   int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

+    /* Offset to next interlace block in the y direction */

+    int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

 #endif

 

-   png_size_t buf_size;

+    png_size_t buf_size;

 

-   png_debug(1, "in png_write_start_row");

+    png_debug(1, "in png_write_start_row");

 

-   buf_size = (png_size_t)(PNG_ROWBYTES(

-      png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);

+    buf_size = (png_size_t)(PNG_ROWBYTES(

+                                png_ptr->usr_channels * png_ptr->usr_bit_depth, png_ptr->width) + 1);

 

-   /* Set up row buffer */

-   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr,

-     (png_alloc_size_t)buf_size);

-   png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;

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

 

 #ifdef PNG_WRITE_FILTER_SUPPORTED

-   /* Set up filtering buffer, if using this filter */

-   if (png_ptr->do_filter & PNG_FILTER_SUB)

-   {

-      png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,

-         (png_alloc_size_t)(png_ptr->rowbytes + 1));

-      png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;

-   }

-

-   /* We only need to keep the previous row if we are using one of these. */

-   if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))

-   {

-      /* Set up previous row buffer */

-      png_ptr->prev_row = (png_bytep)png_calloc(png_ptr,

-         (png_alloc_size_t)buf_size);

-

-      if (png_ptr->do_filter & PNG_FILTER_UP)

-      {

-         png_ptr->up_row = (png_bytep)png_malloc(png_ptr,

-            (png_size_t)(png_ptr->rowbytes + 1));

-         png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;

-      }

-

-      if (png_ptr->do_filter & PNG_FILTER_AVG)

-      {

-         png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,

-            (png_alloc_size_t)(png_ptr->rowbytes + 1));

-         png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;

-      }

-

-      if (png_ptr->do_filter & PNG_FILTER_PAETH)

-      {

-         png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,

-            (png_size_t)(png_ptr->rowbytes + 1));

-         png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;

-      }

-   }

+    /* Set up filtering buffer, if using this filter */

+    if(png_ptr->do_filter & PNG_FILTER_SUB)

+    {

+        png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,

+                           (png_alloc_size_t)(png_ptr->rowbytes + 1));

+        png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;

+    }

+

+    /* We only need to keep the previous row if we are using one of these. */

+    if(png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))

+    {

+        /* Set up previous row buffer */

+        png_ptr->prev_row = (png_bytep)png_calloc(png_ptr,

+                            (png_alloc_size_t)buf_size);

+

+        if(png_ptr->do_filter & PNG_FILTER_UP)

+        {

+            png_ptr->up_row = (png_bytep)png_malloc(png_ptr,

+                                                    (png_size_t)(png_ptr->rowbytes + 1));

+            png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;

+        }

+

+        if(png_ptr->do_filter & PNG_FILTER_AVG)

+        {

+            png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,

+                               (png_alloc_size_t)(png_ptr->rowbytes + 1));

+            png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;

+        }

+

+        if(png_ptr->do_filter & PNG_FILTER_PAETH)

+        {

+            png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,

+                                 (png_size_t)(png_ptr->rowbytes + 1));

+            png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;

+        }

+    }

 #endif /* PNG_WRITE_FILTER_SUPPORTED */

 

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

-   /* If interlaced, we need to set up width and height of pass */

-   if (png_ptr->interlaced)

-   {

-      if (!(png_ptr->transformations & PNG_INTERLACE))

-      {

-         png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -

-            png_pass_ystart[0]) / png_pass_yinc[0];

-         png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -

-            png_pass_start[0]) / png_pass_inc[0];

-      }

-      else

-      {

-         png_ptr->num_rows = png_ptr->height;

-         png_ptr->usr_width = png_ptr->width;

-      }

-   }

-   else

+    /* If interlaced, we need to set up width and height of pass */

+    if(png_ptr->interlaced)

+    {

+        if(!(png_ptr->transformations & PNG_INTERLACE))

+        {

+            png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -

+                                 png_pass_ystart[0]) / png_pass_yinc[0];

+            png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -

+                                  png_pass_start[0]) / png_pass_inc[0];

+        }

+        else

+        {

+            png_ptr->num_rows = png_ptr->height;

+            png_ptr->usr_width = png_ptr->width;

+        }

+    }

+    else

 #endif

-   {

-      png_ptr->num_rows = png_ptr->height;

-      png_ptr->usr_width = png_ptr->width;

-   }

-   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-   png_ptr->zstream.next_out = png_ptr->zbuf;

+    {

+        png_ptr->num_rows = png_ptr->height;

+        png_ptr->usr_width = png_ptr->width;

+    }

+    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+    png_ptr->zstream.next_out = png_ptr->zbuf;

 }

 

 /* Internal use only.  Called when finished processing a row of data. */

@@ -1815,110 +1823,112 @@ void /* PRIVATE */
 png_write_finish_row(png_structp png_ptr)

 {

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

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

-   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+    /* Start of interlace block */

+    int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

 

-   /* Offset to next interlace block */

-   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

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

-   int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

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

-   int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

+    /* Offset to next interlace block in the y direction */

+    int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

 #endif

 

-   int ret;

+    int ret;

 

-   png_debug(1, "in png_write_finish_row");

+    png_debug(1, "in png_write_finish_row");

 

-   /* Next row */

-   png_ptr->row_number++;

+    /* Next row */

+    png_ptr->row_number++;

 

-   /* See if we are done */

-   if (png_ptr->row_number < png_ptr->num_rows)

-      return;

+    /* 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 (png_ptr->interlaced)

-   {

-      png_ptr->row_number = 0;

-      if (png_ptr->transformations & PNG_INTERLACE)

-      {

-         png_ptr->pass++;

-      }

-      else

-      {

-         /* Loop until we find a non-zero width or height pass */

-         do

-         {

+    /* If interlaced, go to next pass */

+    if(png_ptr->interlaced)

+    {

+        png_ptr->row_number = 0;

+        if(png_ptr->transformations & PNG_INTERLACE)

+        {

             png_ptr->pass++;

-            if (png_ptr->pass >= 7)

-               break;

-            png_ptr->usr_width = (png_ptr->width +

-               png_pass_inc[png_ptr->pass] - 1 -

-               png_pass_start[png_ptr->pass]) /

-               png_pass_inc[png_ptr->pass];

-            png_ptr->num_rows = (png_ptr->height +

-               png_pass_yinc[png_ptr->pass] - 1 -

-               png_pass_ystart[png_ptr->pass]) /

-               png_pass_yinc[png_ptr->pass];

-            if (png_ptr->transformations & PNG_INTERLACE)

-               break;

-         } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);

-

-      }

-

-      /* Reset the row above the image for the next pass */

-      if (png_ptr->pass < 7)

-      {

-         if (png_ptr->prev_row != NULL)

-            png_memset(png_ptr->prev_row, 0,

-               (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*

-               png_ptr->usr_bit_depth, png_ptr->width)) + 1);

-         return;

-      }

-   }

+        }

+        else

+        {

+            /* Loop until we find a non-zero width or height pass */

+            do

+            {

+                png_ptr->pass++;

+                if(png_ptr->pass >= 7)

+                    break;

+                png_ptr->usr_width = (png_ptr->width +

+                                      png_pass_inc[png_ptr->pass] - 1 -

+                                      png_pass_start[png_ptr->pass]) /

+                                     png_pass_inc[png_ptr->pass];

+                png_ptr->num_rows = (png_ptr->height +

+                                     png_pass_yinc[png_ptr->pass] - 1 -

+                                     png_pass_ystart[png_ptr->pass]) /

+                                    png_pass_yinc[png_ptr->pass];

+                if(png_ptr->transformations & PNG_INTERLACE)

+                    break;

+            }

+            while(png_ptr->usr_width == 0 || png_ptr->num_rows == 0);

+

+        }

+

+        /* Reset the row above the image for the next pass */

+        if(png_ptr->pass < 7)

+        {

+            if(png_ptr->prev_row != NULL)

+                png_memset(png_ptr->prev_row, 0,

+                           (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*

+                                                     png_ptr->usr_bit_depth, png_ptr->width)) + 1);

+            return;

+        }

+    }

 #endif

 

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

-      ret = deflate(&png_ptr->zstream, Z_FINISH);

-      /* Check for an error */

-      if (ret == Z_OK)

-      {

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

-            png_ptr->zstream.next_out = png_ptr->zbuf;

-            png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

-         }

-      }

-      else if (ret != Z_STREAM_END)

-      {

-         if (png_ptr->zstream.msg != NULL)

-            png_error(png_ptr, png_ptr->zstream.msg);

-         else

-            png_error(png_ptr, "zlib error");

-      }

-   } while (ret != Z_STREAM_END);

-

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

-         png_ptr->zstream.avail_out);

-   }

-

-   deflateReset(&png_ptr->zstream);

-   png_ptr->zstream.data_type = Z_BINARY;

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

+        ret = deflate(&png_ptr->zstream, Z_FINISH);

+        /* Check for an error */

+        if(ret == Z_OK)

+        {

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

+                png_ptr->zstream.next_out = png_ptr->zbuf;

+                png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+            }

+        }

+        else if(ret != Z_STREAM_END)

+        {

+            if(png_ptr->zstream.msg != NULL)

+                png_error(png_ptr, png_ptr->zstream.msg);

+            else

+                png_error(png_ptr, "zlib error");

+        }

+    }

+    while(ret != Z_STREAM_END);

+

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

+                       png_ptr->zstream.avail_out);

+    }

+

+    deflateReset(&png_ptr->zstream);

+    png_ptr->zstream.data_type = Z_BINARY;

 }

 

 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

@@ -1932,24 +1942,24 @@ png_write_finish_row(png_structp png_ptr)
 void /* PRIVATE */

 png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)

 {

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

-   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+    /* Start of interlace block */

+    int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

 

-   /* Offset to next interlace block */

-   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+    /* Offset to next interlace block */

+    int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

 

-   png_debug(1, "in png_do_write_interlace");

+    png_debug(1, "in png_do_write_interlace");

 

-   /* We don't have to do anything on the last pass (6) */

-   if (pass < 6)

-   {

-      /* Each pixel depth is handled separately */

-      switch (row_info->pixel_depth)

-      {

-         case 1:

-         {

+    /* We don't have to do anything on the last pass (6) */

+    if(pass < 6)

+    {

+        /* Each pixel depth is handled separately */

+        switch(row_info->pixel_depth)

+        {

+        case 1:

+        {

             png_bytep sp;

             png_bytep dp;

             int shift;

@@ -1961,29 +1971,29 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             dp = row;

             d = 0;

             shift = 7;

-            for (i = png_pass_start[pass]; i < row_width;

-               i += png_pass_inc[pass])

+            for(i = png_pass_start[pass]; i < row_width;

+                i += png_pass_inc[pass])

             {

-               sp = row + (png_size_t)(i >> 3);

-               value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;

-               d |= (value << shift);

-

-               if (shift == 0)

-               {

-                  shift = 7;

-                  *dp++ = (png_byte)d;

-                  d = 0;

-               }

-               else

-                  shift--;

+                sp = row + (png_size_t)(i >> 3);

+                value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;

+                d |= (value << shift);

+

+                if(shift == 0)

+                {

+                    shift = 7;

+                    *dp++ = (png_byte)d;

+                    d = 0;

+                }

+                else

+                    shift--;

 

             }

-            if (shift != 7)

-               *dp = (png_byte)d;

+            if(shift != 7)

+                *dp = (png_byte)d;

             break;

-         }

-         case 2:

-         {

+        }

+        case 2:

+        {

             png_bytep sp;

             png_bytep dp;

             int shift;

@@ -1995,28 +2005,28 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             dp = row;

             shift = 6;

             d = 0;

-            for (i = png_pass_start[pass]; i < row_width;

-               i += png_pass_inc[pass])

+            for(i = png_pass_start[pass]; i < row_width;

+                i += png_pass_inc[pass])

             {

-               sp = row + (png_size_t)(i >> 2);

-               value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;

-               d |= (value << shift);

-

-               if (shift == 0)

-               {

-                  shift = 6;

-                  *dp++ = (png_byte)d;

-                  d = 0;

-               }

-               else

-                  shift -= 2;

+                sp = row + (png_size_t)(i >> 2);

+                value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;

+                d |= (value << shift);

+

+                if(shift == 0)

+                {

+                    shift = 6;

+                    *dp++ = (png_byte)d;

+                    d = 0;

+                }

+                else

+                    shift -= 2;

             }

-            if (shift != 6)

-                   *dp = (png_byte)d;

+            if(shift != 6)

+                *dp = (png_byte)d;

             break;

-         }

-         case 4:

-         {

+        }

+        case 4:

+        {

             png_bytep sp;

             png_bytep dp;

             int shift;

@@ -2028,28 +2038,28 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             dp = row;

             shift = 4;

             d = 0;

-            for (i = png_pass_start[pass]; i < row_width;

-               i += png_pass_inc[pass])

+            for(i = png_pass_start[pass]; i < row_width;

+                i += png_pass_inc[pass])

             {

-               sp = row + (png_size_t)(i >> 1);

-               value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;

-               d |= (value << shift);

-

-               if (shift == 0)

-               {

-                  shift = 4;

-                  *dp++ = (png_byte)d;

-                  d = 0;

-               }

-               else

-                  shift -= 4;

+                sp = row + (png_size_t)(i >> 1);

+                value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;

+                d |= (value << shift);

+

+                if(shift == 0)

+                {

+                    shift = 4;

+                    *dp++ = (png_byte)d;

+                    d = 0;

+                }

+                else

+                    shift -= 4;

             }

-            if (shift != 4)

-               *dp = (png_byte)d;

+            if(shift != 4)

+                *dp = (png_byte)d;

             break;

-         }

-         default:

-         {

+        }

+        default:

+        {

             png_bytep sp;

             png_bytep dp;

             png_uint_32 i;

@@ -2062,28 +2072,28 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
             pixel_bytes = (row_info->pixel_depth >> 3);

             /* 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])

+            for(i = png_pass_start[pass]; i < row_width;

+                i += png_pass_inc[pass])

             {

-               /* Find out where the original pixel is */

-               sp = row + (png_size_t)i * pixel_bytes;

-               /* Move the pixel */

-               if (dp != sp)

-                  png_memcpy(dp, sp, pixel_bytes);

-               /* Next pixel */

-               dp += pixel_bytes;

+                /* Find out where the original pixel is */

+                sp = row + (png_size_t)i * pixel_bytes;

+                /* Move the pixel */

+                if(dp != sp)

+                    png_memcpy(dp, sp, pixel_bytes);

+                /* Next pixel */

+                dp += pixel_bytes;

             }

             break;

-         }

-      }

-      /* Set new row width */

-      row_info->width = (row_info->width +

-         png_pass_inc[pass] - 1 -

-         png_pass_start[pass]) /

-         png_pass_inc[pass];

-         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

-            row_info->width);

-   }

+        }

+        }

+        /* Set new row width */

+        row_info->width = (row_info->width +

+                           png_pass_inc[pass] - 1 -

+                           png_pass_start[pass]) /

+                          png_pass_inc[pass];

+        row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

+                                          row_info->width);

+    }

 }

 #endif

 

@@ -2098,625 +2108,625 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
 void /* PRIVATE */

 png_write_find_filter(png_structp png_ptr, png_row_infop row_info)

 {

-   png_bytep best_row;

+    png_bytep best_row;

 #ifdef PNG_WRITE_FILTER_SUPPORTED

-   png_bytep prev_row, row_buf;

-   png_uint_32 mins, bpp;

-   png_byte filter_to_do = png_ptr->do_filter;

-   png_uint_32 row_bytes = row_info->rowbytes;

+    png_bytep prev_row, row_buf;

+    png_uint_32 mins, bpp;

+    png_byte filter_to_do = png_ptr->do_filter;

+    png_uint_32 row_bytes = row_info->rowbytes;

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   int num_p_filters = (int)png_ptr->num_prev_filters;

-#endif 

+    int num_p_filters = (int)png_ptr->num_prev_filters;

+#endif

 

-   png_debug(1, "in png_write_find_filter");

+    png_debug(1, "in png_write_find_filter");

 

 #ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-  if (png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS)

-  {

-      /* These will never be selected so we need not test them. */

-      filter_to_do &= ~(PNG_FILTER_UP | PNG_FILTER_PAETH);

-  }

-#endif 

+    if(png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS)

+    {

+        /* These will never be selected so we need not test them. */

+        filter_to_do &= ~(PNG_FILTER_UP | PNG_FILTER_PAETH);

+    }

+#endif

 

-   /* Find out how many bytes offset each pixel is */

-   bpp = (row_info->pixel_depth + 7) >> 3;

+    /* Find out how many bytes offset each pixel is */

+    bpp = (row_info->pixel_depth + 7) >> 3;

 

-   prev_row = png_ptr->prev_row;

+    prev_row = png_ptr->prev_row;

 #endif

-   best_row = png_ptr->row_buf;

+    best_row = png_ptr->row_buf;

 #ifdef PNG_WRITE_FILTER_SUPPORTED

-   row_buf = best_row;

-   mins = PNG_MAXSUM;

-

-   /* The prediction method we use is to find which method provides the

-    * smallest value when summing the absolute values of the distances

-    * from zero, using anything >= 128 as negative numbers.  This is known

-    * as the "minimum sum of absolute differences" heuristic.  Other

-    * heuristics are the "weighted minimum sum of absolute differences"

-    * (experimental and can in theory improve compression), and the "zlib

-    * predictive" method (not implemented yet), which does test compressions

-    * of lines using different filter methods, and then chooses the

-    * (series of) filter(s) that give minimum compressed data size (VERY

-    * computationally expensive).

-    *

-    * GRR 980525:  consider also

-    *   (1) minimum sum of absolute differences from running average (i.e.,

-    *       keep running sum of non-absolute differences & count of bytes)

-    *       [track dispersion, too?  restart average if dispersion too large?]

-    *  (1b) minimum sum of absolute differences from sliding average, probably

-    *       with window size <= deflate window (usually 32K)

-    *   (2) minimum sum of squared differences from zero or running average

-    *       (i.e., ~ root-mean-square approach)

-    */

-

-

-   /* We don't need to test the 'no filter' case if this is the only filter

-    * that has been chosen, as it doesn't actually do anything to the data.

-    */

-   if ((filter_to_do & PNG_FILTER_NONE) &&

+    row_buf = best_row;

+    mins = PNG_MAXSUM;

+

+    /* The prediction method we use is to find which method provides the

+     * smallest value when summing the absolute values of the distances

+     * from zero, using anything >= 128 as negative numbers.  This is known

+     * as the "minimum sum of absolute differences" heuristic.  Other

+     * heuristics are the "weighted minimum sum of absolute differences"

+     * (experimental and can in theory improve compression), and the "zlib

+     * predictive" method (not implemented yet), which does test compressions

+     * of lines using different filter methods, and then chooses the

+     * (series of) filter(s) that give minimum compressed data size (VERY

+     * computationally expensive).

+     *

+     * GRR 980525:  consider also

+     *   (1) minimum sum of absolute differences from running average (i.e.,

+     *       keep running sum of non-absolute differences & count of bytes)

+     *       [track dispersion, too?  restart average if dispersion too large?]

+     *  (1b) minimum sum of absolute differences from sliding average, probably

+     *       with window size <= deflate window (usually 32K)

+     *   (2) minimum sum of squared differences from zero or running average

+     *       (i.e., ~ root-mean-square approach)

+     */

+

+

+    /* We don't need to test the 'no filter' case if this is the only filter

+     * that has been chosen, as it doesn't actually do anything to the data.

+     */

+    if((filter_to_do & PNG_FILTER_NONE) &&

        filter_to_do != PNG_FILTER_NONE)

-   {

-      png_bytep rp;

-      png_uint_32 sum = 0;

-      png_uint_32 i;

-      int v;

-

-      for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)

-      {

-         v = *rp;

-         sum += (v < 128) ? v : 256 - v;

-      }

+    {

+        png_bytep rp;

+        png_uint_32 sum = 0;

+        png_uint_32 i;

+        int v;

+

+        for(i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)

+        {

+            v = *rp;

+            sum += (v < 128) ? v : 256 - v;

+        }

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         png_uint_32 sumhi, sumlo;

-         int j;

-         sumlo = sum & PNG_LOMASK;

-         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */

-

-         /* Reduce the sum if we match any of the previous rows */

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)

+        if(png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+        {

+            png_uint_32 sumhi, sumlo;

+            int j;

+            sumlo = sum & PNG_LOMASK;

+            sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */

+

+            /* Reduce the sum if we match any of the previous rows */

+            for(j = 0; j < num_p_filters; j++)

             {

-               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

+                if(png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)

+                {

+                    sumlo = (sumlo * png_ptr->filter_weights[j]) >>

+                            PNG_WEIGHT_SHIFT;

+                    sumhi = (sumhi * png_ptr->filter_weights[j]) >>

+                            PNG_WEIGHT_SHIFT;

+                }

             }

-         }

-

-         /* Factor in the cost of this filter (this is here for completeness,

-          * but it makes no sense to have a "cost" for the NONE filter, as

-          * it has the minimum possible computational cost - none).

-          */

-         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>

-            PNG_COST_SHIFT;

-         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>

-            PNG_COST_SHIFT;

-

-         if (sumhi > PNG_HIMASK)

-            sum = PNG_MAXSUM;

-         else

-            sum = (sumhi << PNG_HISHIFT) + sumlo;

-      }

+

+            /* Factor in the cost of this filter (this is here for completeness,

+             * but it makes no sense to have a "cost" for the NONE filter, as

+             * it has the minimum possible computational cost - none).

+             */

+            sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>

+                    PNG_COST_SHIFT;

+            sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>

+                    PNG_COST_SHIFT;

+

+            if(sumhi > PNG_HIMASK)

+                sum = PNG_MAXSUM;

+            else

+                sum = (sumhi << PNG_HISHIFT) + sumlo;

+        }

 #endif

-      mins = sum;

-   }

-

-   /* Sub filter */

-   if (filter_to_do == PNG_FILTER_SUB)

-   /* It's the only filter so no testing is needed */

-   {

-      png_bytep rp, lp, dp;

-      png_uint_32 i;

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;

-           i++, rp++, dp++)

-      {

-         *dp = *rp;

-      }

-      for (lp = row_buf + 1; i < row_bytes;

-         i++, rp++, lp++, dp++)

-      {

-         *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);

-      }

-      best_row = png_ptr->sub_row;

-   }

-

-   else if (filter_to_do & PNG_FILTER_SUB)

-   {

-      png_bytep rp, dp, lp;

-      png_uint_32 sum = 0, lmins = mins;

-      png_uint_32 i;

-      int v;

+        mins = sum;

+    }

+

+    /* Sub filter */

+    if(filter_to_do == PNG_FILTER_SUB)

+        /* It's the only filter so no testing is needed */

+    {

+        png_bytep rp, lp, dp;

+        png_uint_32 i;

+        for(i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;

+            i++, rp++, dp++)

+        {

+            *dp = *rp;

+        }

+        for(lp = row_buf + 1; i < row_bytes;

+            i++, rp++, lp++, dp++)

+        {

+            *dp = (png_byte)(((int) * rp - (int) * lp) & 0xff);

+        }

+        best_row = png_ptr->sub_row;

+    }

+

+    else if(filter_to_do & PNG_FILTER_SUB)

+    {

+        png_bytep rp, dp, lp;

+        png_uint_32 sum = 0, lmins = mins;

+        png_uint_32 i;

+        int v;

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      /* We temporarily increase the "minimum sum" by the factor we

-       * would reduce the sum of this filter, so that we can do the

-       * early exit comparison without scaling the sum each time.

-       */

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 lmhi, lmlo;

-         lmlo = lmins & PNG_LOMASK;

-         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)

+        /* We temporarily increase the "minimum sum" by the factor we

+         * would reduce the sum of this filter, so that we can do the

+         * early exit comparison without scaling the sum each time.

+         */

+        if(png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+        {

+            int j;

+            png_uint_32 lmhi, lmlo;

+            lmlo = lmins & PNG_LOMASK;

+            lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

+

+            for(j = 0; j < num_p_filters; j++)

             {

-               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

+                if(png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)

+                {

+                    lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

+                           PNG_WEIGHT_SHIFT;

+                    lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

+                           PNG_WEIGHT_SHIFT;

+                }

             }

-         }

-

-         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

-            PNG_COST_SHIFT;

-         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

-            PNG_COST_SHIFT;

-

-         if (lmhi > PNG_HIMASK)

-            lmins = PNG_MAXSUM;

-         else

-            lmins = (lmhi << PNG_HISHIFT) + lmlo;

-      }

+

+            lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

+                   PNG_COST_SHIFT;

+            lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

+                   PNG_COST_SHIFT;

+

+            if(lmhi > PNG_HIMASK)

+                lmins = PNG_MAXSUM;

+            else

+                lmins = (lmhi << PNG_HISHIFT) + lmlo;

+        }

 #endif

 

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;

-           i++, rp++, dp++)

-      {

-         v = *dp = *rp;

+        for(i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;

+            i++, rp++, dp++)

+        {

+            v = *dp = *rp;

 

-         sum += (v < 128) ? v : 256 - v;

-      }

-      for (lp = row_buf + 1; i < row_bytes;

-         i++, rp++, lp++, dp++)

-      {

-         v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);

+            sum += (v < 128) ? v : 256 - v;

+        }

+        for(lp = row_buf + 1; i < row_bytes;

+            i++, rp++, lp++, dp++)

+        {

+            v = *dp = (png_byte)(((int) * rp - (int) * lp) & 0xff);

 

-         sum += (v < 128) ? v : 256 - v;

+            sum += (v < 128) ? v : 256 - v;

 

-         if (sum > lmins)  /* We are already worse, don't continue. */

-            break;

-      }

+            if(sum > lmins)   /* We are already worse, don't continue. */

+                break;

+        }

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 sumhi, sumlo;

-         sumlo = sum & PNG_LOMASK;

-         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)

+        if(png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+        {

+            int j;

+            png_uint_32 sumhi, sumlo;

+            sumlo = sum & PNG_LOMASK;

+            sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

+

+            for(j = 0; j < num_p_filters; j++)

             {

-               sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

+                if(png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)

+                {

+                    sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>

+                            PNG_WEIGHT_SHIFT;

+                    sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>

+                            PNG_WEIGHT_SHIFT;

+                }

             }

-         }

-

-         sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

-            PNG_COST_SHIFT;

-         sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

-            PNG_COST_SHIFT;

-

-         if (sumhi > PNG_HIMASK)

-            sum = PNG_MAXSUM;

-         else

-            sum = (sumhi << PNG_HISHIFT) + sumlo;

-      }

+

+            sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

+                    PNG_COST_SHIFT;

+            sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

+                    PNG_COST_SHIFT;

+

+            if(sumhi > PNG_HIMASK)

+                sum = PNG_MAXSUM;

+            else

+                sum = (sumhi << PNG_HISHIFT) + sumlo;

+        }

 #endif

 

-      if (sum < mins)

-      {

-         mins = sum;

-         best_row = png_ptr->sub_row;

-      }

-   }

-

-   /* Up filter */

-   if (filter_to_do == PNG_FILTER_UP)

-   {

-      png_bytep rp, dp, pp;

-      png_uint_32 i;

-

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,

-           pp = prev_row + 1; i < row_bytes;

-           i++, rp++, pp++, dp++)

-      {

-         *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);

-      }

-      best_row = png_ptr->up_row;

-   }

-

-   else if (filter_to_do & PNG_FILTER_UP)

-   {

-      png_bytep rp, dp, pp;

-      png_uint_32 sum = 0, lmins = mins;

-      png_uint_32 i;

-      int v;

+        if(sum < mins)

+        {

+            mins = sum;

+            best_row = png_ptr->sub_row;

+        }

+    }

+

+    /* Up filter */

+    if(filter_to_do == PNG_FILTER_UP)

+    {

+        png_bytep rp, dp, pp;

+        png_uint_32 i;

+

+        for(i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,

+            pp = prev_row + 1; i < row_bytes;

+            i++, rp++, pp++, dp++)

+        {

+            *dp = (png_byte)(((int) * rp - (int) * pp) & 0xff);

+        }

+        best_row = png_ptr->up_row;

+    }

+

+    else if(filter_to_do & PNG_FILTER_UP)

+    {

+        png_bytep rp, dp, pp;

+        png_uint_32 sum = 0, lmins = mins;

+        png_uint_32 i;

+        int v;

 

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 lmhi, lmlo;

-         lmlo = lmins & PNG_LOMASK;

-         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)

+        if(png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+        {

+            int j;

+            png_uint_32 lmhi, lmlo;

+            lmlo = lmins & PNG_LOMASK;

+            lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

+

+            for(j = 0; j < num_p_filters; j++)

             {

-               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

+                if(png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)

+                {

+                    lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

+                           PNG_WEIGHT_SHIFT;

+                    lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

+                           PNG_WEIGHT_SHIFT;

+                }

             }

-         }

-

-         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>

-            PNG_COST_SHIFT;

-         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>

-            PNG_COST_SHIFT;

-

-         if (lmhi > PNG_HIMASK)

-            lmins = PNG_MAXSUM;

-         else

-            lmins = (lmhi << PNG_HISHIFT) + lmlo;

-      }

+

+            lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>

+                   PNG_COST_SHIFT;

+            lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>

+                   PNG_COST_SHIFT;

+

+            if(lmhi > PNG_HIMASK)

+                lmins = PNG_MAXSUM;

+            else

+                lmins = (lmhi << PNG_HISHIFT) + lmlo;

+        }

 #endif

 

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,

-           pp = prev_row + 1; i < row_bytes; i++)

-      {

-         v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);

+        for(i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,

+            pp = prev_row + 1; i < row_bytes; i++)

+        {

+            v = *dp++ = (png_byte)(((int) * rp++ - (int) * pp++) & 0xff);

 

-         sum += (v < 128) ? v : 256 - v;

+            sum += (v < 128) ? v : 256 - v;

 

-         if (sum > lmins)  /* We are already worse, don't continue. */

-            break;

-      }

+            if(sum > lmins)   /* We are already worse, don't continue. */

+                break;

+        }

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 sumhi, sumlo;

-         sumlo = sum & PNG_LOMASK;

-         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)

+        if(png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+        {

+            int j;

+            png_uint_32 sumhi, sumlo;

+            sumlo = sum & PNG_LOMASK;

+            sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

+

+            for(j = 0; j < num_p_filters; j++)

             {

-               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

+                if(png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)

+                {

+                    sumlo = (sumlo * png_ptr->filter_weights[j]) >>

+                            PNG_WEIGHT_SHIFT;

+                    sumhi = (sumhi * png_ptr->filter_weights[j]) >>

+                            PNG_WEIGHT_SHIFT;

+                }

             }

-         }

-

-         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>

-            PNG_COST_SHIFT;

-         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>

-            PNG_COST_SHIFT;

-

-         if (sumhi > PNG_HIMASK)

-            sum = PNG_MAXSUM;

-         else

-            sum = (sumhi << PNG_HISHIFT) + sumlo;

-      }

+

+            sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>

+                    PNG_COST_SHIFT;

+            sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>

+                    PNG_COST_SHIFT;

+

+            if(sumhi > PNG_HIMASK)

+                sum = PNG_MAXSUM;

+            else

+                sum = (sumhi << PNG_HISHIFT) + sumlo;

+        }

 #endif

 

-      if (sum < mins)

-      {

-         mins = sum;

-         best_row = png_ptr->up_row;

-      }

-   }

-

-   /* Avg filter */

-   if (filter_to_do == PNG_FILTER_AVG)

-   {

-      png_bytep rp, dp, pp, lp;

-      png_uint_32 i;

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,

-           pp = prev_row + 1; i < bpp; i++)

-      {

-         *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);

-      }

-      for (lp = row_buf + 1; i < row_bytes; i++)

-      {

-         *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))

-                 & 0xff);

-      }

-      best_row = png_ptr->avg_row;

-   }

-

-   else if (filter_to_do & PNG_FILTER_AVG)

-   {

-      png_bytep rp, dp, pp, lp;

-      png_uint_32 sum = 0, lmins = mins;

-      png_uint_32 i;

-      int v;

+        if(sum < mins)

+        {

+            mins = sum;

+            best_row = png_ptr->up_row;

+        }

+    }

+

+    /* Avg filter */

+    if(filter_to_do == PNG_FILTER_AVG)

+    {

+        png_bytep rp, dp, pp, lp;

+        png_uint_32 i;

+        for(i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,

+            pp = prev_row + 1; i < bpp; i++)

+        {

+            *dp++ = (png_byte)(((int) * rp++ - ((int) * pp++ / 2)) & 0xff);

+        }

+        for(lp = row_buf + 1; i < row_bytes; i++)

+        {

+            *dp++ = (png_byte)(((int) * rp++ - (((int) * pp++ + (int) * lp++) / 2))

+                               & 0xff);

+        }

+        best_row = png_ptr->avg_row;

+    }

+

+    else if(filter_to_do & PNG_FILTER_AVG)

+    {

+        png_bytep rp, dp, pp, lp;

+        png_uint_32 sum = 0, lmins = mins;

+        png_uint_32 i;

+        int v;

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 lmhi, lmlo;

-         lmlo = lmins & PNG_LOMASK;

-         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)

+        if(png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+        {

+            int j;

+            png_uint_32 lmhi, lmlo;

+            lmlo = lmins & PNG_LOMASK;

+            lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

+

+            for(j = 0; j < num_p_filters; j++)

             {

-               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

+                if(png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)

+                {

+                    lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

+                           PNG_WEIGHT_SHIFT;

+                    lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

+                           PNG_WEIGHT_SHIFT;

+                }

             }

-         }

-

-         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>

-            PNG_COST_SHIFT;

-         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>

-            PNG_COST_SHIFT;

-

-         if (lmhi > PNG_HIMASK)

-            lmins = PNG_MAXSUM;

-         else

-            lmins = (lmhi << PNG_HISHIFT) + lmlo;

-      }

+

+            lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>

+                   PNG_COST_SHIFT;

+            lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>

+                   PNG_COST_SHIFT;

+

+            if(lmhi > PNG_HIMASK)

+                lmins = PNG_MAXSUM;

+            else

+                lmins = (lmhi << PNG_HISHIFT) + lmlo;

+        }

 #endif

 

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,

-           pp = prev_row + 1; i < bpp; i++)

-      {

-         v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);

+        for(i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,

+            pp = prev_row + 1; i < bpp; i++)

+        {

+            v = *dp++ = (png_byte)(((int) * rp++ - ((int) * pp++ / 2)) & 0xff);

 

-         sum += (v < 128) ? v : 256 - v;

-      }

-      for (lp = row_buf + 1; i < row_bytes; i++)

-      {

-         v = *dp++ =

-          (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);

+            sum += (v < 128) ? v : 256 - v;

+        }

+        for(lp = row_buf + 1; i < row_bytes; i++)

+        {

+            v = *dp++ =

+                    (png_byte)(((int) * rp++ - (((int) * pp++ + (int) * lp++) / 2)) & 0xff);

 

-         sum += (v < 128) ? v : 256 - v;

+            sum += (v < 128) ? v : 256 - v;

 

-         if (sum > lmins)  /* We are already worse, don't continue. */

-            break;

-      }

+            if(sum > lmins)   /* We are already worse, don't continue. */

+                break;

+        }

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 sumhi, sumlo;

-         sumlo = sum & PNG_LOMASK;

-         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)

+        if(png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+        {

+            int j;

+            png_uint_32 sumhi, sumlo;

+            sumlo = sum & PNG_LOMASK;

+            sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

+

+            for(j = 0; j < num_p_filters; j++)

             {

-               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

+                if(png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)

+                {

+                    sumlo = (sumlo * png_ptr->filter_weights[j]) >>

+                            PNG_WEIGHT_SHIFT;

+                    sumhi = (sumhi * png_ptr->filter_weights[j]) >>

+                            PNG_WEIGHT_SHIFT;

+                }

             }

-         }

-

-         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>

-            PNG_COST_SHIFT;

-         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>

-            PNG_COST_SHIFT;

-

-         if (sumhi > PNG_HIMASK)

-            sum = PNG_MAXSUM;

-         else

-            sum = (sumhi << PNG_HISHIFT) + sumlo;

-      }

+

+            sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>

+                    PNG_COST_SHIFT;

+            sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>

+                    PNG_COST_SHIFT;

+

+            if(sumhi > PNG_HIMASK)

+                sum = PNG_MAXSUM;

+            else

+                sum = (sumhi << PNG_HISHIFT) + sumlo;

+        }

 #endif

 

-      if (sum < mins)

-      {

-         mins = sum;

-         best_row = png_ptr->avg_row;

-      }

-   }

-

-   /* Paeth filter */

-   if (filter_to_do == PNG_FILTER_PAETH)

-   {

-      png_bytep rp, dp, pp, cp, lp;

-      png_uint_32 i;

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,

-           pp = prev_row + 1; i < bpp; i++)

-      {

-         *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);

-      }

-

-      for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)

-      {

-         int a, b, c, pa, pb, pc, p;

-

-         b = *pp++;

-         c = *cp++;

-         a = *lp++;

-

-         p = b - c;

-         pc = a - c;

+        if(sum < mins)

+        {

+            mins = sum;

+            best_row = png_ptr->avg_row;

+        }

+    }

+

+    /* Paeth filter */

+    if(filter_to_do == PNG_FILTER_PAETH)

+    {

+        png_bytep rp, dp, pp, cp, lp;

+        png_uint_32 i;

+        for(i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,

+            pp = prev_row + 1; i < bpp; i++)

+        {

+            *dp++ = (png_byte)(((int) * rp++ - (int) * pp++) & 0xff);

+        }

+

+        for(lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)

+        {

+            int a, b, c, pa, pb, pc, p;

+

+            b = *pp++;

+            c = *cp++;

+            a = *lp++;

+

+            p = b - c;

+            pc = a - c;

 

 #ifdef PNG_USE_ABS

-         pa = abs(p);

-         pb = abs(pc);

-         pc = abs(p + pc);

+            pa = abs(p);

+            pb = abs(pc);

+            pc = abs(p + pc);

 #else

-         pa = p < 0 ? -p : p;

-         pb = pc < 0 ? -pc : pc;

-         pc = (p + pc) < 0 ? -(p + pc) : p + pc;

+            pa = p < 0 ? -p : p;

+            pb = pc < 0 ? -pc : pc;

+            pc = (p + pc) < 0 ? -(p + pc) : p + pc;

 #endif

 

-         p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;

+            p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;

 

-         *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);

-      }

-      best_row = png_ptr->paeth_row;

-   }

+            *dp++ = (png_byte)(((int) * rp++ - p) & 0xff);

+        }

+        best_row = png_ptr->paeth_row;

+    }

 

-   else if (filter_to_do & PNG_FILTER_PAETH)

-   {

-      png_bytep rp, dp, pp, cp, lp;

-      png_uint_32 sum = 0, lmins = mins;

-      png_uint_32 i;

-      int v;

+    else if(filter_to_do & PNG_FILTER_PAETH)

+    {

+        png_bytep rp, dp, pp, cp, lp;

+        png_uint_32 sum = 0, lmins = mins;

+        png_uint_32 i;

+        int v;

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 lmhi, lmlo;

-         lmlo = lmins & PNG_LOMASK;

-         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)

+        if(png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+        {

+            int j;

+            png_uint_32 lmhi, lmlo;

+            lmlo = lmins & PNG_LOMASK;

+            lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

+

+            for(j = 0; j < num_p_filters; j++)

             {

-               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

+                if(png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)

+                {

+                    lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

+                           PNG_WEIGHT_SHIFT;

+                    lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

+                           PNG_WEIGHT_SHIFT;

+                }

             }

-         }

-

-         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>

-            PNG_COST_SHIFT;

-         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>

-            PNG_COST_SHIFT;

-

-         if (lmhi > PNG_HIMASK)

-            lmins = PNG_MAXSUM;

-         else

-            lmins = (lmhi << PNG_HISHIFT) + lmlo;

-      }

+

+            lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>

+                   PNG_COST_SHIFT;

+            lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>

+                   PNG_COST_SHIFT;

+

+            if(lmhi > PNG_HIMASK)

+                lmins = PNG_MAXSUM;

+            else

+                lmins = (lmhi << PNG_HISHIFT) + lmlo;

+        }

 #endif

 

-      for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,

-           pp = prev_row + 1; i < bpp; i++)

-      {

-         v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);

+        for(i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,

+            pp = prev_row + 1; i < bpp; i++)

+        {

+            v = *dp++ = (png_byte)(((int) * rp++ - (int) * pp++) & 0xff);

 

-         sum += (v < 128) ? v : 256 - v;

-      }

+            sum += (v < 128) ? v : 256 - v;

+        }

 

-      for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)

-      {

-         int a, b, c, pa, pb, pc, p;

+        for(lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)

+        {

+            int a, b, c, pa, pb, pc, p;

 

-         b = *pp++;

-         c = *cp++;

-         a = *lp++;

+            b = *pp++;

+            c = *cp++;

+            a = *lp++;

 

 #ifndef PNG_SLOW_PAETH

-         p = b - c;

-         pc = a - c;

+            p = b - c;

+            pc = a - c;

 #ifdef PNG_USE_ABS

-         pa = abs(p);

-         pb = abs(pc);

-         pc = abs(p + pc);

+            pa = abs(p);

+            pb = abs(pc);

+            pc = abs(p + pc);

 #else

-         pa = p < 0 ? -p : p;

-         pb = pc < 0 ? -pc : pc;

-         pc = (p + pc) < 0 ? -(p + pc) : p + pc;

+            pa = p < 0 ? -p : p;

+            pb = pc < 0 ? -pc : pc;

+            pc = (p + pc) < 0 ? -(p + pc) : p + pc;

 #endif

-         p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;

+            p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;

 #else /* PNG_SLOW_PAETH */

-         p = a + b - c;

-         pa = abs(p - a);

-         pb = abs(p - b);

-         pc = abs(p - c);

-         if (pa <= pb && pa <= pc)

-            p = a;

-         else if (pb <= pc)

-            p = b;

-         else

-            p = c;

+            p = a + b - c;

+            pa = abs(p - a);

+            pb = abs(p - b);

+            pc = abs(p - c);

+            if(pa <= pb && pa <= pc)

+                p = a;

+            else if(pb <= pc)

+                p = b;

+            else

+                p = c;

 #endif /* PNG_SLOW_PAETH */

 

-         v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);

+            v = *dp++ = (png_byte)(((int) * rp++ - p) & 0xff);

 

-         sum += (v < 128) ? v : 256 - v;

+            sum += (v < 128) ? v : 256 - v;

 

-         if (sum > lmins)  /* We are already worse, don't continue. */

-            break;

-      }

+            if(sum > lmins)   /* We are already worse, don't continue. */

+                break;

+        }

 

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

-      {

-         int j;

-         png_uint_32 sumhi, sumlo;

-         sumlo = sum & PNG_LOMASK;

-         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

-

-         for (j = 0; j < num_p_filters; j++)

-         {

-            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)

+        if(png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+        {

+            int j;

+            png_uint_32 sumhi, sumlo;

+            sumlo = sum & PNG_LOMASK;

+            sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

+

+            for(j = 0; j < num_p_filters; j++)

             {

-               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

-               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

-                  PNG_WEIGHT_SHIFT;

+                if(png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)

+                {

+                    sumlo = (sumlo * png_ptr->filter_weights[j]) >>

+                            PNG_WEIGHT_SHIFT;

+                    sumhi = (sumhi * png_ptr->filter_weights[j]) >>

+                            PNG_WEIGHT_SHIFT;

+                }

             }

-         }

-

-         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>

-            PNG_COST_SHIFT;

-         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>

-            PNG_COST_SHIFT;

-

-         if (sumhi > PNG_HIMASK)

-            sum = PNG_MAXSUM;

-         else

-            sum = (sumhi << PNG_HISHIFT) + sumlo;

-      }

+

+            sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>

+                    PNG_COST_SHIFT;

+            sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>

+                    PNG_COST_SHIFT;

+

+            if(sumhi > PNG_HIMASK)

+                sum = PNG_MAXSUM;

+            else

+                sum = (sumhi << PNG_HISHIFT) + sumlo;

+        }

 #endif

 

-      if (sum < mins)

-      {

-         best_row = png_ptr->paeth_row;

-      }

-   }

+        if(sum < mins)

+        {

+            best_row = png_ptr->paeth_row;

+        }

+    }

 #endif /* PNG_WRITE_FILTER_SUPPORTED */

-   /* Do the actual writing of the filtered row data from the chosen filter. */

+    /* Do the actual writing of the filtered row data from the chosen filter. */

 

-   png_write_filtered_row(png_ptr, best_row);

+    png_write_filtered_row(png_ptr, best_row);

 

 #ifdef PNG_WRITE_FILTER_SUPPORTED

 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

-   /* Save the type of filter we picked this time for future calculations */

-   if (png_ptr->num_prev_filters > 0)

-   {

-      int j;

-      for (j = 1; j < num_p_filters; j++)

-      {

-         png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];

-      }

-      png_ptr->prev_filters[j] = best_row[0];

-   }

+    /* Save the type of filter we picked this time for future calculations */

+    if(png_ptr->num_prev_filters > 0)

+    {

+        int j;

+        for(j = 1; j < num_p_filters; j++)

+        {

+            png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];

+        }

+        png_ptr->prev_filters[j] = best_row[0];

+    }

 #endif

 #endif /* PNG_WRITE_FILTER_SUPPORTED */

 }

@@ -2726,61 +2736,62 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
 void /* PRIVATE */

 png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)

 {

-   png_debug(1, "in png_write_filtered_row");

-

-   png_debug1(2, "filter = %d", filtered_row[0]);

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

-   do

-   {

-      int ret; /* Return of zlib */

-

-      /* Compress the data */

-      ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);

-      /* Check for compression errors */

-      if (ret != Z_OK)

-      {

-         if (png_ptr->zstream.msg != NULL)

-            png_error(png_ptr, png_ptr->zstream.msg);

-         else

-            png_error(png_ptr, "zlib error");

-      }

-

-      /* See if it is time to write another IDAT */

-      if (!(png_ptr->zstream.avail_out))

-      {

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

-   } while (png_ptr->zstream.avail_in);

-

-   /* Swap the current and previous rows */

-   if (png_ptr->prev_row != NULL)

-   {

-      png_bytep tptr;

-

-      tptr = png_ptr->prev_row;

-      png_ptr->prev_row = png_ptr->row_buf;

-      png_ptr->row_buf = tptr;

-   }

-

-   /* Finish row - updates counters and flushes zlib if last row */

-   png_write_finish_row(png_ptr);

+    png_debug(1, "in png_write_filtered_row");

+

+    png_debug1(2, "filter = %d", filtered_row[0]);

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

+    do

+    {

+        int ret; /* Return of zlib */

+

+        /* Compress the data */

+        ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);

+        /* Check for compression errors */

+        if(ret != Z_OK)

+        {

+            if(png_ptr->zstream.msg != NULL)

+                png_error(png_ptr, png_ptr->zstream.msg);

+            else

+                png_error(png_ptr, "zlib error");

+        }

+

+        /* See if it is time to write another IDAT */

+        if(!(png_ptr->zstream.avail_out))

+        {

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

+    }

+    while(png_ptr->zstream.avail_in);

+

+    /* Swap the current and previous rows */

+    if(png_ptr->prev_row != NULL)

+    {

+        png_bytep tptr;

+

+        tptr = png_ptr->prev_row;

+        png_ptr->prev_row = png_ptr->row_buf;

+        png_ptr->row_buf = tptr;

+    }

+

+    /* Finish row - updates counters and flushes zlib if last row */

+    png_write_finish_row(png_ptr);

 

 #ifdef PNG_WRITE_FLUSH_SUPPORTED

-   png_ptr->flush_rows++;

+    png_ptr->flush_rows++;

 

-   if (png_ptr->flush_dist > 0 &&

+    if(png_ptr->flush_dist > 0 &&

        png_ptr->flush_rows >= png_ptr->flush_dist)

-   {

-      png_write_flush(png_ptr);

-   }

+    {

+        png_write_flush(png_ptr);

+    }

 #endif

 }

 #endif /* PNG_WRITE_SUPPORTED */