[devel] Changed "extern PNG_EXPORT" to "PNG_EXPORT" in png.h (Jan Nijtmans)

Changed "extern" to "PNG_EXTERN" in pngpriv.h (except for the 'extern "C" {')

1 files changed, 206 insertions, 206 deletions

diff --git a/png.h b/png.h
index 8a34e3853..f428a8249 100644
--- a/png.h
+++ b/png.h
@@ -1,7 +1,7 @@
 
 /* png.h - header file for PNG reference library
  *
- * libpng version 1.5.0beta33 - June 29, 2010
+ * libpng version 1.5.0beta33 - July 6, 2010
  * Copyright (c) 1998-2010 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -11,7 +11,7 @@
  * Authors and maintainers:
  *   libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
  *   libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger
- *   libpng versions 0.97, January 1998, through 1.5.0beta33 - June 29, 2010: Glenn
+ *   libpng versions 0.97, January 1998, through 1.5.0beta33 - July 6, 2010: Glenn
  *   See also "Contributing Authors", below.
  *
  * Note about libpng version numbers:
@@ -172,7 +172,7 @@
  *
  * This code is released under the libpng license.
  *
- * libpng versions 1.2.6, August 15, 2004, through 1.5.0beta33, June 29, 2010, are
+ * libpng versions 1.2.6, August 15, 2004, through 1.5.0beta33, July 6, 2010, are
  * Copyright (c) 2004, 2006-2010 Glenn Randers-Pehrson, and are
  * distributed according to the same disclaimer and license as libpng-1.2.5
  * with the following individual added to the list of Contributing Authors:
@@ -284,7 +284,7 @@
  * Y2K compliance in libpng:
  * =========================
  *
- *    June 29, 2010
+ *    July 6, 2010
  *
  *    Since the PNG Development group is an ad-hoc body, we can't make
  *    an official declaration.
@@ -348,7 +348,7 @@
 /* Version information for png.h - this should match the version in png.c */
 #define PNG_LIBPNG_VER_STRING "1.5.0beta33"
 #define PNG_HEADER_VERSION_STRING \
-     " libpng version 1.5.0beta33 - June 29, 2010\n"
+     " libpng version 1.5.0beta33 - July 6, 2010\n"
 
 #define PNG_LIBPNG_VER_SONUM   15
 #define PNG_LIBPNG_VER_DLLNUM  15
@@ -848,12 +848,12 @@ typedef png_struct FAR * FAR * png_structpp;
  */
 
 /* Returns the version number of the library */
-extern PNG_EXPORT(png_uint_32,png_access_version_number,(void),,1);
+PNG_EXPORT(png_uint_32,png_access_version_number,(void),,1);
 
 /* 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,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_sig_bytes,(png_structp png_ptr,
     int num_bytes),,2);
 
 /* Check sig[start] through sig[start + num_to_check - 1] to see if it's a
@@ -861,7 +861,7 @@ extern PNG_EXPORT(void,png_set_sig_bytes,(png_structp png_ptr,
  * 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,(png_bytep sig, png_size_t start,
+PNG_EXPORT(int,png_sig_cmp,(png_bytep sig, png_size_t start,
     png_size_t num_to_check),,3);
 
 /* Simple signature checking function.  This is the same as calling
@@ -870,19 +870,19 @@ extern PNG_EXPORT(int,png_sig_cmp,(png_bytep sig, png_size_t start,
 #define png_check_sig(sig,n) !png_sig_cmp((sig), 0, (n))
 
 /* Allocate and initialize png_ptr struct for reading, and any other memory. */
