pngpixel.c@ 107044

Last change on this file since 107044 was 96425, checked in by vboxsync, 2 years ago
src/libs: Switch to libpng-1.6.37, bugref:8515 [re-export]
Property svn:eol-style set to `native`
File size: 14.6 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libpng-1.6.43/contrib/examples/pngpixel.c@ 107044

Download in other formats: