/*- 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)(((PNG_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)

{

PNG_CONST 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:

{

PNG_CONST 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 */