| /*- pngpixel |
| * |
| * COPYRIGHT: Written by John Cunningham Bowler, 2011. |
| * To the extent possible under law, the author has waived all copyright and |
| * related or neighboring rights to this work. This work is published from: |
| * United States. |
| * |
| * Read a single pixel value from a PNG file. |
| * |
| * This code illustrates basic 'by-row' reading of a PNG file using libpng. |
| * Rows are read until a particular pixel is found; the value of this pixel is |
| * then printed on stdout. |
| * |
| * The code illustrates how to do this on interlaced as well as non-interlaced |
| * images. Normally you would call png_set_interlace_handling() to have libpng |
| * deal with the interlace for you, but that obliges you to buffer half of the |
| * image to assemble the interlaced rows. In this code |
| * png_set_interlace_handling() is not called and, instead, the code handles the |
| * interlace passes directly looking for the required pixel. |
| */ |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <setjmp.h> /* required for error handling */ |
| |
| /* Normally use <png.h> here to get the installed libpng, but this is done to |
| * ensure the code picks up the local libpng implementation: |
| */ |
| #include "../../png.h" |
| |
| #if defined(PNG_READ_SUPPORTED) && defined(PNG_SEQUENTIAL_READ_SUPPORTED) |
| |
| /* Return component 'c' of pixel 'x' from the given row. */ |
| static unsigned int |
| component(png_const_bytep row, png_uint_32 x, unsigned int c, |
| unsigned int bit_depth, unsigned int channels) |
| { |
| /* PNG images can be up to 2^31 pixels wide, but this means they can be up to |
| * 2^37 bits wide (for a 64-bit pixel - the largest possible) and hence 2^34 |
| * bytes wide. Since the row fitted into memory, however, the following must |
| * work: |
| */ |
| png_uint_32 bit_offset_hi = bit_depth * ((x >> 6) * channels); |
| png_uint_32 bit_offset_lo = bit_depth * ((x & 0x3f) * channels + c); |
| |
| row = (png_const_bytep)(((const png_byte (*)[8])row) + bit_offset_hi); |
| row += bit_offset_lo >> 3; |
| bit_offset_lo &= 0x07; |
| |
| /* PNG pixels are packed into bytes to put the first pixel in the highest |
| * bits of the byte and into two bytes for 16-bit values with the high 8 bits |
| * first, so: |
| */ |
| switch (bit_depth) |
| { |
| case 1: return (row[0] >> (7-bit_offset_lo)) & 0x01; |
| case 2: return (row[0] >> (6-bit_offset_lo)) & 0x03; |
| case 4: return (row[0] >> (4-bit_offset_lo)) & 0x0f; |
| case 8: return row[0]; |
| case 16: return (row[0] << 8) + row[1]; |
| default: |
| /* This should never happen; it indicates a bug in this program or in |
| * libpng itself: |
| */ |
| fprintf(stderr, "pngpixel: invalid bit depth %u\n", bit_depth); |
| exit(1); |
| } |
| } |
| |
| /* Print a pixel from a row returned by libpng; determine the row format, find |
| * the pixel, and print the relevant information to stdout. |
| */ |
| static void |
| print_pixel(png_structp png_ptr, png_infop info_ptr, png_const_bytep row, |
| png_uint_32 x) |
| { |
| unsigned int bit_depth = png_get_bit_depth(png_ptr, info_ptr); |
| |
| switch (png_get_color_type(png_ptr, info_ptr)) |
| { |
| case PNG_COLOR_TYPE_GRAY: |
| printf("GRAY %u\n", component(row, x, 0, bit_depth, 1)); |
| return; |
| |
| /* The palette case is slightly more difficult - the palette and, if |
| * present, the tRNS ('transparency', though the values are really |
| * opacity) data must be read to give the full picture: |
| */ |
| case PNG_COLOR_TYPE_PALETTE: |
| { |
| int index = component(row, x, 0, bit_depth, 1); |
| png_colorp palette = NULL; |
| int num_palette = 0; |
| |
| if ((png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) & |
| PNG_INFO_PLTE) && num_palette > 0 && palette != NULL) |
| { |
| png_bytep trans_alpha = NULL; |
| int num_trans = 0; |
| if ((png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, |
| NULL) & PNG_INFO_tRNS) && num_trans > 0 && |
| trans_alpha != NULL) |
| printf("INDEXED %u = %d %d %d %d\n", index, |
| palette[index].red, palette[index].green, |
| palette[index].blue, |
| index < num_trans ? trans_alpha[index] : 255); |
| |
| else /* no transparency */ |
| printf("INDEXED %u = %d %d %d\n", index, |
| palette[index].red, palette[index].green, |
| palette[index].blue); |
| } |
| |
| else |
| printf("INDEXED %u = invalid index\n", index); |
| } |
| return; |
| |
| case PNG_COLOR_TYPE_RGB: |
| printf("RGB %u %u %u\n", component(row, x, 0, bit_depth, 3), |
| component(row, x, 1, bit_depth, 3), |
| component(row, x, 2, bit_depth, 3)); |
| return; |
| |
| case PNG_COLOR_TYPE_GRAY_ALPHA: |
| printf("GRAY+ALPHA %u %u\n", component(row, x, 0, bit_depth, 2), |
| component(row, x, 1, bit_depth, 2)); |
| return; |
| |
| case PNG_COLOR_TYPE_RGB_ALPHA: |
| printf("RGBA %u %u %u %u\n", component(row, x, 0, bit_depth, 4), |
| component(row, x, 1, bit_depth, 4), |
| component(row, x, 2, bit_depth, 4), |
| component(row, x, 3, bit_depth, 4)); |
| return; |
| |
| default: |
| png_error(png_ptr, "pngpixel: invalid color type"); |
| } |
| } |
| |
| int main(int argc, const char **argv) |
| { |
| /* This program uses the default, <setjmp.h> based, libpng error handling |
| * mechanism, therefore any local variable that exists before the call to |
| * setjmp and is changed after the call to setjmp returns successfully must |
| * be declared with 'volatile' to ensure that their values don't get |
| * destroyed by longjmp: |
| */ |
| volatile int result = 1/*fail*/; |
| |
| if (argc == 4) |
| { |
| long x = atol(argv[1]); |
| long y = atol(argv[2]); |
| FILE *f = fopen(argv[3], "rb"); |
| volatile png_bytep row = NULL; |
| |
| if (f != NULL) |
| { |
| /* libpng requires a callback function for handling errors; this |
| * callback must not return. The default callback function uses a |
| * stored <setjmp.h> style jmp_buf which is held in a png_struct and |
| * writes error messages to stderr. Creating the png_struct is a |
| * little tricky; just copy the following code. |
| */ |
| png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, |
| NULL, NULL, NULL); |
| |
| if (png_ptr != NULL) |
| { |
| png_infop info_ptr = png_create_info_struct(png_ptr); |
| |
| if (info_ptr != NULL) |
| { |
| /* Declare stack variables to hold pointers to locally allocated |
| * data. |
| */ |
| |
| /* Initialize the error control buffer: */ |
| if (setjmp(png_jmpbuf(png_ptr)) == 0) |
| { |
| png_uint_32 width, height; |
| int bit_depth, color_type, interlace_method, |
| compression_method, filter_method; |
| png_bytep row_tmp; |
| |
| /* Now associate the recently opened (FILE*) with the default |
| * libpng initialization functions. Sometimes libpng is |
| * compiled without stdio support (it can be difficult to do |
| * in some environments); in that case you will have to write |
| * your own read callback to read data from the (FILE*). |
| */ |
| png_init_io(png_ptr, f); |
| |
| /* And read the first part of the PNG file - the header and |
| * all the information up to the first pixel. |
| */ |
| png_read_info(png_ptr, info_ptr); |
| |
| /* This fills in enough information to tell us the width of |
| * each row in bytes, allocate the appropriate amount of |
| * space. In this case png_malloc is used - it will not |
| * return if memory isn't available. |
| */ |
| row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, |
| info_ptr)); |
| |
| /* To avoid the overhead of using a volatile auto copy row_tmp |
| * to a local here - just use row for the png_free below. |
| */ |
| row_tmp = row; |
| |
| /* All the information we need is in the header is returned by |
| * png_get_IHDR, if this fails we can now use 'png_error' to |
| * signal the error and return control to the setjmp above. |
| */ |
| if (png_get_IHDR(png_ptr, info_ptr, &width, &height, |
| &bit_depth, &color_type, &interlace_method, |
| &compression_method, &filter_method)) |
| { |
| int passes, pass; |
| |
| /* png_set_interlace_handling returns the number of |
| * passes required as well as turning on libpng's |
| * handling, but since we do it ourselves this is |
| * necessary: |
| */ |
| switch (interlace_method) |
| { |
| case PNG_INTERLACE_NONE: |
| passes = 1; |
| break; |
| |
| case PNG_INTERLACE_ADAM7: |
| passes = PNG_INTERLACE_ADAM7_PASSES; |
| break; |
| |
| default: |
| png_error(png_ptr, "pngpixel: unknown interlace"); |
| } |
| |
| /* Now read the pixels, pass-by-pass, row-by-row: */ |
| png_start_read_image(png_ptr); |
| |
| for (pass=0; pass<passes; ++pass) |
| { |
| png_uint_32 ystart, xstart, ystep, xstep; |
| png_uint_32 py; |
| |
| if (interlace_method == PNG_INTERLACE_ADAM7) |
| { |
| /* Sometimes the whole pass is empty because the |
| * image is too narrow or too short. libpng |
| * expects to be called for each row that is |
| * present in the pass, so it may be necessary to |
| * skip the loop below (over py) if the image is |
| * too narrow. |
| */ |
| if (PNG_PASS_COLS(width, pass) == 0) |
| continue; |
| |
| /* We need the starting pixel and the offset |
| * between each pixel in this pass; use the macros |
| * in png.h: |
| */ |
| xstart = PNG_PASS_START_COL(pass); |
| ystart = PNG_PASS_START_ROW(pass); |
| xstep = PNG_PASS_COL_OFFSET(pass); |
| ystep = PNG_PASS_ROW_OFFSET(pass); |
| } |
| |
| else |
| { |
| ystart = xstart = 0; |
| ystep = xstep = 1; |
| } |
| |
| /* To find the pixel, loop over 'py' for each pass |
| * reading a row and then checking to see if it |
| * contains the pixel. |
| */ |
| for (py = ystart; py < height; py += ystep) |
| { |
| png_uint_32 px, ppx; |
| |
| /* png_read_row takes two pointers. When libpng |
| * handles the interlace the first is filled in |
| * pixel-by-pixel, and the second receives the same |
| * pixels but they are replicated across the |
| * unwritten pixels so far for each pass. When we |
| * do the interlace, however, they just contain |
| * the pixels from the interlace pass - giving |
| * both is wasteful and pointless, so we pass a |
| * NULL pointer. |
| */ |
| png_read_row(png_ptr, row_tmp, NULL); |
| |
| /* Now find the pixel if it is in this row; there |
| * are, of course, much better ways of doing this |
| * than using a for loop: |
| */ |
| if (y == py) for (px = xstart, ppx = 0; |
| px < width; px += xstep, ++ppx) if (x == px) |
| { |
| /* 'ppx' is the index of the pixel in the row |
| * buffer. |
| */ |
| print_pixel(png_ptr, info_ptr, row_tmp, ppx); |
| |
| /* Now terminate the loops early - we have |
| * found and handled the required data. |
| */ |
| goto pass_loop_end; |
| } /* x loop */ |
| } /* y loop */ |
| } /* pass loop */ |
| |
| /* Finally free the temporary buffer: */ |
| pass_loop_end: |
| row = NULL; |
| png_free(png_ptr, row_tmp); |
| } |
| |
| else |
| png_error(png_ptr, "pngpixel: png_get_IHDR failed"); |
| |
| } |
| |
| else |
| { |
| /* Else libpng has raised an error. An error message has |
| * already been output, so it is only necessary to clean up |
| * locally allocated data: |
| */ |
| if (row != NULL) |
| { |
| /* The default implementation of png_free never errors out |
| * (it just crashes if something goes wrong), but the safe |
| * way of using it is still to clear 'row' before calling |
| * png_free: |
| */ |
| png_bytep row_tmp = row; |
| row = NULL; |
| png_free(png_ptr, row_tmp); |
| } |
| } |
| |
| png_destroy_info_struct(png_ptr, &info_ptr); |
| } |
| |
| else |
| fprintf(stderr, "pngpixel: out of memory allocating png_info\n"); |
| |
| png_destroy_read_struct(&png_ptr, NULL, NULL); |
| } |
| |
| else |
| fprintf(stderr, "pngpixel: out of memory allocating png_struct\n"); |
| } |
| |
| else |
| fprintf(stderr, "pngpixel: %s: could not open file\n", argv[3]); |
| } |
| |
| else |
| /* Wrong number of arguments */ |
| fprintf(stderr, "pngpixel: usage: pngpixel x y png-file\n"); |
| |
| return result; |
| } |
| #endif /* READ && SEQUENTIAL_READ */ |
