#if 0 /* in case someone actually tries to compile this */ /* example.c - an example of using libpng * * Maintained 2018 Cosmin Truta * Maintained 1998-2016 Glenn Randers-Pehrson * Maintained 1996-1997 Andreas Dilger * Written 1995-1996 Guy Eric Schalnat, Group 42, Inc. * * To the extent possible under law, the authors have waived * all copyright and related or neighboring rights to this file. * This work is published from: United States, Canada. */ /* This is an example of how to use libpng to read and write PNG files. * The file libpng-manual.txt is much more verbose then this.  If you have * not read it, do so first.  This was designed to be a starting point of an * implementation.  This is not officially part of libpng, is hereby placed * in the public domain, and therefore does not require a copyright notice. * * This file does not currently compile, because it is missing certain * parts, like allocating memory to hold an image.  You will have to * supply these parts to get it to compile.  For an example of a minimal * working PNG reader/writer, see pngtest.c, included in this distribution; * see also the programs in the contrib directory. */ /* The simple, but restricted approach to reading a PNG file or data stream * requires just two function calls, as in the following complete program. * Writing a file needs just one function call, so long as the data has an * appropriate layout. * * The following code reads PNG image data from a file and writes it, in a * potentially new format, to a new file.  While this code will compile, there * is minimal (insufficient) error checking.  For a more realistic version, * see contrib/examples/pngtopng.c */ #include <stddef.h>#include <stdlib.h>#include <string.h>#include <stdio.h>#include <png.h>#include <zlib.h> int main(int argc, const char **argv){   if (argc == 3)   {      png_image image; /* The control structure used by libpng */       /* Initialize the 'png_image' structure. */      memset(&image, 0, (sizeof image));      image.version = PNG_IMAGE_VERSION;       /* The first argument is the file to read: */      if (png_image_begin_read_from_file(&image, argv[1]) != 0)      {         png_bytep buffer;          /* Set the format in which to read the PNG file; this code chooses a          * simple sRGB format with a non-associated alpha channel, adequate to          * store most images.          */         image.format = PNG_FORMAT_RGBA;          /* Now allocate enough memory to hold the image in this format; the          * PNG_IMAGE_SIZE macro uses the information about the image (width,          * height and format) stored in 'image'.          */         buffer = malloc(PNG_IMAGE_SIZE(image));          /* If enough memory was available, read the image in the desired          * format, then write the result out to the new file.  'background' is          * not necessary when reading the image, because the alpha channel is          * preserved; if it were to be removed, for example if we requested          * PNG_FORMAT_RGB, then either a solid background color would have to          * be supplied, or the output buffer would have to be initialized to          * the actual background of the image.          *          * The fourth argument to png_image_finish_read is the 'row_stride' -          * this is the number of components allocated for the image in each          * row.  It has to be at least as big as the value returned by          * PNG_IMAGE_ROW_STRIDE, but if you just allocate space for the          * default, minimum size, using PNG_IMAGE_SIZE as above, you can pass          * zero.          *          * The final argument is a pointer to a buffer for the colormap;          * colormaps have exactly the same format as a row of image pixels          * (so you choose what format to make the colormap by setting          * image.format).  A colormap is only returned if          * PNG_FORMAT_FLAG_COLORMAP is also set in image.format, so in this          * case NULL is passed as the final argument.  If you do want to force          * all images into an index/color-mapped format, then you can use:          *          *    PNG_IMAGE_COLORMAP_SIZE(image)          *          * to find the maximum size of the colormap in bytes.          */         if (buffer != NULL &&            png_image_finish_read(&image, NULL/*background*/, buffer,                0/*row_stride*/, NULL/*colormap*/) != 0)         {            /* Now write the image out to the second argument.  In the write             * call 'convert_to_8bit' allows 16-bit data to be squashed down to             * 8 bits; this isn't necessary here because the original read was             * to the 8-bit format.             */            if (png_image_write_to_file(&image, argv[2], 0/*convert_to_8bit*/,                buffer, 0/*row_stride*/, NULL/*colormap*/) != 0)            {               /* The image has been written successfully. */               exit(0);            }         }         else         {            /* Calling png_image_free is optional unless the simplified API was             * not run to completion.  In this case, if there wasn't enough             * memory for 'buffer', we didn't complete the read, so we must             * free the image:             */            if (buffer == NULL)               png_image_free(&image);            else               free(buffer);      }       /* Something went wrong reading or writing the image.  libpng stores a       * textual message in the 'png_image' structure:       */      fprintf(stderr, "pngtopng: error: %s\n", image.message);      exit(1);   }    fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n");   exit(2);} /* That's it ;-)  Of course you probably want to do more with PNG files than * just converting them all to 32-bit RGBA PNG files; you can do that between * the call to png_image_finish_read and png_image_write_to_file.  You can also * ask for the image data to be presented in a number of different formats. * You do this by simply changing the 'format' parameter set before allocating * the buffer. * * The format parameter consists of five flags that define various aspects of * the image.  You can simply add these together to get the format, or you can * use one of the predefined macros from png.h (as above): * * PNG_FORMAT_FLAG_COLOR: if set, the image will have three color components *    per pixel (red, green and blue); if not set, the image will just have one *    luminance (grayscale) component. * * PNG_FORMAT_FLAG_ALPHA: if set, each pixel in the image will have an *    additional alpha value; a linear value that describes the degree the *    image pixel covers (overwrites) the contents of the existing pixel on the *    display. * * PNG_FORMAT_FLAG_LINEAR: if set, the components of each pixel will be *    returned as a series of 16-bit linear values; if not set, the components *    will be returned as a series of 8-bit values encoded according to the *    sRGB standard.  The 8-bit format is the normal format for images intended *    for direct display, because almost all display devices do the inverse of *    the sRGB transformation to the data they receive.  The 16-bit format is *    more common for scientific data and image data that must be further *    processed; because it is linear, simple math can be done on the component *    values.  Regardless of the setting of this flag, the alpha channel is *    always linear, although it will be 8 bits or 16 bits wide as specified by *    the flag. * * PNG_FORMAT_FLAG_BGR: if set, the components of a color pixel will be *    returned in the order blue, then green, then red.  If not set, the pixel *    components are in the order red, then green, then blue. * * PNG_FORMAT_FLAG_AFIRST: if set, the alpha channel (if present) precedes the *    color or grayscale components.  If not set, the alpha channel follows the *    components. * * You do not have to read directly from a file.  You can read from memory or, * on systems that support it, from a <stdio.h> FILE*.  This is controlled by * the particular png_image_read_from_ function you call at the start. * Likewise, on write, you can write to a FILE* if your system supports it. * Check the macro PNG_STDIO_SUPPORTED to see if stdio support has been * included in your libpng build. * * If you read 16-bit (PNG_FORMAT_FLAG_LINEAR) data, you may need to write it * in the 8-bit format for display.  You do this by setting the convert_to_8bit * flag to 'true'. * * Don't repeatedly convert between the 8-bit and 16-bit forms.  There is * significant data loss when 16-bit data is converted to the 8-bit encoding, * and the current libpng implementation of conversion to 16-bit is also * significantly lossy.  The latter will be fixed in the future, but the former * is unavoidable - the 8-bit format just doesn't have enough resolution. */ /* If your program needs more information from the PNG data it reads, or if you * need to do more complex transformations, or minimize transformations, on the * data you read, then you must use one of the several lower level libpng * interfaces. * * All these interfaces require that you do your own error handling - your * program must be able to arrange for control to return to your own code, any * time libpng encounters a problem.  There are several ways to do this, but * the standard way is to use the <setjmp.h> interface to establish a return * point within your own code.  You must do this if you do not use the * simplified interface (above). * * The first step is to include the header files you need, including the libpng * header file.  Include any standard headers and feature test macros your * program requires before including png.h: */#include <png.h>  /* The png_jmpbuf() macro, used in error handling, became available in  * libpng version 1.0.6.  If you want to be able to run your code with older  * versions of libpng, you must define the macro yourself (but only if it  * is not already defined by libpng!)  */ #ifndef png_jmpbuf#  define png_jmpbuf(png_ptr) ((png_ptr)->png_jmpbuf)#endif /* Check to see if a file is a PNG file using png_sig_cmp().  png_sig_cmp() * returns zero if the image is a PNG, and nonzero otherwise. * * The function check_if_png() shown here, but not used, returns nonzero (true) * if the file can be opened and is a PNG, and 0 (false) otherwise. * * If this call is successful, and you are going to keep the file open, * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once * you have created the png_ptr, so that libpng knows your application * has read that many bytes from the start of the file.  Make sure you * don't call png_set_sig_bytes() with more than 8 bytes read or give it * an incorrect number of bytes read, or you will either have read too * many bytes (your fault), or you are telling libpng to read the wrong * number of magic bytes (also your fault). * * Many applications already read the first 2 or 4 bytes from the start * of the image to determine the file type, so it would be easiest just * to pass the bytes to png_sig_cmp(), or even skip that if you know * you have a PNG file, and call png_set_sig_bytes(). */#define PNG_BYTES_TO_CHECK 4int check_if_png(char *file_name, FILE **fp){   char buf[PNG_BYTES_TO_CHECK];    /* Open the prospective PNG file. */   if ((*fp = fopen(file_name, "rb")) == NULL)      return 0;    /* Read in some of the signature bytes. */   if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK)      return 0;    /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature.    * Return nonzero (true) if they match.    */   return(!png_sig_cmp(buf, 0, PNG_BYTES_TO_CHECK));} /* Read a PNG file.  You may want to return an error code if the read * fails (depending upon the failure).  There are two "prototypes" given * here - one where we are given the filename, and we need to open the * file, and the other where we are given an open file (possibly with * some or all of the magic bytes read - see comments above). */#ifdef open_file /* prototype 1 */void read_png(char *file_name) /* We need to open the file */{   png_structp png_ptr;   png_infop info_ptr;   int sig_read = 0;   png_uint_32 width, height;   int bit_depth, color_type, interlace_type;   FILE *fp;    if ((fp = fopen(file_name, "rb")) == NULL)      return (ERROR); #else no_open_file /* prototype 2 */void read_png(FILE *fp, int sig_read) /* File is already open */{   png_structp png_ptr;   png_infop info_ptr;   png_uint_32 width, height;   int bit_depth, color_type, interlace_type;#endif no_open_file /* Only use one prototype! */    /* Create and initialize the png_struct with the desired error handler    * functions.  If you want to use the default stderr and longjump method,    * you can supply NULL for the last three parameters.  We also supply the    * the compiler header file version, so that we know if the application    * was compiled with a compatible version of the library.  REQUIRED.    */   png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,       png_voidp user_error_ptr, user_error_fn, user_warning_fn);    if (png_ptr == NULL)   {      fclose(fp);      return (ERROR);   }    /* Allocate/initialize the memory for image information.  REQUIRED. */   info_ptr = png_create_info_struct(png_ptr);   if (info_ptr == NULL)   {      fclose(fp);      png_destroy_read_struct(&png_ptr, NULL, NULL);      return (ERROR);   }    /* Set error handling if you are using the setjmp/longjmp method (this is    * the normal method of doing things with libpng).  REQUIRED unless you    * set up your own error handlers in the png_create_read_struct() earlier.    */   if (setjmp(png_jmpbuf(png_ptr)))   {      /* Free all of the memory associated with the png_ptr and info_ptr. */      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);      fclose(fp);      /* If we get here, we had a problem reading the file. */      return (ERROR);   }    /* One of the following I/O initialization methods is REQUIRED. */#ifdef streams /* PNG file I/O method 1 */   /* Set up the input control if you are using standard C streams. */   png_init_io(png_ptr, fp); #else no_streams /* PNG file I/O method 2 */   /* If you are using replacement read functions, instead of calling    * png_init_io(), you would call:    */   png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);   /* where user_io_ptr is a structure you want available to the callbacks. */#endif no_streams /* Use only one I/O method! */    /* If we have already read some of the signature */   png_set_sig_bytes(png_ptr, sig_read); #ifdef hilevel   /* If you have enough memory to read in the entire image at once,    * and you need to specify only transforms that can be controlled    * with one of the PNG_TRANSFORM_* bits (this presently excludes    * quantizing, filling, setting background, and doing gamma    * adjustment), then you can read the entire image (including    * pixels) into the info structure with this call:    */   png_read_png(png_ptr, info_ptr, png_transforms, NULL); #else   /* OK, you're doing it the hard way, with the lower-level functions. */    /* The call to png_read_info() gives us all of the information from the    * PNG file before the first IDAT (image data chunk).  REQUIRED.    */   png_read_info(png_ptr, info_ptr);    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,       &interlace_type, NULL, NULL);    /* Set up the data transformations you want.  Note that these are all    * optional.  Only call them if you want/need them.  Many of the    * transformations only work on specific types of images, and many    * are mutually exclusive.    */    /* Tell libpng to strip 16 bits/color files down to 8 bits/color.    * Use accurate scaling if it's available, otherwise just chop off the    * low byte.    */#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED   png_set_scale_16(png_ptr);#else   png_set_strip_16(png_ptr);#endif    /* Strip alpha bytes from the input data without combining with the    * background (not recommended).    */   png_set_strip_alpha(png_ptr);    /* Extract multiple pixels with bit depths of 1, 2 or 4 from a single    * byte into separate bytes (useful for paletted and grayscale images).    */   png_set_packing(png_ptr);    /* Change the order of packed pixels to least significant bit first    * (not useful if you are using png_set_packing).    */   png_set_packswap(png_ptr);    /* Expand paletted colors into true RGB triplets. */   if (color_type == PNG_COLOR_TYPE_PALETTE)      png_set_palette_to_rgb(png_ptr);    /* Expand grayscale images to the full 8 bits from 1, 2 or 4 bits/pixel. */   if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)      png_set_expand_gray_1_2_4_to_8(png_ptr);    /* Expand paletted or RGB images with transparency to full alpha channels    * so the data will be available as RGBA quartets.    */   if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) != 0)      png_set_tRNS_to_alpha(png_ptr);    /* Set the background color to draw transparent and alpha images over.    * It is possible to set the red, green and blue components directly    * for paletted images, instead of supplying a palette index.  Note that,    * even if the PNG file supplies a background, you are not required to    * use it - you should use the (solid) application background if it has one.    */   png_color_16 my_background, *image_background;    if (png_get_bKGD(png_ptr, info_ptr, &image_background) != 0)      png_set_background(png_ptr, image_background,          PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);   else      png_set_background(png_ptr, &my_background,          PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);    /* Some suggestions as to how to get a screen gamma value.    *    * Note that screen gamma is the display_exponent, which includes    * the CRT_exponent and any correction for viewing conditions.    */   if (/* We have a user-defined screen gamma value */)      screen_gamma = user-defined screen_gamma;   /* This is one way that applications share the same screen gamma value. */   else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL)      screen_gamma = atof(gamma_str);   /* If we don't have another value */   else   {      screen_gamma = PNG_DEFAULT_sRGB; /* A good guess for a PC monitor                                          in a dimly lit room */      screen_gamma = PNG_GAMMA_MAC_18 or 1.0; /* Good guesses for Mac                                                 systems */   }    /* Tell libpng to handle the gamma conversion for you.  The final call    * is a good guess for PC generated images, but it should be configurable    * by the user at run time.  Gamma correction support in your application    * is strongly recommended.    */    int intent;    if (png_get_sRGB(png_ptr, info_ptr, &intent) != 0)      png_set_gamma(png_ptr, screen_gamma, PNG_DEFAULT_sRGB);   else   {      double image_gamma;      if (png_get_gAMA(png_ptr, info_ptr, &image_gamma) != 0)         png_set_gamma(png_ptr, screen_gamma, image_gamma);      else         png_set_gamma(png_ptr, screen_gamma, 0.45455);   } #ifdef PNG_READ_QUANTIZE_SUPPORTED   /* Quantize RGB files down to 8-bit palette, or reduce palettes    * to the number of colors available on your screen.    */   if ((color_type & PNG_COLOR_MASK_COLOR) != 0)   {      int num_palette;      png_colorp palette;       /* This reduces the image to the application-supplied palette. */      if (/* We have our own palette */)      {         /* An array of colors to which the image should be quantized. */         png_color std_color_cube[MAX_SCREEN_COLORS];         png_set_quantize(png_ptr, std_color_cube, MAX_SCREEN_COLORS,             MAX_SCREEN_COLORS, NULL, 0);      }      /* This reduces the image to the palette supplied in the file. */      else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) != 0)      {         png_uint_16p histogram = NULL;         png_get_hIST(png_ptr, info_ptr, &histogram);         png_set_quantize(png_ptr, palette, num_palette,             max_screen_colors, histogram, 0);      }   }#endif /* READ_QUANTIZE */    /* Invert monochrome files to have 0 as white and 1 as black. */   png_set_invert_mono(png_ptr);    /* If you want to shift the pixel values from the range [0,255] or    * [0,65535] to the original [0,7] or [0,31], or whatever range the    * colors were originally in:    */

Lines 1–500 of 1040. Load more