Glenn Randers-Pehrson | 08a3343 | 1998-03-07 06:06:55 -0600 | [diff] [blame] | 1 | |
Glenn Randers-Pehrson | 860ab2b | 1999-10-14 07:43:10 -0500 | [diff] [blame] | 2 | #if 0 /* in case someone actually tries to compile this */ |
| 3 | |
Glenn Randers-Pehrson | b7f9593 | 2006-03-05 20:15:20 -0600 | [diff] [blame] | 4 | /* example.c - an example of using libpng |
Cosmin Truta | a873893 | 2018-07-28 18:47:21 -0400 | [diff] [blame] | 5 | * |
Cosmin Truta | 46aedd8 | 2018-07-15 23:58:00 -0400 | [diff] [blame] | 6 | * Maintained 2018 Cosmin Truta |
Glenn Randers-Pehrson | 7a18a2d | 2016-07-13 16:26:00 -0500 | [diff] [blame] | 7 | * Maintained 1998-2016 Glenn Randers-Pehrson |
Cosmin Truta | a873893 | 2018-07-28 18:47:21 -0400 | [diff] [blame] | 8 | * Maintained 1996-1997 Andreas Dilger |
| 9 | * Written 1995-1996 Guy Eric Schalnat, Group 42, Inc. |
| 10 | * |
Glenn Randers-Pehrson | 2ddb252 | 2011-11-25 07:27:51 -0600 | [diff] [blame] | 11 | * To the extent possible under law, the authors have waived |
| 12 | * all copyright and related or neighboring rights to this file. |
Cosmin Truta | 46aedd8 | 2018-07-15 23:58:00 -0400 | [diff] [blame] | 13 | * This work is published from: United States, Canada. |
Glenn Randers-Pehrson | b7f9593 | 2006-03-05 20:15:20 -0600 | [diff] [blame] | 14 | */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 15 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 16 | /* This is an example of how to use libpng to read and write PNG files. |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 17 | * The file libpng-manual.txt is much more verbose then this. If you have |
| 18 | * not read it, do so first. This was designed to be a starting point of an |
Glenn Randers-Pehrson | 520a764 | 2000-03-21 05:13:06 -0600 | [diff] [blame] | 19 | * implementation. This is not officially part of libpng, is hereby placed |
| 20 | * in the public domain, and therefore does not require a copyright notice. |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 21 | * |
| 22 | * This file does not currently compile, because it is missing certain |
| 23 | * parts, like allocating memory to hold an image. You will have to |
| 24 | * supply these parts to get it to compile. For an example of a minimal |
Glenn Randers-Pehrson | 520a764 | 2000-03-21 05:13:06 -0600 | [diff] [blame] | 25 | * working PNG reader/writer, see pngtest.c, included in this distribution; |
| 26 | * see also the programs in the contrib directory. |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 27 | */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 28 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 29 | /* The simple, but restricted approach to reading a PNG file or data stream |
| 30 | * requires just two function calls, as in the following complete program. |
| 31 | * Writing a file needs just one function call, so long as the data has an |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 32 | * appropriate layout. |
| 33 | * |
| 34 | * The following code reads PNG image data from a file and writes it, in a |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 35 | * potentially new format, to a new file. While this code will compile, there |
| 36 | * is minimal (insufficient) error checking. For a more realistic version, |
| 37 | * see contrib/examples/pngtopng.c |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 38 | */ |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 39 | |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 40 | #include <stddef.h> |
| 41 | #include <stdlib.h> |
| 42 | #include <string.h> |
| 43 | #include <stdio.h> |
| 44 | #include <png.h> |
John Bowler | 5d56786 | 2011-12-24 09:12:00 -0600 | [diff] [blame] | 45 | #include <zlib.h> |
Glenn Randers-Pehrson | e1018a5 | 2011-05-05 21:03:07 -0500 | [diff] [blame] | 46 | |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 47 | int main(int argc, const char **argv) |
| 48 | { |
| 49 | if (argc == 3) |
| 50 | { |
| 51 | png_image image; /* The control structure used by libpng */ |
| 52 | |
| 53 | /* Initialize the 'png_image' structure. */ |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 54 | memset(&image, 0, (sizeof image)); |
| 55 | image.version = PNG_IMAGE_VERSION; |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 56 | |
| 57 | /* The first argument is the file to read: */ |
Glenn Randers-Pehrson | 5d713fe | 2014-10-31 20:48:55 -0500 | [diff] [blame] | 58 | if (png_image_begin_read_from_file(&image, argv[1]) != 0) |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 59 | { |
| 60 | png_bytep buffer; |
| 61 | |
| 62 | /* Set the format in which to read the PNG file; this code chooses a |
| 63 | * simple sRGB format with a non-associated alpha channel, adequate to |
| 64 | * store most images. |
| 65 | */ |
| 66 | image.format = PNG_FORMAT_RGBA; |
| 67 | |
| 68 | /* Now allocate enough memory to hold the image in this format; the |
| 69 | * PNG_IMAGE_SIZE macro uses the information about the image (width, |
| 70 | * height and format) stored in 'image'. |
| 71 | */ |
| 72 | buffer = malloc(PNG_IMAGE_SIZE(image)); |
| 73 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 74 | /* If enough memory was available, read the image in the desired |
| 75 | * format, then write the result out to the new file. 'background' is |
| 76 | * not necessary when reading the image, because the alpha channel is |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 77 | * preserved; if it were to be removed, for example if we requested |
| 78 | * PNG_FORMAT_RGB, then either a solid background color would have to |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 79 | * be supplied, or the output buffer would have to be initialized to |
| 80 | * the actual background of the image. |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 81 | * |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 82 | * The fourth argument to png_image_finish_read is the 'row_stride' - |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 83 | * this is the number of components allocated for the image in each |
| 84 | * row. It has to be at least as big as the value returned by |
| 85 | * PNG_IMAGE_ROW_STRIDE, but if you just allocate space for the |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 86 | * default, minimum size, using PNG_IMAGE_SIZE as above, you can pass |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 87 | * zero. |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 88 | * |
| 89 | * The final argument is a pointer to a buffer for the colormap; |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 90 | * colormaps have exactly the same format as a row of image pixels |
| 91 | * (so you choose what format to make the colormap by setting |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 92 | * image.format). A colormap is only returned if |
| 93 | * PNG_FORMAT_FLAG_COLORMAP is also set in image.format, so in this |
| 94 | * case NULL is passed as the final argument. If you do want to force |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 95 | * all images into an index/color-mapped format, then you can use: |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 96 | * |
| 97 | * PNG_IMAGE_COLORMAP_SIZE(image) |
| 98 | * |
| 99 | * to find the maximum size of the colormap in bytes. |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 100 | */ |
| 101 | if (buffer != NULL && |
| 102 | png_image_finish_read(&image, NULL/*background*/, buffer, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 103 | 0/*row_stride*/, NULL/*colormap*/) != 0) |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 104 | { |
| 105 | /* Now write the image out to the second argument. In the write |
| 106 | * call 'convert_to_8bit' allows 16-bit data to be squashed down to |
| 107 | * 8 bits; this isn't necessary here because the original read was |
| 108 | * to the 8-bit format. |
| 109 | */ |
| 110 | if (png_image_write_to_file(&image, argv[2], 0/*convert_to_8bit*/, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 111 | buffer, 0/*row_stride*/, NULL/*colormap*/) != 0) |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 112 | { |
| 113 | /* The image has been written successfully. */ |
| 114 | exit(0); |
| 115 | } |
| 116 | } |
John Bowler | 414769b | 2011-11-27 21:39:13 -0600 | [diff] [blame] | 117 | else |
| 118 | { |
Glenn Randers-Pehrson | 1ed0b3f | 2017-07-25 15:32:19 -0500 | [diff] [blame] | 119 | /* Calling png_image_free is optional unless the simplified API was |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 120 | * not run to completion. In this case, if there wasn't enough |
| 121 | * memory for 'buffer', we didn't complete the read, so we must |
| 122 | * free the image: |
John Bowler | 414769b | 2011-11-27 21:39:13 -0600 | [diff] [blame] | 123 | */ |
| 124 | if (buffer == NULL) |
Glenn Randers-Pehrson | 1ed0b3f | 2017-07-25 15:32:19 -0500 | [diff] [blame] | 125 | png_image_free(&image); |
John Bowler | 414769b | 2011-11-27 21:39:13 -0600 | [diff] [blame] | 126 | else |
| 127 | free(buffer); |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 128 | } |
| 129 | |
| 130 | /* Something went wrong reading or writing the image. libpng stores a |
| 131 | * textual message in the 'png_image' structure: |
| 132 | */ |
| 133 | fprintf(stderr, "pngtopng: error: %s\n", image.message); |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 134 | exit(1); |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 135 | } |
| 136 | |
| 137 | fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n"); |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 138 | exit(2); |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 139 | } |
| 140 | |
| 141 | /* That's it ;-) Of course you probably want to do more with PNG files than |
| 142 | * just converting them all to 32-bit RGBA PNG files; you can do that between |
| 143 | * the call to png_image_finish_read and png_image_write_to_file. You can also |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 144 | * ask for the image data to be presented in a number of different formats. |
| 145 | * You do this by simply changing the 'format' parameter set before allocating |
| 146 | * the buffer. |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 147 | * |
| 148 | * The format parameter consists of five flags that define various aspects of |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 149 | * the image. You can simply add these together to get the format, or you can |
| 150 | * use one of the predefined macros from png.h (as above): |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 151 | * |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 152 | * PNG_FORMAT_FLAG_COLOR: if set, the image will have three color components |
| 153 | * per pixel (red, green and blue); if not set, the image will just have one |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 154 | * luminance (grayscale) component. |
| 155 | * |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 156 | * PNG_FORMAT_FLAG_ALPHA: if set, each pixel in the image will have an |
| 157 | * additional alpha value; a linear value that describes the degree the |
| 158 | * image pixel covers (overwrites) the contents of the existing pixel on the |
| 159 | * display. |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 160 | * |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 161 | * PNG_FORMAT_FLAG_LINEAR: if set, the components of each pixel will be |
| 162 | * returned as a series of 16-bit linear values; if not set, the components |
| 163 | * will be returned as a series of 8-bit values encoded according to the |
| 164 | * sRGB standard. The 8-bit format is the normal format for images intended |
| 165 | * for direct display, because almost all display devices do the inverse of |
| 166 | * the sRGB transformation to the data they receive. The 16-bit format is |
| 167 | * more common for scientific data and image data that must be further |
| 168 | * processed; because it is linear, simple math can be done on the component |
| 169 | * values. Regardless of the setting of this flag, the alpha channel is |
| 170 | * always linear, although it will be 8 bits or 16 bits wide as specified by |
| 171 | * the flag. |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 172 | * |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 173 | * PNG_FORMAT_FLAG_BGR: if set, the components of a color pixel will be |
| 174 | * returned in the order blue, then green, then red. If not set, the pixel |
| 175 | * components are in the order red, then green, then blue. |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 176 | * |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 177 | * PNG_FORMAT_FLAG_AFIRST: if set, the alpha channel (if present) precedes the |
| 178 | * color or grayscale components. If not set, the alpha channel follows the |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 179 | * components. |
| 180 | * |
| 181 | * You do not have to read directly from a file. You can read from memory or, |
| 182 | * on systems that support it, from a <stdio.h> FILE*. This is controlled by |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 183 | * the particular png_image_read_from_ function you call at the start. |
| 184 | * Likewise, on write, you can write to a FILE* if your system supports it. |
| 185 | * Check the macro PNG_STDIO_SUPPORTED to see if stdio support has been |
| 186 | * included in your libpng build. |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 187 | * |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 188 | * If you read 16-bit (PNG_FORMAT_FLAG_LINEAR) data, you may need to write it |
| 189 | * in the 8-bit format for display. You do this by setting the convert_to_8bit |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 190 | * flag to 'true'. |
| 191 | * |
| 192 | * Don't repeatedly convert between the 8-bit and 16-bit forms. There is |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 193 | * significant data loss when 16-bit data is converted to the 8-bit encoding, |
| 194 | * and the current libpng implementation of conversion to 16-bit is also |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 195 | * significantly lossy. The latter will be fixed in the future, but the former |
| 196 | * is unavoidable - the 8-bit format just doesn't have enough resolution. |
| 197 | */ |
| 198 | |
| 199 | /* If your program needs more information from the PNG data it reads, or if you |
Glenn Randers-Pehrson | 6cae24c | 2014-10-13 11:11:21 -0500 | [diff] [blame] | 200 | * need to do more complex transformations, or minimize transformations, on the |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 201 | * data you read, then you must use one of the several lower level libpng |
| 202 | * interfaces. |
| 203 | * |
| 204 | * All these interfaces require that you do your own error handling - your |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 205 | * program must be able to arrange for control to return to your own code, any |
| 206 | * time libpng encounters a problem. There are several ways to do this, but |
| 207 | * the standard way is to use the <setjmp.h> interface to establish a return |
| 208 | * point within your own code. You must do this if you do not use the |
Glenn Randers-Pehrson | 7455cbf | 2011-11-24 14:40:36 -0600 | [diff] [blame] | 209 | * simplified interface (above). |
| 210 | * |
| 211 | * The first step is to include the header files you need, including the libpng |
| 212 | * header file. Include any standard headers and feature test macros your |
| 213 | * program requires before including png.h: |
| 214 | */ |
| 215 | #include <png.h> |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 216 | |
Glenn Randers-Pehrson | 520a764 | 2000-03-21 05:13:06 -0600 | [diff] [blame] | 217 | /* The png_jmpbuf() macro, used in error handling, became available in |
| 218 | * libpng version 1.0.6. If you want to be able to run your code with older |
| 219 | * versions of libpng, you must define the macro yourself (but only if it |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 220 | * is not already defined by libpng!) |
Glenn Randers-Pehrson | 520a764 | 2000-03-21 05:13:06 -0600 | [diff] [blame] | 221 | */ |
| 222 | |
| 223 | #ifndef png_jmpbuf |
Glenn Randers-Pehrson | 95ca51b | 2010-02-19 14:09:09 -0600 | [diff] [blame] | 224 | # define png_jmpbuf(png_ptr) ((png_ptr)->png_jmpbuf) |
Glenn Randers-Pehrson | 520a764 | 2000-03-21 05:13:06 -0600 | [diff] [blame] | 225 | #endif |
| 226 | |
Glenn Randers-Pehrson | c944229 | 1999-01-06 21:50:16 -0600 | [diff] [blame] | 227 | /* Check to see if a file is a PNG file using png_sig_cmp(). png_sig_cmp() |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 228 | * returns zero if the image is a PNG, and nonzero otherwise. |
Glenn Randers-Pehrson | c944229 | 1999-01-06 21:50:16 -0600 | [diff] [blame] | 229 | * |
| 230 | * The function check_if_png() shown here, but not used, returns nonzero (true) |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 231 | * if the file can be opened and is a PNG, and 0 (false) otherwise. |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 232 | * |
| 233 | * If this call is successful, and you are going to keep the file open, |
| 234 | * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once |
| 235 | * you have created the png_ptr, so that libpng knows your application |
| 236 | * has read that many bytes from the start of the file. Make sure you |
| 237 | * don't call png_set_sig_bytes() with more than 8 bytes read or give it |
| 238 | * an incorrect number of bytes read, or you will either have read too |
| 239 | * many bytes (your fault), or you are telling libpng to read the wrong |
| 240 | * number of magic bytes (also your fault). |
| 241 | * |
| 242 | * Many applications already read the first 2 or 4 bytes from the start |
| 243 | * of the image to determine the file type, so it would be easiest just |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 244 | * to pass the bytes to png_sig_cmp(), or even skip that if you know |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 245 | * you have a PNG file, and call png_set_sig_bytes(). |
| 246 | */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 247 | #define PNG_BYTES_TO_CHECK 4 |
| 248 | int check_if_png(char *file_name, FILE **fp) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 249 | { |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 250 | char buf[PNG_BYTES_TO_CHECK]; |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 251 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 252 | /* Open the prospective PNG file. */ |
Glenn Randers-Pehrson | 68ea243 | 2000-04-01 21:10:05 -0600 | [diff] [blame] | 253 | if ((*fp = fopen(file_name, "rb")) == NULL) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 254 | return 0; |
| 255 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 256 | /* Read in some of the signature bytes. */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 257 | if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK) |
| 258 | return 0; |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 259 | |
Glenn Randers-Pehrson | c944229 | 1999-01-06 21:50:16 -0600 | [diff] [blame] | 260 | /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature. |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 261 | * Return nonzero (true) if they match. |
| 262 | */ |
Cosmin Truta | a74aa9a | 2018-06-17 22:37:44 -0400 | [diff] [blame] | 263 | return(!png_sig_cmp(buf, 0, PNG_BYTES_TO_CHECK)); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 264 | } |
| 265 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 266 | /* Read a PNG file. You may want to return an error code if the read |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 267 | * fails (depending upon the failure). There are two "prototypes" given |
| 268 | * here - one where we are given the filename, and we need to open the |
| 269 | * file, and the other where we are given an open file (possibly with |
| 270 | * some or all of the magic bytes read - see comments above). |
| 271 | */ |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 272 | #ifdef open_file /* prototype 1 */ |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 273 | void read_png(char *file_name) /* We need to open the file */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 274 | { |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 275 | png_structp png_ptr; |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 276 | png_infop info_ptr; |
Glenn Randers-Pehrson | a8242fe | 2015-08-17 20:46:27 -0500 | [diff] [blame] | 277 | int sig_read = 0; |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 278 | png_uint_32 width, height; |
| 279 | int bit_depth, color_type, interlace_type; |
Andreas Dilger | 02ad0ef | 1997-01-17 01:34:35 -0600 | [diff] [blame] | 280 | FILE *fp; |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 281 | |
Andreas Dilger | 02ad0ef | 1997-01-17 01:34:35 -0600 | [diff] [blame] | 282 | if ((fp = fopen(file_name, "rb")) == NULL) |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 283 | return (ERROR); |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 284 | |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 285 | #else no_open_file /* prototype 2 */ |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 286 | void read_png(FILE *fp, int sig_read) /* File is already open */ |
Andreas Dilger | 02ad0ef | 1997-01-17 01:34:35 -0600 | [diff] [blame] | 287 | { |
| 288 | png_structp png_ptr; |
| 289 | png_infop info_ptr; |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 290 | png_uint_32 width, height; |
| 291 | int bit_depth, color_type, interlace_type; |
Glenn Randers-Pehrson | 4bb4d01 | 2009-05-20 12:45:29 -0500 | [diff] [blame] | 292 | #endif no_open_file /* Only use one prototype! */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 293 | |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 294 | /* Create and initialize the png_struct with the desired error handler |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 295 | * functions. If you want to use the default stderr and longjump method, |
| 296 | * you can supply NULL for the last three parameters. We also supply the |
| 297 | * the compiler header file version, so that we know if the application |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 298 | * was compiled with a compatible version of the library. REQUIRED. |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 299 | */ |
Glenn Randers-Pehrson | 61ea3ea | 2014-11-06 06:39:56 -0600 | [diff] [blame] | 300 | png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 301 | png_voidp user_error_ptr, user_error_fn, user_warning_fn); |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 302 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 303 | if (png_ptr == NULL) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 304 | { |
| 305 | fclose(fp); |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 306 | return (ERROR); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 307 | } |
| 308 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 309 | /* Allocate/initialize the memory for image information. REQUIRED. */ |
Glenn Randers-Pehrson | 0f7202f | 1998-03-08 18:52:15 -0600 | [diff] [blame] | 310 | info_ptr = png_create_info_struct(png_ptr); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 311 | if (info_ptr == NULL) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 312 | { |
| 313 | fclose(fp); |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 314 | png_destroy_read_struct(&png_ptr, NULL, NULL); |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 315 | return (ERROR); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 316 | } |
| 317 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 318 | /* Set error handling if you are using the setjmp/longjmp method (this is |
| 319 | * the normal method of doing things with libpng). REQUIRED unless you |
| 320 | * set up your own error handlers in the png_create_read_struct() earlier. |
| 321 | */ |
Glenn Randers-Pehrson | 520a764 | 2000-03-21 05:13:06 -0600 | [diff] [blame] | 322 | if (setjmp(png_jmpbuf(png_ptr))) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 323 | { |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 324 | /* Free all of the memory associated with the png_ptr and info_ptr. */ |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 325 | png_destroy_read_struct(&png_ptr, &info_ptr, NULL); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 326 | fclose(fp); |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 327 | /* If we get here, we had a problem reading the file. */ |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 328 | return (ERROR); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 329 | } |
| 330 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 331 | /* One of the following I/O initialization methods is REQUIRED. */ |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 332 | #ifdef streams /* PNG file I/O method 1 */ |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 333 | /* Set up the input control if you are using standard C streams. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 334 | png_init_io(png_ptr, fp); |
| 335 | |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 336 | #else no_streams /* PNG file I/O method 2 */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 337 | /* If you are using replacement read functions, instead of calling |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 338 | * png_init_io(), you would call: |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 339 | */ |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 340 | png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn); |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 341 | /* where user_io_ptr is a structure you want available to the callbacks. */ |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 342 | #endif no_streams /* Use only one I/O method! */ |
Guy Schalnat | 69b1448 | 1996-01-10 02:56:49 -0600 | [diff] [blame] | 343 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 344 | /* If we have already read some of the signature */ |
Glenn Randers-Pehrson | 0f7202f | 1998-03-08 18:52:15 -0600 | [diff] [blame] | 345 | png_set_sig_bytes(png_ptr, sig_read); |
Andreas Dilger | 02ad0ef | 1997-01-17 01:34:35 -0600 | [diff] [blame] | 346 | |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 347 | #ifdef hilevel |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 348 | /* If you have enough memory to read in the entire image at once, |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 349 | * and you need to specify only transforms that can be controlled |
| 350 | * with one of the PNG_TRANSFORM_* bits (this presently excludes |
Glenn Randers-Pehrson | 3cd7cff | 2010-04-16 19:27:08 -0500 | [diff] [blame] | 351 | * quantizing, filling, setting background, and doing gamma |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 352 | * adjustment), then you can read the entire image (including |
| 353 | * pixels) into the info structure with this call: |
| 354 | */ |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 355 | png_read_png(png_ptr, info_ptr, png_transforms, NULL); |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 356 | |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 357 | #else |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 358 | /* OK, you're doing it the hard way, with the lower-level functions. */ |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 359 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 360 | /* The call to png_read_info() gives us all of the information from the |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 361 | * PNG file before the first IDAT (image data chunk). REQUIRED. |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 362 | */ |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 363 | png_read_info(png_ptr, info_ptr); |
Guy Schalnat | 69b1448 | 1996-01-10 02:56:49 -0600 | [diff] [blame] | 364 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 365 | png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 366 | &interlace_type, NULL, NULL); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 367 | |
Glenn Randers-Pehrson glennrp@comcast.net | b1c0d33 | 2009-05-15 20:39:34 -0500 | [diff] [blame] | 368 | /* Set up the data transformations you want. Note that these are all |
| 369 | * optional. Only call them if you want/need them. Many of the |
| 370 | * transformations only work on specific types of images, and many |
| 371 | * are mutually exclusive. |
| 372 | */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 373 | |
Glenn Randers-Pehrson | 8b83ff3 | 2015-08-13 20:57:18 -0500 | [diff] [blame] | 374 | /* Tell libpng to strip 16 bits/color files down to 8 bits/color. |
Glenn Randers-Pehrson | 857dbbe | 2011-06-16 09:39:40 -0500 | [diff] [blame] | 375 | * Use accurate scaling if it's available, otherwise just chop off the |
| 376 | * low byte. |
| 377 | */ |
John Bowler | 8d26126 | 2011-06-18 13:37:11 -0500 | [diff] [blame] | 378 | #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED |
Glenn Randers-Pehrson | 192e92d | 2016-07-13 14:43:42 -0500 | [diff] [blame] | 379 | png_set_scale_16(png_ptr); |
Glenn Randers-Pehrson | 857dbbe | 2011-06-16 09:39:40 -0500 | [diff] [blame] | 380 | #else |
Glenn Randers-Pehrson | ab63dd0 | 2011-06-17 20:04:17 -0500 | [diff] [blame] | 381 | png_set_strip_16(png_ptr); |
Glenn Randers-Pehrson | 857dbbe | 2011-06-16 09:39:40 -0500 | [diff] [blame] | 382 | #endif |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 383 | |
Glenn Randers-Pehrson | 4393a9a | 1999-09-17 12:27:26 -0500 | [diff] [blame] | 384 | /* Strip alpha bytes from the input data without combining with the |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 385 | * background (not recommended). |
| 386 | */ |
Glenn Randers-Pehrson | 7a18a2d | 2016-07-13 16:26:00 -0500 | [diff] [blame] | 387 | png_set_strip_alpha(png_ptr); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 388 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 389 | /* Extract multiple pixels with bit depths of 1, 2 or 4 from a single |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 390 | * byte into separate bytes (useful for paletted and grayscale images). |
| 391 | */ |
Glenn Randers-Pehrson | 7a18a2d | 2016-07-13 16:26:00 -0500 | [diff] [blame] | 392 | png_set_packing(png_ptr); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 393 | |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 394 | /* Change the order of packed pixels to least significant bit first |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 395 | * (not useful if you are using png_set_packing). |
| 396 | */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 397 | png_set_packswap(png_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 398 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 399 | /* Expand paletted colors into true RGB triplets. */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 400 | if (color_type == PNG_COLOR_TYPE_PALETTE) |
Glenn Randers-Pehrson | f46918d | 2006-06-02 05:31:20 -0500 | [diff] [blame] | 401 | png_set_palette_to_rgb(png_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 402 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 403 | /* Expand grayscale images to the full 8 bits from 1, 2 or 4 bits/pixel. */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 404 | if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) |
Glenn Randers-Pehrson | 56f6396 | 2008-10-06 10:16:17 -0500 | [diff] [blame] | 405 | png_set_expand_gray_1_2_4_to_8(png_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 406 | |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 407 | /* Expand paletted or RGB images with transparency to full alpha channels |
| 408 | * so the data will be available as RGBA quartets. |
| 409 | */ |
Glenn Randers-Pehrson | 5d713fe | 2014-10-31 20:48:55 -0500 | [diff] [blame] | 410 | if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) != 0) |
Glenn Randers-Pehrson | b182893 | 2001-06-23 08:03:17 -0500 | [diff] [blame] | 411 | png_set_tRNS_to_alpha(png_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 412 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 413 | /* Set the background color to draw transparent and alpha images over. |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 414 | * It is possible to set the red, green and blue components directly |
| 415 | * for paletted images, instead of supplying a palette index. Note that, |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 416 | * even if the PNG file supplies a background, you are not required to |
| 417 | * use it - you should use the (solid) application background if it has one. |
| 418 | */ |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 419 | png_color_16 my_background, *image_background; |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 420 | |
Glenn Randers-Pehrson | 5d713fe | 2014-10-31 20:48:55 -0500 | [diff] [blame] | 421 | if (png_get_bKGD(png_ptr, info_ptr, &image_background) != 0) |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 422 | png_set_background(png_ptr, image_background, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 423 | PNG_BACKGROUND_GAMMA_FILE, 1, 1.0); |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 424 | else |
| 425 | png_set_background(png_ptr, &my_background, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 426 | PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 427 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 428 | /* Some suggestions as to how to get a screen gamma value. |
Glenn Randers-Pehrson glennrp@comcast.net | b1c0d33 | 2009-05-15 20:39:34 -0500 | [diff] [blame] | 429 | * |
| 430 | * Note that screen gamma is the display_exponent, which includes |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 431 | * the CRT_exponent and any correction for viewing conditions. |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 432 | */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 433 | if (/* We have a user-defined screen gamma value */) |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 434 | screen_gamma = user-defined screen_gamma; |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 435 | /* This is one way that applications share the same screen gamma value. */ |
Glenn Randers-Pehrson | c4a2ae6 | 1998-01-16 22:06:18 -0600 | [diff] [blame] | 436 | else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL) |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 437 | screen_gamma = atof(gamma_str); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 438 | /* If we don't have another value */ |
| 439 | else |
| 440 | { |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 441 | screen_gamma = PNG_DEFAULT_sRGB; /* A good guess for a PC monitor |
| 442 | in a dimly lit room */ |
| 443 | screen_gamma = PNG_GAMMA_MAC_18 or 1.0; /* Good guesses for Mac |
| 444 | systems */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 445 | } |
| 446 | |
Glenn Randers-Pehrson | 520a764 | 2000-03-21 05:13:06 -0600 | [diff] [blame] | 447 | /* Tell libpng to handle the gamma conversion for you. The final call |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 448 | * is a good guess for PC generated images, but it should be configurable |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 449 | * by the user at run time. Gamma correction support in your application |
| 450 | * is strongly recommended. |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 451 | */ |
Glenn Randers-Pehrson | c4a2ae6 | 1998-01-16 22:06:18 -0600 | [diff] [blame] | 452 | |
| 453 | int intent; |
| 454 | |
Glenn Randers-Pehrson | 5d713fe | 2014-10-31 20:48:55 -0500 | [diff] [blame] | 455 | if (png_get_sRGB(png_ptr, info_ptr, &intent) != 0) |
Glenn Randers-Pehrson | b0d9735 | 2013-06-25 19:36:15 -0500 | [diff] [blame] | 456 | png_set_gamma(png_ptr, screen_gamma, PNG_DEFAULT_sRGB); |
Glenn Randers-Pehrson | 5c6aeb2 | 1998-12-29 11:47:59 -0600 | [diff] [blame] | 457 | else |
| 458 | { |
| 459 | double image_gamma; |
Glenn Randers-Pehrson | 5d713fe | 2014-10-31 20:48:55 -0500 | [diff] [blame] | 460 | if (png_get_gAMA(png_ptr, info_ptr, &image_gamma) != 0) |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 461 | png_set_gamma(png_ptr, screen_gamma, image_gamma); |
| 462 | else |
Glenn Randers-Pehrson | 5c6aeb2 | 1998-12-29 11:47:59 -0600 | [diff] [blame] | 463 | png_set_gamma(png_ptr, screen_gamma, 0.45455); |
| 464 | } |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 465 | |
Glenn Randers-Pehrson | 3cd7cff | 2010-04-16 19:27:08 -0500 | [diff] [blame] | 466 | #ifdef PNG_READ_QUANTIZE_SUPPORTED |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 467 | /* Quantize RGB files down to 8-bit palette, or reduce palettes |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 468 | * to the number of colors available on your screen. |
| 469 | */ |
Glenn Randers-Pehrson | 5d713fe | 2014-10-31 20:48:55 -0500 | [diff] [blame] | 470 | if ((color_type & PNG_COLOR_MASK_COLOR) != 0) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 471 | { |
Glenn Randers-Pehrson | f05f803 | 2000-12-23 14:27:39 -0600 | [diff] [blame] | 472 | int num_palette; |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 473 | png_colorp palette; |
| 474 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 475 | /* This reduces the image to the application-supplied palette. */ |
Glenn Randers-Pehrson | 4bb4d01 | 2009-05-20 12:45:29 -0500 | [diff] [blame] | 476 | if (/* We have our own palette */) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 477 | { |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 478 | /* An array of colors to which the image should be quantized. */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 479 | png_color std_color_cube[MAX_SCREEN_COLORS]; |
Glenn Randers-Pehrson | 3cd7cff | 2010-04-16 19:27:08 -0500 | [diff] [blame] | 480 | png_set_quantize(png_ptr, std_color_cube, MAX_SCREEN_COLORS, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 481 | MAX_SCREEN_COLORS, NULL, 0); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 482 | } |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 483 | /* This reduces the image to the palette supplied in the file. */ |
Glenn Randers-Pehrson | 5d713fe | 2014-10-31 20:48:55 -0500 | [diff] [blame] | 484 | else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) != 0) |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 485 | { |
Glenn Randers-Pehrson | 865f4f0 | 2002-09-15 20:30:38 -0500 | [diff] [blame] | 486 | png_uint_16p histogram = NULL; |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 487 | png_get_hIST(png_ptr, info_ptr, &histogram); |
Glenn Randers-Pehrson | 3cd7cff | 2010-04-16 19:27:08 -0500 | [diff] [blame] | 488 | png_set_quantize(png_ptr, palette, num_palette, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 489 | max_screen_colors, histogram, 0); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 490 | } |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 491 | } |
Glenn Randers-Pehrson | 985dc00 | 2014-11-06 23:17:35 -0600 | [diff] [blame] | 492 | #endif /* READ_QUANTIZE */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 493 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 494 | /* Invert monochrome files to have 0 as white and 1 as black. */ |
Glenn Randers-Pehrson | 46f61e2 | 1998-01-30 21:45:12 -0600 | [diff] [blame] | 495 | png_set_invert_mono(png_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 496 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 497 | /* If you want to shift the pixel values from the range [0,255] or |
| 498 | * [0,65535] to the original [0,7] or [0,31], or whatever range the |
| 499 | * colors were originally in: |
| 500 | */ |
Glenn Randers-Pehrson | 5d713fe | 2014-10-31 20:48:55 -0500 | [diff] [blame] | 501 | if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT) != 0) |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 502 | { |
Glenn Randers-Pehrson | 640b7d5 | 2009-05-13 07:33:22 -0500 | [diff] [blame] | 503 | png_color_8p sig_bit_p; |
Glenn Randers-Pehrson | 640b7d5 | 2009-05-13 07:33:22 -0500 | [diff] [blame] | 504 | png_get_sBIT(png_ptr, info_ptr, &sig_bit_p); |
| 505 | png_set_shift(png_ptr, sig_bit_p); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 506 | } |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 507 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 508 | /* Flip the RGB pixels to BGR (or RGBA to BGRA). */ |
Glenn Randers-Pehrson | 5d713fe | 2014-10-31 20:48:55 -0500 | [diff] [blame] | 509 | if ((color_type & PNG_COLOR_MASK_COLOR) != 0) |
Glenn Randers-Pehrson | 6942d53 | 2000-05-01 09:31:54 -0500 | [diff] [blame] | 510 | png_set_bgr(png_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 511 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 512 | /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR). */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 513 | png_set_swap_alpha(png_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 514 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 515 | /* Swap bytes of 16-bit files to least significant byte first. */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 516 | png_set_swap(png_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 517 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 518 | /* Add filler (or alpha) byte (before/after each RGB triplet). */ |
Glenn Randers-Pehrson | 01a0e80 | 2015-09-24 22:39:53 -0500 | [diff] [blame] | 519 | png_set_filler(png_ptr, 0xffff, PNG_FILLER_AFTER); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 520 | |
Glenn Randers-Pehrson | 4daae30 | 2011-10-06 21:37:47 -0500 | [diff] [blame] | 521 | #ifdef PNG_READ_INTERLACING_SUPPORTED |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 522 | /* Turn on interlace handling. REQUIRED if you are not using |
| 523 | * png_read_image(). To see how to handle interlacing passes, |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 524 | * see the png_read_row() method below: |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 525 | */ |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 526 | number_passes = png_set_interlace_handling(png_ptr); |
Glenn Randers-Pehrson | 7a18a2d | 2016-07-13 16:26:00 -0500 | [diff] [blame] | 527 | #else /* !READ_INTERLACING */ |
Glenn Randers-Pehrson | 4daae30 | 2011-10-06 21:37:47 -0500 | [diff] [blame] | 528 | number_passes = 1; |
Glenn Randers-Pehrson | cda68df | 2014-11-06 22:11:39 -0600 | [diff] [blame] | 529 | #endif /* READ_INTERLACING */ |
Glenn Randers-Pehrson | 4daae30 | 2011-10-06 21:37:47 -0500 | [diff] [blame] | 530 | |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 531 | /* Optional call to gamma correct and add the background to the palette |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 532 | * and update info structure. REQUIRED if you are expecting libpng to |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 533 | * update the palette for you (i.e. you selected such a transform above). |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 534 | */ |
Guy Schalnat | 51f0eb4 | 1995-09-26 05:22:39 -0500 | [diff] [blame] | 535 | png_read_update_info(png_ptr, info_ptr); |
| 536 | |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 537 | /* Allocate the memory to hold the image using the fields of info_ptr. */ |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 538 | png_bytep row_pointers[height]; |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 539 | for (row = 0; row < height; row++) |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 540 | row_pointers[row] = NULL; /* Clear the pointer array */ |
Glenn Randers-Pehrson | 8fb550c | 2009-03-21 08:15:32 -0500 | [diff] [blame] | 541 | for (row = 0; row < height; row++) |
Glenn Randers-Pehrson | 3097f61 | 2001-05-07 14:52:45 -0500 | [diff] [blame] | 542 | row_pointers[row] = png_malloc(png_ptr, png_get_rowbytes(png_ptr, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 543 | info_ptr)); |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 544 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 545 | /* Now it's time to read the image. One of these methods is REQUIRED. */ |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 546 | #ifdef entire /* Read the entire image in one go */ |
Guy Schalnat | 51f0eb4 | 1995-09-26 05:22:39 -0500 | [diff] [blame] | 547 | png_read_image(png_ptr, row_pointers); |
| 548 | |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 549 | #else no_entire /* Read the image one or more scanlines at a time */ |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 550 | /* The other way to read images - deal with interlacing: */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 551 | for (pass = 0; pass < number_passes; pass++) |
| 552 | { |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 553 | #ifdef single /* Read the image a single row at a time */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 554 | for (y = 0; y < height; y++) |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 555 | png_read_rows(png_ptr, &row_pointers[y], NULL, 1); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 556 | |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 557 | #else no_single /* Read the image several rows at a time */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 558 | for (y = 0; y < height; y += number_of_rows) |
| 559 | { |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 560 | #ifdef sparkle /* Read the image using the "sparkle" effect. */ |
Glenn Randers-Pehrson | 145f5c8 | 2008-07-10 09:13:13 -0500 | [diff] [blame] | 561 | png_read_rows(png_ptr, &row_pointers[y], NULL, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 562 | number_of_rows); |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 563 | #else no_sparkle /* Read the image using the "rectangle" effect */ |
Glenn Randers-Pehrson | 145f5c8 | 2008-07-10 09:13:13 -0500 | [diff] [blame] | 564 | png_read_rows(png_ptr, NULL, &row_pointers[y], |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 565 | number_of_rows); |
Glenn Randers-Pehrson | 4bb4d01 | 2009-05-20 12:45:29 -0500 | [diff] [blame] | 566 | #endif no_sparkle /* Use only one of these two methods */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 567 | } |
Glenn Randers-Pehrson | 5c6aeb2 | 1998-12-29 11:47:59 -0600 | [diff] [blame] | 568 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 569 | /* If you want to display the image after every pass, do so here. */ |
Glenn Randers-Pehrson | 4bb4d01 | 2009-05-20 12:45:29 -0500 | [diff] [blame] | 570 | #endif no_single /* Use only one of these two methods */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 571 | } |
Glenn Randers-Pehrson | 4bb4d01 | 2009-05-20 12:45:29 -0500 | [diff] [blame] | 572 | #endif no_entire /* Use only one of these two methods */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 573 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 574 | /* Read rest of file, and get additional chunks in info_ptr. REQUIRED. */ |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 575 | png_read_end(png_ptr, info_ptr); |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 576 | #endif hilevel |
| 577 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 578 | /* At this point you have read the entire image. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 579 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 580 | /* Clean up after the read, and free any memory allocated. REQUIRED. */ |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 581 | png_destroy_read_struct(&png_ptr, &info_ptr, NULL); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 582 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 583 | /* Close the file. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 584 | fclose(fp); |
| 585 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 586 | /* That's it! */ |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 587 | return (OK); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 588 | } |
| 589 | |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 590 | /* Progressively read a file */ |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 591 | |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 592 | int |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 593 | initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr) |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 594 | { |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 595 | /* Create and initialize the png_struct with the desired error handler |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 596 | * functions. If you want to use the default stderr and longjump method, |
| 597 | * you can supply NULL for the last three parameters. We also check that |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 598 | * the library version is compatible, in case we are using dynamically |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 599 | * linked libraries. |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 600 | */ |
Glenn Randers-Pehrson | 61ea3ea | 2014-11-06 06:39:56 -0600 | [diff] [blame] | 601 | *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 602 | png_voidp user_error_ptr, user_error_fn, user_warning_fn); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 603 | if (*png_ptr == NULL) |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 604 | { |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 605 | *info_ptr = NULL; |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 606 | return (ERROR); |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 607 | } |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 608 | *info_ptr = png_create_info_struct(png_ptr); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 609 | if (*info_ptr == NULL) |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 610 | { |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 611 | png_destroy_read_struct(png_ptr, info_ptr, NULL); |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 612 | return (ERROR); |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 613 | } |
Glenn Randers-Pehrson | 520a764 | 2000-03-21 05:13:06 -0600 | [diff] [blame] | 614 | if (setjmp(png_jmpbuf((*png_ptr)))) |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 615 | { |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 616 | png_destroy_read_struct(png_ptr, info_ptr, NULL); |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 617 | return (ERROR); |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 618 | } |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 619 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 620 | /* You will need to provide all three function callbacks, |
| 621 | * even if you aren't using all of them. |
Glenn Randers-Pehrson | 5c6aeb2 | 1998-12-29 11:47:59 -0600 | [diff] [blame] | 622 | * If you aren't using all functions, you can specify NULL |
| 623 | * parameters. Even when all three functions are NULL, |
| 624 | * you need to call png_set_progressive_read_fn(). |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 625 | * These functions shouldn't be dependent on global or |
| 626 | * static variables if you are decoding several images |
| 627 | * simultaneously. You should store stream specific data |
| 628 | * in a separate struct, given as the second parameter, |
| 629 | * and retrieve the pointer from inside the callbacks using |
| 630 | * the function png_get_progressive_ptr(png_ptr). |
| 631 | */ |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 632 | png_set_progressive_read_fn(*png_ptr, (void *)stream_data, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 633 | info_callback, row_callback, end_callback); |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 634 | return (OK); |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 635 | } |
| 636 | |
| 637 | int |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 638 | process_data(png_structp *png_ptr, png_infop *info_ptr, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 639 | png_bytep buffer, png_uint_32 length) |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 640 | { |
Glenn Randers-Pehrson | 520a764 | 2000-03-21 05:13:06 -0600 | [diff] [blame] | 641 | if (setjmp(png_jmpbuf((*png_ptr)))) |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 642 | { |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 643 | /* Free the png_ptr and info_ptr memory on error. */ |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 644 | png_destroy_read_struct(png_ptr, info_ptr, NULL); |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 645 | return (ERROR); |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 646 | } |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 647 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 648 | /* Give chunks of data as they arrive from the data stream |
| 649 | * (in order, of course). |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 650 | * On segmented machines, don't give it any more than 64K. |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 651 | * The library seems to run fine with sizes of 4K, although |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 652 | * you can give it much less if necessary. (I assume you can |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 653 | * give it chunks of 1 byte, but I haven't tried with less |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 654 | * than 256 bytes yet.) When this function returns, you may |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 655 | * want to display any rows that were generated in the row |
| 656 | * callback, if you aren't already displaying them there. |
| 657 | */ |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 658 | png_process_data(*png_ptr, *info_ptr, buffer, length); |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 659 | return (OK); |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 660 | } |
| 661 | |
| 662 | info_callback(png_structp png_ptr, png_infop info) |
| 663 | { |
Glenn Randers-Pehrson glennrp@comcast.net | b1c0d33 | 2009-05-15 20:39:34 -0500 | [diff] [blame] | 664 | /* Do any setup here, including setting any of the transformations |
| 665 | * mentioned in the Reading PNG files section. For now, you _must_ |
| 666 | * call either png_start_read_image() or png_read_update_info() |
| 667 | * after all the transformations are set (even if you don't set |
| 668 | * any). You may start getting rows before png_process_data() |
| 669 | * returns, so this is your last chance to prepare for that. |
| 670 | */ |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 671 | } |
| 672 | |
| 673 | row_callback(png_structp png_ptr, png_bytep new_row, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 674 | png_uint_32 row_num, int pass) |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 675 | { |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 676 | /* This function is called for every row in the image. If the |
Glenn Randers-Pehrson glennrp@comcast.net | b1c0d33 | 2009-05-15 20:39:34 -0500 | [diff] [blame] | 677 | * image is interlaced, and you turned on the interlace handler, |
| 678 | * this function will be called for every row in every pass. |
| 679 | * |
| 680 | * In this function you will receive a pointer to new row data from |
| 681 | * libpng called new_row that is to replace a corresponding row (of |
| 682 | * the same data format) in a buffer allocated by your application. |
| 683 | * |
| 684 | * The new row data pointer "new_row" may be NULL, indicating there is |
| 685 | * no new data to be replaced (in cases of interlace loading). |
| 686 | * |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 687 | * If new_row is not NULL, then you need to call |
| 688 | * png_progressive_combine_row(), to replace the corresponding row as |
Glenn Randers-Pehrson glennrp@comcast.net | b1c0d33 | 2009-05-15 20:39:34 -0500 | [diff] [blame] | 689 | * shown below: |
| 690 | */ |
| 691 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 692 | /* Get pointer to corresponding row in our PNG read buffer. */ |
Glenn Randers-Pehrson | 53c07f5 | 2010-06-18 18:55:55 -0500 | [diff] [blame] | 693 | png_bytep old_row = ((png_bytep *)our_data)[row_num]; |
Glenn Randers-Pehrson | 5a0be34 | 2001-10-18 20:55:13 -0500 | [diff] [blame] | 694 | |
Glenn Randers-Pehrson | 4daae30 | 2011-10-06 21:37:47 -0500 | [diff] [blame] | 695 | #ifdef PNG_READ_INTERLACING_SUPPORTED |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 696 | /* If both rows are allocated, then copy the new row |
Glenn Randers-Pehrson | 53c07f5 | 2010-06-18 18:55:55 -0500 | [diff] [blame] | 697 | * data to the corresponding row data. |
| 698 | */ |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 699 | if (old_row != NULL && new_row != NULL) |
| 700 | png_progressive_combine_row(png_ptr, old_row, new_row); |
Glenn Randers-Pehrson | 53c07f5 | 2010-06-18 18:55:55 -0500 | [diff] [blame] | 701 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 702 | /* The rows and passes are called in order, so you don't really |
Glenn Randers-Pehrson glennrp@comcast.net | b1c0d33 | 2009-05-15 20:39:34 -0500 | [diff] [blame] | 703 | * need the row_num and pass, but I'm supplying them because it |
| 704 | * may make your life easier. |
| 705 | * |
| 706 | * For the non-NULL rows of interlaced images, you must call |
| 707 | * png_progressive_combine_row() passing in the new row and the |
| 708 | * old row, as demonstrated above. You can call this function for |
| 709 | * NULL rows (it will just return) and for non-interlaced images |
John Bowler | fcd301d | 2011-12-28 21:34:27 -0600 | [diff] [blame] | 710 | * (it just does the memcpy for you) if it will make the code |
Glenn Randers-Pehrson glennrp@comcast.net | b1c0d33 | 2009-05-15 20:39:34 -0500 | [diff] [blame] | 711 | * easier. Thus, you can just do this for all cases: |
| 712 | */ |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 713 | png_progressive_combine_row(png_ptr, old_row, new_row); |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 714 | |
Glenn Randers-Pehrson glennrp@comcast.net | b1c0d33 | 2009-05-15 20:39:34 -0500 | [diff] [blame] | 715 | /* where old_row is what was displayed for previous rows. Note |
| 716 | * that the first pass (pass == 0 really) will completely cover |
| 717 | * the old row, so the rows do not have to be initialized. After |
| 718 | * the first pass (and only for interlaced images), you will have |
| 719 | * to pass the current row as new_row, and the function will combine |
| 720 | * the old row and the new row. |
| 721 | */ |
Glenn Randers-Pehrson | cda68df | 2014-11-06 22:11:39 -0600 | [diff] [blame] | 722 | #endif /* READ_INTERLACING */ |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 723 | } |
| 724 | |
| 725 | end_callback(png_structp png_ptr, png_infop info) |
| 726 | { |
Glenn Randers-Pehrson glennrp@comcast.net | b1c0d33 | 2009-05-15 20:39:34 -0500 | [diff] [blame] | 727 | /* This function is called when the whole image has been read, |
| 728 | * including any chunks after the image (up to and including |
| 729 | * the IEND). You will usually have the same info chunk as you |
| 730 | * had in the header, although some data may have been added |
| 731 | * to the comments and time fields. |
| 732 | * |
| 733 | * Most people won't do much here, perhaps setting a flag that |
| 734 | * marks the image as finished. |
| 735 | */ |
Guy Schalnat | 6d76471 | 1995-12-19 03:22:19 -0600 | [diff] [blame] | 736 | } |
| 737 | |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 738 | /* Write a png file */ |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 739 | void write_png(char *file_name /* , ... other image information ... */) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 740 | { |
| 741 | FILE *fp; |
Guy Schalnat | b2e01bd | 1996-01-26 01:38:47 -0600 | [diff] [blame] | 742 | png_structp png_ptr; |
| 743 | png_infop info_ptr; |
Glenn Randers-Pehrson | a77ef62 | 2000-02-18 13:48:52 -0600 | [diff] [blame] | 744 | png_colorp palette; |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 745 | |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 746 | /* Open the file */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 747 | fp = fopen(file_name, "wb"); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 748 | if (fp == NULL) |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 749 | return (ERROR); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 750 | |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 751 | /* Create and initialize the png_struct with the desired error handler |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 752 | * functions. If you want to use the default stderr and longjump method, |
| 753 | * you can supply NULL for the last three parameters. We also check that |
| 754 | * the library version is compatible with the one used at compile time, |
| 755 | * in case we are using dynamically linked libraries. REQUIRED. |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 756 | */ |
Glenn Randers-Pehrson | 61ea3ea | 2014-11-06 06:39:56 -0600 | [diff] [blame] | 757 | png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 758 | png_voidp user_error_ptr, user_error_fn, user_warning_fn); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 759 | if (png_ptr == NULL) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 760 | { |
| 761 | fclose(fp); |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 762 | return (ERROR); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 763 | } |
| 764 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 765 | /* Allocate/initialize the image information data. REQUIRED. */ |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 766 | info_ptr = png_create_info_struct(png_ptr); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 767 | if (info_ptr == NULL) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 768 | { |
| 769 | fclose(fp); |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 770 | png_destroy_write_struct(&png_ptr, NULL); |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 771 | return (ERROR); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 772 | } |
| 773 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 774 | /* Set up error handling. REQUIRED if you aren't supplying your own |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 775 | * error handling functions in the png_create_write_struct() call. |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 776 | */ |
Glenn Randers-Pehrson | 520a764 | 2000-03-21 05:13:06 -0600 | [diff] [blame] | 777 | if (setjmp(png_jmpbuf(png_ptr))) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 778 | { |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 779 | /* If we get here, we had a problem writing the file. */ |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 780 | fclose(fp); |
Glenn Randers-Pehrson | fc4a143 | 2000-05-17 17:39:34 -0500 | [diff] [blame] | 781 | png_destroy_write_struct(&png_ptr, &info_ptr); |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 782 | return (ERROR); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 783 | } |
| 784 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 785 | /* One of the following I/O initialization functions is REQUIRED. */ |
Glenn Randers-Pehrson glennrp@comcast.net | b1c0d33 | 2009-05-15 20:39:34 -0500 | [diff] [blame] | 786 | |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 787 | #ifdef streams /* I/O initialization method 1 */ |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 788 | /* Set up the output control if you are using standard C streams. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 789 | png_init_io(png_ptr, fp); |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 790 | |
Glenn Randers-Pehrson | cbe52d8 | 1998-02-28 07:00:24 -0600 | [diff] [blame] | 791 | #else no_streams /* I/O initialization method 2 */ |
Glenn Randers-Pehrson | a5fa5c9 | 2008-09-06 07:06:22 -0500 | [diff] [blame] | 792 | /* If you are using replacement write functions, instead of calling |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 793 | * png_init_io(), you would call: |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 794 | */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 795 | png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn, |
Glenn Randers-Pehrson | dd70604 | 2016-07-15 11:20:46 -0500 | [diff] [blame] | 796 | user_IO_flush_function); |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 797 | /* where user_io_ptr is a structure you want available to the callbacks. */ |
Glenn Randers-Pehrson | 4bb4d01 | 2009-05-20 12:45:29 -0500 | [diff] [blame] | 798 | #endif no_streams /* Only use one initialization method */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 799 | |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 800 | #ifdef hilevel |
| 801 | /* This is the easy way. Use it if you already have all the |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 802 | * image info living in the structure. You could "|" many |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 803 | * PNG_TRANSFORM flags into the png_transforms integer here. |
| 804 | */ |
Glenn Randers-Pehrson | beb572e | 2006-08-19 13:59:24 -0500 | [diff] [blame] | 805 | png_write_png(png_ptr, info_ptr, png_transforms, NULL); |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 806 | |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 807 | #else |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 808 | /* This is the hard way. */ |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 809 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 810 | /* Set the image information here. Width and height are up to 2^31, |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 811 | * bit_depth is one of 1, 2, 4, 8 or 16, but valid values also depend on |
| 812 | * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY, |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 813 | * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB, |
| 814 | * or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or |
| 815 | * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 816 | * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. |
| 817 | * REQUIRED. |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 818 | */ |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 819 | png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, |
| 820 | PNG_COLOR_TYPE_???, PNG_INTERLACE_????, |
| 821 | PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 822 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 823 | /* Set the palette if there is one. REQUIRED for indexed-color images. */ |
| 824 | palette = (png_colorp)png_malloc(png_ptr, |
| 825 | PNG_MAX_PALETTE_LENGTH * (sizeof (png_color))); |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 826 | /* ... Set palette colors ... */ |
Glenn Randers-Pehrson | 76e5fd6 | 2000-12-28 07:50:05 -0600 | [diff] [blame] | 827 | png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH); |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 828 | /* You must not free palette here, because png_set_PLTE only makes a link |
| 829 | * to the palette that you allocated. Wait until you are about to destroy |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 830 | * the png structure. |
| 831 | */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 832 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 833 | /* Optional significant bit (sBIT) chunk. */ |
Glenn Randers-Pehrson | 640b7d5 | 2009-05-13 07:33:22 -0500 | [diff] [blame] | 834 | png_color_8 sig_bit; |
Glenn Randers-Pehrson | f24daf2 | 2010-05-06 09:44:04 -0500 | [diff] [blame] | 835 | |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 836 | /* If we are dealing with a grayscale image then */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 837 | sig_bit.gray = true_bit_depth; |
Glenn Randers-Pehrson | f24daf2 | 2010-05-06 09:44:04 -0500 | [diff] [blame] | 838 | |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 839 | /* Otherwise, if we are dealing with a color image then */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 840 | sig_bit.red = true_red_bit_depth; |
| 841 | sig_bit.green = true_green_bit_depth; |
| 842 | sig_bit.blue = true_blue_bit_depth; |
Glenn Randers-Pehrson | f24daf2 | 2010-05-06 09:44:04 -0500 | [diff] [blame] | 843 | |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 844 | /* If the image has an alpha channel then */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 845 | sig_bit.alpha = true_alpha_bit_depth; |
Glenn Randers-Pehrson | f24daf2 | 2010-05-06 09:44:04 -0500 | [diff] [blame] | 846 | |
Glenn Randers-Pehrson | 640b7d5 | 2009-05-13 07:33:22 -0500 | [diff] [blame] | 847 | png_set_sBIT(png_ptr, info_ptr, &sig_bit); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 848 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 849 | /* Optional gamma chunk is strongly suggested if you have any guess |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 850 | * as to the correct gamma of the image. |
| 851 | */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 852 | png_set_gAMA(png_ptr, info_ptr, gamma); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 853 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 854 | /* Optionally write comments into the image. */ |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 855 | { |
| 856 | png_text text_ptr[3]; |
| 857 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 858 | char key0[] = "Title"; |
| 859 | char text0[] = "Mona Lisa"; |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 860 | text_ptr[0].key = key0; |
| 861 | text_ptr[0].text = text0; |
| 862 | text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE; |
| 863 | text_ptr[0].itxt_length = 0; |
| 864 | text_ptr[0].lang = NULL; |
| 865 | text_ptr[0].lang_key = NULL; |
| 866 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 867 | char key1[] = "Author"; |
| 868 | char text1[] = "Leonardo DaVinci"; |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 869 | text_ptr[1].key = key1; |
| 870 | text_ptr[1].text = text1; |
| 871 | text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE; |
| 872 | text_ptr[1].itxt_length = 0; |
| 873 | text_ptr[1].lang = NULL; |
| 874 | text_ptr[1].lang_key = NULL; |
| 875 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 876 | char key2[] = "Description"; |
| 877 | char text2[] = "<long text>"; |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 878 | text_ptr[2].key = key2; |
| 879 | text_ptr[2].text = text2; |
| 880 | text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt; |
| 881 | text_ptr[2].itxt_length = 0; |
| 882 | text_ptr[2].lang = NULL; |
| 883 | text_ptr[2].lang_key = NULL; |
| 884 | |
| 885 | png_set_text(write_ptr, write_info_ptr, text_ptr, 3); |
| 886 | } |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 887 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 888 | /* Other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs. */ |
Glenn Randers-Pehrson | 640b7d5 | 2009-05-13 07:33:22 -0500 | [diff] [blame] | 889 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 890 | /* Note that if sRGB is present, the gAMA and cHRM chunks must be ignored |
Glenn Randers-Pehrson | 640b7d5 | 2009-05-13 07:33:22 -0500 | [diff] [blame] | 891 | * on read and, if your application chooses to write them, they must |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 892 | * be written in accordance with the sRGB profile. |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 893 | */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 894 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 895 | /* Write the file header information. REQUIRED. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 896 | png_write_info(png_ptr, info_ptr); |
| 897 | |
Glenn Randers-Pehrson | 5379b24 | 1999-11-27 10:22:33 -0600 | [diff] [blame] | 898 | /* If you want, you can write the info in two steps, in case you need to |
| 899 | * write your private chunk ahead of PLTE: |
| 900 | * |
| 901 | * png_write_info_before_PLTE(write_ptr, write_info_ptr); |
| 902 | * write_my_chunk(); |
| 903 | * png_write_info(png_ptr, info_ptr); |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 904 | * |
Glenn Randers-Pehrson | 8fb550c | 2009-03-21 08:15:32 -0500 | [diff] [blame] | 905 | * However, given the level of known- and unknown-chunk support in 1.2.0 |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 906 | * and up, this should no longer be necessary. |
Glenn Randers-Pehrson | 5379b24 | 1999-11-27 10:22:33 -0600 | [diff] [blame] | 907 | */ |
| 908 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 909 | /* Once we write out the header, the compression type on the text |
Glenn Randers-Pehrson | a11cd84 | 2014-10-05 13:45:38 -0500 | [diff] [blame] | 910 | * chunk gets changed to PNG_TEXT_COMPRESSION_NONE_WR or |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 911 | * PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again |
| 912 | * at the end. |
| 913 | */ |
| 914 | |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 915 | /* Set up the transformations you want. Note that these are |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 916 | * all optional. Only call them if you want them. |
| 917 | */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 918 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 919 | /* Invert monochrome pixels. */ |
Glenn Randers-Pehrson | 46f61e2 | 1998-01-30 21:45:12 -0600 | [diff] [blame] | 920 | png_set_invert_mono(png_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 921 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 922 | /* Shift the pixels up to a legal bit depth and fill in |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 923 | * as appropriate to correctly scale the image. |
| 924 | */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 925 | png_set_shift(png_ptr, &sig_bit); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 926 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 927 | /* Pack pixels into bytes. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 928 | png_set_packing(png_ptr); |
| 929 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 930 | /* Swap location of alpha bytes from ARGB to RGBA. */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 931 | png_set_swap_alpha(png_ptr); |
| 932 | |
| 933 | /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 934 | * RGB (4 channels -> 3 channels). The second parameter is not used. |
Glenn Randers-Pehrson | b6ce43d | 1998-01-01 07:13:13 -0600 | [diff] [blame] | 935 | */ |
Glenn Randers-Pehrson | 01a0e80 | 2015-09-24 22:39:53 -0500 | [diff] [blame] | 936 | png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 937 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 938 | /* Flip BGR pixels to RGB. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 939 | png_set_bgr(png_ptr); |
| 940 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 941 | /* Swap bytes of 16-bit files to most significant byte first. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 942 | png_set_swap(png_ptr); |
| 943 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 944 | /* Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats. */ |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 945 | png_set_packswap(png_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 946 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 947 | /* Turn on interlace handling if you are not using png_write_image(). */ |
Glenn Randers-Pehrson | 0567015 | 2014-03-08 12:39:52 -0600 | [diff] [blame] | 948 | if (interlacing != 0) |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 949 | number_passes = png_set_interlace_handling(png_ptr); |
| 950 | else |
| 951 | number_passes = 1; |
| 952 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 953 | /* The easiest way to write the image (you may have a different memory |
| 954 | * layout, however, so choose what fits your needs best). You need to |
| 955 | * use the first method if you aren't handling interlacing yourself. |
| 956 | */ |
Glenn Randers-Pehrson | 8686fff | 1998-05-21 09:27:50 -0500 | [diff] [blame] | 957 | png_uint_32 k, height, width; |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 958 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 959 | /* In this example, "image" is a one-dimensional array of bytes. */ |
Glenn Randers-Pehrson | 2eff8ef | 2017-04-22 15:30:52 -0500 | [diff] [blame] | 960 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 961 | /* Guard against integer overflow. */ |
| 962 | if (height > PNG_SIZE_MAX / (width * bytes_per_pixel)) |
| 963 | png_error(png_ptr, "Image data buffer would be too large"); |
Glenn Randers-Pehrson | 871b1d0 | 2013-03-02 14:58:22 -0600 | [diff] [blame] | 964 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 965 | png_byte image[height * width * bytes_per_pixel]; |
Glenn Randers-Pehrson | 8686fff | 1998-05-21 09:27:50 -0500 | [diff] [blame] | 966 | png_bytep row_pointers[height]; |
Glenn Randers-Pehrson | 5fea36f | 2004-07-28 08:20:44 -0500 | [diff] [blame] | 967 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 968 | if (height > PNG_UINT_32_MAX / (sizeof (png_bytep))) |
| 969 | png_error(png_ptr, "Image is too tall to process in memory"); |
Glenn Randers-Pehrson | 67864af | 2004-08-28 23:30:07 -0500 | [diff] [blame] | 970 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 971 | /* Set up pointers into your "image" byte array. */ |
Glenn Randers-Pehrson | 8686fff | 1998-05-21 09:27:50 -0500 | [diff] [blame] | 972 | for (k = 0; k < height; k++) |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 973 | row_pointers[k] = image + k * width * bytes_per_pixel; |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 974 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 975 | /* One of the following output methods is REQUIRED. */ |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 976 | |
| 977 | #ifdef entire /* Write out the entire image data in one call */ |
Guy Schalnat | 51f0eb4 | 1995-09-26 05:22:39 -0500 | [diff] [blame] | 978 | png_write_image(png_ptr, row_pointers); |
| 979 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 980 | /* The other way to write the image - deal with interlacing. */ |
Guy Schalnat | 51f0eb4 | 1995-09-26 05:22:39 -0500 | [diff] [blame] | 981 | |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 982 | #else no_entire /* Write out the image data by one or more scanlines */ |
| 983 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 984 | /* The number of passes is either 1 for non-interlaced images, |
| 985 | * or 7 for interlaced images. |
| 986 | */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 987 | for (pass = 0; pass < number_passes; pass++) |
| 988 | { |
| 989 | /* Write a few rows at a time. */ |
Glenn Randers-Pehrson | 8686fff | 1998-05-21 09:27:50 -0500 | [diff] [blame] | 990 | png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 991 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 992 | /* If you are only writing one row at a time, this works. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 993 | for (y = 0; y < height; y++) |
Glenn Randers-Pehrson | 8686fff | 1998-05-21 09:27:50 -0500 | [diff] [blame] | 994 | png_write_rows(png_ptr, &row_pointers[y], 1); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 995 | } |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 996 | #endif no_entire /* Use only one output method */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 997 | |
Andreas Dilger | 47a0c42 | 1997-05-16 02:46:07 -0500 | [diff] [blame] | 998 | /* You can write optional chunks like tEXt, zTXt, and tIME at the end |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 999 | * as well. Shouldn't be necessary in 1.2.0 and up, as all the public |
| 1000 | * chunks are supported, and you can use png_set_unknown_chunks() to |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 1001 | * register unknown chunks into the info structure to be written out. |
Guy Schalnat | e5a3779 | 1996-06-05 15:50:50 -0500 | [diff] [blame] | 1002 | */ |
| 1003 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 1004 | /* It is REQUIRED to call this to finish writing the rest of the file. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 1005 | png_write_end(png_ptr, info_ptr); |
Glenn Randers-Pehrson | 61c32d9 | 2000-02-04 23:40:16 -0600 | [diff] [blame] | 1006 | #endif hilevel |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 1007 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 1008 | /* If you png_malloced a palette, free it here. |
| 1009 | * (Don't free info_ptr->palette, as shown in versions 1.0.5m and earlier of |
| 1010 | * this example; if libpng mallocs info_ptr->palette, libpng will free it). |
| 1011 | * If you allocated it with malloc() instead of png_malloc(), use free() |
| 1012 | * instead of png_free(). |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 1013 | */ |
Glenn Randers-Pehrson | a77ef62 | 2000-02-18 13:48:52 -0600 | [diff] [blame] | 1014 | png_free(png_ptr, palette); |
Glenn Randers-Pehrson | 895a9c9 | 2008-07-25 08:51:18 -0500 | [diff] [blame] | 1015 | palette = NULL; |
Glenn Randers-Pehrson | a77ef62 | 2000-02-18 13:48:52 -0600 | [diff] [blame] | 1016 | |
| 1017 | /* Similarly, if you png_malloced any data that you passed in with |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 1018 | * png_set_something(), such as a hist or trans array, free it here, |
| 1019 | * when you can be sure that libpng is through with it. |
| 1020 | */ |
Glenn Randers-Pehrson | a77ef62 | 2000-02-18 13:48:52 -0600 | [diff] [blame] | 1021 | png_free(png_ptr, trans); |
Glenn Randers-Pehrson | 895a9c9 | 2008-07-25 08:51:18 -0500 | [diff] [blame] | 1022 | trans = NULL; |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 1023 | |
| 1024 | /* Whenever you use png_free(), it is a good idea to set the pointer to |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 1025 | * NULL in case your application inadvertently tries to png_free() it |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 1026 | * again. When png_free() sees a NULL it returns without action, avoiding |
| 1027 | * the double-free problem. |
Glenn Randers-Pehrson | 64548de | 2009-05-13 15:23:03 -0500 | [diff] [blame] | 1028 | */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 1029 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 1030 | /* Clean up after the write, and free any allocated memory. */ |
Glenn Randers-Pehrson | fc4a143 | 2000-05-17 17:39:34 -0500 | [diff] [blame] | 1031 | png_destroy_write_struct(&png_ptr, &info_ptr); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 1032 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 1033 | /* Close the file. */ |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 1034 | fclose(fp); |
| 1035 | |
Cosmin Truta | 81a65de | 2018-11-25 20:27:04 -0500 | [diff] [blame] | 1036 | /* That's it! */ |
Glenn Randers-Pehrson | 104622b | 2000-05-29 08:58:03 -0500 | [diff] [blame] | 1037 | return (OK); |
Guy Schalnat | 0d58058 | 1995-07-20 02:43:20 -0500 | [diff] [blame] | 1038 | } |
| 1039 | |
Glenn Randers-Pehrson | 860ab2b | 1999-10-14 07:43:10 -0500 | [diff] [blame] | 1040 | #endif /* if 0 */ |