2 #if 0 /* in case someone actually tries to compile this */
4 /* example.c - an example of using libpng
5 * Last changed in libpng 1.6.35 [July 15, 2018]
6 * Maintained 2018 Cosmin Truta
7 * Maintained 1998-2016 Glenn Randers-Pehrson
8 * Maintained 1996, 1997 Andreas Dilger)
9 * Written 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
10 * To the extent possible under law, the authors have waived
11 * all copyright and related or neighboring rights to this file.
12 * This work is published from: United States, Canada.
15 /* This is an example of how to use libpng to read and write PNG files.
16 * The file libpng-manual.txt is much more verbose then this. If you have not
17 * read it, do so first. This was designed to be a starting point of an
18 * implementation. This is not officially part of libpng, is hereby placed
19 * in the public domain, and therefore does not require a copyright notice.
21 * This file does not currently compile, because it is missing certain
22 * parts, like allocating memory to hold an image. You will have to
23 * supply these parts to get it to compile. For an example of a minimal
24 * working PNG reader/writer, see pngtest.c, included in this distribution;
25 * see also the programs in the contrib directory.
28 /* The simple, but restricted, approach to reading a PNG file or data stream
29 * just requires two function calls, as in the following complete program.
30 * Writing a file just needs one function call, so long as the data has an
33 * The following code reads PNG image data from a file and writes it, in a
34 * potentially new format, to a new file. While this code will compile there is
35 * minimal (insufficient) error checking; for a more realistic version look at
36 * contrib/examples/pngtopng.c
45 int main(int argc
, const char **argv
)
49 png_image image
; /* The control structure used by libpng */
51 /* Initialize the 'png_image' structure. */
52 memset(&image
, 0, (sizeof image
));
53 image
.version
= PNG_IMAGE_VERSION
;
55 /* The first argument is the file to read: */
56 if (png_image_begin_read_from_file(&image
, argv
[1]) != 0)
60 /* Set the format in which to read the PNG file; this code chooses a
61 * simple sRGB format with a non-associated alpha channel, adequate to
64 image
.format
= PNG_FORMAT_RGBA
;
66 /* Now allocate enough memory to hold the image in this format; the
67 * PNG_IMAGE_SIZE macro uses the information about the image (width,
68 * height and format) stored in 'image'.
70 buffer
= malloc(PNG_IMAGE_SIZE(image
));
72 /* If enough memory was available read the image in the desired format
73 * then write the result out to the new file. 'background' is not
74 * necessary when reading the image because the alpha channel is
75 * preserved; if it were to be removed, for example if we requested
76 * PNG_FORMAT_RGB, then either a solid background color would have to
77 * be supplied or the output buffer would have to be initialized to the
78 * actual background of the image.
80 * The fourth argument to png_image_finish_read is the 'row_stride' -
81 * this is the number of components allocated for the image in each
82 * row. It has to be at least as big as the value returned by
83 * PNG_IMAGE_ROW_STRIDE, but if you just allocate space for the
84 * default, minimum, size using PNG_IMAGE_SIZE as above you can pass
87 * The final argument is a pointer to a buffer for the colormap;
88 * colormaps have exactly the same format as a row of image pixels (so
89 * you choose what format to make the colormap by setting
90 * image.format). A colormap is only returned if
91 * PNG_FORMAT_FLAG_COLORMAP is also set in image.format, so in this
92 * case NULL is passed as the final argument. If you do want to force
93 * all images into an index/color-mapped format then you can use:
95 * PNG_IMAGE_COLORMAP_SIZE(image)
97 * to find the maximum size of the colormap in bytes.
100 png_image_finish_read(&image
, NULL
/*background*/, buffer
,
101 0/*row_stride*/, NULL
/*colormap*/) != 0)
103 /* Now write the image out to the second argument. In the write
104 * call 'convert_to_8bit' allows 16-bit data to be squashed down to
105 * 8 bits; this isn't necessary here because the original read was
106 * to the 8-bit format.
108 if (png_image_write_to_file(&image
, argv
[2], 0/*convert_to_8bit*/,
109 buffer
, 0/*row_stride*/, NULL
/*colormap*/) != 0)
111 /* The image has been written successfully. */
118 /* Calling png_image_free is optional unless the simplified API was
119 * not run to completion. In this case if there wasn't enough
120 * memory for 'buffer' we didn't complete the read, so we must free
124 png_image_free(&image
);
130 /* Something went wrong reading or writing the image. libpng stores a
131 * textual message in the 'png_image' structure:
133 fprintf(stderr
, "pngtopng: error: %s\n", image
.message
);
137 fprintf(stderr
, "pngtopng: usage: pngtopng input-file output-file\n");
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
144 * ask for the image data to be presented in a number of different formats. You
145 * do this by simply changing the 'format' parameter set before allocating the
148 * The format parameter consists of five flags that define various aspects of
149 * the image, you can simply add these together to get the format or you can use
150 * one of the predefined macros from png.h (as above):
152 * PNG_FORMAT_FLAG_COLOR: if set the image will have three color components per
153 * pixel (red, green and blue), if not set the image will just have one
154 * luminance (grayscale) component.
156 * PNG_FORMAT_FLAG_ALPHA: if set each pixel in the image will have an additional
157 * alpha value; a linear value that describes the degree the image pixel
158 * covers (overwrites) the contents of the existing pixel on the display.
160 * PNG_FORMAT_FLAG_LINEAR: if set the components of each pixel will be returned
161 * as a series of 16-bit linear values, if not set the components will be
162 * returned as a series of 8-bit values encoded according to the 'sRGB'
163 * standard. The 8-bit format is the normal format for images intended for
164 * direct display, because almost all display devices do the inverse of the
165 * sRGB transformation to the data they receive. The 16-bit format is more
166 * common for scientific data and image data that must be further processed;
167 * because it is linear simple math can be done on the component values.
168 * Regardless of the setting of this flag the alpha channel is always linear,
169 * although it will be 8 bits or 16 bits wide as specified by the flag.
171 * PNG_FORMAT_FLAG_BGR: if set the components of a color pixel will be returned
172 * in the order blue, then green, then red. If not set the pixel components
173 * are in the order red, then green, then blue.
175 * PNG_FORMAT_FLAG_AFIRST: if set the alpha channel (if present) precedes the
176 * color or grayscale components. If not set the alpha channel follows the
179 * You do not have to read directly from a file. You can read from memory or,
180 * on systems that support it, from a <stdio.h> FILE*. This is controlled by
181 * the particular png_image_read_from_ function you call at the start. Likewise
182 * on write you can write to a FILE* if your system supports it. Check the
183 * macro PNG_STDIO_SUPPORTED to see if stdio support has been included in your
186 * If you read 16-bit (PNG_FORMAT_FLAG_LINEAR) data you may need to write it in
187 * the 8-bit format for display. You do this by setting the convert_to_8bit
190 * Don't repeatedly convert between the 8-bit and 16-bit forms. There is
191 * significant data loss when 16-bit data is converted to the 8-bit encoding and
192 * the current libpng implementation of conversion to 16-bit is also
193 * significantly lossy. The latter will be fixed in the future, but the former
194 * is unavoidable - the 8-bit format just doesn't have enough resolution.
197 /* If your program needs more information from the PNG data it reads, or if you
198 * need to do more complex transformations, or minimize transformations, on the
199 * data you read, then you must use one of the several lower level libpng
202 * All these interfaces require that you do your own error handling - your
203 * program must be able to arrange for control to return to your own code any
204 * time libpng encounters a problem. There are several ways to do this, but the
205 * standard way is to use the ANSI-C (C90) <setjmp.h> interface to establish a
206 * return point within your own code. You must do this if you do not use the
207 * simplified interface (above).
209 * The first step is to include the header files you need, including the libpng
210 * header file. Include any standard headers and feature test macros your
211 * program requires before including png.h:
215 /* The png_jmpbuf() macro, used in error handling, became available in
216 * libpng version 1.0.6. If you want to be able to run your code with older
217 * versions of libpng, you must define the macro yourself (but only if it
218 * is not already defined by libpng!).
222 # define png_jmpbuf(png_ptr) ((png_ptr)->png_jmpbuf)
225 /* Check to see if a file is a PNG file using png_sig_cmp(). png_sig_cmp()
226 * returns zero if the image is a PNG and nonzero if it isn't a PNG.
228 * The function check_if_png() shown here, but not used, returns nonzero (true)
229 * if the file can be opened and is a PNG, 0 (false) otherwise.
231 * If this call is successful, and you are going to keep the file open,
232 * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once
233 * you have created the png_ptr, so that libpng knows your application
234 * has read that many bytes from the start of the file. Make sure you
235 * don't call png_set_sig_bytes() with more than 8 bytes read or give it
236 * an incorrect number of bytes read, or you will either have read too
237 * many bytes (your fault), or you are telling libpng to read the wrong
238 * number of magic bytes (also your fault).
240 * Many applications already read the first 2 or 4 bytes from the start
241 * of the image to determine the file type, so it would be easiest just
242 * to pass the bytes to png_sig_cmp() or even skip that if you know
243 * you have a PNG file, and call png_set_sig_bytes().
245 #define PNG_BYTES_TO_CHECK 4
246 int check_if_png(char *file_name
, FILE **fp
)
248 char buf
[PNG_BYTES_TO_CHECK
];
250 /* Open the prospective PNG file. */
251 if ((*fp
= fopen(file_name
, "rb")) == NULL
)
254 /* Read in some of the signature bytes */
255 if (fread(buf
, 1, PNG_BYTES_TO_CHECK
, *fp
) != PNG_BYTES_TO_CHECK
)
258 /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature.
259 Return nonzero (true) if they match */
261 return(!png_sig_cmp(buf
, 0, PNG_BYTES_TO_CHECK
));
264 /* Read a PNG file. You may want to return an error code if the read
265 * fails (depending upon the failure). There are two "prototypes" given
266 * here - one where we are given the filename, and we need to open the
267 * file, and the other where we are given an open file (possibly with
268 * some or all of the magic bytes read - see comments above).
270 #ifdef open_file /* prototype 1 */
271 void read_png(char *file_name
) /* We need to open the file */
276 png_uint_32 width
, height
;
277 int bit_depth
, color_type
, interlace_type
;
280 if ((fp
= fopen(file_name
, "rb")) == NULL
)
283 #else no_open_file /* prototype 2 */
284 void read_png(FILE *fp
, int sig_read
) /* File is already open */
288 png_uint_32 width
, height
;
289 int bit_depth
, color_type
, interlace_type
;
290 #endif no_open_file /* Only use one prototype! */
292 /* Create and initialize the png_struct with the desired error handler
293 * functions. If you want to use the default stderr and longjump method,
294 * you can supply NULL for the last three parameters. We also supply the
295 * the compiler header file version, so that we know if the application
296 * was compiled with a compatible version of the library. REQUIRED
298 png_ptr
= png_create_read_struct(PNG_LIBPNG_VER_STRING
,
299 png_voidp user_error_ptr
, user_error_fn
, user_warning_fn
);
307 /* Allocate/initialize the memory for image information. REQUIRED. */
308 info_ptr
= png_create_info_struct(png_ptr
);
309 if (info_ptr
== NULL
)
312 png_destroy_read_struct(&png_ptr
, NULL
, NULL
);
316 /* Set error handling if you are using the setjmp/longjmp method (this is
317 * the normal method of doing things with libpng). REQUIRED unless you
318 * set up your own error handlers in the png_create_read_struct() earlier.
321 if (setjmp(png_jmpbuf(png_ptr
)))
323 /* Free all of the memory associated with the png_ptr and info_ptr */
324 png_destroy_read_struct(&png_ptr
, &info_ptr
, NULL
);
326 /* If we get here, we had a problem reading the file */
330 /* One of the following I/O initialization methods is REQUIRED */
331 #ifdef streams /* PNG file I/O method 1 */
332 /* Set up the input control if you are using standard C streams */
333 png_init_io(png_ptr
, fp
);
335 #else no_streams /* PNG file I/O method 2 */
336 /* If you are using replacement read functions, instead of calling
337 * png_init_io() here you would call:
339 png_set_read_fn(png_ptr
, (void *)user_io_ptr
, user_read_fn
);
340 /* where user_io_ptr is a structure you want available to the callbacks */
341 #endif no_streams /* Use only one I/O method! */
343 /* If we have already read some of the signature */
344 png_set_sig_bytes(png_ptr
, sig_read
);
348 * If you have enough memory to read in the entire image at once,
349 * and you need to specify only transforms that can be controlled
350 * with one of the PNG_TRANSFORM_* bits (this presently excludes
351 * quantizing, filling, setting background, and doing gamma
352 * adjustment), then you can read the entire image (including
353 * pixels) into the info structure with this call:
355 png_read_png(png_ptr
, info_ptr
, png_transforms
, NULL
);
358 /* OK, you're doing it the hard way, with the lower-level functions */
360 /* The call to png_read_info() gives us all of the information from the
361 * PNG file before the first IDAT (image data chunk). REQUIRED
363 png_read_info(png_ptr
, info_ptr
);
365 png_get_IHDR(png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
366 &interlace_type
, NULL
, NULL
);
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.
374 /* Tell libpng to strip 16 bits/color files down to 8 bits/color.
375 * Use accurate scaling if it's available, otherwise just chop off the
378 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
379 png_set_scale_16(png_ptr
);
381 png_set_strip_16(png_ptr
);
384 /* Strip alpha bytes from the input data without combining with the
385 * background (not recommended).
387 png_set_strip_alpha(png_ptr
);
389 /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
390 * byte into separate bytes (useful for paletted and grayscale images).
392 png_set_packing(png_ptr
);
394 /* Change the order of packed pixels to least significant bit first
395 * (not useful if you are using png_set_packing). */
396 png_set_packswap(png_ptr
);
398 /* Expand paletted colors into true RGB triplets */
399 if (color_type
== PNG_COLOR_TYPE_PALETTE
)
400 png_set_palette_to_rgb(png_ptr
);
402 /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
403 if (color_type
== PNG_COLOR_TYPE_GRAY
&& bit_depth
< 8)
404 png_set_expand_gray_1_2_4_to_8(png_ptr
);
406 /* Expand paletted or RGB images with transparency to full alpha channels
407 * so the data will be available as RGBA quartets.
409 if (png_get_valid(png_ptr
, info_ptr
, PNG_INFO_tRNS
) != 0)
410 png_set_tRNS_to_alpha(png_ptr
);
412 /* Set the background color to draw transparent and alpha images over.
413 * It is possible to set the red, green, and blue components directly
414 * for paletted images instead of supplying a palette index. Note that
415 * even if the PNG file supplies a background, you are not required to
416 * use it - you should use the (solid) application background if it has one.
419 png_color_16 my_background
, *image_background
;
421 if (png_get_bKGD(png_ptr
, info_ptr
, &image_background
) != 0)
422 png_set_background(png_ptr
, image_background
,
423 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
425 png_set_background(png_ptr
, &my_background
,
426 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
428 /* Some suggestions as to how to get a screen gamma value
430 * Note that screen gamma is the display_exponent, which includes
431 * the CRT_exponent and any correction for viewing conditions
433 if (/* We have a user-defined screen gamma value */)
435 screen_gamma
= user
-defined screen_gamma
;
437 /* This is one way that applications share the same screen gamma value */
438 else if ((gamma_str
= getenv("SCREEN_GAMMA")) != NULL
)
440 screen_gamma
= atof(gamma_str
);
442 /* If we don't have another value */
445 screen_gamma
= PNG_DEFAULT_sRGB
; /* A good guess for a PC monitor
446 in a dimly lit room */
447 screen_gamma
= PNG_GAMMA_MAC_18
or 1.0; /* Good guesses for Mac systems */
450 /* Tell libpng to handle the gamma conversion for you. The final call
451 * is a good guess for PC generated images, but it should be configurable
452 * by the user at run time by the user. It is strongly suggested that
453 * your application support gamma correction.
458 if (png_get_sRGB(png_ptr
, info_ptr
, &intent
) != 0)
459 png_set_gamma(png_ptr
, screen_gamma
, PNG_DEFAULT_sRGB
);
463 if (png_get_gAMA(png_ptr
, info_ptr
, &image_gamma
) != 0)
464 png_set_gamma(png_ptr
, screen_gamma
, image_gamma
);
466 png_set_gamma(png_ptr
, screen_gamma
, 0.45455);
469 #ifdef PNG_READ_QUANTIZE_SUPPORTED
470 /* Quantize RGB files down to 8-bit palette or reduce palettes
471 * to the number of colors available on your screen.
473 if ((color_type
& PNG_COLOR_MASK_COLOR
) != 0)
478 /* This reduces the image to the application supplied palette */
479 if (/* We have our own palette */)
481 /* An array of colors to which the image should be quantized */
482 png_color std_color_cube
[MAX_SCREEN_COLORS
];
484 png_set_quantize(png_ptr
, std_color_cube
, MAX_SCREEN_COLORS
,
485 MAX_SCREEN_COLORS
, NULL
, 0);
487 /* This reduces the image to the palette supplied in the file */
488 else if (png_get_PLTE(png_ptr
, info_ptr
, &palette
, &num_palette
) != 0)
490 png_uint_16p histogram
= NULL
;
492 png_get_hIST(png_ptr
, info_ptr
, &histogram
);
494 png_set_quantize(png_ptr
, palette
, num_palette
,
495 max_screen_colors
, histogram
, 0);
498 #endif /* READ_QUANTIZE */
500 /* Invert monochrome files to have 0 as white and 1 as black */
501 png_set_invert_mono(png_ptr
);
503 /* If you want to shift the pixel values from the range [0,255] or
504 * [0,65535] to the original [0,7] or [0,31], or whatever range the
505 * colors were originally in:
507 if (png_get_valid(png_ptr
, info_ptr
, PNG_INFO_sBIT
) != 0)
509 png_color_8p sig_bit_p
;
511 png_get_sBIT(png_ptr
, info_ptr
, &sig_bit_p
);
512 png_set_shift(png_ptr
, sig_bit_p
);
515 /* Flip the RGB pixels to BGR (or RGBA to BGRA) */
516 if ((color_type
& PNG_COLOR_MASK_COLOR
) != 0)
517 png_set_bgr(png_ptr
);
519 /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
520 png_set_swap_alpha(png_ptr
);
522 /* Swap bytes of 16-bit files to least significant byte first */
523 png_set_swap(png_ptr
);
525 /* Add filler (or alpha) byte (before/after each RGB triplet) */
526 png_set_filler(png_ptr
, 0xffff, PNG_FILLER_AFTER
);
528 #ifdef PNG_READ_INTERLACING_SUPPORTED
529 /* Turn on interlace handling. REQUIRED if you are not using
530 * png_read_image(). To see how to handle interlacing passes,
531 * see the png_read_row() method below:
533 number_passes
= png_set_interlace_handling(png_ptr
);
534 #else /* !READ_INTERLACING */
536 #endif /* READ_INTERLACING */
539 /* Optional call to gamma correct and add the background to the palette
540 * and update info structure. REQUIRED if you are expecting libpng to
541 * update the palette for you (ie you selected such a transform above).
543 png_read_update_info(png_ptr
, info_ptr
);
545 /* Allocate the memory to hold the image using the fields of info_ptr. */
547 /* The easiest way to read the image: */
548 png_bytep row_pointers
[height
];
550 /* Clear the pointer array */
551 for (row
= 0; row
< height
; row
++)
552 row_pointers
[row
] = NULL
;
554 for (row
= 0; row
< height
; row
++)
555 row_pointers
[row
] = png_malloc(png_ptr
, png_get_rowbytes(png_ptr
,
558 /* Now it's time to read the image. One of these methods is REQUIRED */
559 #ifdef entire /* Read the entire image in one go */
560 png_read_image(png_ptr
, row_pointers
);
562 #else no_entire /* Read the image one or more scanlines at a time */
563 /* The other way to read images - deal with interlacing: */
565 for (pass
= 0; pass
< number_passes
; pass
++)
567 #ifdef single /* Read the image a single row at a time */
568 for (y
= 0; y
< height
; y
++)
570 png_read_rows(png_ptr
, &row_pointers
[y
], NULL
, 1);
573 #else no_single /* Read the image several rows at a time */
574 for (y
= 0; y
< height
; y
+= number_of_rows
)
576 #ifdef sparkle /* Read the image using the "sparkle" effect. */
577 png_read_rows(png_ptr
, &row_pointers
[y
], NULL
,
579 #else no_sparkle /* Read the image using the "rectangle" effect */
580 png_read_rows(png_ptr
, NULL
, &row_pointers
[y
],
582 #endif no_sparkle /* Use only one of these two methods */
585 /* If you want to display the image after every pass, do so here */
586 #endif no_single /* Use only one of these two methods */
588 #endif no_entire /* Use only one of these two methods */
590 /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
591 png_read_end(png_ptr
, info_ptr
);
594 /* At this point you have read the entire image */
596 /* Clean up after the read, and free any memory allocated - REQUIRED */
597 png_destroy_read_struct(&png_ptr
, &info_ptr
, NULL
);
606 /* Progressively read a file */
609 initialize_png_reader(png_structp
*png_ptr
, png_infop
*info_ptr
)
611 /* Create and initialize the png_struct with the desired error handler
612 * functions. If you want to use the default stderr and longjump method,
613 * you can supply NULL for the last three parameters. We also check that
614 * the library version is compatible in case we are using dynamically
617 *png_ptr
= png_create_read_struct(PNG_LIBPNG_VER_STRING
,
618 png_voidp user_error_ptr
, user_error_fn
, user_warning_fn
);
620 if (*png_ptr
== NULL
)
626 *info_ptr
= png_create_info_struct(png_ptr
);
628 if (*info_ptr
== NULL
)
630 png_destroy_read_struct(png_ptr
, info_ptr
, NULL
);
634 if (setjmp(png_jmpbuf((*png_ptr
))))
636 png_destroy_read_struct(png_ptr
, info_ptr
, NULL
);
640 /* This one's new. You will need to provide all three
641 * function callbacks, even if you aren't using them all.
642 * If you aren't using all functions, you can specify NULL
643 * parameters. Even when all three functions are NULL,
644 * you need to call png_set_progressive_read_fn().
645 * These functions shouldn't be dependent on global or
646 * static variables if you are decoding several images
647 * simultaneously. You should store stream specific data
648 * in a separate struct, given as the second parameter,
649 * and retrieve the pointer from inside the callbacks using
650 * the function png_get_progressive_ptr(png_ptr).
652 png_set_progressive_read_fn(*png_ptr
, (void *)stream_data
,
653 info_callback
, row_callback
, end_callback
);
659 process_data(png_structp
*png_ptr
, png_infop
*info_ptr
,
660 png_bytep buffer
, png_uint_32 length
)
662 if (setjmp(png_jmpbuf((*png_ptr
))))
664 /* Free the png_ptr and info_ptr memory on error */
665 png_destroy_read_struct(png_ptr
, info_ptr
, NULL
);
669 /* This one's new also. Simply give it chunks of data as
670 * they arrive from the data stream (in order, of course).
671 * On segmented machines, don't give it any more than 64K.
672 * The library seems to run fine with sizes of 4K, although
673 * you can give it much less if necessary (I assume you can
674 * give it chunks of 1 byte, but I haven't tried with less
675 * than 256 bytes yet). When this function returns, you may
676 * want to display any rows that were generated in the row
677 * callback, if you aren't already displaying them there.
679 png_process_data(*png_ptr
, *info_ptr
, buffer
, length
);
683 info_callback(png_structp png_ptr
, png_infop info
)
685 /* Do any setup here, including setting any of the transformations
686 * mentioned in the Reading PNG files section. For now, you _must_
687 * call either png_start_read_image() or png_read_update_info()
688 * after all the transformations are set (even if you don't set
689 * any). You may start getting rows before png_process_data()
690 * returns, so this is your last chance to prepare for that.
694 row_callback(png_structp png_ptr
, png_bytep new_row
,
695 png_uint_32 row_num
, int pass
)
698 * This function is called for every row in the image. If the
699 * image is interlaced, and you turned on the interlace handler,
700 * this function will be called for every row in every pass.
702 * In this function you will receive a pointer to new row data from
703 * libpng called new_row that is to replace a corresponding row (of
704 * the same data format) in a buffer allocated by your application.
706 * The new row data pointer "new_row" may be NULL, indicating there is
707 * no new data to be replaced (in cases of interlace loading).
709 * If new_row is not NULL then you need to call
710 * png_progressive_combine_row() to replace the corresponding row as
714 /* Get pointer to corresponding row in our
717 png_bytep old_row
= ((png_bytep
*)our_data
)[row_num
];
719 #ifdef PNG_READ_INTERLACING_SUPPORTED
720 /* If both rows are allocated then copy the new row
721 * data to the corresponding row data.
723 if ((old_row
!= NULL
) && (new_row
!= NULL
))
724 png_progressive_combine_row(png_ptr
, old_row
, new_row
);
727 * The rows and passes are called in order, so you don't really
728 * need the row_num and pass, but I'm supplying them because it
729 * may make your life easier.
731 * For the non-NULL rows of interlaced images, you must call
732 * png_progressive_combine_row() passing in the new row and the
733 * old row, as demonstrated above. You can call this function for
734 * NULL rows (it will just return) and for non-interlaced images
735 * (it just does the memcpy for you) if it will make the code
736 * easier. Thus, you can just do this for all cases:
739 png_progressive_combine_row(png_ptr
, old_row
, new_row
);
741 /* where old_row is what was displayed for previous rows. Note
742 * that the first pass (pass == 0 really) will completely cover
743 * the old row, so the rows do not have to be initialized. After
744 * the first pass (and only for interlaced images), you will have
745 * to pass the current row as new_row, and the function will combine
746 * the old row and the new row.
748 #endif /* READ_INTERLACING */
751 end_callback(png_structp png_ptr
, png_infop info
)
753 /* This function is called when the whole image has been read,
754 * including any chunks after the image (up to and including
755 * the IEND). You will usually have the same info chunk as you
756 * had in the header, although some data may have been added
757 * to the comments and time fields.
759 * Most people won't do much here, perhaps setting a flag that
760 * marks the image as finished.
764 /* Write a png file */
765 void write_png(char *file_name
/* , ... other image information ... */)
773 fp
= fopen(file_name
, "wb");
777 /* Create and initialize the png_struct with the desired error handler
778 * functions. If you want to use the default stderr and longjump method,
779 * you can supply NULL for the last three parameters. We also check that
780 * the library version is compatible with the one used at compile time,
781 * in case we are using dynamically linked libraries. REQUIRED.
783 png_ptr
= png_create_write_struct(PNG_LIBPNG_VER_STRING
,
784 png_voidp user_error_ptr
, user_error_fn
, user_warning_fn
);
792 /* Allocate/initialize the image information data. REQUIRED */
793 info_ptr
= png_create_info_struct(png_ptr
);
794 if (info_ptr
== NULL
)
797 png_destroy_write_struct(&png_ptr
, NULL
);
801 /* Set error handling. REQUIRED if you aren't supplying your own
802 * error handling functions in the png_create_write_struct() call.
804 if (setjmp(png_jmpbuf(png_ptr
)))
806 /* If we get here, we had a problem writing the file */
808 png_destroy_write_struct(&png_ptr
, &info_ptr
);
812 /* One of the following I/O initialization functions is REQUIRED */
814 #ifdef streams /* I/O initialization method 1 */
815 /* Set up the output control if you are using standard C streams */
816 png_init_io(png_ptr
, fp
);
818 #else no_streams /* I/O initialization method 2 */
819 /* If you are using replacement write functions, instead of calling
820 * png_init_io() here you would call
822 png_set_write_fn(png_ptr
, (void *)user_io_ptr
, user_write_fn
,
823 user_IO_flush_function
);
824 /* where user_io_ptr is a structure you want available to the callbacks */
825 #endif no_streams /* Only use one initialization method */
828 /* This is the easy way. Use it if you already have all the
829 * image info living in the structure. You could "|" many
830 * PNG_TRANSFORM flags into the png_transforms integer here.
832 png_write_png(png_ptr
, info_ptr
, png_transforms
, NULL
);
835 /* This is the hard way */
837 /* Set the image information here. Width and height are up to 2^31,
838 * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
839 * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
840 * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
841 * or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
842 * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
843 * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
845 png_set_IHDR(png_ptr
, info_ptr
, width
, height
, bit_depth
, PNG_COLOR_TYPE_
???,
846 PNG_INTERLACE_
????, PNG_COMPRESSION_TYPE_BASE
, PNG_FILTER_TYPE_BASE
);
848 /* Set the palette if there is one. REQUIRED for indexed-color images */
849 palette
= (png_colorp
)png_malloc(png_ptr
, PNG_MAX_PALETTE_LENGTH
850 * (sizeof (png_color
)));
851 /* ... Set palette colors ... */
852 png_set_PLTE(png_ptr
, info_ptr
, palette
, PNG_MAX_PALETTE_LENGTH
);
853 /* You must not free palette here, because png_set_PLTE only makes a link to
854 * the palette that you malloced. Wait until you are about to destroy
858 /* Optional significant bit (sBIT) chunk */
861 /* If we are dealing with a grayscale image then */
862 sig_bit
.gray
= true_bit_depth
;
864 /* Otherwise, if we are dealing with a color image then */
865 sig_bit
.red
= true_red_bit_depth
;
866 sig_bit
.green
= true_green_bit_depth
;
867 sig_bit
.blue
= true_blue_bit_depth
;
869 /* If the image has an alpha channel then */
870 sig_bit
.alpha
= true_alpha_bit_depth
;
872 png_set_sBIT(png_ptr
, info_ptr
, &sig_bit
);
875 /* Optional gamma chunk is strongly suggested if you have any guess
876 * as to the correct gamma of the image.
878 png_set_gAMA(png_ptr
, info_ptr
, gamma
);
880 /* Optionally write comments into the image */
882 png_text text_ptr
[3];
885 char text0
[]="Mona Lisa";
886 text_ptr
[0].key
= key0
;
887 text_ptr
[0].text
= text0
;
888 text_ptr
[0].compression
= PNG_TEXT_COMPRESSION_NONE
;
889 text_ptr
[0].itxt_length
= 0;
890 text_ptr
[0].lang
= NULL
;
891 text_ptr
[0].lang_key
= NULL
;
893 char key1
[]="Author";
894 char text1
[]="Leonardo DaVinci";
895 text_ptr
[1].key
= key1
;
896 text_ptr
[1].text
= text1
;
897 text_ptr
[1].compression
= PNG_TEXT_COMPRESSION_NONE
;
898 text_ptr
[1].itxt_length
= 0;
899 text_ptr
[1].lang
= NULL
;
900 text_ptr
[1].lang_key
= NULL
;
902 char key2
[]="Description";
903 char text2
[]="<long text>";
904 text_ptr
[2].key
= key2
;
905 text_ptr
[2].text
= text2
;
906 text_ptr
[2].compression
= PNG_TEXT_COMPRESSION_zTXt
;
907 text_ptr
[2].itxt_length
= 0;
908 text_ptr
[2].lang
= NULL
;
909 text_ptr
[2].lang_key
= NULL
;
911 png_set_text(write_ptr
, write_info_ptr
, text_ptr
, 3);
914 /* Other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs */
916 /* Note that if sRGB is present the gAMA and cHRM chunks must be ignored
917 * on read and, if your application chooses to write them, they must
918 * be written in accordance with the sRGB profile
921 /* Write the file header information. REQUIRED */
922 png_write_info(png_ptr
, info_ptr
);
924 /* If you want, you can write the info in two steps, in case you need to
925 * write your private chunk ahead of PLTE:
927 * png_write_info_before_PLTE(write_ptr, write_info_ptr);
929 * png_write_info(png_ptr, info_ptr);
931 * However, given the level of known- and unknown-chunk support in 1.2.0
932 * and up, this should no longer be necessary.
935 /* Once we write out the header, the compression type on the text
936 * chunk gets changed to PNG_TEXT_COMPRESSION_NONE_WR or
937 * PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again
941 /* Set up the transformations you want. Note that these are
942 * all optional. Only call them if you want them.
945 /* Invert monochrome pixels */
946 png_set_invert_mono(png_ptr
);
948 /* Shift the pixels up to a legal bit depth and fill in
949 * as appropriate to correctly scale the image.
951 png_set_shift(png_ptr
, &sig_bit
);
953 /* Pack pixels into bytes */
954 png_set_packing(png_ptr
);
956 /* Swap location of alpha bytes from ARGB to RGBA */
957 png_set_swap_alpha(png_ptr
);
959 /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
960 * RGB (4 channels -> 3 channels). The second parameter is not used.
962 png_set_filler(png_ptr
, 0, PNG_FILLER_BEFORE
);
964 /* Flip BGR pixels to RGB */
965 png_set_bgr(png_ptr
);
967 /* Swap bytes of 16-bit files to most significant byte first */
968 png_set_swap(png_ptr
);
970 /* Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats */
971 png_set_packswap(png_ptr
);
973 /* Turn on interlace handling if you are not using png_write_image() */
974 if (interlacing
!= 0)
975 number_passes
= png_set_interlace_handling(png_ptr
);
980 /* The easiest way to write the image (you may have a different memory
981 * layout, however, so choose what fits your needs best). You need to
982 * use the first method if you aren't handling interlacing yourself.
984 png_uint_32 k
, height
, width
;
986 /* In this example, "image" is a one-dimensional array of bytes */
988 /* Guard against integer overflow */
989 if (height
> PNG_SIZE_MAX
/(width
*bytes_per_pixel
)) {
990 png_error(png_ptr
, "Image_data buffer would be too large");
992 png_byte image
[height
*width
*bytes_per_pixel
];
994 png_bytep row_pointers
[height
];
996 if (height
> PNG_UINT_32_MAX
/(sizeof (png_bytep
)))
997 png_error (png_ptr
, "Image is too tall to process in memory");
999 /* Set up pointers into your "image" byte array */
1000 for (k
= 0; k
< height
; k
++)
1001 row_pointers
[k
] = image
+ k
*width
*bytes_per_pixel
;
1003 /* One of the following output methods is REQUIRED */
1005 #ifdef entire /* Write out the entire image data in one call */
1006 png_write_image(png_ptr
, row_pointers
);
1008 /* The other way to write the image - deal with interlacing */
1010 #else no_entire /* Write out the image data by one or more scanlines */
1012 /* The number of passes is either 1 for non-interlaced images,
1013 * or 7 for interlaced images.
1015 for (pass
= 0; pass
< number_passes
; pass
++)
1017 /* Write a few rows at a time. */
1018 png_write_rows(png_ptr
, &row_pointers
[first_row
], number_of_rows
);
1020 /* If you are only writing one row at a time, this works */
1021 for (y
= 0; y
< height
; y
++)
1022 png_write_rows(png_ptr
, &row_pointers
[y
], 1);
1024 #endif no_entire /* Use only one output method */
1026 /* You can write optional chunks like tEXt, zTXt, and tIME at the end
1027 * as well. Shouldn't be necessary in 1.2.0 and up as all the public
1028 * chunks are supported and you can use png_set_unknown_chunks() to
1029 * register unknown chunks into the info structure to be written out.
1032 /* It is REQUIRED to call this to finish writing the rest of the file */
1033 png_write_end(png_ptr
, info_ptr
);
1036 /* If you png_malloced a palette, free it here (don't free info_ptr->palette,
1037 * as recommended in versions 1.0.5m and earlier of this example; if
1038 * libpng mallocs info_ptr->palette, libpng will free it). If you
1039 * allocated it with malloc() instead of png_malloc(), use free() instead
1042 png_free(png_ptr
, palette
);
1045 /* Similarly, if you png_malloced any data that you passed in with
1046 * png_set_something(), such as a hist or trans array, free it here,
1047 * when you can be sure that libpng is through with it.
1049 png_free(png_ptr
, trans
);
1051 /* Whenever you use png_free() it is a good idea to set the pointer to
1052 * NULL in case your application inadvertently tries to png_free() it
1053 * again. When png_free() sees a NULL it returns without action, thus
1054 * avoiding the double-free security problem.
1057 /* Clean up after the write, and free any memory allocated */
1058 png_destroy_write_struct(&png_ptr
, &info_ptr
);
1060 /* Close the file */