workbench/libs/png/contrib/examples/pngpixel.c

   1 /*- pngpixel
   2  *
   3  * COPYRIGHT: Written by John Cunningham Bowler, 2011.
   4  * To the extent possible under law, the author has waived all copyright and
   5  * related or neighboring rights to this work.  This work is published from:
   6  * United States.
   7  *
   8  * Read a single pixel value from a PNG file.
   9  *
  10  * This code illustrates basic 'by-row' reading of a PNG file using libpng.
  11  * Rows are read until a particular pixel is found; the value of this pixel is
  12  * then printed on stdout.
  13  *
  14  * The code illustrates how to do this on interlaced as well as non-interlaced
  15  * images.  Normally you would call png_set_interlace_handling() to have libpng
  16  * deal with the interlace for you, but that obliges you to buffer half of the
  17  * image to assemble the interlaced rows.  In this code
  18  * png_set_interlace_handling() is not called and, instead, the code handles the
  19  * interlace passes directly looking for the required pixel.
  20  */
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <setjmp.h> /* required for error handling */
  24
  25 /* Normally use <png.h> here to get the installed libpng, but this is done to
  26  * ensure the code picks up the local libpng implementation:
  27  */
  28 #include "../../png.h"
  29
  30 #if defined(PNG_READ_SUPPORTED) && defined(PNG_SEQUENTIAL_READ_SUPPORTED)
  31
  32 /* Return component 'c' of pixel 'x' from the given row. */
  33 static unsigned int
  34 component(png_const_bytep row, png_uint_32 x, unsigned int c,
  35    unsigned int bit_depth, unsigned int channels)
  36 {
  37    /* PNG images can be up to 2^31 pixels wide, but this means they can be up to
  38     * 2^37 bits wide (for a 64-bit pixel - the largest possible) and hence 2^34
  39     * bytes wide.  Since the row fitted into memory, however, the following must
  40     * work:
  41     */
  42    png_uint_32 bit_offset_hi = bit_depth * ((x >> 6) * channels);
  43    png_uint_32 bit_offset_lo = bit_depth * ((x & 0x3f) * channels + c);
  44
  45    row = (png_const_bytep)(((const png_byte (*)[8])row) + bit_offset_hi);
  46    row += bit_offset_lo >> 3;
  47    bit_offset_lo &= 0x07;
  48
  49    /* PNG pixels are packed into bytes to put the first pixel in the highest
  50     * bits of the byte and into two bytes for 16-bit values with the high 8 bits
  51     * first, so:
  52     */
  53    switch (bit_depth)
  54    {
  55       case 1: return (row[0] >> (7-bit_offset_lo)) & 0x01;
  56       case 2: return (row[0] >> (6-bit_offset_lo)) & 0x03;
  57       case 4: return (row[0] >> (4-bit_offset_lo)) & 0x0f;
  58       case 8: return row[0];
  59       case 16: return (row[0] << 8) + row[1];
  60       default:
  61          /* This should never happen; it indicates a bug in this program or in
  62           * libpng itself:
  63           */
  64          fprintf(stderr, "pngpixel: invalid bit depth %u\n", bit_depth);
  65          exit(1);
  66    }
  67 }
  68
  69 /* Print a pixel from a row returned by libpng; determine the row format, find
  70  * the pixel, and print the relevant information to stdout.
  71  */
  72 static void
  73 print_pixel(png_structp png_ptr, png_infop info_ptr, png_const_bytep row,
  74    png_uint_32 x)
  75 {
  76    unsigned int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
  77
  78    switch (png_get_color_type(png_ptr, info_ptr))
  79    {
  80       case PNG_COLOR_TYPE_GRAY:
  81          printf("GRAY %u\n", component(row, x, 0, bit_depth, 1));
  82          return;
  83
  84       /* The palette case is slightly more difficult - the palette and, if
  85        * present, the tRNS ('transparency', though the values are really
  86        * opacity) data must be read to give the full picture:
  87        */
  88       case PNG_COLOR_TYPE_PALETTE:
  89          {
  90             int index = component(row, x, 0, bit_depth, 1);
  91             png_colorp palette = NULL;
  92             int num_palette = 0;
  93
  94             if ((png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) &
  95                PNG_INFO_PLTE) && num_palette > 0 && palette != NULL)
  96             {
  97                png_bytep trans_alpha = NULL;
  98                int num_trans = 0;
  99                if ((png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans,
 100                   NULL) & PNG_INFO_tRNS) && num_trans > 0 &&
 101                   trans_alpha != NULL)
 102                   printf("INDEXED %u = %d %d %d %d\n", index,
 103                      palette[index].red, palette[index].green,
 104                      palette[index].blue,
 105                      index < num_trans ? trans_alpha[index] : 255);
 106
 107                else /* no transparency */
 108                   printf("INDEXED %u = %d %d %d\n", index,
 109                      palette[index].red, palette[index].green,
 110                      palette[index].blue);
 111             }
 112
 113             else
 114                printf("INDEXED %u = invalid index\n", index);
 115          }
 116          return;
 117
 118       case PNG_COLOR_TYPE_RGB:
 119          printf("RGB %u %u %u\n", component(row, x, 0, bit_depth, 3),
 120             component(row, x, 1, bit_depth, 3),
 121             component(row, x, 2, bit_depth, 3));
 122          return;
 123
 124       case PNG_COLOR_TYPE_GRAY_ALPHA:
 125          printf("GRAY+ALPHA %u %u\n", component(row, x, 0, bit_depth, 2),
 126             component(row, x, 1, bit_depth, 2));
 127          return;
 128
 129       case PNG_COLOR_TYPE_RGB_ALPHA:
 130          printf("RGBA %u %u %u %u\n", component(row, x, 0, bit_depth, 4),
 131             component(row, x, 1, bit_depth, 4),
 132             component(row, x, 2, bit_depth, 4),
 133             component(row, x, 3, bit_depth, 4));
 134          return;
 135
 136       default:
 137          png_error(png_ptr, "pngpixel: invalid color type");
 138    }
 139 }
 140
 141 int main(int argc, const char **argv)
 142 {
 143    /* This program uses the default, <setjmp.h> based, libpng error handling
 144     * mechanism, therefore any local variable that exists before the call to
 145     * setjmp and is changed after the call to setjmp returns successfully must
 146     * be declared with 'volatile' to ensure that their values don't get
 147     * destroyed by longjmp:
 148     */
 149    volatile int result = 1/*fail*/;
 150
 151    if (argc == 4)
 152    {
 153       long x = atol(argv[1]);
 154       long y = atol(argv[2]);
 155       FILE *f = fopen(argv[3], "rb");
 156       volatile png_bytep row = NULL;
 157
 158       if (f != NULL)
 159       {
 160          /* libpng requires a callback function for handling errors; this
 161           * callback must not return.  The default callback function uses a
 162           * stored <setjmp.h> style jmp_buf which is held in a png_struct and
 163           * writes error messages to stderr.  Creating the png_struct is a
 164           * little tricky; just copy the following code.
 165           */
 166          png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
 167             NULL, NULL, NULL);
 168
 169          if (png_ptr != NULL)
 170          {
 171             png_infop info_ptr = png_create_info_struct(png_ptr);
 172
 173             if (info_ptr != NULL)
 174             {
 175                /* Declare stack variables to hold pointers to locally allocated
 176                 * data.
 177                 */
 178
 179                /* Initialize the error control buffer: */
 180                if (setjmp(png_jmpbuf(png_ptr)) == 0)
 181                {
 182                   png_uint_32 width, height;
 183                   int bit_depth, color_type, interlace_method,
 184                      compression_method, filter_method;
 185                   png_bytep row_tmp;
 186
 187                   /* Now associate the recently opened (FILE*) with the default
 188                    * libpng initialization functions.  Sometimes libpng is
 189                    * compiled without stdio support (it can be difficult to do
 190                    * in some environments); in that case you will have to write
 191                    * your own read callback to read data from the (FILE*).
 192                    */
 193                   png_init_io(png_ptr, f);
 194
 195                   /* And read the first part of the PNG file - the header and
 196                    * all the information up to the first pixel.
 197                    */
 198                   png_read_info(png_ptr, info_ptr);
 199
 200                   /* This fills in enough information to tell us the width of
 201                    * each row in bytes, allocate the appropriate amount of
 202                    * space.  In this case png_malloc is used - it will not
 203                    * return if memory isn't available.
 204                    */
 205                   row = png_malloc(png_ptr, png_get_rowbytes(png_ptr,
 206                      info_ptr));
 207
 208                   /* To avoid the overhead of using a volatile auto copy row_tmp
 209                    * to a local here - just use row for the png_free below.
 210                    */
 211                   row_tmp = row;
 212
 213                   /* All the information we need is in the header is returned by
 214                    * png_get_IHDR, if this fails we can now use 'png_error' to
 215                    * signal the error and return control to the setjmp above.
 216                    */
 217                   if (png_get_IHDR(png_ptr, info_ptr, &width, &height,
 218                      &bit_depth, &color_type, &interlace_method,
 219                      &compression_method, &filter_method))
 220                   {
 221                      int passes, pass;
 222
 223                      /* png_set_interlace_handling returns the number of
 224                       * passes required as well as turning on libpng's
 225                       * handling, but since we do it ourselves this is
 226                       * necessary:
 227                       */
 228                      switch (interlace_method)
 229                      {
 230                         case PNG_INTERLACE_NONE:
 231                            passes = 1;
 232                            break;
 233
 234                         case PNG_INTERLACE_ADAM7:
 235                            passes = PNG_INTERLACE_ADAM7_PASSES;
 236                            break;
 237
 238                         default:
 239                            png_error(png_ptr, "pngpixel: unknown interlace");
 240                      }
 241
 242                      /* Now read the pixels, pass-by-pass, row-by-row: */
 243                      png_start_read_image(png_ptr);
 244
 245                      for (pass=0; pass<passes; ++pass)
 246                      {
 247                         png_uint_32 ystart, xstart, ystep, xstep;
 248                         png_uint_32 py;
 249
 250                         if (interlace_method == PNG_INTERLACE_ADAM7)
 251                         {
 252                            /* Sometimes the whole pass is empty because the
 253                             * image is too narrow or too short.  libpng
 254                             * expects to be called for each row that is
 255                             * present in the pass, so it may be necessary to
 256                             * skip the loop below (over py) if the image is
 257                             * too narrow.
 258                             */
 259                            if (PNG_PASS_COLS(width, pass) == 0)
 260                               continue;
 261
 262                            /* We need the starting pixel and the offset
 263                             * between each pixel in this pass; use the macros
 264                             * in png.h:
 265                             */
 266                            xstart = PNG_PASS_START_COL(pass);
 267                            ystart = PNG_PASS_START_ROW(pass);
 268                            xstep = PNG_PASS_COL_OFFSET(pass);
 269                            ystep = PNG_PASS_ROW_OFFSET(pass);
 270                         }
 271
 272                         else
 273                         {
 274                            ystart = xstart = 0;
 275                            ystep = xstep = 1;
 276                         }
 277
 278                         /* To find the pixel, loop over 'py' for each pass
 279                          * reading a row and then checking to see if it
 280                          * contains the pixel.
 281                          */
 282                         for (py = ystart; py < height; py += ystep)
 283                         {
 284                            png_uint_32 px, ppx;
 285
 286                            /* png_read_row takes two pointers.  When libpng
 287                             * handles the interlace the first is filled in
 288                             * pixel-by-pixel, and the second receives the same
 289                             * pixels but they are replicated across the
 290                             * unwritten pixels so far for each pass.  When we
 291                             * do the interlace, however, they just contain
 292                             * the pixels from the interlace pass - giving
 293                             * both is wasteful and pointless, so we pass a
 294                             * NULL pointer.
 295                             */
 296                            png_read_row(png_ptr, row_tmp, NULL);
 297
 298                            /* Now find the pixel if it is in this row; there
 299                             * are, of course, much better ways of doing this
 300                             * than using a for loop:
 301                             */
 302                            if (y == py) for (px = xstart, ppx = 0;
 303                               px < width; px += xstep, ++ppx) if (x == px)
 304                            {
 305                               /* 'ppx' is the index of the pixel in the row
 306                                * buffer.
 307                                */
 308                               print_pixel(png_ptr, info_ptr, row_tmp, ppx);
 309
 310                               /* Now terminate the loops early - we have
 311                                * found and handled the required data.
 312                                */
 313                               goto pass_loop_end;
 314                            } /* x loop */
 315                         } /* y loop */
 316                      } /* pass loop */
 317
 318                      /* Finally free the temporary buffer: */
 319                   pass_loop_end:
 320                      row = NULL;
 321                      png_free(png_ptr, row_tmp);
 322                   }
 323
 324                   else
 325                      png_error(png_ptr, "pngpixel: png_get_IHDR failed");
 326
 327                }
 328
 329                else
 330                {
 331                   /* Else libpng has raised an error.  An error message has
 332                    * already been output, so it is only necessary to clean up
 333                    * locally allocated data:
 334                    */
 335                   if (row != NULL)
 336                   {
 337                      /* The default implementation of png_free never errors out
 338                       * (it just crashes if something goes wrong), but the safe
 339                       * way of using it is still to clear 'row' before calling
 340                       * png_free:
 341                       */
 342                      png_bytep row_tmp = row;
 343                      row = NULL;
 344                      png_free(png_ptr, row_tmp);
 345                   }
 346                }
 347
 348                png_destroy_info_struct(png_ptr, &info_ptr);
 349             }
 350
 351             else
 352                fprintf(stderr, "pngpixel: out of memory allocating png_info\n");
 353
 354             png_destroy_read_struct(&png_ptr, NULL, NULL);
 355          }
 356
 357          else
 358             fprintf(stderr, "pngpixel: out of memory allocating png_struct\n");
 359       }
 360
 361       else
 362          fprintf(stderr, "pngpixel: %s: could not open file\n", argv[3]);
 363    }
 364
 365    else
 366       /* Wrong number of arguments */
 367       fprintf(stderr, "pngpixel: usage: pngpixel x y png-file\n");
 368
 369    return result;
 370 }
 371 #endif /* READ && SEQUENTIAL_READ */