lpng1232/example.c
Go to the documentation of this file.
1 
2 #if 0 /* in case someone actually tries to compile this */
3 
4 /* example.c - an example of using libpng
5  * Last changed in libpng 1.2.32 [September 18, 2008]
6  * This file has been placed in the public domain by the authors.
7  * Maintained 1998-2008 Glenn Randers-Pehrson
8  * Maintained 1996, 1997 Andreas Dilger)
9  * Written 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
10  */
11 
12 /* This is an example of how to use libpng to read and write PNG files.
13  * The file libpng.txt is much more verbose then this. If you have not
14  * read it, do so first. This was designed to be a starting point of an
15  * implementation. This is not officially part of libpng, is hereby placed
16  * in the public domain, and therefore does not require a copyright notice.
17  *
18  * This file does not currently compile, because it is missing certain
19  * parts, like allocating memory to hold an image. You will have to
20  * supply these parts to get it to compile. For an example of a minimal
21  * working PNG reader/writer, see pngtest.c, included in this distribution;
22  * see also the programs in the contrib directory.
23  */
24 
25 #include "png.h"
26 
27  /* The png_jmpbuf() macro, used in error handling, became available in
28  * libpng version 1.0.6. If you want to be able to run your code with older
29  * versions of libpng, you must define the macro yourself (but only if it
30  * is not already defined by libpng!).
31  */
32 
33 #ifndef png_jmpbuf
34 # define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
35 #endif
36 
37 /* Check to see if a file is a PNG file using png_sig_cmp(). png_sig_cmp()
38  * returns zero if the image is a PNG and nonzero if it isn't a PNG.
39  *
40  * The function check_if_png() shown here, but not used, returns nonzero (true)
41  * if the file can be opened and is a PNG, 0 (false) otherwise.
42  *
43  * If this call is successful, and you are going to keep the file open,
44  * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once
45  * you have created the png_ptr, so that libpng knows your application
46  * has read that many bytes from the start of the file. Make sure you
47  * don't call png_set_sig_bytes() with more than 8 bytes read or give it
48  * an incorrect number of bytes read, or you will either have read too
49  * many bytes (your fault), or you are telling libpng to read the wrong
50  * number of magic bytes (also your fault).
51  *
52  * Many applications already read the first 2 or 4 bytes from the start
53  * of the image to determine the file type, so it would be easiest just
54  * to pass the bytes to png_sig_cmp() or even skip that if you know
55  * you have a PNG file, and call png_set_sig_bytes().
56  */
57 #define PNG_BYTES_TO_CHECK 4
58 int check_if_png(char *file_name, FILE **fp)
59 {
60  char buf[PNG_BYTES_TO_CHECK];
61 
62  /* Open the prospective PNG file. */
63  if ((*fp = fopen(file_name, "rb")) == NULL)
64  return 0;
65 
66  /* Read in some of the signature bytes */
67  if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK)
68  return 0;
69 
70  /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature.
71  Return nonzero (true) if they match */
72 
73  return(!png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK));
74 }
75 
76 /* Read a PNG file. You may want to return an error code if the read
77  * fails (depending upon the failure). There are two "prototypes" given
78  * here - one where we are given the filename, and we need to open the
79  * file, and the other where we are given an open file (possibly with
80  * some or all of the magic bytes read - see comments above).
81  */
82 #ifdef open_file /* prototype 1 */
83 void read_png(char *file_name) /* We need to open the file */
84 {
85  png_structp png_ptr;
87  unsigned int sig_read = 0;
89  int bit_depth, color_type, interlace_type;
90  FILE *fp;
91 
92  if ((fp = fopen(file_name, "rb")) == NULL)
93  return (ERROR);
94 #else no_open_file /* prototype 2 */
95 void read_png(FILE *fp, unsigned int sig_read) /* file is already open */
96 {
97  png_structp png_ptr;
100  int bit_depth, color_type, interlace_type;
101 #endif no_open_file /* only use one prototype! */
102 
103  /* Create and initialize the png_struct with the desired error handler
104  * functions. If you want to use the default stderr and longjump method,
105  * you can supply NULL for the last three parameters. We also supply the
106  * the compiler header file version, so that we know if the application
107  * was compiled with a compatible version of the library. REQUIRED
108  */
110  png_voidp user_error_ptr, user_error_fn, user_warning_fn);
111 
112  if (png_ptr == NULL)
113  {
114  fclose(fp);
115  return (ERROR);
116  }
117 
118  /* Allocate/initialize the memory for image information. REQUIRED. */
119  info_ptr = png_create_info_struct(png_ptr);
120  if (info_ptr == NULL)
121  {
122  fclose(fp);
124  return (ERROR);
125  }
126 
127  /* Set error handling if you are using the setjmp/longjmp method (this is
128  * the normal method of doing things with libpng). REQUIRED unless you
129  * set up your own error handlers in the png_create_read_struct() earlier.
130  */
131 
132  if (setjmp(png_jmpbuf(png_ptr)))
133  {
134  /* Free all of the memory associated with the png_ptr and info_ptr */
135  png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
136  fclose(fp);
137  /* If we get here, we had a problem reading the file */
138  return (ERROR);
139  }
140 
141  /* One of the following I/O initialization methods is REQUIRED */
142 #ifdef streams /* PNG file I/O method 1 */
143  /* Set up the input control if you are using standard C streams */
144  png_init_io(png_ptr, fp);
145 
146 #else no_streams /* PNG file I/O method 2 */
147  /* If you are using replacement read functions, instead of calling
148  * png_init_io() here you would call:
149  */
150  png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);
151  /* where user_io_ptr is a structure you want available to the callbacks */
152 #endif no_streams /* Use only one I/O method! */
153 
154  /* If we have already read some of the signature */
155  png_set_sig_bytes(png_ptr, sig_read);
156 
157 #ifdef hilevel
158  /*
159  * If you have enough memory to read in the entire image at once,
160  * and you need to specify only transforms that can be controlled
161  * with one of the PNG_TRANSFORM_* bits (this presently excludes
162  * dithering, filling, setting background, and doing gamma
163  * adjustment), then you can read the entire image (including
164  * pixels) into the info structure with this call:
165  */
166  png_read_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL);
167 #else
168  /* OK, you're doing it the hard way, with the lower-level functions */
169 
170  /* The call to png_read_info() gives us all of the information from the
171  * PNG file before the first IDAT (image data chunk). REQUIRED
172  */
173  png_read_info(png_ptr, info_ptr);
174 
175  png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
176  &interlace_type, int_p_NULL, int_p_NULL);
177 
178 /* Set up the data transformations you want. Note that these are all
179  * optional. Only call them if you want/need them. Many of the
180  * transformations only work on specific types of images, and many
181  * are mutually exclusive.
182  */
183 
184  /* tell libpng to strip 16 bit/color files down to 8 bits/color */
185  png_set_strip_16(png_ptr);
186 
187  /* Strip alpha bytes from the input data without combining with the
188  * background (not recommended).
189  */
190  png_set_strip_alpha(png_ptr);
191 
192  /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
193  * byte into separate bytes (useful for paletted and grayscale images).
194  */
195  png_set_packing(png_ptr);
196 
197  /* Change the order of packed pixels to least significant bit first
198  * (not useful if you are using png_set_packing). */
199  png_set_packswap(png_ptr);
200 
201  /* Expand paletted colors into true RGB triplets */
202  if (color_type == PNG_COLOR_TYPE_PALETTE)
203  png_set_palette_to_rgb(png_ptr);
204 
205  /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
206  if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
207  png_set_gray_1_2_4_to_8(png_ptr);
208 
209  /* Expand paletted or RGB images with transparency to full alpha channels
210  * so the data will be available as RGBA quartets.
211  */
212  if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
213  png_set_tRNS_to_alpha(png_ptr);
214 
215  /* Set the background color to draw transparent and alpha images over.
216  * It is possible to set the red, green, and blue components directly
217  * for paletted images instead of supplying a palette index. Note that
218  * even if the PNG file supplies a background, you are not required to
219  * use it - you should use the (solid) application background if it has one.
220  */
221 
222  png_color_16 my_background, *image_background;
223 
224  if (png_get_bKGD(png_ptr, info_ptr, &image_background))
225  png_set_background(png_ptr, image_background,
226  PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
227  else
228  png_set_background(png_ptr, &my_background,
230 
231  /* Some suggestions as to how to get a screen gamma value */
232 
233  /* Note that screen gamma is the display_exponent, which includes
234  * the CRT_exponent and any correction for viewing conditions */
235  if (/* We have a user-defined screen gamma value */)
236  {
237  screen_gamma = user-defined screen_gamma;
238  }
239  /* This is one way that applications share the same screen gamma value */
240  else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL)
241  {
242  screen_gamma = atof(gamma_str);
243  }
244  /* If we don't have another value */
245  else
246  {
247  screen_gamma = 2.2; /* A good guess for a PC monitors in a dimly
248  lit room */
249  screen_gamma = 1.7 or 1.0; /* A good guess for Mac systems */
250  }
251 
252  /* Tell libpng to handle the gamma conversion for you. The final call
253  * is a good guess for PC generated images, but it should be configurable
254  * by the user at run time by the user. It is strongly suggested that
255  * your application support gamma correction.
256  */
257 
258  int intent;
259 
260  if (png_get_sRGB(png_ptr, info_ptr, &intent))
261  png_set_gamma(png_ptr, screen_gamma, 0.45455);
262  else
263  {
264  double image_gamma;
265  if (png_get_gAMA(png_ptr, info_ptr, &image_gamma))
266  png_set_gamma(png_ptr, screen_gamma, image_gamma);
267  else
268  png_set_gamma(png_ptr, screen_gamma, 0.45455);
269  }
270 
271  /* Dither RGB files down to 8 bit palette or reduce palettes
272  * to the number of colors available on your screen.
273  */
274  if (color_type & PNG_COLOR_MASK_COLOR)
275  {
276  int num_palette;
278 
279  /* This reduces the image to the application supplied palette */
280  if (/* we have our own palette */)
281  {
282  /* An array of colors to which the image should be dithered */
283  png_color std_color_cube[MAX_SCREEN_COLORS];
284 
285  png_set_dither(png_ptr, std_color_cube, MAX_SCREEN_COLORS,
286  MAX_SCREEN_COLORS, png_uint_16p_NULL, 0);
287  }
288  /* This reduces the image to the palette supplied in the file */
289  else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette))
290  {
291  png_uint_16p histogram = NULL;
292 
293  png_get_hIST(png_ptr, info_ptr, &histogram);
294 
295  png_set_dither(png_ptr, palette, num_palette,
296  max_screen_colors, histogram, 0);
297  }
298  }
299 
300  /* invert monochrome files to have 0 as white and 1 as black */
301  png_set_invert_mono(png_ptr);
302 
303  /* If you want to shift the pixel values from the range [0,255] or
304  * [0,65535] to the original [0,7] or [0,31], or whatever range the
305  * colors were originally in:
306  */
307  if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
308  {
310 
311  png_get_sBIT(png_ptr, info_ptr, &sig_bit);
312  png_set_shift(png_ptr, sig_bit);
313  }
314 
315  /* flip the RGB pixels to BGR (or RGBA to BGRA) */
316  if (color_type & PNG_COLOR_MASK_COLOR)
317  png_set_bgr(png_ptr);
318 
319  /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
320  png_set_swap_alpha(png_ptr);
321 
322  /* swap bytes of 16 bit files to least significant byte first */
323  png_set_swap(png_ptr);
324 
325  /* Add filler (or alpha) byte (before/after each RGB triplet) */
326  png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
327 
328  /* Turn on interlace handling. REQUIRED if you are not using
329  * png_read_image(). To see how to handle interlacing passes,
330  * see the png_read_row() method below:
331  */
332  number_passes = png_set_interlace_handling(png_ptr);
333 
334  /* Optional call to gamma correct and add the background to the palette
335  * and update info structure. REQUIRED if you are expecting libpng to
336  * update the palette for you (ie you selected such a transform above).
337  */
338  png_read_update_info(png_ptr, info_ptr);
339 
340  /* Allocate the memory to hold the image using the fields of info_ptr. */
341 
342  /* The easiest way to read the image: */
344 
345  for (row = 0; row < height; row++)
346  {
347  row_pointers[row] = png_malloc(png_ptr, png_get_rowbytes(png_ptr,
348  info_ptr));
349  }
350 
351  /* Now it's time to read the image. One of these methods is REQUIRED */
352 #ifdef entire /* Read the entire image in one go */
353  png_read_image(png_ptr, row_pointers);
354 
355 #else no_entire /* Read the image one or more scanlines at a time */
356  /* The other way to read images - deal with interlacing: */
357 
358  for (pass = 0; pass < number_passes; pass++)
359  {
360 #ifdef single /* Read the image a single row at a time */
361  for (y = 0; y < height; y++)
362  {
363  png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL, 1);
364  }
365 
366 #else no_single /* Read the image several rows at a time */
367  for (y = 0; y < height; y += number_of_rows)
368  {
369 #ifdef sparkle /* Read the image using the "sparkle" effect. */
370  png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL,
371  number_of_rows);
372 #else no_sparkle /* Read the image using the "rectangle" effect */
373  png_read_rows(png_ptr, png_bytepp_NULL, &row_pointers[y],
374  number_of_rows);
375 #endif no_sparkle /* use only one of these two methods */
376  }
377 
378  /* if you want to display the image after every pass, do
379  so here */
380 #endif no_single /* use only one of these two methods */
381  }
382 #endif no_entire /* use only one of these two methods */
383 
384  /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
385  png_read_end(png_ptr, info_ptr);
386 #endif hilevel
387 
388  /* At this point you have read the entire image */
389 
390  /* clean up after the read, and free any memory allocated - REQUIRED */
391  png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
392 
393  /* close the file */
394  fclose(fp);
395 
396  /* that's it */
397  return (OK);
398 }
399 
400 /* progressively read a file */
401 
402 int
403 initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
404 {
405  /* Create and initialize the png_struct with the desired error handler
406  * functions. If you want to use the default stderr and longjump method,
407  * you can supply NULL for the last three parameters. We also check that
408  * the library version is compatible in case we are using dynamically
409  * linked libraries.
410  */
412  png_voidp user_error_ptr, user_error_fn, user_warning_fn);
413 
414  if (*png_ptr == NULL)
415  {
416  *info_ptr = NULL;
417  return (ERROR);
418  }
419 
420  *info_ptr = png_create_info_struct(png_ptr);
421 
422  if (*info_ptr == NULL)
423  {
424  png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL);
425  return (ERROR);
426  }
427 
428  if (setjmp(png_jmpbuf((*png_ptr))))
429  {
430  png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL);
431  return (ERROR);
432  }
433 
434  /* This one's new. You will need to provide all three
435  * function callbacks, even if you aren't using them all.
436  * If you aren't using all functions, you can specify NULL
437  * parameters. Even when all three functions are NULL,
438  * you need to call png_set_progressive_read_fn().
439  * These functions shouldn't be dependent on global or
440  * static variables if you are decoding several images
441  * simultaneously. You should store stream specific data
442  * in a separate struct, given as the second parameter,
443  * and retrieve the pointer from inside the callbacks using
444  * the function png_get_progressive_ptr(png_ptr).
445  */
446  png_set_progressive_read_fn(*png_ptr, (void *)stream_data,
447  info_callback, row_callback, end_callback);
448 
449  return (OK);
450 }
451 
452 int
453 process_data(png_structp *png_ptr, png_infop *info_ptr,
455 {
456  if (setjmp(png_jmpbuf((*png_ptr))))
457  {
458  /* Free the png_ptr and info_ptr memory on error */
459  png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL);
460  return (ERROR);
461  }
462 
463  /* This one's new also. Simply give it chunks of data as
464  * they arrive from the data stream (in order, of course).
465  * On Segmented machines, don't give it any more than 64K.
466  * The library seems to run fine with sizes of 4K, although
467  * you can give it much less if necessary (I assume you can
468  * give it chunks of 1 byte, but I haven't tried with less
469  * than 256 bytes yet). When this function returns, you may
470  * want to display any rows that were generated in the row
471  * callback, if you aren't already displaying them there.
472  */
473  png_process_data(*png_ptr, *info_ptr, buffer, length);
474  return (OK);
475 }
476 
477 info_callback(png_structp png_ptr, png_infop info)
478 {
479 /* do any setup here, including setting any of the transformations
480  * mentioned in the Reading PNG files section. For now, you _must_
481  * call either png_start_read_image() or png_read_update_info()
482  * after all the transformations are set (even if you don't set
483  * any). You may start getting rows before png_process_data()
484  * returns, so this is your last chance to prepare for that.
485  */
486 }
487 
488 row_callback(png_structp png_ptr, png_bytep new_row,
489  png_uint_32 row_num, int pass)
490 {
491 /*
492  * This function is called for every row in the image. If the
493  * image is interlaced, and you turned on the interlace handler,
494  * this function will be called for every row in every pass.
495  *
496  * In this function you will receive a pointer to new row data from
497  * libpng called new_row that is to replace a corresponding row (of
498  * the same data format) in a buffer allocated by your application.
499  *
500  * The new row data pointer new_row may be NULL, indicating there is
501  * no new data to be replaced (in cases of interlace loading).
502  *
503  * If new_row is not NULL then you need to call
504  * png_progressive_combine_row() to replace the corresponding row as
505  * shown below:
506  */
507  /* Check if row_num is in bounds. */
508  if ((row_num >= 0) && (row_num < height))
509  {
510  /* Get pointer to corresponding row in our
511  * PNG read buffer.
512  */
513  png_bytep old_row = ((png_bytep *)our_data)[row_num];
514 
515  /* If both rows are allocated then copy the new row
516  * data to the corresponding row data.
517  */
518  if ((old_row != NULL) && (new_row != NULL))
519  png_progressive_combine_row(png_ptr, old_row, new_row);
520  }
521 /*
522  * The rows and passes are called in order, so you don't really
523  * need the row_num and pass, but I'm supplying them because it
524  * may make your life easier.
525  *
526  * For the non-NULL rows of interlaced images, you must call
527  * png_progressive_combine_row() passing in the new row and the
528  * old row, as demonstrated above. You can call this function for
529  * NULL rows (it will just return) and for non-interlaced images
530  * (it just does the png_memcpy for you) if it will make the code
531  * easier. Thus, you can just do this for all cases:
532  */
533 
534  png_progressive_combine_row(png_ptr, old_row, new_row);
535 
536 /* where old_row is what was displayed for previous rows. Note
537  * that the first pass (pass == 0 really) will completely cover
538  * the old row, so the rows do not have to be initialized. After
539  * the first pass (and only for interlaced images), you will have
540  * to pass the current row as new_row, and the function will combine
541  * the old row and the new row.
542  */
543 }
544 
545 end_callback(png_structp png_ptr, png_infop info)
546 {
547 /* this function is called when the whole image has been read,
548  * including any chunks after the image (up to and including
549  * the IEND). You will usually have the same info chunk as you
550  * had in the header, although some data may have been added
551  * to the comments and time fields.
552  *
553  * Most people won't do much here, perhaps setting a flag that
554  * marks the image as finished.
555  */
556 }
557 
558 /* write a png file */
559 void write_png(char *file_name /* , ... other image information ... */)
560 {
561  FILE *fp;
562  png_structp png_ptr;
565 
566  /* open the file */
567  fp = fopen(file_name, "wb");
568  if (fp == NULL)
569  return (ERROR);
570 
571  /* Create and initialize the png_struct with the desired error handler
572  * functions. If you want to use the default stderr and longjump method,
573  * you can supply NULL for the last three parameters. We also check that
574  * the library version is compatible with the one used at compile time,
575  * in case we are using dynamically linked libraries. REQUIRED.
576  */
578  png_voidp user_error_ptr, user_error_fn, user_warning_fn);
579 
580  if (png_ptr == NULL)
581  {
582  fclose(fp);
583  return (ERROR);
584  }
585 
586  /* Allocate/initialize the image information data. REQUIRED */
587  info_ptr = png_create_info_struct(png_ptr);
588  if (info_ptr == NULL)
589  {
590  fclose(fp);
592  return (ERROR);
593  }
594 
595  /* Set error handling. REQUIRED if you aren't supplying your own
596  * error handling functions in the png_create_write_struct() call.
597  */
598  if (setjmp(png_jmpbuf(png_ptr)))
599  {
600  /* If we get here, we had a problem reading the file */
601  fclose(fp);
602  png_destroy_write_struct(&png_ptr, &info_ptr);
603  return (ERROR);
604  }
605 
606  /* One of the following I/O initialization functions is REQUIRED */
607 #ifdef streams /* I/O initialization method 1 */
608  /* set up the output control if you are using standard C streams */
609  png_init_io(png_ptr, fp);
610 #else no_streams /* I/O initialization method 2 */
611  /* If you are using replacement write functions, instead of calling
612  * png_init_io() here you would call */
613  png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn,
614  user_IO_flush_function);
615  /* where user_io_ptr is a structure you want available to the callbacks */
616 #endif no_streams /* only use one initialization method */
617 
618 #ifdef hilevel
619  /* This is the easy way. Use it if you already have all the
620  * image info living info in the structure. You could "|" many
621  * PNG_TRANSFORM flags into the png_transforms integer here.
622  */
623  png_write_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL);
624 #else
625  /* This is the hard way */
626 
627  /* Set the image information here. Width and height are up to 2^31,
628  * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
629  * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
630  * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
631  * or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
632  * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
633  * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
634  */
635  png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_???,
636  PNG_INTERLACE_????, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
637 
638  /* set the palette if there is one. REQUIRED for indexed-color images */
639  palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH
640  * png_sizeof(png_color));
641  /* ... set palette colors ... */
642  png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH);
643  /* You must not free palette here, because png_set_PLTE only makes a link to
644  the palette that you malloced. Wait until you are about to destroy
645  the png structure. */
646 
647  /* optional significant bit chunk */
648  /* if we are dealing with a grayscale image then */
649  sig_bit.gray = true_bit_depth;
650  /* otherwise, if we are dealing with a color image then */
651  sig_bit.red = true_red_bit_depth;
652  sig_bit.green = true_green_bit_depth;
653  sig_bit.blue = true_blue_bit_depth;
654  /* if the image has an alpha channel then */
655  sig_bit.alpha = true_alpha_bit_depth;
656  png_set_sBIT(png_ptr, info_ptr, sig_bit);
657 
658 
659  /* Optional gamma chunk is strongly suggested if you have any guess
660  * as to the correct gamma of the image.
661  */
662  png_set_gAMA(png_ptr, info_ptr, gamma);
663 
664  /* Optionally write comments into the image */
665  text_ptr[0].key = "Title";
666  text_ptr[0].text = "Mona Lisa";
667  text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
668  text_ptr[1].key = "Author";
669  text_ptr[1].text = "Leonardo DaVinci";
670  text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
671  text_ptr[2].key = "Description";
672  text_ptr[2].text = "<long text>";
673  text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;
674 #ifdef PNG_iTXt_SUPPORTED
675  text_ptr[0].lang = NULL;
676  text_ptr[1].lang = NULL;
677  text_ptr[2].lang = NULL;
678 #endif
679  png_set_text(png_ptr, info_ptr, text_ptr, 3);
680 
681  /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
682  /* note that if sRGB is present the gAMA and cHRM chunks must be ignored
683  * on read and must be written in accordance with the sRGB profile */
684 
685  /* Write the file header information. REQUIRED */
686  png_write_info(png_ptr, info_ptr);
687 
688  /* If you want, you can write the info in two steps, in case you need to
689  * write your private chunk ahead of PLTE:
690  *
691  * png_write_info_before_PLTE(write_ptr, write_info_ptr);
692  * write_my_chunk();
693  * png_write_info(png_ptr, info_ptr);
694  *
695  * However, given the level of known- and unknown-chunk support in 1.1.0
696  * and up, this should no longer be necessary.
697  */
698 
699  /* Once we write out the header, the compression type on the text
700  * chunks gets changed to PNG_TEXT_COMPRESSION_NONE_WR or
701  * PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again
702  * at the end.
703  */
704 
705  /* set up the transformations you want. Note that these are
706  * all optional. Only call them if you want them.
707  */
708 
709  /* invert monochrome pixels */
710  png_set_invert_mono(png_ptr);
711 
712  /* Shift the pixels up to a legal bit depth and fill in
713  * as appropriate to correctly scale the image.
714  */
715  png_set_shift(png_ptr, &sig_bit);
716 
717  /* pack pixels into bytes */
718  png_set_packing(png_ptr);
719 
720  /* swap location of alpha bytes from ARGB to RGBA */
721  png_set_swap_alpha(png_ptr);
722 
723  /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
724  * RGB (4 channels -> 3 channels). The second parameter is not used.
725  */
726  png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
727 
728  /* flip BGR pixels to RGB */
729  png_set_bgr(png_ptr);
730 
731  /* swap bytes of 16-bit files to most significant byte first */
732  png_set_swap(png_ptr);
733 
734  /* swap bits of 1, 2, 4 bit packed pixel formats */
735  png_set_packswap(png_ptr);
736 
737  /* turn on interlace handling if you are not using png_write_image() */
738  if (interlacing)
739  number_passes = png_set_interlace_handling(png_ptr);
740  else
741  number_passes = 1;
742 
743  /* The easiest way to write the image (you may have a different memory
744  * layout, however, so choose what fits your needs best). You need to
745  * use the first method if you aren't handling interlacing yourself.
746  */
748  png_byte image[height][width*bytes_per_pixel];
749  png_bytep row_pointers[height];
750 
751  if (height > PNG_UINT_32_MAX/png_sizeof(png_bytep))
752  png_error (png_ptr, "Image is too tall to process in memory");
753 
754  for (k = 0; k < height; k++)
755  row_pointers[k] = image + k*width*bytes_per_pixel;
756 
757  /* One of the following output methods is REQUIRED */
758 #ifdef entire /* write out the entire image data in one call */
759  png_write_image(png_ptr, row_pointers);
760 
761  /* the other way to write the image - deal with interlacing */
762 
763 #else no_entire /* write out the image data by one or more scanlines */
764  /* The number of passes is either 1 for non-interlaced images,
765  * or 7 for interlaced images.
766  */
767  for (pass = 0; pass < number_passes; pass++)
768  {
769  /* Write a few rows at a time. */
770  png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows);
771 
772  /* If you are only writing one row at a time, this works */
773  for (y = 0; y < height; y++)
774  {
775  png_write_rows(png_ptr, &row_pointers[y], 1);
776  }
777  }
778 #endif no_entire /* use only one output method */
779 
780  /* You can write optional chunks like tEXt, zTXt, and tIME at the end
781  * as well. Shouldn't be necessary in 1.1.0 and up as all the public
782  * chunks are supported and you can use png_set_unknown_chunks() to
783  * register unknown chunks into the info structure to be written out.
784  */
785 
786  /* It is REQUIRED to call this to finish writing the rest of the file */
787  png_write_end(png_ptr, info_ptr);
788 #endif hilevel
789 
790  /* If you png_malloced a palette, free it here (don't free info_ptr->palette,
791  as recommended in versions 1.0.5m and earlier of this example; if
792  libpng mallocs info_ptr->palette, libpng will free it). If you
793  allocated it with malloc() instead of png_malloc(), use free() instead
794  of png_free(). */
795  png_free(png_ptr, palette);
796  palette = NULL;
797 
798  /* Similarly, if you png_malloced any data that you passed in with
799  png_set_something(), such as a hist or trans array, free it here,
800  when you can be sure that libpng is through with it. */
801  png_free(png_ptr, trans);
802  trans = NULL;
803 
804  /* clean up after the write, and free any memory allocated */
805  png_destroy_write_struct(&png_ptr, &info_ptr);
806 
807  /* close the file */
808  fclose(fp);
809 
810  /* that's it */
811  return (OK);
812 }
813 
814 #endif /* if 0 */
#define png_infopp_NULL
Definition: png.h:507
void PNGAPI png_set_packing(png_structp png_ptr)
Definition: pngtrans.c:41
void PNGAPI png_set_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int interlace_type, int compression_type, int filter_type)
Definition: pngset.c:261
void PNGAPI png_write_image(png_structp png_ptr, png_bytepp image)
Definition: pngwrite.c:732
void PNGAPI png_write_png(png_structp png_ptr, png_infop info_ptr, int transforms, voidp params)
Definition: pngwrite.c:1465
png_bytep png_bytep new_row
Definition: png.h:2048
png_uint_32 PNGAPI png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
Definition: pngget.c:524
#define PNG_FILLER_BEFORE
Definition: png.h:1658
void PNGAPI png_process_data(png_structp png_ptr, png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)
Definition: pngpread.c:27
png_infop PNGAPI png_create_info_struct(png_structp png_ptr)
Definition: png.c:239
png_infop png_textp * text_ptr
Definition: png.h:2407
png_colorp int num_palette
Definition: png.h:1720
#define PNG_BACKGROUND_GAMMA_SCREEN
Definition: png.h:1707
#define PNG_MAX_PALETTE_LENGTH
Definition: png.h:1060
void PNGAPI png_set_palette_to_rgb(png_structp png_ptr)
Definition: pngrtran.c:573
png_uint_32 PNGAPI png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
Definition: pngget.c:16
void PNGAPI png_write_rows(png_structp png_ptr, png_bytepp row, png_uint_32 num_rows)
Definition: pngwrite.c:710
png_byte FAR * png_bytep
Definition: pngconf.h:1197
#define PNG_COLOR_TYPE_PALETTE
Definition: png.h:1004
png_colorp int int png_uint_16p histogram
Definition: png.h:1720
void PNGAPI png_set_dither(png_structp png_ptr, png_colorp palette, int num_palette, int maximum_colors, png_uint_16p histogram, int full_dither)
Definition: pngrtran.c:141
png_uint_32 PNGAPI png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
Definition: pngget.c:442
void PNGAPI png_set_background(png_structp png_ptr, png_color_16p background_color, int background_gamma_code, int need_expand, double background_gamma)
Definition: pngrtran.c:79
void PNGAPI png_read_rows(png_structp png_ptr, png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)
Definition: pngread.c:818
#define PNG_LIBPNG_VER_STRING
Definition: png.h:413
void PNGAPI png_progressive_combine_row(png_structp png_ptr, png_bytep old_row, png_bytep new_row)
Definition: pngpread.c:1563
void PNGAPI png_set_sig_bytes(png_structp png_ptr, int num_bytes)
Definition: png.c:93
void PNGAPI png_set_strip_16(png_structp png_ptr)
Definition: pngrtran.c:103
png_infop int * intent
Definition: png.h:2370
void PNGAPI png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
Definition: pngwio.c:170
png_bytep png_bytep png_size_t length
Definition: png.h:1541
#define PNG_BACKGROUND_GAMMA_FILE
Definition: png.h:1708
void PNGAPI png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
Definition: pngset.c:156
png_infop png_bytep * trans
Definition: png.h:2435
void PNGAPI png_set_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p sig_bit)
Definition: pngset.c:587
png_bytepp image
Definition: png.h:1772
png_infop png_uint_32 * width
Definition: png.h:2309
void PNGAPI png_set_gray_1_2_4_to_8(png_structp png_ptr)
Definition: pngrtran.c:597
void PNGAPI png_set_bgr(png_structp png_ptr)
Definition: pngtrans.c:18
png_FILE_p fp
Definition: png.h:1951
#define PNG_TEXT_COMPRESSION_zTXt
Definition: png.h:663
#define png_uint_16p_NULL
Definition: png.h:512
png_infop png_bytepp row_pointers
Definition: png.h:2173
png_uint_32 PNGAPI png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
Definition: pngget.c:710
#define PNG_TEXT_COMPRESSION_NONE
Definition: png.h:662
png_struct FAR * png_structp
Definition: png.h:1108
void PNGAPI png_write_info(png_structp png_ptr, png_infop info_ptr)
Definition: pngwrite.c:127
void PNGAPI png_read_end(png_structp png_ptr, png_infop info_ptr)
Definition: pngread.c:908
void PNGAPI png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
Definition: pngtrans.c:99
#define PNG_COLOR_MASK_COLOR
Definition: png.h:999
png_uint_32 PNGAPI png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette, int *num_palette)
Definition: pngget.c:693
void PNGAPI png_error(png_structp png_ptr, png_const_charp error_message)
Definition: pngerror.c:36
void PNGAPI png_set_packswap(png_structp png_ptr)
Definition: pngtrans.c:56
png_infop png_uint_32 png_uint_32 * height
Definition: png.h:2309
png_uint_32 PNGAPI png_get_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, int *bit_depth, int *color_type, int *interlace_type, int *compression_type, int *filter_type)
Definition: pngget.c:538
void PNGAPI png_set_swap(png_structp png_ptr)
Definition: pngtrans.c:29
unsigned char png_byte
Definition: pngconf.h:1120
#define PNG_COLOR_TYPE_GRAY
Definition: png.h:1003
png_uint_16 FAR * png_uint_16p
Definition: pngconf.h:1200
#define PNG_UINT_32_MAX
Definition: png.h:989
png_colorp palette
Definition: png.h:1637
void PNGAPI png_write_end(png_structp png_ptr, png_infop info_ptr)
Definition: pngwrite.c:297
png_bytepp row
Definition: png.h:1759
void PNGAPI png_set_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp palette, int num_palette)
Definition: pngset.c:537
void PNGAPI png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
Definition: pngrtran.c:527
int PNGAPI png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
Definition: png.c:112
#define PNG_INFO_sBIT
Definition: png.h:1068
void PNGAPI png_set_strip_alpha(png_structp png_ptr)
Definition: pngrtran.c:113
#define png_jmpbuf(png_ptr)
Definition: pngconf.h:1422
png_bytep buf
Definition: png.h:2729
#define png_bytepp_NULL
Definition: png.h:502
void PNGAPI png_read_info(png_structp png_ptr, png_infop info_ptr)
Definition: pngread.c:327
void PNGAPI png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, png_rw_ptr read_data_fn)
Definition: pngrio.c:137
void PNGAPI png_set_invert_mono(png_structp png_ptr)
Definition: pngtrans.c:167
png_infop png_uint_32 png_uint_32 int * bit_depth
Definition: png.h:2309
png_bytep old_row
Definition: png.h:2048
char * getenv(const char *name)
#define PNG_FILTER_TYPE_BASE
Definition: png.h:1017
backing_store_ptr info
Definition: jmemsys.h:181
png_structp PNGAPI png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn)
Definition: pngread.c:20
#define PNG_COMPRESSION_TYPE_BASE
Definition: png.h:1013
#define png_voidp_NULL
Definition: png.h:513
#define PNG_INFO_tRNS
Definition: png.h:1071
png_infop png_uint_32 png_uint_32 int int * color_type
Definition: png.h:2309
png_uint_32 PNGAPI png_get_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p *background)
Definition: pngget.c:361
void PNGAPI png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
Definition: pngwrite.c:1004
png_infop png_bytep buffer
Definition: png.h:2042
png_color_8 FAR * png_color_8p
Definition: png.h:593
int PNGAPI png_set_interlace_handling(png_structp png_ptr)
Definition: pngtrans.c:79
double screen_gamma
Definition: png.h:1728
void FAR * png_voidp
Definition: pngconf.h:1196
void PNGAPI png_set_tRNS_to_alpha(png_structp png_ptr)
Definition: pngrtran.c:608
void PNGAPI png_read_png(png_structp png_ptr, png_infop info_ptr, int transforms, voidp params)
Definition: pngread.c:1307
void PNGAPI png_set_shift(png_structp png_ptr, png_color_8p true_bits)
Definition: pngtrans.c:67
void PNGAPI png_read_image(png_structp png_ptr, png_bytepp image)
Definition: pngread.c:868
png_structp PNGAPI png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn)
Definition: pngwrite.c:439
#define PNG_FILLER_AFTER
Definition: png.h:1659
size_t png_size_t
Definition: pngconf.h:1128
void PNGAPI png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, int num_text)
Definition: pngset.c:731
void PNGAPI png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr, png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn)
Definition: pngpread.c:1576
* y
Definition: IceUtils.h:97
png_infop info_ptr
Definition: png.h:1571
unsigned long png_uint_32
Definition: pngconf.h:1116
void PNGAPI png_free(png_structp png_ptr, png_voidp ptr)
Definition: pngmem.c:498
png_uint_32 PNGAPI png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
Definition: pngget.c:25
void PNGAPI png_set_swap_alpha(png_structp png_ptr)
Definition: pngtrans.c:146
void PNGAPI png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)
Definition: pngread.c:1080
void PNGAPI png_read_update_info(png_structp png_ptr, png_infop info_ptr)
Definition: pngread.c:534
png_uint_32 PNGAPI png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
Definition: pngget.c:473
void PNGAPI png_init_io(png_structp png_ptr, png_FILE_p fp)
Definition: png.c:633
#define int_p_NULL
Definition: png.h:500
png_voidp PNGAPI png_malloc(png_structp png_ptr, png_uint_32 size)
Definition: pngmem.c:429
#define png_sizeof(x)
Definition: pngconf.h:1129
png_infop png_color_8p * sig_bit
Definition: png.h:2360
png_color FAR * png_colorp
Definition: png.h:571
png_info FAR * png_infop
Definition: png.h:984


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sat May 8 2021 02:42:37