-extern PNG_EXPORT(png_structp,png_create_read_struct,
+PNG_EXPORT(png_structp,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_ALLOCATED,4);
 
 /* Allocate and initialize png_ptr struct for writing, and any other memory */
-extern PNG_EXPORT(png_structp,png_create_write_struct,
+PNG_EXPORT(png_structp,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_ALLOCATED,5);
 
-extern PNG_EXPORT(png_size_t,png_get_compression_buffer_size,(png_structp
+PNG_EXPORT(png_size_t,png_get_compression_buffer_size,(png_structp
     png_ptr),,6);
 
-extern PNG_EXPORT(void,png_set_compression_buffer_size,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_compression_buffer_size,(png_structp png_ptr,
     png_size_t size),,7);
 
 /* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp
@@ -896,7 +896,7 @@ extern PNG_EXPORT(void,png_set_compression_buffer_size,(png_structp png_ptr,
  * 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, (png_structp png_ptr,
+PNG_EXPORT(jmp_buf*, png_set_longjmp_fn, (png_structp png_ptr,
     png_longjmp_ptr longjmp_fn, size_t jmp_buf_size),,8);
 #  define png_jmpbuf(png_ptr) \
       (*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf)))
@@ -909,176 +909,176 @@ extern PNG_EXPORT(jmp_buf*, png_set_longjmp_fn, (png_structp png_ptr,
  * will use it; otherwise it will call PNG_ABORT().  This function was
  * added in libpng-1.5.0.
  */
-extern PNG_EXPORT(void, png_longjmp, (png_structp png_ptr, int val),
+PNG_EXPORT(void, png_longjmp, (png_structp png_ptr, int val),
     PNG_NORETURN,9);
 
 #ifdef PNG_READ_SUPPORTED
 /* Reset the compression stream */
-extern PNG_EXPORT(int,png_reset_zstream,(png_structp png_ptr),,10);
+PNG_EXPORT(int,png_reset_zstream,(png_structp png_ptr),,10);
 #endif
 
 /* 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,
+PNG_EXPORT(png_structp,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_ALLOCATED,11);
-extern PNG_EXPORT(png_structp,png_create_write_struct_2,
+PNG_EXPORT(png_structp,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_ALLOCATED,12);
 #endif
 
 /* Write the PNG file signature. */
-extern PNG_EXPORT(void,png_write_sig,(png_structp png_ptr),,13);
+PNG_EXPORT(void,png_write_sig,(png_structp png_ptr),,13);
 
 /* Write a PNG chunk - size, type, (optional) data, CRC. */
-extern PNG_EXPORT(void,png_write_chunk,(png_structp png_ptr,
+PNG_EXPORT(void,png_write_chunk,(png_structp png_ptr,
     png_bytep chunk_name, png_bytep data, png_size_t length),,14);
 
 /* Write the start of a PNG chunk - length and chunk name. */
-extern PNG_EXPORT(void,png_write_chunk_start,(png_structp png_ptr,
+PNG_EXPORT(void,png_write_chunk_start,(png_structp png_ptr,
     png_bytep chunk_name, png_uint_32 length),,15);
 
 /* Write the data of a PNG chunk started with png_write_chunk_start(). */
-extern PNG_EXPORT(void,png_write_chunk_data,(png_structp png_ptr,
+PNG_EXPORT(void,png_write_chunk_data,(png_structp png_ptr,
     png_bytep data, png_size_t length),,16);
 
 /* Finish a chunk started with png_write_chunk_start() (includes CRC). */
-extern PNG_EXPORT(void,png_write_chunk_end,(png_structp png_ptr),,17);
+PNG_EXPORT(void,png_write_chunk_end,(png_structp png_ptr),,17);
 
 /* Allocate and initialize the info structure */
-extern PNG_EXPORT(png_infop,png_create_info_struct,(png_structp png_ptr),
+PNG_EXPORT(png_infop,png_create_info_struct,(png_structp png_ptr),
     PNG_ALLOCATED,18);
 
-extern PNG_EXPORT(void,png_info_init_3,(png_infopp info_ptr,
+PNG_EXPORT(void,png_info_init_3,(png_infopp info_ptr,
     png_size_t png_info_struct_size),,19);
 
 /* Writes all the PNG information before the image. */
-extern PNG_EXPORT(void,png_write_info_before_PLTE,(png_structp png_ptr,
+PNG_EXPORT(void,png_write_info_before_PLTE,(png_structp png_ptr,
     png_infop info_ptr),,20);
-extern PNG_EXPORT(void,png_write_info,(png_structp png_ptr,
+PNG_EXPORT(void,png_write_info,(png_structp png_ptr,
     png_infop info_ptr),,21);
 
 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 /* Read the information before the actual image data. */
-extern PNG_EXPORT(void,png_read_info,(png_structp png_ptr,
+PNG_EXPORT(void,png_read_info,(png_structp png_ptr,
     png_infop info_ptr),,22);
 #endif
 
 #ifdef PNG_TIME_RFC1123_SUPPORTED
-extern PNG_EXPORT(png_charp,png_convert_to_rfc1123,(png_structp png_ptr,
+PNG_EXPORT(png_charp,png_convert_to_rfc1123,(png_structp png_ptr,
     png_timep ptime),,23);
 #endif
 
 #ifdef PNG_CONVERT_tIME_SUPPORTED
 /* Convert from a struct tm to png_time */
-extern PNG_EXPORT(void,png_convert_from_struct_tm,(png_timep ptime,
+PNG_EXPORT(void,png_convert_from_struct_tm,(png_timep ptime,
     struct tm FAR * ttime),,24);
 
 /* Convert from time_t to png_time.  Uses gmtime() */
-extern PNG_EXPORT(void,png_convert_from_time_t,(png_timep ptime,
+PNG_EXPORT(void,png_convert_from_time_t,(png_timep ptime,
     time_t ttime),,25);
 #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,(png_structp png_ptr),,26);
-extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8,(png_structp png_ptr),,
+PNG_EXPORT(void,png_set_expand,(png_structp png_ptr),,26);
+PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8,(png_structp png_ptr),,
     27);
-extern PNG_EXPORT(void,png_set_palette_to_rgb,(png_structp png_ptr),,28);
-extern PNG_EXPORT(void,png_set_tRNS_to_alpha,(png_structp png_ptr),,29);
+PNG_EXPORT(void,png_set_palette_to_rgb,(png_structp png_ptr),,28);
+PNG_EXPORT(void,png_set_tRNS_to_alpha,(png_structp png_ptr),,29);
 #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,(png_structp png_ptr),,30);
+PNG_EXPORT(void,png_set_bgr,(png_structp png_ptr),,30);
 #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,(png_structp png_ptr),,31);
+PNG_EXPORT(void,png_set_gray_to_rgb,(png_structp png_ptr),,31);
 
 /* Reduce RGB to grayscale. */
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_rgb_to_gray,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_rgb_to_gray,(png_structp png_ptr,
     int error_action, double red, double green ),,32);
 #  endif
 #  ifdef PNG_FIXED_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_rgb_to_gray_fixed,(png_structp png_ptr,
     int error_action, png_fixed_point red, png_fixed_point green),,33);
 #  endif
 
-extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status,(png_structp png_ptr),,
+PNG_EXPORT(png_byte,png_get_rgb_to_gray_status,(png_structp png_ptr),,
     34);
 #endif
 
-extern PNG_EXPORT(void,png_build_grayscale_palette,(int bit_depth,
+PNG_EXPORT(void,png_build_grayscale_palette,(int bit_depth,
     png_colorp palette),,35);
 
 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
-extern PNG_EXPORT(void,png_set_strip_alpha,(png_structp png_ptr),,36);
+PNG_EXPORT(void,png_set_strip_alpha,(png_structp png_ptr),,36);
 #endif
 
 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
     defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
-extern PNG_EXPORT(void,png_set_swap_alpha,(png_structp png_ptr),,37);
+PNG_EXPORT(void,png_set_swap_alpha,(png_structp png_ptr),,37);
 #endif
 
 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
     defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
-extern PNG_EXPORT(void,png_set_invert_alpha,(png_structp png_ptr),,38);
+PNG_EXPORT(void,png_set_invert_alpha,(png_structp png_ptr),,38);
 #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,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_filler,(png_structp png_ptr,
     png_uint_32 filler, int flags),,39);
 /* 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,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_add_alpha,(png_structp png_ptr,
     png_uint_32 filler, int flags),,40);
 #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,(png_structp png_ptr),,41);
+PNG_EXPORT(void,png_set_swap,(png_structp png_ptr),,41);
 #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,(png_structp png_ptr),,42);
+PNG_EXPORT(void,png_set_packing,(png_structp png_ptr),,42);
 #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,(png_structp png_ptr),,43);
+PNG_EXPORT(void,png_set_packswap,(png_structp png_ptr),,43);
 #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,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_shift,(png_structp png_ptr,
     png_color_8p true_bits),,44);
 #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,(png_structp png_ptr),,45);
+PNG_EXPORT(int,png_set_interlace_handling,(png_structp png_ptr),,45);
 #endif
 
 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
 /* Invert monochrome files */
-extern PNG_EXPORT(void,png_set_invert_mono,(png_structp png_ptr),,46);
+PNG_EXPORT(void,png_set_invert_mono,(png_structp png_ptr),,46);
 #endif
 
 #ifdef PNG_READ_BACKGROUND_SUPPORTED
 /* Handle alpha and tRNS by replacing with a background color. */
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_background,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_background,(png_structp png_ptr,
     png_color_16p background_color, int background_gamma_code,
     int need_expand, double background_gamma),,47);
 #  endif
@@ -1091,14 +1091,14 @@ extern PNG_EXPORT(void,png_set_background,(png_structp png_ptr,
 
 #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,(png_structp png_ptr),,48);
+PNG_EXPORT(void,png_set_strip_16,(png_structp png_ptr),,48);
 #endif
 
 #ifdef PNG_READ_QUANTIZE_SUPPORTED
 /* Turn on quantizing, and reduce the palette to the number of colors
  * available.
  */
-extern PNG_EXPORT(void,png_set_quantize,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_quantize,(png_structp png_ptr,
     png_colorp palette, int num_palette, int maximum_colors,
     png_uint_16p histogram, int full_quantize),,49);
 #endif
@@ -1106,7 +1106,7 @@ extern PNG_EXPORT(void,png_set_quantize,(png_structp png_ptr,
 #ifdef PNG_READ_GAMMA_SUPPORTED
 /* Handle gamma correction. Screen_gamma=(display_exponent) */
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_gamma,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_gamma,(png_structp png_ptr,
     double screen_gamma, double default_file_gamma),,50);
 #  endif
 /* TODO: png_set_gamma_fixed */
@@ -1115,71 +1115,71 @@ extern PNG_EXPORT(void,png_set_gamma,(png_structp png_ptr,
 
 #ifdef PNG_WRITE_FLUSH_SUPPORTED
 /* Set how many lines between output flushes - 0 for no flushing */
-extern PNG_EXPORT(void,png_set_flush,(png_structp png_ptr, int nrows),,51);
+PNG_EXPORT(void,png_set_flush,(png_structp png_ptr, int nrows),,51);
 /* Flush the current PNG output buffer */
-extern PNG_EXPORT(void,png_write_flush,(png_structp png_ptr),,52);
+PNG_EXPORT(void,png_write_flush,(png_structp png_ptr),,52);
 #endif
 
 /* Optional update palette with requested transformations */
-extern PNG_EXPORT(void,png_start_read_image,(png_structp png_ptr),,53);
+PNG_EXPORT(void,png_start_read_image,(png_structp png_ptr),,53);
 
 /* Optional call to update the users info structure */
-extern PNG_EXPORT(void,png_read_update_info,(png_structp png_ptr,
+PNG_EXPORT(void,png_read_update_info,(png_structp png_ptr,
     png_infop info_ptr),,54);
 
 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 /* Read one or more rows of image data. */
-extern PNG_EXPORT(void,png_read_rows,(png_structp png_ptr, png_bytepp row,
+PNG_EXPORT(void,png_read_rows,(png_structp png_ptr, png_bytepp row,
     png_bytepp display_row, png_uint_32 num_rows),,55);
 #endif
 
 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 /* Read a row of data. */
-extern PNG_EXPORT(void,png_read_row,(png_structp png_ptr, png_bytep row,
+PNG_EXPORT(void,png_read_row,(png_structp png_ptr, png_bytep row,
     png_bytep display_row),,56);
 #endif
 
 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 /* Read the whole image into memory at once. */
-extern PNG_EXPORT(void,png_read_image,(png_structp png_ptr,
+PNG_EXPORT(void,png_read_image,(png_structp png_ptr,
     png_bytepp image),,57);
 #endif
 
 /* Write a row of image data */
-extern PNG_EXPORT(void,png_write_row,(png_structp png_ptr, png_bytep row),,58);
+PNG_EXPORT(void,png_write_row,(png_structp png_ptr, png_bytep row),,58);
 
 /* Write a few rows of image data */
-extern PNG_EXPORT(void,png_write_rows,(png_structp png_ptr,
+PNG_EXPORT(void,png_write_rows,(png_structp png_ptr,
     png_bytepp row, png_uint_32 num_rows),,59);
 
 /* Write the image data */
-extern PNG_EXPORT(void,png_write_image,(png_structp png_ptr,
+PNG_EXPORT(void,png_write_image,(png_structp png_ptr,
     png_bytepp image),,60);
 
 /* Write the end of the PNG file. */
-extern PNG_EXPORT(void,png_write_end,(png_structp png_ptr,
+PNG_EXPORT(void,png_write_end,(png_structp png_ptr,
     png_infop info_ptr),,61);
 
 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 /* Read the end of the PNG file. */
-extern PNG_EXPORT(void,png_read_end,(png_structp png_ptr,
+PNG_EXPORT(void,png_read_end,(png_structp png_ptr,
     png_infop info_ptr),,62);
 #endif
 
 /* Free any memory associated with the png_info_struct */
-extern PNG_EXPORT(void,png_destroy_info_struct,(png_structp png_ptr,
+PNG_EXPORT(void,png_destroy_info_struct,(png_structp png_ptr,
     png_infopp info_ptr_ptr),,63);
 
 /* Free any memory associated with the png_struct and the png_info_structs */
-extern PNG_EXPORT(void,png_destroy_read_struct,(png_structpp png_ptr_ptr,
+PNG_EXPORT(void,png_destroy_read_struct,(png_structpp png_ptr_ptr,
     png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr),,64);
 
 /* Free any memory associated with the png_struct and the png_info_structs */
-extern PNG_EXPORT(void,png_destroy_write_struct,(png_structpp png_ptr_ptr,
+PNG_EXPORT(void,png_destroy_write_struct,(png_structpp png_ptr_ptr,
     png_infopp info_ptr_ptr),,65);
 
 /* Set the libpng method of handling chunk CRC errors */
-extern PNG_EXPORT(void,png_set_crc_action,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_crc_action,(png_structp png_ptr,
     int crit_action, int ancil_action),,66);
 
 /* Values for png_set_crc_action() to say how to handle CRC errors in
@@ -1209,7 +1209,7 @@ extern PNG_EXPORT(void,png_set_crc_action,(png_structp png_ptr,
 /* Set the filtering method(s) used by libpng.  Currently, the only valid
  * value for "method" is 0.
  */
-extern PNG_EXPORT(void,png_set_filter,(png_structp png_ptr, int method,
+PNG_EXPORT(void,png_set_filter,(png_structp png_ptr, int method,
     int filters),,67);
 
 /* Flags for png_set_filter() to say which filters to use.  The flags
@@ -1266,7 +1266,7 @@ extern PNG_EXPORT(void,png_set_filter,(png_structp png_ptr, int method,
  * to the UNWEIGHTED method, but with added encoding time/computation.
  */
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_filter_heuristics,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_filter_heuristics,(png_structp png_ptr,
     int heuristic_method, int num_weights, png_doublep filter_weights,
     png_doublep filter_costs),,68);
 #  endif
@@ -1288,19 +1288,19 @@ extern PNG_EXPORT(void,png_set_filter_heuristics,(png_structp png_ptr,
  * 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,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_compression_level,(png_structp png_ptr,
     int level),,69);
 
-extern PNG_EXPORT(void,png_set_compression_mem_level,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_compression_mem_level,(png_structp png_ptr,
     int mem_level),,70);
 
-extern PNG_EXPORT(void,png_set_compression_strategy,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_compression_strategy,(png_structp png_ptr,
     int strategy),,71);
 
-extern PNG_EXPORT(void,png_set_compression_window_bits,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_compression_window_bits,(png_structp png_ptr,
     int window_bits),,72);
 
-extern PNG_EXPORT(void,png_set_compression_method,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_compression_method,(png_structp png_ptr,
     int method),,73);
 
 /* These next functions are called for input/output, memory, and error
@@ -1314,7 +1314,7 @@ extern PNG_EXPORT(void,png_set_compression_method,(png_structp png_ptr,
 
 #ifdef PNG_STDIO_SUPPORTED
 /* Initialize the input/output for the PNG file to the default functions. */
-extern PNG_EXPORT(void,png_init_io,(png_structp png_ptr, png_FILE_p fp),,74);
+PNG_EXPORT(void,png_init_io,(png_structp png_ptr, png_FILE_p fp),,74);
 #endif
 
 /* Replace the (error and abort), and warning functions with user
@@ -1325,12 +1325,12 @@ extern PNG_EXPORT(void,png_init_io,(png_structp png_ptr, png_FILE_p fp),,74);
  * default function will be used.
  */
 
-extern PNG_EXPORT(void,png_set_error_fn,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_error_fn,(png_structp png_ptr,
     png_voidp error_ptr, png_error_ptr error_fn,
     png_error_ptr warning_fn),,75);
 
 /* Return the user pointer associated with the error functions */
-extern PNG_EXPORT(png_voidp,png_get_error_ptr,(png_structp png_ptr),,76);
+PNG_EXPORT(png_voidp,png_get_error_ptr,(png_structp png_ptr),,76);
 
 /* 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.
@@ -1342,98 +1342,98 @@ extern PNG_EXPORT(png_voidp,png_get_error_ptr,(png_structp png_ptr),,76);
  * default flush function, which uses the standard *FILE structure, will
  * be used.
  */
-extern PNG_EXPORT(void,png_set_write_fn,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_write_fn,(png_structp png_ptr,
     png_voidp io_ptr, png_rw_ptr write_data_fn,
     png_flush_ptr output_flush_fn),,77);
 
 /* Replace the default data input function with a user supplied one. */
-extern PNG_EXPORT(void,png_set_read_fn,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_read_fn,(png_structp png_ptr,
     png_voidp io_ptr, png_rw_ptr read_data_fn),,78);
 
 /* Return the user pointer associated with the I/O functions */
-extern PNG_EXPORT(png_voidp,png_get_io_ptr,(png_structp png_ptr),,79);
+PNG_EXPORT(png_voidp,png_get_io_ptr,(png_structp png_ptr),,79);
 
-extern PNG_EXPORT(void,png_set_read_status_fn,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_read_status_fn,(png_structp png_ptr,
     png_read_status_ptr read_row_fn),,80);
 
-extern PNG_EXPORT(void,png_set_write_status_fn,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_write_status_fn,(png_structp png_ptr,
     png_write_status_ptr write_row_fn),,81);
 
 #ifdef PNG_USER_MEM_SUPPORTED
 /* Replace the default memory allocation functions with user supplied one(s). */
-extern PNG_EXPORT(void,png_set_mem_fn,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_mem_fn,(png_structp png_ptr,
     png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),,82);
 /* Return the user pointer associated with the memory functions */
-extern PNG_EXPORT(png_voidp,png_get_mem_ptr,(png_structp png_ptr),,83);
+PNG_EXPORT(png_voidp,png_get_mem_ptr,(png_structp png_ptr),,83);
 #endif
 
 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
-extern PNG_EXPORT(void,png_set_read_user_transform_fn,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_read_user_transform_fn,(png_structp png_ptr,
     png_user_transform_ptr read_user_transform_fn),,84);
 #endif
 
 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
-extern PNG_EXPORT(void,png_set_write_user_transform_fn,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_write_user_transform_fn,(png_structp png_ptr,
     png_user_transform_ptr write_user_transform_fn),,85);
 #endif
 
 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
-extern PNG_EXPORT(void,png_set_user_transform_info,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_user_transform_info,(png_structp png_ptr,
     png_voidp user_transform_ptr, int user_transform_depth,
     int user_transform_channels),,86);
 /* Return the user pointer associated with the user transform functions */
-extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr,
+PNG_EXPORT(png_voidp,png_get_user_transform_ptr,
     (png_structp png_ptr),,87);
 #endif
 
 #ifdef PNG_USER_CHUNKS_SUPPORTED
-extern PNG_EXPORT(void,png_set_read_user_chunk_fn,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_read_user_chunk_fn,(png_structp png_ptr,
     png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn),,88);
-extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr,(png_structp png_ptr),,89);
+PNG_EXPORT(png_voidp,png_get_user_chunk_ptr,(png_structp png_ptr),,89);
 #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,(png_structp png_ptr,
+PNG_EXPORT(void,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),,90);
 
 /* Returns the user pointer associated with the push read functions */
-extern PNG_EXPORT(png_voidp,png_get_progressive_ptr,(png_structp png_ptr),,91);
+PNG_EXPORT(png_voidp,png_get_progressive_ptr,(png_structp png_ptr),,91);
 
 /* Function to be called when data becomes available */
-extern PNG_EXPORT(void,png_process_data,(png_structp png_ptr,
+PNG_EXPORT(void,png_process_data,(png_structp png_ptr,
     png_infop info_ptr, png_bytep buffer, png_size_t buffer_size),,92);
 
 /* 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,(png_structp png_ptr,
+PNG_EXPORT(void,png_progressive_combine_row,(png_structp png_ptr,
     png_bytep old_row, png_bytep new_row),,93);
 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
 
-extern PNG_EXPORT(png_voidp,png_malloc,(png_structp png_ptr,
+PNG_EXPORT(png_voidp,png_malloc,(png_structp png_ptr,
     png_alloc_size_t size),PNG_ALLOCATED,94);
 /* Added at libpng version 1.4.0 */
-extern PNG_EXPORT(png_voidp,png_calloc,(png_structp png_ptr,
+PNG_EXPORT(png_voidp,png_calloc,(png_structp png_ptr,
     png_alloc_size_t size),PNG_ALLOCATED,95);
 
 /* Added at libpng version 1.2.4 */
-extern PNG_EXPORT(png_voidp,png_malloc_warn,(png_structp png_ptr,
+PNG_EXPORT(png_voidp,png_malloc_warn,(png_structp png_ptr,
     png_alloc_size_t size),PNG_ALLOCATED,96);
 
 /* Frees a pointer allocated by png_malloc() */
-extern PNG_EXPORT(void,png_free,(png_structp png_ptr, png_voidp ptr),,97);
+PNG_EXPORT(void,png_free,(png_structp png_ptr, png_voidp ptr),,97);
 
 /* Free data that was allocated internally */
-extern PNG_EXPORT(void,png_free_data,(png_structp png_ptr, png_infop info_ptr,
+PNG_EXPORT(void,png_free_data,(png_structp png_ptr, png_infop info_ptr,
     png_uint_32 free_me, int num),,98);
 /* Reassign responsibility for freeing existing data, whether allocated
  * by libpng or by the application */
-extern PNG_EXPORT(void,png_data_freer,(png_structp png_ptr, png_infop info_ptr,
+PNG_EXPORT(void,png_data_freer,(png_structp png_ptr, png_infop info_ptr,
     int freer, png_uint_32 mask),,99);
 /* Assignments for png_data_freer */
 #define PNG_DESTROY_WILL_FREE_DATA 1
@@ -1455,47 +1455,47 @@ extern PNG_EXPORT(void,png_data_freer,(png_structp png_ptr, png_infop info_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,(png_structp png_ptr,
+PNG_EXPORT(png_voidp,png_malloc_default,(png_structp png_ptr,
     png_alloc_size_t size),PNG_ALLOCATED,100);
-extern PNG_EXPORT(void,png_free_default,(png_structp png_ptr,
+PNG_EXPORT(void,png_free_default,(png_structp png_ptr,
     png_voidp ptr),,101);
 #endif
 
 #ifdef PNG_ERROR_TEXT_SUPPORTED
 /* Fatal error in PNG image of libpng - can't continue */
-extern PNG_EXPORT(void,png_error,(png_structp png_ptr,
+PNG_EXPORT(void,png_error,(png_structp png_ptr,
     png_const_charp error_message),PNG_NORETURN,102);
 
 /* The same, but the chunk name is prepended to the error string. */
-extern PNG_EXPORT(void,png_chunk_error,(png_structp png_ptr,
+PNG_EXPORT(void,png_chunk_error,(png_structp png_ptr,
     png_const_charp error_message),PNG_NORETURN,103);
 
 #else
 /* Fatal error in PNG image of libpng - can't continue */
-extern PNG_EXPORT(void,png_err,(png_structp png_ptr),PNG_NORETURN,104);
+PNG_EXPORT(void,png_err,(png_structp png_ptr),PNG_NORETURN,104);
 #endif
 
 /* Non-fatal error in libpng.  Can continue, but may have a problem. */
-extern PNG_EXPORT(void,png_warning,(png_structp png_ptr,
+PNG_EXPORT(void,png_warning,(png_structp png_ptr,
     png_const_charp warning_message),,105);
 
 /* Non-fatal error in libpng, chunk name is prepended to message. */
-extern PNG_EXPORT(void,png_chunk_warning,(png_structp png_ptr,
+PNG_EXPORT(void,png_chunk_warning,(png_structp png_ptr,
     png_const_charp warning_message),,106);
 
 #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. */
 #  undef png_benign_error
-extern PNG_EXPORT(void,png_benign_error,(png_structp png_ptr,
+PNG_EXPORT(void,png_benign_error,(png_structp png_ptr,
     png_const_charp warning_message),,107);
 
 /* Same, chunk name is prepended to message. */
 #  undef png_chunk_benign_error
-extern PNG_EXPORT(void,png_chunk_benign_error,(png_structp png_ptr,
+PNG_EXPORT(void,png_chunk_benign_error,(png_structp png_ptr,
     png_const_charp warning_message),,108);
 
-extern PNG_EXPORT(void,png_set_benign_errors,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_benign_errors,(png_structp png_ptr,
     int allowed),,109);
 #else
 #  ifdef PNG_ALLOW_BENIGN_ERRORS
@@ -1520,109 +1520,109 @@ extern PNG_EXPORT(void,png_set_benign_errors,(png_structp png_ptr,
  * png_info_struct.
  */
 /* Returns "flag" if chunk data is valid in info_ptr. */
-extern PNG_EXPORT(png_uint_32,png_get_valid,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_valid,(png_structp png_ptr,
     png_infop info_ptr, png_uint_32 flag),,110);
 
 /* Returns number of bytes needed to hold a transformed row. */
-extern PNG_EXPORT(png_size_t,png_get_rowbytes,(png_structp png_ptr,
+PNG_EXPORT(png_size_t,png_get_rowbytes,(png_structp png_ptr,
     png_infop info_ptr),,111);
 
 #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,(png_structp png_ptr,
+PNG_EXPORT(png_bytepp,png_get_rows,(png_structp png_ptr,
     png_infop info_ptr),,112);
 /* Set row_pointers, which is an array of pointers to scanlines for use
  * by png_write_png().
  */
-extern PNG_EXPORT(void,png_set_rows,(png_structp png_ptr, png_infop info_ptr,
+PNG_EXPORT(void,png_set_rows,(png_structp png_ptr, png_infop info_ptr,
     png_bytepp row_pointers),,113);
 #endif
 
 /* Returns number of color channels in image. */
-extern PNG_EXPORT(png_byte,png_get_channels,(png_structp png_ptr,
+PNG_EXPORT(png_byte,png_get_channels,(png_structp png_ptr,
     png_infop info_ptr),,114);
 
 #ifdef PNG_EASY_ACCESS_SUPPORTED
 /* Returns image width in pixels. */
-extern PNG_EXPORT(png_uint_32, png_get_image_width,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32, png_get_image_width,(png_structp png_ptr,
     png_infop info_ptr),,115);
 
 /* Returns image height in pixels. */
-extern PNG_EXPORT(png_uint_32, png_get_image_height,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32, png_get_image_height,(png_structp png_ptr,
     png_infop info_ptr),,116);
 
 /* Returns image bit_depth. */
-extern PNG_EXPORT(png_byte, png_get_bit_depth,(png_structp png_ptr,
+PNG_EXPORT(png_byte, png_get_bit_depth,(png_structp png_ptr,
     png_infop info_ptr),,117);
 
 /* Returns image color_type. */
-extern PNG_EXPORT(png_byte, png_get_color_type,(png_structp png_ptr,
+PNG_EXPORT(png_byte, png_get_color_type,(png_structp png_ptr,
     png_infop info_ptr),,118);
 
 /* Returns image filter_type. */
-extern PNG_EXPORT(png_byte, png_get_filter_type,(png_structp png_ptr,
+PNG_EXPORT(png_byte, png_get_filter_type,(png_structp png_ptr,
     png_infop info_ptr),,119);
 
 /* Returns image interlace_type. */
-extern PNG_EXPORT(png_byte, png_get_interlace_type,(png_structp png_ptr,
+PNG_EXPORT(png_byte, png_get_interlace_type,(png_structp png_ptr,
     png_infop info_ptr),,120);
 
 /* Returns image compression_type. */
-extern PNG_EXPORT(png_byte, png_get_compression_type,(png_structp png_ptr,
+PNG_EXPORT(png_byte, png_get_compression_type,(png_structp png_ptr,
     png_infop info_ptr),,121);
 
 /* Returns image resolution in pixels per meter, from pHYs chunk data. */
-extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32, png_get_pixels_per_meter,(png_structp png_ptr,
     png_infop info_ptr),,122);
-extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter,
+PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter,
     (png_structp png_ptr, png_infop info_ptr),,123);
-extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter,
+PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter,
     (png_structp png_ptr, png_infop info_ptr),,124);
 
 /* Returns pixel aspect ratio, computed from pHYs chunk data.  */
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(float, png_get_pixel_aspect_ratio,
+PNG_EXPORT(float, png_get_pixel_aspect_ratio,
     (png_structp png_ptr, png_infop info_ptr),,125);
 #  endif
 /* TODO: png_get_pixel_aspect_ratio_fixed */
 
 /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
-extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels,
+PNG_EXPORT(png_int_32, png_get_x_offset_pixels,
     (png_structp png_ptr, png_infop info_ptr),,126);
-extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels,
+PNG_EXPORT(png_int_32, png_get_y_offset_pixels,
     (png_structp png_ptr, png_infop info_ptr),,127);
-extern PNG_EXPORT(png_int_32, png_get_x_offset_microns,
+PNG_EXPORT(png_int_32, png_get_x_offset_microns,
     (png_structp png_ptr, png_infop info_ptr),,128);
-extern PNG_EXPORT(png_int_32, png_get_y_offset_microns,
+PNG_EXPORT(png_int_32, png_get_y_offset_microns,
     (png_structp png_ptr, png_infop info_ptr),,129);
 
 #endif /* PNG_EASY_ACCESS_SUPPORTED */
 
 /* Returns pointer to signature string read from PNG header */
-extern PNG_EXPORT(png_bytep,png_get_signature,(png_structp png_ptr,
+PNG_EXPORT(png_bytep,png_get_signature,(png_structp png_ptr,
     png_infop info_ptr),,130);
 
 #ifdef PNG_bKGD_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_bKGD,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_bKGD,(png_structp png_ptr,
     png_infop info_ptr, png_color_16p *background),,131);
 #endif
 
 #ifdef PNG_bKGD_SUPPORTED
-extern PNG_EXPORT(void,png_set_bKGD,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_bKGD,(png_structp png_ptr,
     png_infop info_ptr, png_color_16p background),,132);
 #endif
 
 #ifdef PNG_cHRM_SUPPORTED
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_cHRM,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,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),,133);
 #  endif
 #  ifdef PNG_FIXED_POINT_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_cHRM_fixed,(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,
@@ -1633,13 +1633,13 @@ extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed,(png_structp png_ptr,
 
 #ifdef PNG_cHRM_SUPPORTED
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_cHRM,(png_structp png_ptr,
+PNG_EXPORT(void,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),,135);
 #  endif
 #  ifdef PNG_FIXED_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_cHRM_fixed,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_cHRM_fixed,(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,
@@ -1650,137 +1650,137 @@ extern PNG_EXPORT(void,png_set_cHRM_fixed,(png_structp png_ptr,
 
 #ifdef PNG_gAMA_SUPPORTED
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_gAMA,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_gAMA,(png_structp png_ptr,
     png_infop info_ptr, double *file_gamma),,137);
 #  endif
 #  ifdef PNG_FIXED_POINT_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_gAMA_fixed,(png_structp png_ptr,
     png_infop info_ptr, png_fixed_point *int_file_gamma),,138);
 #  endif
 #endif
 
 #ifdef PNG_gAMA_SUPPORTED
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_gAMA,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_gAMA,(png_structp png_ptr,
     png_infop info_ptr, double file_gamma),,139);
 #  endif
 #  ifdef PNG_FIXED_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_gAMA_fixed,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_gAMA_fixed,(png_structp png_ptr,
     png_infop info_ptr, png_fixed_point int_file_gamma),,140);
 #  endif
 #endif
 
 #ifdef PNG_hIST_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_hIST,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_hIST,(png_structp png_ptr,
     png_infop info_ptr, png_uint_16p *hist),,141);
 #endif
 
 #ifdef PNG_hIST_SUPPORTED
-extern PNG_EXPORT(void,png_set_hIST,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_hIST,(png_structp png_ptr,
     png_infop info_ptr, png_uint_16p hist),,142);
 #endif
 
-extern PNG_EXPORT(png_uint_32,png_get_IHDR,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,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_method,
     int *compression_method, int *filter_method),,143);
 
-extern PNG_EXPORT(void,png_set_IHDR,(png_structp png_ptr,
+PNG_EXPORT(void,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_method, int compression_method,
     int filter_method),,144);
 
 #ifdef PNG_oFFs_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_oFFs,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_oFFs,(png_structp png_ptr,
     png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,
     int *unit_type),,145);
 #endif
 
 #ifdef PNG_oFFs_SUPPORTED
-extern PNG_EXPORT(void,png_set_oFFs,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_oFFs,(png_structp png_ptr,
     png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y,
     int unit_type),,146);
 #endif
 
 #ifdef PNG_pCAL_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_pCAL,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,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),,147);
 #endif
 
 #ifdef PNG_pCAL_SUPPORTED
-extern PNG_EXPORT(void,png_set_pCAL,(png_structp png_ptr,
+PNG_EXPORT(void,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),,148);
 #endif
 
 #ifdef PNG_pHYs_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_pHYs,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_pHYs,(png_structp png_ptr,
     png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y,
     int *unit_type),,149);
 #endif
 
 #ifdef PNG_pHYs_SUPPORTED
-extern PNG_EXPORT(void,png_set_pHYs,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_pHYs,(png_structp png_ptr,
     png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y,
     int unit_type),,150);
 #endif
 
-extern PNG_EXPORT(png_uint_32,png_get_PLTE,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_PLTE,(png_structp png_ptr,
     png_infop info_ptr, png_colorp *palette, int *num_palette),,151);
 
-extern PNG_EXPORT(void,png_set_PLTE,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_PLTE,(png_structp png_ptr,
     png_infop info_ptr, png_colorp palette, int num_palette),,152);
 
 #ifdef PNG_sBIT_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_sBIT,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_sBIT,(png_structp png_ptr,
     png_infop info_ptr, png_color_8p *sig_bit),,153);
 #endif
 
 #ifdef PNG_sBIT_SUPPORTED
-extern PNG_EXPORT(void,png_set_sBIT,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_sBIT,(png_structp png_ptr,
     png_infop info_ptr, png_color_8p sig_bit),,154);
 #endif
 
 #ifdef PNG_sRGB_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_sRGB,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_sRGB,(png_structp png_ptr,
     png_infop info_ptr, int *intent),,155);
 #endif
 
 #ifdef PNG_sRGB_SUPPORTED
-extern PNG_EXPORT(void,png_set_sRGB,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_sRGB,(png_structp png_ptr,
     png_infop info_ptr, int intent),,156);
-extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM,(png_structp png_ptr,
     png_infop info_ptr, int intent),,157);
 #endif
 
 #ifdef PNG_iCCP_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_iCCP,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_iCCP,(png_structp png_ptr,
     png_infop info_ptr, png_charpp name, int *compression_type,
     png_charpp profile, png_uint_32 *proflen),,158);
     /* Note to maintainer: profile should be png_bytepp */
 #endif
 
 #ifdef PNG_iCCP_SUPPORTED
-extern PNG_EXPORT(void,png_set_iCCP,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_iCCP,(png_structp png_ptr,
     png_infop info_ptr, png_charp name, int compression_type,
     png_charp profile, png_uint_32 proflen),,159);
     /* Note to maintainer: profile should be png_bytep */
 #endif
 
 #ifdef PNG_sPLT_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_sPLT,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_sPLT,(png_structp png_ptr,
     png_infop info_ptr, png_sPLT_tpp entries),,160);
 #endif
 
 #ifdef PNG_sPLT_SUPPORTED
-extern PNG_EXPORT(void,png_set_sPLT,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_sPLT,(png_structp png_ptr,
     png_infop info_ptr, png_sPLT_tp entries, int nentries),,161);
 #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,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_text,(png_structp png_ptr,
     png_infop info_ptr, png_textp *text_ptr, int *num_text),,162);
 #endif
 
@@ -1792,39 +1792,39 @@ extern PNG_EXPORT(png_uint_32,png_get_text,(png_structp png_ptr,
  */
 
 #ifdef PNG_TEXT_SUPPORTED
-extern PNG_EXPORT(void,png_set_text,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_text,(png_structp png_ptr,
     png_infop info_ptr, png_textp text_ptr, int num_text),,163);
 #endif
 
 #ifdef PNG_tIME_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_tIME,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_tIME,(png_structp png_ptr,
     png_infop info_ptr, png_timep *mod_time),,164);
 #endif
 
 #ifdef PNG_tIME_SUPPORTED
-extern PNG_EXPORT(void,png_set_tIME,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_tIME,(png_structp png_ptr,
     png_infop info_ptr, png_timep mod_time),,165);
 #endif
 
 #ifdef PNG_tRNS_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_tRNS,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_tRNS,(png_structp png_ptr,
     png_infop info_ptr, png_bytep *trans_alpha, int *num_trans,
     png_color_16p *trans_color),,166);
 #endif
 
 #ifdef PNG_tRNS_SUPPORTED
-extern PNG_EXPORT(void,png_set_tRNS,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_tRNS,(png_structp png_ptr,
     png_infop info_ptr, png_bytep trans_alpha, int num_trans,
     png_color_16p trans_color),,167);
 #endif
 
 #ifdef PNG_sCAL_SUPPORTED
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_sCAL,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_sCAL,(png_structp png_ptr,
     png_infop info_ptr, int *unit, double *width, double *height),,168);
 #  endif
 #  ifdef PNG_FIXED_POINT_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_sCAL_s,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_sCAL_s,(png_structp png_ptr,
     png_infop info_ptr, int *unit, png_charpp swidth,
     png_charpp sheight),,169);
 #  endif
@@ -1832,11 +1832,11 @@ extern PNG_EXPORT(png_uint_32,png_get_sCAL_s,(png_structp png_ptr,
 
 #ifdef PNG_sCAL_SUPPORTED
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_sCAL,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_sCAL,(png_structp png_ptr,
     png_infop info_ptr, int unit, double width, double height),,170);
 #  endif
 #  ifdef PNG_FIXED_POINT_SUPPORTED
-extern PNG_EXPORT(void,png_set_sCAL_s,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_sCAL_s,(png_structp png_ptr,
     png_infop info_ptr, int unit, png_charp swidth,
     png_charp sheight),,171);
 #  endif
@@ -1852,19 +1852,19 @@ extern PNG_EXPORT(void,png_set_sCAL_s,(png_structp png_ptr,
            = 2: keep only if safe-to-copy
            = 3: keep even if unsafe-to-copy
 */
-extern PNG_EXPORT(void, png_set_keep_unknown_chunks,(png_structp png_ptr,
+PNG_EXPORT(void, png_set_keep_unknown_chunks,(png_structp png_ptr,
     int keep, png_bytep chunk_list, int num_chunks),,172);
-extern PNG_EXPORT(int,png_handle_as_unknown,(png_structp png_ptr,
+PNG_EXPORT(int,png_handle_as_unknown,(png_structp png_ptr,
     png_bytep chunk_name),,173);
 #endif
 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
-extern PNG_EXPORT(void, png_set_unknown_chunks,(png_structp png_ptr,
+PNG_EXPORT(void, png_set_unknown_chunks,(png_structp png_ptr,
     png_infop info_ptr, png_unknown_chunkp unknowns,
     int num_unknowns),,174);
-extern PNG_EXPORT(void, png_set_unknown_chunk_location,
+PNG_EXPORT(void, png_set_unknown_chunk_location,
     (png_structp png_ptr, png_infop info_ptr, int chunk,
     int location),,175);
-extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_unknown_chunks,(png_structp png_ptr,
     png_infop info_ptr, png_unknown_chunkpp entries),,176);
 #endif
 
@@ -1872,24 +1872,24 @@ extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks,(png_structp png_ptr,
  * 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,(png_structp png_ptr,
+PNG_EXPORT(void, png_set_invalid,(png_structp png_ptr,
     png_infop info_ptr, int mask),,177);
 
 #ifdef PNG_INFO_IMAGE_SUPPORTED
 /* The "params" pointer is currently not used and is for future expansion. */
-extern PNG_EXPORT(void, png_read_png,(png_structp png_ptr,
+PNG_EXPORT(void, png_read_png,(png_structp png_ptr,
     png_infop info_ptr, int transforms, png_voidp params),,178);
-extern PNG_EXPORT(void, png_write_png,(png_structp png_ptr,
+PNG_EXPORT(void, png_write_png,(png_structp png_ptr,
     png_infop info_ptr, int transforms, png_voidp params),,179);
 #endif
 
-extern PNG_EXPORT(png_charp,png_get_copyright,(png_structp png_ptr),,180);
-extern PNG_EXPORT(png_charp,png_get_header_ver,(png_structp png_ptr),,181);
-extern PNG_EXPORT(png_charp,png_get_header_version,(png_structp png_ptr),,182);
-extern PNG_EXPORT(png_charp,png_get_libpng_ver,(png_structp png_ptr),,183);
+PNG_EXPORT(png_charp,png_get_copyright,(png_structp png_ptr),,180);
+PNG_EXPORT(png_charp,png_get_header_ver,(png_structp png_ptr),,181);
+PNG_EXPORT(png_charp,png_get_header_version,(png_structp png_ptr),,182);
+PNG_EXPORT(png_charp,png_get_libpng_ver,(png_structp png_ptr),,183);
 
 #ifdef PNG_MNG_FEATURES_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_permit_mng_features,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_permit_mng_features,(png_structp png_ptr,
     png_uint_32 mng_features_permitted),,184);
 #endif
 
@@ -1903,27 +1903,27 @@ extern PNG_EXPORT(png_uint_32,png_permit_mng_features,(png_structp png_ptr,
  * messages before passing them to the error or warning handler.
  */
 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
-extern PNG_EXPORT(void,png_set_strip_error_numbers,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_strip_error_numbers,(png_structp png_ptr,
     png_uint_32 strip_mode),,185);
 #endif
 
 /* Added in libpng-1.2.6 */
 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
-extern PNG_EXPORT(void,png_set_user_limits,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_user_limits,(png_structp png_ptr,
     png_uint_32 user_width_max, png_uint_32 user_height_max),,186);
-extern PNG_EXPORT(png_uint_32,png_get_user_width_max,
+PNG_EXPORT(png_uint_32,png_get_user_width_max,
     (png_structp png_ptr),,187);
-extern PNG_EXPORT(png_uint_32,png_get_user_height_max,
+PNG_EXPORT(png_uint_32,png_get_user_height_max,
     (png_structp png_ptr),,188);
 /* Added in libpng-1.4.0 */
-extern PNG_EXPORT(void,png_set_chunk_cache_max,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_chunk_cache_max,(png_structp png_ptr,
     png_uint_32 user_chunk_cache_max),,189);
-extern PNG_EXPORT(png_uint_32,png_get_chunk_cache_max,
+PNG_EXPORT(png_uint_32,png_get_chunk_cache_max,
     (png_structp png_ptr),,190);
 /* Added in libpng-1.4.1 */
-extern PNG_EXPORT(void,png_set_chunk_malloc_max,(png_structp png_ptr,
+PNG_EXPORT(void,png_set_chunk_malloc_max,(png_structp png_ptr,
     png_alloc_size_t user_chunk_cache_max),,191);
-extern PNG_EXPORT(png_alloc_size_t,png_get_chunk_malloc_max,
+PNG_EXPORT(png_alloc_size_t,png_get_chunk_malloc_max,
     (png_structp png_ptr),,192);
 #endif
 
@@ -1952,9 +1952,9 @@ PNG_EXPORT(png_uint_32,png_get_pHYs_dpi,(png_structp png_ptr,
 
 /* Added in libpng-1.4.0 */
 #ifdef PNG_IO_STATE_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_io_state,(png_structp png_ptr),,199);
+PNG_EXPORT(png_uint_32,png_get_io_state,(png_structp png_ptr),,199);
 
-extern PNG_EXPORT(png_bytep,png_get_io_chunk_name,(png_structp png_ptr),,200);
+PNG_EXPORT(png_bytep,png_get_io_chunk_name,(png_structp png_ptr),,200);
 
 /* The flags returned by png_get_io_state() are the following: */
 #  define PNG_IO_NONE        0x0000   /* no I/O at this moment */
@@ -2037,23 +2037,23 @@ extern PNG_EXPORT(png_bytep,png_get_io_chunk_name,(png_structp png_ptr),,200);
 #endif
 
 #ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
-extern PNG_EXPORT(png_uint_32,png_get_uint_32,(png_bytep buf),,201);
-extern PNG_EXPORT(png_uint_16,png_get_uint_16,(png_bytep buf),,202);
+PNG_EXPORT(png_uint_32,png_get_uint_32,(png_bytep buf),,201);
+PNG_EXPORT(png_uint_16,png_get_uint_16,(png_bytep buf),,202);
 #endif
 #ifdef PNG_GET_INT_32_SUPPORTED
-extern PNG_EXPORT(png_int_32,png_get_int_32,(png_bytep buf),,203);
+PNG_EXPORT(png_int_32,png_get_int_32,(png_bytep buf),,203);
 #endif
 
-extern PNG_EXPORT(png_uint_32,png_get_uint_31,(png_structp png_ptr,
+PNG_EXPORT(png_uint_32,png_get_uint_31,(png_structp png_ptr,
     png_bytep buf),,204);
 /* 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). */
 #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
-extern PNG_EXPORT(void,png_save_uint_32,(png_bytep buf, png_uint_32 i),,205);
+PNG_EXPORT(void,png_save_uint_32,(png_bytep buf, png_uint_32 i),,205);
 #endif
 #ifdef PNG_SAVE_INT_32_SUPPORTED
-extern PNG_EXPORT(void,png_save_int_32,(png_bytep buf, png_int_32 i),,206);
+PNG_EXPORT(void,png_save_int_32,(png_bytep buf, png_int_32 i),,206);
 #endif
 
 /* Place a 16-bit number into a buffer in PNG byte order.
@@ -2061,7 +2061,7 @@ extern PNG_EXPORT(void,png_save_int_32,(png_bytep buf, png_int_32 i),,206);
  * just to avoid potential problems on pre-ANSI C compilers.
  */
 #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
-extern PNG_EXPORT(void,png_save_uint_16,(png_bytep buf, unsigned int i),,207);
+PNG_EXPORT(void,png_save_uint_16,(png_bytep buf, unsigned int i),,207);
 /* No png_save_int_16 -- may be added if there's a real need for it. */
 #endif