cheng/libpng
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up config, scripts, examples, etc.

Browse Source
This commit is contained in:
Cosmin Truta 2018-11-25 20:27:04 -05:00
parent 702a07e716
commit 81a65de25d
9 changed files with 219 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

424
example.c
View File

@ -14,8 +14,8 @@
*/ */
/* This is an example of how to use libpng to read and write PNG files. /* This is an example of how to use libpng to read and write PNG files.
* The file libpng-manual.txt is much more verbose then this. If you have not * The file libpng-manual.txt is much more verbose then this. If you have
* read it, do so first. This was designed to be a starting point of an * not read it, do so first. This was designed to be a starting point of an
* implementation. This is not officially part of libpng, is hereby placed * implementation. This is not officially part of libpng, is hereby placed
* in the public domain, and therefore does not require a copyright notice. * in the public domain, and therefore does not require a copyright notice.
* *
@ -26,16 +26,17 @@
* see also the programs in the contrib directory. * see also the programs in the contrib directory.
*/ */
/* The simple, but restricted, approach to reading a PNG file or data stream /* The simple, but restricted approach to reading a PNG file or data stream
* just requires two function calls, as in the following complete program. * requires just two function calls, as in the following complete program.
* Writing a file just needs one function call, so long as the data has an * Writing a file needs just one function call, so long as the data has an
* appropriate layout. * appropriate layout.
* *
* The following code reads PNG image data from a file and writes it, in a * The following code reads PNG image data from a file and writes it, in a
* potentially new format, to a new file. While this code will compile there is * potentially new format, to a new file. While this code will compile, there
* minimal (insufficient) error checking; for a more realistic version look at * is minimal (insufficient) error checking. For a more realistic version,
* contrib/examples/pngtopng.c * see contrib/examples/pngtopng.c
*/ */
#include <stddef.h> #include <stddef.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -70,28 +71,28 @@ int main(int argc, const char **argv)
*/ */
buffer = malloc(PNG_IMAGE_SIZE(image)); buffer = malloc(PNG_IMAGE_SIZE(image));
/* If enough memory was available read the image in the desired format /* If enough memory was available, read the image in the desired
* then write the result out to the new file. 'background' is not * format, then write the result out to the new file. 'background' is
* necessary when reading the image because the alpha channel is * not necessary when reading the image, because the alpha channel is
* preserved; if it were to be removed, for example if we requested * preserved; if it were to be removed, for example if we requested
* PNG_FORMAT_RGB, then either a solid background color would have to * PNG_FORMAT_RGB, then either a solid background color would have to
* be supplied or the output buffer would have to be initialized to the * be supplied, or the output buffer would have to be initialized to
* actual background of the image. * the actual background of the image.
* *
* The fourth argument to png_image_finish_read is the 'row_stride' - * The fourth argument to png_image_finish_read is the 'row_stride' -
* this is the number of components allocated for the image in each * this is the number of components allocated for the image in each
* row. It has to be at least as big as the value returned by * row. It has to be at least as big as the value returned by
* PNG_IMAGE_ROW_STRIDE, but if you just allocate space for the * PNG_IMAGE_ROW_STRIDE, but if you just allocate space for the
* default, minimum, size using PNG_IMAGE_SIZE as above you can pass * default, minimum size, using PNG_IMAGE_SIZE as above, you can pass
* zero. * zero.
* *
* The final argument is a pointer to a buffer for the colormap; * The final argument is a pointer to a buffer for the colormap;
* colormaps have exactly the same format as a row of image pixels (so * colormaps have exactly the same format as a row of image pixels
* you choose what format to make the colormap by setting * (so you choose what format to make the colormap by setting
* image.format). A colormap is only returned if * image.format). A colormap is only returned if
* PNG_FORMAT_FLAG_COLORMAP is also set in image.format, so in this * PNG_FORMAT_FLAG_COLORMAP is also set in image.format, so in this
* case NULL is passed as the final argument. If you do want to force * case NULL is passed as the final argument. If you do want to force
* all images into an index/color-mapped format then you can use: * all images into an index/color-mapped format, then you can use:
* *
* PNG_IMAGE_COLORMAP_SIZE(image) * PNG_IMAGE_COLORMAP_SIZE(image)
* *
@ -113,17 +114,15 @@ int main(int argc, const char **argv)
exit(0); exit(0);
} }
} }
else else
{ {
/* Calling png_image_free is optional unless the simplified API was /* Calling png_image_free is optional unless the simplified API was
* not run to completion. In this case if there wasn't enough * not run to completion. In this case, if there wasn't enough
* memory for 'buffer' we didn't complete the read, so we must free * memory for 'buffer', we didn't complete the read, so we must
* the image: * free the image:
*/ */
if (buffer == NULL) if (buffer == NULL)
png_image_free(&image); png_image_free(&image);
else else
free(buffer); free(buffer);
} }
@ -132,65 +131,67 @@ int main(int argc, const char **argv)
* textual message in the 'png_image' structure: * textual message in the 'png_image' structure:
*/ */
fprintf(stderr, "pngtopng: error: %s\n", image.message); fprintf(stderr, "pngtopng: error: %s\n", image.message);
exit (1); exit(1);
} }
fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n"); fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n");
exit(1); exit(2);
} }
/* That's it ;-) Of course you probably want to do more with PNG files than /* That's it ;-) Of course you probably want to do more with PNG files than
* just converting them all to 32-bit RGBA PNG files; you can do that between * just converting them all to 32-bit RGBA PNG files; you can do that between
* the call to png_image_finish_read and png_image_write_to_file. You can also * the call to png_image_finish_read and png_image_write_to_file. You can also
* ask for the image data to be presented in a number of different formats. You * ask for the image data to be presented in a number of different formats.
* do this by simply changing the 'format' parameter set before allocating the * You do this by simply changing the 'format' parameter set before allocating
* buffer. * the buffer.
* *
* The format parameter consists of five flags that define various aspects of * The format parameter consists of five flags that define various aspects of
* the image, you can simply add these together to get the format or you can use * the image. You can simply add these together to get the format, or you can
* one of the predefined macros from png.h (as above): * use one of the predefined macros from png.h (as above):
* *
* PNG_FORMAT_FLAG_COLOR: if set the image will have three color components per * PNG_FORMAT_FLAG_COLOR: if set, the image will have three color components
* pixel (red, green and blue), if not set the image will just have one * per pixel (red, green and blue); if not set, the image will just have one
* luminance (grayscale) component. * luminance (grayscale) component.
* *
* PNG_FORMAT_FLAG_ALPHA: if set each pixel in the image will have an additional * PNG_FORMAT_FLAG_ALPHA: if set, each pixel in the image will have an
* alpha value; a linear value that describes the degree the image pixel * additional alpha value; a linear value that describes the degree the
* covers (overwrites) the contents of the existing pixel on the display. * image pixel covers (overwrites) the contents of the existing pixel on the
* display.
* *
* PNG_FORMAT_FLAG_LINEAR: if set the components of each pixel will be returned * PNG_FORMAT_FLAG_LINEAR: if set, the components of each pixel will be
* as a series of 16-bit linear values, if not set the components will be * returned as a series of 16-bit linear values; if not set, the components
* returned as a series of 8-bit values encoded according to the 'sRGB' * will be returned as a series of 8-bit values encoded according to the
* standard. The 8-bit format is the normal format for images intended for * sRGB standard. The 8-bit format is the normal format for images intended
* direct display, because almost all display devices do the inverse of the * for direct display, because almost all display devices do the inverse of
* sRGB transformation to the data they receive. The 16-bit format is more * the sRGB transformation to the data they receive. The 16-bit format is
* common for scientific data and image data that must be further processed; * more common for scientific data and image data that must be further
* because it is linear simple math can be done on the component values. * processed; because it is linear, simple math can be done on the component
* Regardless of the setting of this flag the alpha channel is always linear, * values. Regardless of the setting of this flag, the alpha channel is
* although it will be 8 bits or 16 bits wide as specified by the flag. * always linear, although it will be 8 bits or 16 bits wide as specified by
* the flag.
* *
* PNG_FORMAT_FLAG_BGR: if set the components of a color pixel will be returned * PNG_FORMAT_FLAG_BGR: if set, the components of a color pixel will be
* in the order blue, then green, then red. If not set the pixel components * returned in the order blue, then green, then red. If not set, the pixel
* are in the order red, then green, then blue. * components are in the order red, then green, then blue.
* *
* PNG_FORMAT_FLAG_AFIRST: if set the alpha channel (if present) precedes the * PNG_FORMAT_FLAG_AFIRST: if set, the alpha channel (if present) precedes the
* color or grayscale components. If not set the alpha channel follows the * color or grayscale components. If not set, the alpha channel follows the
* components. * components.
* *
* You do not have to read directly from a file. You can read from memory or, * You do not have to read directly from a file. You can read from memory or,
* on systems that support it, from a <stdio.h> FILE*. This is controlled by * on systems that support it, from a <stdio.h> FILE*. This is controlled by
* the particular png_image_read_from_ function you call at the start. Likewise * the particular png_image_read_from_ function you call at the start.
* on write you can write to a FILE* if your system supports it. Check the * Likewise, on write, you can write to a FILE* if your system supports it.
* macro PNG_STDIO_SUPPORTED to see if stdio support has been included in your * Check the macro PNG_STDIO_SUPPORTED to see if stdio support has been
* libpng build. * included in your libpng build.
* *
* If you read 16-bit (PNG_FORMAT_FLAG_LINEAR) data you may need to write it in * If you read 16-bit (PNG_FORMAT_FLAG_LINEAR) data, you may need to write it
* the 8-bit format for display. You do this by setting the convert_to_8bit * in the 8-bit format for display. You do this by setting the convert_to_8bit
* flag to 'true'. * flag to 'true'.
* *
* Don't repeatedly convert between the 8-bit and 16-bit forms. There is * Don't repeatedly convert between the 8-bit and 16-bit forms. There is
* significant data loss when 16-bit data is converted to the 8-bit encoding and * significant data loss when 16-bit data is converted to the 8-bit encoding,
* the current libpng implementation of conversion to 16-bit is also * and the current libpng implementation of conversion to 16-bit is also
* significantly lossy. The latter will be fixed in the future, but the former * significantly lossy. The latter will be fixed in the future, but the former
* is unavoidable - the 8-bit format just doesn't have enough resolution. * is unavoidable - the 8-bit format just doesn't have enough resolution.
*/ */
@ -201,10 +202,10 @@ int main(int argc, const char **argv)
* interfaces. * interfaces.
* *
* All these interfaces require that you do your own error handling - your * All these interfaces require that you do your own error handling - your
* program must be able to arrange for control to return to your own code any * program must be able to arrange for control to return to your own code, any
* time libpng encounters a problem. There are several ways to do this, but the * time libpng encounters a problem. There are several ways to do this, but
* standard way is to use the ANSI-C (C90) <setjmp.h> interface to establish a * the standard way is to use the <setjmp.h> interface to establish a return
* return point within your own code. You must do this if you do not use the * point within your own code. You must do this if you do not use the
* simplified interface (above). * simplified interface (above).
* *
* The first step is to include the header files you need, including the libpng * The first step is to include the header files you need, including the libpng
@ -216,7 +217,7 @@ int main(int argc, const char **argv)
/* The png_jmpbuf() macro, used in error handling, became available in /* The png_jmpbuf() macro, used in error handling, became available in
* libpng version 1.0.6. If you want to be able to run your code with older * libpng version 1.0.6. If you want to be able to run your code with older
* versions of libpng, you must define the macro yourself (but only if it * versions of libpng, you must define the macro yourself (but only if it
* is not already defined by libpng!). * is not already defined by libpng!)
*/ */
#ifndef png_jmpbuf #ifndef png_jmpbuf
@ -224,10 +225,10 @@ int main(int argc, const char **argv)
#endif #endif
/* Check to see if a file is a PNG file using png_sig_cmp(). png_sig_cmp() /* Check to see if a file is a PNG file using png_sig_cmp(). png_sig_cmp()
* returns zero if the image is a PNG and nonzero if it isn't a PNG. * returns zero if the image is a PNG, and nonzero otherwise.
* *
* The function check_if_png() shown here, but not used, returns nonzero (true) * The function check_if_png() shown here, but not used, returns nonzero (true)
* if the file can be opened and is a PNG, 0 (false) otherwise. * if the file can be opened and is a PNG, and 0 (false) otherwise.
* *
* If this call is successful, and you are going to keep the file open, * If this call is successful, and you are going to keep the file open,
* you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once
@ -240,7 +241,7 @@ int main(int argc, const char **argv)
* *
* Many applications already read the first 2 or 4 bytes from the start * Many applications already read the first 2 or 4 bytes from the start
* of the image to determine the file type, so it would be easiest just * of the image to determine the file type, so it would be easiest just
* to pass the bytes to png_sig_cmp() or even skip that if you know * to pass the bytes to png_sig_cmp(), or even skip that if you know
* you have a PNG file, and call png_set_sig_bytes(). * you have a PNG file, and call png_set_sig_bytes().
*/ */
#define PNG_BYTES_TO_CHECK 4 #define PNG_BYTES_TO_CHECK 4
@ -252,13 +253,13 @@ int check_if_png(char *file_name, FILE **fp)
if ((*fp = fopen(file_name, "rb")) == NULL) if ((*fp = fopen(file_name, "rb")) == NULL)
return 0; return 0;
/* Read in some of the signature bytes */ /* Read in some of the signature bytes. */
if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK) if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK)
return 0; return 0;
/* Compare the first PNG_BYTES_TO_CHECK bytes of the signature. /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature.
Return nonzero (true) if they match */ * Return nonzero (true) if they match.
*/
return(!png_sig_cmp(buf, 0, PNG_BYTES_TO_CHECK)); return(!png_sig_cmp(buf, 0, PNG_BYTES_TO_CHECK));
} }
@ -269,7 +270,7 @@ int check_if_png(char *file_name, FILE **fp)
* some or all of the magic bytes read - see comments above). * some or all of the magic bytes read - see comments above).
*/ */
#ifdef open_file /* prototype 1 */ #ifdef open_file /* prototype 1 */
void read_png(char *file_name) /* We need to open the file */ void read_png(char *file_name) /* We need to open the file */
{ {
png_structp png_ptr; png_structp png_ptr;
png_infop info_ptr; png_infop info_ptr;
@ -282,7 +283,7 @@ void read_png(char *file_name) /* We need to open the file */
return (ERROR); return (ERROR);
#else no_open_file /* prototype 2 */ #else no_open_file /* prototype 2 */
void read_png(FILE *fp, int sig_read) /* File is already open */ void read_png(FILE *fp, int sig_read) /* File is already open */
{ {
png_structp png_ptr; png_structp png_ptr;
png_infop info_ptr; png_infop info_ptr;
@ -294,7 +295,7 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
* functions. If you want to use the default stderr and longjump method, * functions. If you want to use the default stderr and longjump method,
* you can supply NULL for the last three parameters. We also supply the * you can supply NULL for the last three parameters. We also supply the
* the compiler header file version, so that we know if the application * the compiler header file version, so that we know if the application
* was compiled with a compatible version of the library. REQUIRED * was compiled with a compatible version of the library. REQUIRED.
*/ */
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
png_voidp user_error_ptr, user_error_fn, user_warning_fn); png_voidp user_error_ptr, user_error_fn, user_warning_fn);
@ -318,35 +319,33 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
* the normal method of doing things with libpng). REQUIRED unless you * the normal method of doing things with libpng). REQUIRED unless you
* set up your own error handlers in the png_create_read_struct() earlier. * set up your own error handlers in the png_create_read_struct() earlier.
*/ */
if (setjmp(png_jmpbuf(png_ptr))) if (setjmp(png_jmpbuf(png_ptr)))
{ {
/* Free all of the memory associated with the png_ptr and info_ptr */ /* Free all of the memory associated with the png_ptr and info_ptr. */
png_destroy_read_struct(&png_ptr, &info_ptr, NULL); png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
fclose(fp); fclose(fp);
/* If we get here, we had a problem reading the file */ /* If we get here, we had a problem reading the file. */
return (ERROR); return (ERROR);
} }
/* One of the following I/O initialization methods is REQUIRED */ /* One of the following I/O initialization methods is REQUIRED. */
#ifdef streams /* PNG file I/O method 1 */ #ifdef streams /* PNG file I/O method 1 */
/* Set up the input control if you are using standard C streams */ /* Set up the input control if you are using standard C streams. */
png_init_io(png_ptr, fp); png_init_io(png_ptr, fp);
#else no_streams /* PNG file I/O method 2 */ #else no_streams /* PNG file I/O method 2 */
/* If you are using replacement read functions, instead of calling /* If you are using replacement read functions, instead of calling
* png_init_io() here you would call: * png_init_io(), you would call:
*/ */
png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn); png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);
/* where user_io_ptr is a structure you want available to the callbacks */ /* where user_io_ptr is a structure you want available to the callbacks. */
#endif no_streams /* Use only one I/O method! */ #endif no_streams /* Use only one I/O method! */
/* If we have already read some of the signature */ /* If we have already read some of the signature */
png_set_sig_bytes(png_ptr, sig_read); png_set_sig_bytes(png_ptr, sig_read);
#ifdef hilevel #ifdef hilevel
/* /* If you have enough memory to read in the entire image at once,
* If you have enough memory to read in the entire image at once,
* and you need to specify only transforms that can be controlled * and you need to specify only transforms that can be controlled
* with one of the PNG_TRANSFORM_* bits (this presently excludes * with one of the PNG_TRANSFORM_* bits (this presently excludes
* quantizing, filling, setting background, and doing gamma * quantizing, filling, setting background, and doing gamma
@ -356,10 +355,10 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
png_read_png(png_ptr, info_ptr, png_transforms, NULL); png_read_png(png_ptr, info_ptr, png_transforms, NULL);
#else #else
/* OK, you're doing it the hard way, with the lower-level functions */ /* OK, you're doing it the hard way, with the lower-level functions. */
/* The call to png_read_info() gives us all of the information from the /* The call to png_read_info() gives us all of the information from the
* PNG file before the first IDAT (image data chunk). REQUIRED * PNG file before the first IDAT (image data chunk). REQUIRED.
*/ */
png_read_info(png_ptr, info_ptr); png_read_info(png_ptr, info_ptr);
@ -387,20 +386,21 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
*/ */
png_set_strip_alpha(png_ptr); png_set_strip_alpha(png_ptr);
/* Extract multiple pixels with bit depths of 1, 2, and 4 from a single /* Extract multiple pixels with bit depths of 1, 2 or 4 from a single
* byte into separate bytes (useful for paletted and grayscale images). * byte into separate bytes (useful for paletted and grayscale images).
*/ */
png_set_packing(png_ptr); png_set_packing(png_ptr);
/* Change the order of packed pixels to least significant bit first /* Change the order of packed pixels to least significant bit first
* (not useful if you are using png_set_packing). */ * (not useful if you are using png_set_packing).
*/
png_set_packswap(png_ptr); png_set_packswap(png_ptr);
/* Expand paletted colors into true RGB triplets */ /* Expand paletted colors into true RGB triplets. */
if (color_type == PNG_COLOR_TYPE_PALETTE) if (color_type == PNG_COLOR_TYPE_PALETTE)
png_set_palette_to_rgb(png_ptr); png_set_palette_to_rgb(png_ptr);
/* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */ /* Expand grayscale images to the full 8 bits from 1, 2 or 4 bits/pixel. */
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
png_set_expand_gray_1_2_4_to_8(png_ptr); png_set_expand_gray_1_2_4_to_8(png_ptr);
@ -411,12 +411,11 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
png_set_tRNS_to_alpha(png_ptr); png_set_tRNS_to_alpha(png_ptr);
/* Set the background color to draw transparent and alpha images over. /* Set the background color to draw transparent and alpha images over.
* It is possible to set the red, green, and blue components directly * It is possible to set the red, green and blue components directly
* for paletted images instead of supplying a palette index. Note that * for paletted images, instead of supplying a palette index. Note that,
* even if the PNG file supplies a background, you are not required to * even if the PNG file supplies a background, you are not required to
* use it - you should use the (solid) application background if it has one. * use it - you should use the (solid) application background if it has one.
*/ */
png_color_16 my_background, *image_background; png_color_16 my_background, *image_background;
if (png_get_bKGD(png_ptr, info_ptr, &image_background) != 0) if (png_get_bKGD(png_ptr, info_ptr, &image_background) != 0)
@ -426,32 +425,29 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
png_set_background(png_ptr, &my_background, png_set_background(png_ptr, &my_background,
PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
/* Some suggestions as to how to get a screen gamma value /* Some suggestions as to how to get a screen gamma value.
* *
* Note that screen gamma is the display_exponent, which includes * Note that screen gamma is the display_exponent, which includes
* the CRT_exponent and any correction for viewing conditions * the CRT_exponent and any correction for viewing conditions.
*/ */
if (/* We have a user-defined screen gamma value */) if (/* We have a user-defined screen gamma value */)
{
screen_gamma = user-defined screen_gamma; screen_gamma = user-defined screen_gamma;
} /* This is one way that applications share the same screen gamma value. */
/* This is one way that applications share the same screen gamma value */
else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL) else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL)
{
screen_gamma = atof(gamma_str); screen_gamma = atof(gamma_str);
}
/* If we don't have another value */ /* If we don't have another value */
else else
{ {
screen_gamma = PNG_DEFAULT_sRGB; /* A good guess for a PC monitor screen_gamma = PNG_DEFAULT_sRGB; /* A good guess for a PC monitor
in a dimly lit room */ in a dimly lit room */
screen_gamma = PNG_GAMMA_MAC_18 or 1.0; /* Good guesses for Mac systems */ screen_gamma = PNG_GAMMA_MAC_18 or 1.0; /* Good guesses for Mac
systems */
} }
/* Tell libpng to handle the gamma conversion for you. The final call /* Tell libpng to handle the gamma conversion for you. The final call
* is a good guess for PC generated images, but it should be configurable * is a good guess for PC generated images, but it should be configurable
* by the user at run time by the user. It is strongly suggested that * by the user at run time. Gamma correction support in your application
* your application support gamma correction. * is strongly recommended.
*/ */
int intent; int intent;
@ -468,7 +464,7 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
} }
#ifdef PNG_READ_QUANTIZE_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
/* Quantize RGB files down to 8-bit palette or reduce palettes /* Quantize RGB files down to 8-bit palette, or reduce palettes
* to the number of colors available on your screen. * to the number of colors available on your screen.
*/ */
if ((color_type & PNG_COLOR_MASK_COLOR) != 0) if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
@ -476,29 +472,26 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
int num_palette; int num_palette;
png_colorp palette; png_colorp palette;
/* This reduces the image to the application supplied palette */ /* This reduces the image to the application-supplied palette. */
if (/* We have our own palette */) if (/* We have our own palette */)
{ {
/* An array of colors to which the image should be quantized */ /* An array of colors to which the image should be quantized. */
png_color std_color_cube[MAX_SCREEN_COLORS]; png_color std_color_cube[MAX_SCREEN_COLORS];
png_set_quantize(png_ptr, std_color_cube, MAX_SCREEN_COLORS, png_set_quantize(png_ptr, std_color_cube, MAX_SCREEN_COLORS,
MAX_SCREEN_COLORS, NULL, 0); MAX_SCREEN_COLORS, NULL, 0);
} }
/* This reduces the image to the palette supplied in the file */ /* This reduces the image to the palette supplied in the file. */
else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) != 0) else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) != 0)
{ {
png_uint_16p histogram = NULL; png_uint_16p histogram = NULL;
png_get_hIST(png_ptr, info_ptr, &histogram); png_get_hIST(png_ptr, info_ptr, &histogram);
png_set_quantize(png_ptr, palette, num_palette, png_set_quantize(png_ptr, palette, num_palette,
max_screen_colors, histogram, 0); max_screen_colors, histogram, 0);
} }
} }
#endif /* READ_QUANTIZE */ #endif /* READ_QUANTIZE */
/* Invert monochrome files to have 0 as white and 1 as black */ /* Invert monochrome files to have 0 as white and 1 as black. */
png_set_invert_mono(png_ptr); png_set_invert_mono(png_ptr);
/* If you want to shift the pixel values from the range [0,255] or /* If you want to shift the pixel values from the range [0,255] or
@ -508,22 +501,21 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT) != 0) if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT) != 0)
{ {
png_color_8p sig_bit_p; png_color_8p sig_bit_p;
png_get_sBIT(png_ptr, info_ptr, &sig_bit_p); png_get_sBIT(png_ptr, info_ptr, &sig_bit_p);
png_set_shift(png_ptr, sig_bit_p); png_set_shift(png_ptr, sig_bit_p);
} }
/* Flip the RGB pixels to BGR (or RGBA to BGRA) */ /* Flip the RGB pixels to BGR (or RGBA to BGRA). */
if ((color_type & PNG_COLOR_MASK_COLOR) != 0) if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
/* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */ /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR). */
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
/* Swap bytes of 16-bit files to least significant byte first */ /* Swap bytes of 16-bit files to least significant byte first. */
png_set_swap(png_ptr); png_set_swap(png_ptr);
/* Add filler (or alpha) byte (before/after each RGB triplet) */ /* Add filler (or alpha) byte (before/after each RGB triplet). */
png_set_filler(png_ptr, 0xffff, PNG_FILLER_AFTER); png_set_filler(png_ptr, 0xffff, PNG_FILLER_AFTER);
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
@ -536,40 +528,31 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
number_passes = 1; number_passes = 1;
#endif /* READ_INTERLACING */ #endif /* READ_INTERLACING */
/* Optional call to gamma correct and add the background to the palette /* Optional call to gamma correct and add the background to the palette
* and update info structure. REQUIRED if you are expecting libpng to * and update info structure. REQUIRED if you are expecting libpng to
* update the palette for you (ie you selected such a transform above). * update the palette for you (i.e. you selected such a transform above).
*/ */
png_read_update_info(png_ptr, info_ptr); png_read_update_info(png_ptr, info_ptr);
/* Allocate the memory to hold the image using the fields of info_ptr. */ /* Allocate the memory to hold the image using the fields of info_ptr. */
/* The easiest way to read the image: */
png_bytep row_pointers[height]; png_bytep row_pointers[height];
/* Clear the pointer array */
for (row = 0; row < height; row++) for (row = 0; row < height; row++)
row_pointers[row] = NULL; row_pointers[row] = NULL; /* Clear the pointer array */
for (row = 0; row < height; row++) for (row = 0; row < height; row++)
row_pointers[row] = png_malloc(png_ptr, png_get_rowbytes(png_ptr, row_pointers[row] = png_malloc(png_ptr, png_get_rowbytes(png_ptr,
info_ptr)); info_ptr));
/* Now it's time to read the image. One of these methods is REQUIRED */ /* Now it's time to read the image. One of these methods is REQUIRED. */
#ifdef entire /* Read the entire image in one go */ #ifdef entire /* Read the entire image in one go */
png_read_image(png_ptr, row_pointers); png_read_image(png_ptr, row_pointers);
#else no_entire /* Read the image one or more scanlines at a time */ #else no_entire /* Read the image one or more scanlines at a time */
/* The other way to read images - deal with interlacing: */ /* The other way to read images - deal with interlacing: */
for (pass = 0; pass < number_passes; pass++) for (pass = 0; pass < number_passes; pass++)
{ {
#ifdef single /* Read the image a single row at a time */ #ifdef single /* Read the image a single row at a time */
for (y = 0; y < height; y++) for (y = 0; y < height; y++)
{
png_read_rows(png_ptr, &row_pointers[y], NULL, 1); png_read_rows(png_ptr, &row_pointers[y], NULL, 1);
}
#else no_single /* Read the image several rows at a time */ #else no_single /* Read the image several rows at a time */
for (y = 0; y < height; y += number_of_rows) for (y = 0; y < height; y += number_of_rows)
@ -583,24 +566,24 @@ void read_png(FILE *fp, int sig_read) /* File is already open */
#endif no_sparkle /* Use only one of these two methods */ #endif no_sparkle /* Use only one of these two methods */
} }
/* If you want to display the image after every pass, do so here */ /* If you want to display the image after every pass, do so here. */
#endif no_single /* Use only one of these two methods */ #endif no_single /* Use only one of these two methods */
} }
#endif no_entire /* Use only one of these two methods */ #endif no_entire /* Use only one of these two methods */
/* Read rest of file, and get additional chunks in info_ptr - REQUIRED */ /* Read rest of file, and get additional chunks in info_ptr. REQUIRED. */
png_read_end(png_ptr, info_ptr); png_read_end(png_ptr, info_ptr);
#endif hilevel #endif hilevel
/* At this point you have read the entire image */ /* At this point you have read the entire image. */
/* Clean up after the read, and free any memory allocated - REQUIRED */ /* Clean up after the read, and free any memory allocated. REQUIRED. */
png_destroy_read_struct(&png_ptr, &info_ptr, NULL); png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
/* Close the file */ /* Close the file. */
fclose(fp); fclose(fp);
/* That's it */ /* That's it! */
return (OK); return (OK);
} }
@ -612,34 +595,30 @@ initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
/* Create and initialize the png_struct with the desired error handler /* Create and initialize the png_struct with the desired error handler
* functions. If you want to use the default stderr and longjump method, * functions. If you want to use the default stderr and longjump method,
* you can supply NULL for the last three parameters. We also check that * you can supply NULL for the last three parameters. We also check that
* the library version is compatible in case we are using dynamically * the library version is compatible, in case we are using dynamically
* linked libraries. * linked libraries.
*/ */
*png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
png_voidp user_error_ptr, user_error_fn, user_warning_fn); png_voidp user_error_ptr, user_error_fn, user_warning_fn);
if (*png_ptr == NULL) if (*png_ptr == NULL)
{ {
*info_ptr = NULL; *info_ptr = NULL;
return (ERROR); return (ERROR);
} }
*info_ptr = png_create_info_struct(png_ptr); *info_ptr = png_create_info_struct(png_ptr);
if (*info_ptr == NULL) if (*info_ptr == NULL)
{ {
png_destroy_read_struct(png_ptr, info_ptr, NULL); png_destroy_read_struct(png_ptr, info_ptr, NULL);
return (ERROR); return (ERROR);
} }
if (setjmp(png_jmpbuf((*png_ptr)))) if (setjmp(png_jmpbuf((*png_ptr))))
{ {
png_destroy_read_struct(png_ptr, info_ptr, NULL); png_destroy_read_struct(png_ptr, info_ptr, NULL);
return (ERROR); return (ERROR);
} }
/* This one's new. You will need to provide all three /* You will need to provide all three function callbacks,
* function callbacks, even if you aren't using them all. * even if you aren't using all of them.
* If you aren't using all functions, you can specify NULL * If you aren't using all functions, you can specify NULL
* parameters. Even when all three functions are NULL, * parameters. Even when all three functions are NULL,
* you need to call png_set_progressive_read_fn(). * you need to call png_set_progressive_read_fn().
@ -652,7 +631,6 @@ initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
*/ */
png_set_progressive_read_fn(*png_ptr, (void *)stream_data, png_set_progressive_read_fn(*png_ptr, (void *)stream_data,
info_callback, row_callback, end_callback); info_callback, row_callback, end_callback);
return (OK); return (OK);
} }
@ -662,18 +640,18 @@ process_data(png_structp *png_ptr, png_infop *info_ptr,
{ {
if (setjmp(png_jmpbuf((*png_ptr)))) if (setjmp(png_jmpbuf((*png_ptr))))
{ {
/* Free the png_ptr and info_ptr memory on error */ /* Free the png_ptr and info_ptr memory on error. */
png_destroy_read_struct(png_ptr, info_ptr, NULL); png_destroy_read_struct(png_ptr, info_ptr, NULL);
return (ERROR); return (ERROR);
} }
/* This one's new also. Simply give it chunks of data as /* Give chunks of data as they arrive from the data stream
* they arrive from the data stream (in order, of course). * (in order, of course).
* On segmented machines, don't give it any more than 64K. * On segmented machines, don't give it any more than 64K.
* The library seems to run fine with sizes of 4K, although * The library seems to run fine with sizes of 4K, although
* you can give it much less if necessary (I assume you can * you can give it much less if necessary. (I assume you can
* give it chunks of 1 byte, but I haven't tried with less * give it chunks of 1 byte, but I haven't tried with less
* than 256 bytes yet). When this function returns, you may * than 256 bytes yet.) When this function returns, you may
* want to display any rows that were generated in the row * want to display any rows that were generated in the row
* callback, if you aren't already displaying them there. * callback, if you aren't already displaying them there.
*/ */
@ -695,8 +673,7 @@ info_callback(png_structp png_ptr, png_infop info)
row_callback(png_structp png_ptr, png_bytep new_row, row_callback(png_structp png_ptr, png_bytep new_row,
png_uint_32 row_num, int pass) png_uint_32 row_num, int pass)
{ {
/* /* This function is called for every row in the image. If the
* This function is called for every row in the image. If the
* image is interlaced, and you turned on the interlace handler, * image is interlaced, and you turned on the interlace handler,
* this function will be called for every row in every pass. * this function will be called for every row in every pass.
* *
@ -707,25 +684,22 @@ row_callback(png_structp png_ptr, png_bytep new_row,
* The new row data pointer "new_row" may be NULL, indicating there is * The new row data pointer "new_row" may be NULL, indicating there is
* no new data to be replaced (in cases of interlace loading). * no new data to be replaced (in cases of interlace loading).
* *
* If new_row is not NULL then you need to call * If new_row is not NULL, then you need to call
* png_progressive_combine_row() to replace the corresponding row as * png_progressive_combine_row(), to replace the corresponding row as
* shown below: * shown below:
*/ */
/* Get pointer to corresponding row in our /* Get pointer to corresponding row in our PNG read buffer. */
* PNG read buffer.
*/
png_bytep old_row = ((png_bytep *)our_data)[row_num]; png_bytep old_row = ((png_bytep *)our_data)[row_num];
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
/* If both rows are allocated then copy the new row /* If both rows are allocated, then copy the new row
* data to the corresponding row data. * data to the corresponding row data.
*/ */
if ((old_row != NULL) && (new_row != NULL)) if (old_row != NULL && new_row != NULL)
png_progressive_combine_row(png_ptr, old_row, new_row); png_progressive_combine_row(png_ptr, old_row, new_row);
/* /* The rows and passes are called in order, so you don't really
* The rows and passes are called in order, so you don't really
* need the row_num and pass, but I'm supplying them because it * need the row_num and pass, but I'm supplying them because it
* may make your life easier. * may make your life easier.
* *
@ -736,7 +710,6 @@ row_callback(png_structp png_ptr, png_bytep new_row,
* (it just does the memcpy for you) if it will make the code * (it just does the memcpy for you) if it will make the code
* easier. Thus, you can just do this for all cases: * easier. Thus, you can just do this for all cases:
*/ */
png_progressive_combine_row(png_ptr, old_row, new_row); png_progressive_combine_row(png_ptr, old_row, new_row);
/* where old_row is what was displayed for previous rows. Note /* where old_row is what was displayed for previous rows. Note
@ -783,14 +756,13 @@ void write_png(char *file_name /* , ... other image information ... */)
*/ */
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
png_voidp user_error_ptr, user_error_fn, user_warning_fn); png_voidp user_error_ptr, user_error_fn, user_warning_fn);
if (png_ptr == NULL) if (png_ptr == NULL)
{ {
fclose(fp); fclose(fp);
return (ERROR); return (ERROR);
} }
/* Allocate/initialize the image information data. REQUIRED */ /* Allocate/initialize the image information data. REQUIRED. */
info_ptr = png_create_info_struct(png_ptr); info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) if (info_ptr == NULL)
{ {
@ -799,30 +771,30 @@ void write_png(char *file_name /* , ... other image information ... */)
return (ERROR); return (ERROR);
} }
/* Set error handling. REQUIRED if you aren't supplying your own /* Set up error handling. REQUIRED if you aren't supplying your own
* error handling functions in the png_create_write_struct() call. * error handling functions in the png_create_write_struct() call.
*/ */
if (setjmp(png_jmpbuf(png_ptr))) if (setjmp(png_jmpbuf(png_ptr)))
{ {
/* If we get here, we had a problem writing the file */ /* If we get here, we had a problem writing the file. */
fclose(fp); fclose(fp);
png_destroy_write_struct(&png_ptr, &info_ptr); png_destroy_write_struct(&png_ptr, &info_ptr);
return (ERROR); return (ERROR);
} }
/* One of the following I/O initialization functions is REQUIRED */ /* One of the following I/O initialization functions is REQUIRED. */
#ifdef streams /* I/O initialization method 1 */ #ifdef streams /* I/O initialization method 1 */
/* Set up the output control if you are using standard C streams */ /* Set up the output control if you are using standard C streams. */
png_init_io(png_ptr, fp); png_init_io(png_ptr, fp);
#else no_streams /* I/O initialization method 2 */ #else no_streams /* I/O initialization method 2 */
/* If you are using replacement write functions, instead of calling /* If you are using replacement write functions, instead of calling
* png_init_io() here you would call * png_init_io(), you would call:
*/ */
png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn, png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn,
user_IO_flush_function); user_IO_flush_function);
/* where user_io_ptr is a structure you want available to the callbacks */ /* where user_io_ptr is a structure you want available to the callbacks. */
#endif no_streams /* Only use one initialization method */ #endif no_streams /* Only use one initialization method */
#ifdef hilevel #ifdef hilevel
@ -833,30 +805,32 @@ void write_png(char *file_name /* , ... other image information ... */)
png_write_png(png_ptr, info_ptr, png_transforms, NULL); png_write_png(png_ptr, info_ptr, png_transforms, NULL);
#else #else
/* This is the hard way */ /* This is the hard way. */
/* Set the image information here. Width and height are up to 2^31, /* Set the image information here. Width and height are up to 2^31,
* bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on * bit_depth is one of 1, 2, 4, 8 or 16, but valid values also depend on
* the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY, * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
* PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB, * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
* or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or * or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
* PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
* currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE.
* REQUIRED.
*/ */
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_???, png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
PNG_INTERLACE_????, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); PNG_COLOR_TYPE_???, PNG_INTERLACE_????,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
/* Set the palette if there is one. REQUIRED for indexed-color images */ /* Set the palette if there is one. REQUIRED for indexed-color images. */
palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH palette = (png_colorp)png_malloc(png_ptr,
* (sizeof (png_color))); PNG_MAX_PALETTE_LENGTH * (sizeof (png_color)));
/* ... Set palette colors ... */ /* ... Set palette colors ... */
png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH); png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH);
/* You must not free palette here, because png_set_PLTE only makes a link to /* You must not free palette here, because png_set_PLTE only makes a link
* the palette that you malloced. Wait until you are about to destroy * to the palette that you allocated. Wait until you are about to destroy
* the png structure. * the png structure.
*/ */
/* Optional significant bit (sBIT) chunk */ /* Optional significant bit (sBIT) chunk. */
png_color_8 sig_bit; png_color_8 sig_bit;
/* If we are dealing with a grayscale image then */ /* If we are dealing with a grayscale image then */
@ -872,18 +846,17 @@ void write_png(char *file_name /* , ... other image information ... */)
png_set_sBIT(png_ptr, info_ptr, &sig_bit); png_set_sBIT(png_ptr, info_ptr, &sig_bit);
/* Optional gamma chunk is strongly suggested if you have any guess /* Optional gamma chunk is strongly suggested if you have any guess
* as to the correct gamma of the image. * as to the correct gamma of the image.
*/ */
png_set_gAMA(png_ptr, info_ptr, gamma); png_set_gAMA(png_ptr, info_ptr, gamma);
/* Optionally write comments into the image */ /* Optionally write comments into the image. */
{ {
png_text text_ptr[3]; png_text text_ptr[3];
char key0[]="Title"; char key0[] = "Title";
char text0[]="Mona Lisa"; char text0[] = "Mona Lisa";
text_ptr[0].key = key0; text_ptr[0].key = key0;
text_ptr[0].text = text0; text_ptr[0].text = text0;
text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE; text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
@ -891,8 +864,8 @@ void write_png(char *file_name /* , ... other image information ... */)
text_ptr[0].lang = NULL; text_ptr[0].lang = NULL;
text_ptr[0].lang_key = NULL; text_ptr[0].lang_key = NULL;
char key1[]="Author"; char key1[] = "Author";
char text1[]="Leonardo DaVinci"; char text1[] = "Leonardo DaVinci";
text_ptr[1].key = key1; text_ptr[1].key = key1;
text_ptr[1].text = text1; text_ptr[1].text = text1;
text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE; text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
@ -900,8 +873,8 @@ void write_png(char *file_name /* , ... other image information ... */)
text_ptr[1].lang = NULL; text_ptr[1].lang = NULL;
text_ptr[1].lang_key = NULL; text_ptr[1].lang_key = NULL;
char key2[]="Description"; char key2[] = "Description";
char text2[]="<long text>"; char text2[] = "<long text>";
text_ptr[2].key = key2; text_ptr[2].key = key2;
text_ptr[2].text = text2; text_ptr[2].text = text2;
text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt; text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;
@ -912,14 +885,14 @@ void write_png(char *file_name /* , ... other image information ... */)
png_set_text(write_ptr, write_info_ptr, text_ptr, 3); png_set_text(write_ptr, write_info_ptr, text_ptr, 3);
} }
/* Other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs */ /* Other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs. */
/* Note that if sRGB is present the gAMA and cHRM chunks must be ignored /* Note that if sRGB is present, the gAMA and cHRM chunks must be ignored
* on read and, if your application chooses to write them, they must * on read and, if your application chooses to write them, they must
* be written in accordance with the sRGB profile * be written in accordance with the sRGB profile.
*/ */
/* Write the file header information. REQUIRED */ /* Write the file header information. REQUIRED. */
png_write_info(png_ptr, info_ptr); png_write_info(png_ptr, info_ptr);
/* If you want, you can write the info in two steps, in case you need to /* If you want, you can write the info in two steps, in case you need to
@ -943,7 +916,7 @@ void write_png(char *file_name /* , ... other image information ... */)
* all optional. Only call them if you want them. * all optional. Only call them if you want them.
*/ */
/* Invert monochrome pixels */ /* Invert monochrome pixels. */
png_set_invert_mono(png_ptr); png_set_invert_mono(png_ptr);
/* Shift the pixels up to a legal bit depth and fill in /* Shift the pixels up to a legal bit depth and fill in
@ -951,30 +924,29 @@ void write_png(char *file_name /* , ... other image information ... */)
*/ */
png_set_shift(png_ptr, &sig_bit); png_set_shift(png_ptr, &sig_bit);
/* Pack pixels into bytes */ /* Pack pixels into bytes. */
png_set_packing(png_ptr); png_set_packing(png_ptr);
/* Swap location of alpha bytes from ARGB to RGBA */ /* Swap location of alpha bytes from ARGB to RGBA. */
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
/* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
* RGB (4 channels -> 3 channels). The second parameter is not used. * RGB (4 channels -> 3 channels). The second parameter is not used.
*/ */
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
/* Flip BGR pixels to RGB */ /* Flip BGR pixels to RGB. */
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
/* Swap bytes of 16-bit files to most significant byte first */ /* Swap bytes of 16-bit files to most significant byte first. */
png_set_swap(png_ptr); png_set_swap(png_ptr);
/* Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats */ /* Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats. */
png_set_packswap(png_ptr); png_set_packswap(png_ptr);
/* Turn on interlace handling if you are not using png_write_image() */ /* Turn on interlace handling if you are not using png_write_image(). */
if (interlacing != 0) if (interlacing != 0)
number_passes = png_set_interlace_handling(png_ptr); number_passes = png_set_interlace_handling(png_ptr);
else else
number_passes = 1; number_passes = 1;
@ -984,29 +956,28 @@ void write_png(char *file_name /* , ... other image information ... */)
*/ */
png_uint_32 k, height, width; png_uint_32 k, height, width;
/* In this example, "image" is a one-dimensional array of bytes */ /* In this example, "image" is a one-dimensional array of bytes. */
/* Guard against integer overflow */ /* Guard against integer overflow. */
if (height > PNG_SIZE_MAX/(width*bytes_per_pixel)) { if (height > PNG_SIZE_MAX / (width * bytes_per_pixel))
png_error(png_ptr, "Image_data buffer would be too large"); png_error(png_ptr, "Image data buffer would be too large");
}
png_byte image[height*width*bytes_per_pixel];
png_byte image[height * width * bytes_per_pixel];
png_bytep row_pointers[height]; png_bytep row_pointers[height];
if (height > PNG_UINT_32_MAX/(sizeof (png_bytep))) if (height > PNG_UINT_32_MAX / (sizeof (png_bytep)))
png_error (png_ptr, "Image is too tall to process in memory"); png_error(png_ptr, "Image is too tall to process in memory");
/* Set up pointers into your "image" byte array */ /* Set up pointers into your "image" byte array. */
for (k = 0; k < height; k++) for (k = 0; k < height; k++)
row_pointers[k] = image + k*width*bytes_per_pixel; row_pointers[k] = image + k * width * bytes_per_pixel;
/* One of the following output methods is REQUIRED */ /* One of the following output methods is REQUIRED. */
#ifdef entire /* Write out the entire image data in one call */ #ifdef entire /* Write out the entire image data in one call */
png_write_image(png_ptr, row_pointers); png_write_image(png_ptr, row_pointers);
/* The other way to write the image - deal with interlacing */ /* The other way to write the image - deal with interlacing. */
#else no_entire /* Write out the image data by one or more scanlines */ #else no_entire /* Write out the image data by one or more scanlines */
@ -1018,27 +989,27 @@ void write_png(char *file_name /* , ... other image information ... */)
/* Write a few rows at a time. */ /* Write a few rows at a time. */
png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows); png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows);
/* If you are only writing one row at a time, this works */ /* If you are only writing one row at a time, this works. */
for (y = 0; y < height; y++) for (y = 0; y < height; y++)
png_write_rows(png_ptr, &row_pointers[y], 1); png_write_rows(png_ptr, &row_pointers[y], 1);
} }
#endif no_entire /* Use only one output method */ #endif no_entire /* Use only one output method */
/* You can write optional chunks like tEXt, zTXt, and tIME at the end /* You can write optional chunks like tEXt, zTXt, and tIME at the end
* as well. Shouldn't be necessary in 1.2.0 and up as all the public * as well. Shouldn't be necessary in 1.2.0 and up, as all the public
* chunks are supported and you can use png_set_unknown_chunks() to * chunks are supported, and you can use png_set_unknown_chunks() to
* register unknown chunks into the info structure to be written out. * register unknown chunks into the info structure to be written out.
*/ */
/* It is REQUIRED to call this to finish writing the rest of the file */ /* It is REQUIRED to call this to finish writing the rest of the file. */
png_write_end(png_ptr, info_ptr); png_write_end(png_ptr, info_ptr);
#endif hilevel #endif hilevel
/* If you png_malloced a palette, free it here (don't free info_ptr->palette, /* If you png_malloced a palette, free it here.
* as recommended in versions 1.0.5m and earlier of this example; if * (Don't free info_ptr->palette, as shown in versions 1.0.5m and earlier of
* libpng mallocs info_ptr->palette, libpng will free it). If you * this example; if libpng mallocs info_ptr->palette, libpng will free it).
* allocated it with malloc() instead of png_malloc(), use free() instead * If you allocated it with malloc() instead of png_malloc(), use free()
* of png_free(). * instead of png_free().
*/ */
png_free(png_ptr, palette); png_free(png_ptr, palette);
palette = NULL; palette = NULL;
@ -1049,19 +1020,20 @@ void write_png(char *file_name /* , ... other image information ... */)
*/ */
png_free(png_ptr, trans); png_free(png_ptr, trans);
trans = NULL; trans = NULL;
/* Whenever you use png_free() it is a good idea to set the pointer to
/* Whenever you use png_free(), it is a good idea to set the pointer to
* NULL in case your application inadvertently tries to png_free() it * NULL in case your application inadvertently tries to png_free() it
* again. When png_free() sees a NULL it returns without action, thus * again. When png_free() sees a NULL it returns without action, avoiding
* avoiding the double-free security problem. * the double-free problem.
*/ */
/* Clean up after the write, and free any memory allocated */ /* Clean up after the write, and free any allocated memory. */
png_destroy_write_struct(&png_ptr, &info_ptr); png_destroy_write_struct(&png_ptr, &info_ptr);
/* Close the file */ /* Close the file. */
fclose(fp); fclose(fp);
/* That's it */ /* That's it! */
return (OK); return (OK);
} }

16
png.c
View File

@ -3128,11 +3128,11 @@ png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, size_t size,
/* The total output count (max) is now 4+precision */ /* The total output count (max) is now 4+precision */
/* Check for an exponent, if we don't need one we are /* Check for an exponent, if we don't need one we are
* done and just need to terminate the string. At * done and just need to terminate the string. At this
* this point exp_b10==(-1) is effectively a flag - it got * point, exp_b10==(-1) is effectively a flag: it got
* to '-1' because of the decrement after outputting * to '-1' because of the decrement, after outputting
* the decimal point above (the exponent required is * the decimal point above. (The exponent required is
* *not* -1!) * *not* -1.)
*/ */
if (exp_b10 >= (-1) && exp_b10 <= 2) if (exp_b10 >= (-1) && exp_b10 <= 2)
{ {
@ -3978,10 +3978,10 @@ png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable,
/* CSE the division and work round wacky GCC warnings (see the comments /* CSE the division and work round wacky GCC warnings (see the comments
* in png_gamma_8bit_correct for where these come from.) * in png_gamma_8bit_correct for where these come from.)
*/ */
const double fmax = 1./(((png_int_32)1 << (16U - shift))-1); double fmax = 1.0 / (((png_int_32)1 << (16U - shift)) - 1);
#endif #endif
unsigned int max = (1U << (16U - shift))-1U; unsigned int max = (1U << (16U - shift)) - 1U;
unsigned int max_by_2 = 1U << (15U-shift); unsigned int max_by_2 = 1U << (15U - shift);
unsigned int i; unsigned int i;
png_uint_16pp table = *ptable = png_uint_16pp table = *ptable =

4
pngconf.h
View File

@ -63,8 +63,8 @@
*/ */
#define PNG_CONST const /* backward compatibility only */ #define PNG_CONST const /* backward compatibility only */
/* This controls optimization of the reading of 16-bit and 32-bit values /* This controls optimization of the reading of 16-bit and 32-bit
* from PNG files. It can be set on a per-app-file basis - it * values from PNG files. It can be set on a per-app-file basis: it
* just changes whether a macro is used when the function is called. * just changes whether a macro is used when the function is called.
* The library builder sets the default; if read functions are not * The library builder sets the default; if read functions are not
* built into the library the macro implementation is forced on. * built into the library the macro implementation is forced on.

4
scripts/descrip.mms
View File

@ -16,10 +16,10 @@ OBJS = png.obj, pngset.obj, pngget.obj, pngrutil.obj, pngtrans.obj,\
CFLAGS= $(C_DEB) $(CC_DEFS) $(PREF) CFLAGS= $(C_DEB) $(CC_DEFS) $(PREF)
all : pngtest.exe libpng.olb all : pngtest.exe libpng.olb
@ write sys$output " pngtest available" @ write sys$output " pngtest available"
libpng.olb : libpng.olb($(OBJS)) libpng.olb : libpng.olb($(OBJS))
@ write sys$output " Libpng available" @ write sys$output " libpng available"
pngtest.exe : pngtest.obj libpng.olb pngtest.exe : pngtest.obj libpng.olb

2
scripts/makefile.hp64
View File

@ -1,7 +1,7 @@
# makefile for libpng, HPUX (10.20 and 11.00) using the ANSI/C product. # makefile for libpng, HPUX (10.20 and 11.00) using the ANSI/C product.
# Copyright (C) 1999-2002, 2006, 2009, 2010-2014 Glenn Randers-Pehrson # Copyright (C) 1999-2002, 2006, 2009, 2010-2014 Glenn Randers-Pehrson
# Copyright (C) 1995 Guy Eric Schalnat, Group 42 # Copyright (C) 1995 Guy Eric Schalnat, Group 42
# contributed by Jim Rice and updated by Chris Schleicher, Hewlett Packard # Contributed by Jim Rice and updated by Chris Schleicher, Hewlett Packard
# #
# This code is released under the libpng license. # This code is released under the libpng license.
# For conditions of distribution and use, see the disclaimer # For conditions of distribution and use, see the disclaimer

2
scripts/makefile.hpux
View File

@ -1,7 +1,7 @@
# makefile for libpng, HPUX (10.20 and 11.00) using the ANSI/C product. # makefile for libpng, HPUX (10.20 and 11.00) using the ANSI/C product.
# Copyright (C) 1999-2002, 2006, 2010-2014 Glenn Randers-Pehrson # Copyright (C) 1999-2002, 2006, 2010-2014 Glenn Randers-Pehrson
# Copyright (C) 1995 Guy Eric Schalnat, Group 42 # Copyright (C) 1995 Guy Eric Schalnat, Group 42
# contributed by Jim Rice and updated by Chris Schleicher, Hewlett Packard # Contributed by Jim Rice and updated by Chris Schleicher, Hewlett Packard
# #
# This code is released under the libpng license. # This code is released under the libpng license.
# For conditions of distribution and use, see the disclaimer # For conditions of distribution and use, see the disclaimer

2
scripts/makefile.std
View File

@ -122,6 +122,7 @@ pngwio.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.
pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h pngmem.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h pngset.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h pngget.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h pngread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h pngrtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h pngrutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
@ -129,6 +130,5 @@ pngtrans.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebu
pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h pngwrite.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h pngwtran.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h pngwutil.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
pngpread.o: png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
pngtest.o: png.h pngconf.h pnglibconf.h pngtest.o: png.h pngconf.h pnglibconf.h

3
scripts/pnglibconf.dfa
View File

@ -8,7 +8,8 @@ com pnglibconf.h - library build configuration
com com
version version
com com
com Copyright (c) 1998-2017 Glenn Randers-Pehrson com Copyright (c) 2018 Cosmin Truta
com Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
com com
com This code is released under the libpng license. com This code is released under the libpng license.
com For conditions of distribution and use, see the disclaimer com For conditions of distribution and use, see the disclaimer

8
scripts/pnglibconf.h.prebuilt
View File

@ -2,10 +2,10 @@
/* pnglibconf.h - library build configuration */ /* pnglibconf.h - library build configuration */
/* Libpng version 1.6.36.git */ /* libpng version 1.6.36.git */
/* Copyright (c) 2018 Cosmin Truta */ /* Copyright (c) 2018 Cosmin Truta */
/* Copyright (c) 1998-2018 Glenn Randers-Pehrson */ /* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson */
/* This code is released under the libpng license. */ /* This code is released under the libpng license. */
/* For conditions of distribution and use, see the disclaimer */ /* For conditions of distribution and use, see the disclaimer */
@ -21,8 +21,6 @@
#define PNG_ALIGNED_MEMORY_SUPPORTED #define PNG_ALIGNED_MEMORY_SUPPORTED
/*#undef PNG_ARM_NEON_API_SUPPORTED*/ /*#undef PNG_ARM_NEON_API_SUPPORTED*/
/*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/ /*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/
/*#undef PNG_POWERPC_VSX_API_SUPPORTED*/
/*#undef PNG_POWERPC_VSX_CHECK_SUPPORTED*/
#define PNG_BENIGN_ERRORS_SUPPORTED #define PNG_BENIGN_ERRORS_SUPPORTED
#define PNG_BENIGN_READ_ERRORS_SUPPORTED #define PNG_BENIGN_READ_ERRORS_SUPPORTED
/*#undef PNG_BENIGN_WRITE_ERRORS_SUPPORTED*/ /*#undef PNG_BENIGN_WRITE_ERRORS_SUPPORTED*/
@ -47,6 +45,8 @@
#define PNG_IO_STATE_SUPPORTED #define PNG_IO_STATE_SUPPORTED
#define PNG_MNG_FEATURES_SUPPORTED #define PNG_MNG_FEATURES_SUPPORTED
#define PNG_POINTER_INDEXING_SUPPORTED #define PNG_POINTER_INDEXING_SUPPORTED
/*#undef PNG_POWERPC_VSX_API_SUPPORTED*/
/*#undef PNG_POWERPC_VSX_CHECK_SUPPORTED*/
#define PNG_PROGRESSIVE_READ_SUPPORTED #define PNG_PROGRESSIVE_READ_SUPPORTED
#define PNG_READ_16BIT_SUPPORTED #define PNG_READ_16BIT_SUPPORTED
#define PNG_READ_ALPHA_MODE_SUPPORTED #define PNG_READ_ALPHA_MODE_SUPPORTED