rpng-x.c@ 90330

Last change on this file since 90330 was 76030, checked in by vboxsync, 6 years ago
libpng-1.6.36: properly export to OSE, and while at it fix EOL style for shell scripts
Property svn:eol-style set to `native`
File size: 30.3 KB

Line
1	/*---------------------------------------------------------------------------
2
3	rpng - simple PNG display program rpng-x.c
4
5	This program decodes and displays PNG images, with gamma correction and
6	optionally with a user-specified background color (in case the image has
7	transparency). It is very nearly the most basic PNG viewer possible.
8	This version is for the X Window System (tested by author under Unix and
9	by Martin Zinser under OpenVMS; may work under OS/2 with some tweaking).
10
11	to do:
12	- 8-bit (colormapped) X support
13	- use %.1023s to simplify truncation of title-bar string?
14
15	---------------------------------------------------------------------------
16
17	Changelog:
18	- 1.01: initial public release
19	- 1.02: modified to allow abbreviated options; fixed long/ulong mis-
20	match; switched to png_jmpbuf() macro
21	- 1.10: added support for non-default visuals; fixed X pixel-conversion
22	- 1.11: added extra set of parentheses to png_jmpbuf() macro; fixed
23	command-line parsing bug
24	- 1.12: fixed some small X memory leaks (thanks to François Petitjean)
25	- 1.13: fixed XFreeGC() crash bug (thanks to Patrick Welche)
26	- 1.14: added support for X resources (thanks to Gerhard Niklasch)
27	- 2.00: dual-licensed (added GNU GPL)
28	- 2.01: fixed improper display of usage screen on PNG error(s)
29	- 2.02: Added "void(argc);" statement to quiet pedantic compiler warnings
30	about unused variable (GR-P)
31	- 2.03: check for integer overflow (Glenn R-P)
32
33	---------------------------------------------------------------------------
34
35	Copyright (c) 1998-2008, 2017 Greg Roelofs. All rights reserved.
36
37	This software is provided "as is," without warranty of any kind,
38	express or implied. In no event shall the author or contributors
39	be held liable for any damages arising in any way from the use of
40	this software.
41
42	The contents of this file are DUAL-LICENSED. You may modify and/or
43	redistribute this software according to the terms of one of the
44	following two licenses (at your option):
45
46
47	LICENSE 1 ("BSD-like with advertising clause"):
48
49	Permission is granted to anyone to use this software for any purpose,
50	including commercial applications, and to alter it and redistribute
51	it freely, subject to the following restrictions:
52
53	1. Redistributions of source code must retain the above copyright
54	notice, disclaimer, and this list of conditions.
55	2. Redistributions in binary form must reproduce the above copyright
56	notice, disclaimer, and this list of conditions in the documenta-
57	tion and/or other materials provided with the distribution.
58	3. All advertising materials mentioning features or use of this
59	software must display the following acknowledgment:
60
61	This product includes software developed by Greg Roelofs
62	and contributors for the book, "PNG: The Definitive Guide,"
63	published by O'Reilly and Associates.
64
65
66	LICENSE 2 (GNU GPL v2 or later):
67
68	This program is free software; you can redistribute it and/or modify
69	it under the terms of the GNU General Public License as published by
70	the Free Software Foundation; either version 2 of the License, or
71	(at your option) any later version.
72
73	This program is distributed in the hope that it will be useful,
74	but WITHOUT ANY WARRANTY; without even the implied warranty of
75	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
76	GNU General Public License for more details.
77
78	You should have received a copy of the GNU General Public License
79	along with this program; if not, write to the Free Software Foundation,
80	Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
81
82	---------------------------------------------------------------------------*/
83
84	#define PROGNAME "rpng-x"
85	#define LONGNAME "Simple PNG Viewer for X"
86	#define VERSION "2.02 of 15 June 2014"
87	#define RESNAME "rpng" /* our X resource application name */
88	#define RESCLASS "Rpng" /* our X resource class name */
89
90	#include <stdio.h>
91	#include <stdlib.h>
92	#include <string.h>
93	#include <time.h>
94	#include <X11/Xlib.h>
95	#include <X11/Xutil.h>
96	#include <X11/Xos.h>
97	#include <X11/keysym.h>
98
99	/* #define DEBUG : this enables the Trace() macros */
100
101	#include "readpng.h" /* typedefs, common macros, readpng prototypes */
102
103
104	/* could just include png.h, but this macro is the only thing we need
105	* (name and typedefs changed to local versions); note that side effects
106	* only happen with alpha (which could easily be avoided with
107	* "ush acopy = (alpha);") */
108
109	#define alpha_composite(composite, fg, alpha, bg) { \
110	ush temp = ((ush)(fg)*(ush)(alpha) + \
111	(ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128); \
112	(composite) = (uch)((temp + (temp >> 8)) >> 8); \
113	}
114
115
116	/* local prototypes */
117	static int rpng_x_create_window(void);
118	static int rpng_x_display_image(void);
119	static void rpng_x_cleanup(void);
120	static int rpng_x_msb(ulg u32val);
121
122
123	static char titlebar[1024], *window_name = titlebar;
124	static char *appname = LONGNAME;
125	static char *icon_name = PROGNAME;
126	static char *res_name = RESNAME;
127	static char *res_class = RESCLASS;
128	static char *filename;
129	static FILE *infile;
130
131	static char *bgstr;
132	static uch bg_red=0, bg_green=0, bg_blue=0;
133
134	static double display_exponent;
135
136	static ulg image_width, image_height, image_rowbytes;
137	static int image_channels;
138	static uch *image_data;
139
140	/* X-specific variables */
141	static char *displayname;
142	static XImage *ximage;
143	static Display *display;
144	static int depth;
145	static Visual *visual;
146	static XVisualInfo *visual_list;
147	static int RShift, GShift, BShift;
148	static ulg RMask, GMask, BMask;
149	static Window window;
150	static GC gc;
151	static Colormap colormap;
152
153	static int have_nondefault_visual = FALSE;
154	static int have_colormap = FALSE;
155	static int have_window = FALSE;
156	static int have_gc = FALSE;
157	/*
158	ulg numcolors=0, pixels[256];
159	ush reds[256], greens[256], blues[256];
160	*/
161
162
163
164
165	int main(int argc, char **argv)
166	{
167	#ifdef sgi
168	char tmpline[80];
169	#endif
170	char *p;
171	int rc, alen, flen;
172	int error = 0;
173	int have_bg = FALSE;
174	double LUT_exponent; /* just the lookup table */
175	double CRT_exponent = 2.2; /* just the monitor */
176	double default_display_exponent; /* whole display system */
177	XEvent e;
178	KeySym k;
179
180
181	displayname = (char *)NULL;
182	filename = (char *)NULL;
183
184
185	/* First set the default value for our display-system exponent, i.e.,
186	* the product of the CRT exponent and the exponent corresponding to
187	* the frame-buffer's lookup table (LUT), if any. This is not an
188	* exhaustive list of LUT values (e.g., OpenStep has a lot of weird
189	* ones), but it should cover 99% of the current possibilities. */
190
191	#if defined(NeXT)
192	LUT_exponent = 1.0 / 2.2;
193	/*
194	if (some_next_function_that_returns_gamma(&next_gamma))
195	LUT_exponent = 1.0 / next_gamma;
196	*/
197	#elif defined(sgi)
198	LUT_exponent = 1.0 / 1.7;
199	/* there doesn't seem to be any documented function to get the
200	* "gamma" value, so we do it the hard way */
201	infile = fopen("/etc/config/system.glGammaVal", "r");
202	if (infile) {
203	double sgi_gamma;
204
205	fgets(tmpline, 80, infile);
206	fclose(infile);
207	sgi_gamma = atof(tmpline);
208	if (sgi_gamma > 0.0)
209	LUT_exponent = 1.0 / sgi_gamma;
210	}
211	#elif defined(Macintosh)
212	LUT_exponent = 1.8 / 2.61;
213	/*
214	if (some_mac_function_that_returns_gamma(&mac_gamma))
215	LUT_exponent = mac_gamma / 2.61;
216	*/
217	#else
218	LUT_exponent = 1.0; /* assume no LUT: most PCs */
219	#endif
220
221	/* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
222	default_display_exponent = LUT_exponent * CRT_exponent;
223
224
225	/* If the user has set the SCREEN_GAMMA environment variable as suggested
226	* (somewhat imprecisely) in the libpng documentation, use that; otherwise
227	* use the default value we just calculated. Either way, the user may
228	* override this via a command-line option. */
229
230	if ((p = getenv("SCREEN_GAMMA")) != NULL)
231	display_exponent = atof(p);
232	else
233	display_exponent = default_display_exponent;
234
235
236	/* Now parse the command line for options and the PNG filename. */
237
238	while (*++argv && !error) {
239	if (!strncmp(*argv, "-display", 2)) {
240	if (!*++argv)
241	++error;
242	else
243	displayname = *argv;
244	} else if (!strncmp(*argv, "-gamma", 2)) {
245	if (!*++argv)
246	++error;
247	else {
248	display_exponent = atof(*argv);
249	if (display_exponent <= 0.0)
250	++error;
251	}
252	} else if (!strncmp(*argv, "-bgcolor", 2)) {
253	if (!*++argv)
254	++error;
255	else {
256	bgstr = *argv;
257	if (strlen(bgstr) != 7 \|\| bgstr[0] != '#')
258	++error;
259	else
260	have_bg = TRUE;
261	}
262	} else {
263	if (**argv != '-') {
264	filename = *argv;
265	if (argv[1]) /* shouldn't be any more args after filename */
266	++error;
267	} else
268	++error; /* not expecting any other options */
269	}
270	}
271
272	if (!filename)
273	++error;
274
275
276	/* print usage screen if any errors up to this point */
277
278	if (error) {
279	fprintf(stderr, "\n%s %s: %s\n", PROGNAME, VERSION, appname);
280	readpng_version_info();
281	fprintf(stderr, "\n"
282	"Usage: %s [-display xdpy] [-gamma exp] [-bgcolor bg] file.png\n"
283	" xdpy\tname of the target X display (e.g., ``hostname:0'')\n"
284	" exp \ttransfer-function exponent (``gamma'') of the display\n"
285	"\t\t system in floating-point format (e.g., ``%.1f''); equal\n",
286	PROGNAME, default_display_exponent);
287
288	fprintf(stderr, "\n"
289	"\t\t to the product of the lookup-table exponent (varies)\n"
290	"\t\t and the CRT exponent (usually 2.2); must be positive\n"
291	" bg \tdesired background color in 7-character hex RGB format\n"
292	"\t\t (e.g., ``#ff7700'' for orange: same as HTML colors);\n"
293	"\t\t used with transparent images\n"
294	"\nPress Q, Esc or mouse button 1 (within image window, after image\n"
295	"is displayed) to quit.\n");
296	exit(1);
297	}
298
299
300	if (!(infile = fopen(filename, "rb"))) {
301	fprintf(stderr, PROGNAME ": can't open PNG file [%s]\n", filename);
302	++error;
303	} else {
304	if ((rc = readpng_init(infile, &image_width, &image_height)) != 0) {
305	switch (rc) {
306	case 1:
307	fprintf(stderr, PROGNAME
308	": [%s] is not a PNG file: incorrect signature\n",
309	filename);
310	break;
311	case 2:
312	fprintf(stderr, PROGNAME
313	": [%s] has bad IHDR (libpng longjmp)\n", filename);
314	break;
315	case 4:
316	fprintf(stderr, PROGNAME ": insufficient memory\n");
317	break;
318	default:
319	fprintf(stderr, PROGNAME
320	": unknown readpng_init() error\n");
321	break;
322	}
323	++error;
324	} else {
325	display = XOpenDisplay(displayname);
326	if (!display) {
327	readpng_cleanup(TRUE);
328	fprintf(stderr, PROGNAME ": can't open X display [%s]\n",
329	displayname? displayname : "default");
330	++error;
331	}
332	}
333	if (error)
334	fclose(infile);
335	}
336
337
338	if (error) {
339	fprintf(stderr, PROGNAME ": aborting.\n");
340	exit(2);
341	}
342
343
344	/* set the title-bar string, but make sure buffer doesn't overflow */
345
346	alen = strlen(appname);
347	flen = strlen(filename);
348	if (alen + flen + 3 > 1023)
349	sprintf(titlebar, "%s: ...%s", appname, filename+(alen+flen+6-1023));
350	else
351	sprintf(titlebar, "%s: %s", appname, filename);
352
353
354	/* if the user didn't specify a background color on the command line,
355	* check for one in the PNG file--if not, the initialized values of 0
356	* (black) will be used */
357
358	if (have_bg) {
359	unsigned r, g, b; /* this approach quiets compiler warnings */
360
361	sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
362	bg_red = (uch)r;
363	bg_green = (uch)g;
364	bg_blue = (uch)b;
365	} else if (readpng_get_bgcolor(&bg_red, &bg_green, &bg_blue) > 1) {
366	readpng_cleanup(TRUE);
367	fprintf(stderr, PROGNAME
368	": libpng error while checking for background color\n");
369	exit(2);
370	}
371
372
373	/* do the basic X initialization stuff, make the window and fill it
374	* with the background color */
375
376	if (rpng_x_create_window())
377	exit(2);
378
379
380	/* decode the image, all at once */
381
382	Trace((stderr, "calling readpng_get_image()\n"))
383	image_data = readpng_get_image(display_exponent, &image_channels,
384	&image_rowbytes);
385	Trace((stderr, "done with readpng_get_image()\n"))
386
387
388	/* done with PNG file, so clean up to minimize memory usage (but do NOT
389	* nuke image_data!) */
390
391	readpng_cleanup(FALSE);
392	fclose(infile);
393
394	if (!image_data) {
395	fprintf(stderr, PROGNAME ": unable to decode PNG image\n");
396	exit(3);
397	}
398
399
400	/* display image (composite with background if requested) */
401
402	Trace((stderr, "calling rpng_x_display_image()\n"))
403	if (rpng_x_display_image()) {
404	free(image_data);
405	exit(4);
406	}
407	Trace((stderr, "done with rpng_x_display_image()\n"))
408
409
410	/* wait for the user to tell us when to quit */
411
412	printf(
413	"Done. Press Q, Esc or mouse button 1 (within image window) to quit.\n");
414	fflush(stdout);
415
416	do
417	XNextEvent(display, &e);
418	while (!(e.type == ButtonPress && e.xbutton.button == Button1) &&
419	!(e.type == KeyPress && /* v--- or 1 for shifted keys */
420	((k = XLookupKeysym(&e.xkey, 0)) == XK_q \|\| k == XK_Escape) ));
421
422
423	/* OK, we're done: clean up all image and X resources and go away */
424
425	rpng_x_cleanup();
426
427	(void)argc; /* Unused */
428
429	return 0;
430	}
431
432
433
434
435
436	static int rpng_x_create_window(void)
437	{
438	uch *xdata;
439	int need_colormap = FALSE;
440	int screen, pad;
441	ulg bg_pixel = 0L;
442	ulg attrmask;
443	Window root;
444	XEvent e;
445	XGCValues gcvalues;
446	XSetWindowAttributes attr;
447	XTextProperty windowName, *pWindowName = &windowName;
448	XTextProperty iconName, *pIconName = &iconName;
449	XVisualInfo visual_info;
450	XSizeHints *size_hints;
451	XWMHints *wm_hints;
452	XClassHint *class_hints;
453
454
455	screen = DefaultScreen(display);
456	depth = DisplayPlanes(display, screen);
457	root = RootWindow(display, screen);
458
459	#ifdef DEBUG
460	XSynchronize(display, True);
461	#endif
462
463	#if 0
464	/* GRR: add 8-bit support */
465	if (/* depth != 8 && */ depth != 16 && depth != 24 && depth != 32) {
466	fprintf(stderr,
467	"screen depth %d not supported (only 16-, 24- or 32-bit TrueColor)\n",
468	depth);
469	return 2;
470	}
471
472	XMatchVisualInfo(display, screen, depth,
473	(depth == 8)? PseudoColor : TrueColor, &visual_info);
474	visual = visual_info.visual;
475	#else
476	if (depth != 16 && depth != 24 && depth != 32) {
477	int visuals_matched = 0;
478
479	Trace((stderr, "default depth is %d: checking other visuals\n",
480	depth))
481
482	/* 24-bit first */
483	visual_info.screen = screen;
484	visual_info.depth = 24;
485	visual_list = XGetVisualInfo(display,
486	VisualScreenMask \| VisualDepthMask, &visual_info, &visuals_matched);
487	if (visuals_matched == 0) {
488	/* GRR: add 15-, 16- and 32-bit TrueColor visuals (also DirectColor?) */
489	fprintf(stderr, "default screen depth %d not supported, and no"
490	" 24-bit visuals found\n", depth);
491	return 2;
492	}
493	Trace((stderr, "XGetVisualInfo() returned %d 24-bit visuals\n",
494	visuals_matched))
495	visual = visual_list[0].visual;
496	depth = visual_list[0].depth;
497	/*
498	colormap_size = visual_list[0].colormap_size;
499	visual_class = visual->class;
500	visualID = XVisualIDFromVisual(visual);
501	*/
502	have_nondefault_visual = TRUE;
503	need_colormap = TRUE;
504	} else {
505	XMatchVisualInfo(display, screen, depth, TrueColor, &visual_info);
506	visual = visual_info.visual;
507	}
508	#endif
509
510	RMask = visual->red_mask;
511	GMask = visual->green_mask;
512	BMask = visual->blue_mask;
513
514	/* GRR: add/check 8-bit support */
515	if (depth == 8 \|\| need_colormap) {
516	colormap = XCreateColormap(display, root, visual, AllocNone);
517	if (!colormap) {
518	fprintf(stderr, "XCreateColormap() failed\n");
519	return 2;
520	}
521	have_colormap = TRUE;
522	}
523	if (depth == 15 \|\| depth == 16) {
524	RShift = 15 - rpng_x_msb(RMask); /* these are right-shifts */
525	GShift = 15 - rpng_x_msb(GMask);
526	BShift = 15 - rpng_x_msb(BMask);
527	} else if (depth > 16) {
528	#define NO_24BIT_MASKS
529	#ifdef NO_24BIT_MASKS
530	RShift = rpng_x_msb(RMask) - 7; /* these are left-shifts */
531	GShift = rpng_x_msb(GMask) - 7;
532	BShift = rpng_x_msb(BMask) - 7;
533	#else
534	RShift = 7 - rpng_x_msb(RMask); /* these are right-shifts, too */
535	GShift = 7 - rpng_x_msb(GMask);
536	BShift = 7 - rpng_x_msb(BMask);
537	#endif
538	}
539	if (depth >= 15 && (RShift < 0 \|\| GShift < 0 \|\| BShift < 0)) {
540	fprintf(stderr, "rpng internal logic error: negative X shift(s)!\n");
541	return 2;
542	}
543
544	/*---------------------------------------------------------------------------
545	Finally, create the window.
546	---------------------------------------------------------------------------*/
547
548	attr.backing_store = Always;
549	attr.event_mask = ExposureMask \| KeyPressMask \| ButtonPressMask;
550	attrmask = CWBackingStore \| CWEventMask;
551	if (have_nondefault_visual) {
552	attr.colormap = colormap;
553	attr.background_pixel = 0;
554	attr.border_pixel = 1;
555	attrmask \|= CWColormap \| CWBackPixel \| CWBorderPixel;
556	}
557
558	window = XCreateWindow(display, root, 0, 0, image_width, image_height, 0,
559	depth, InputOutput, visual, attrmask, &attr);
560
561	if (window == None) {
562	fprintf(stderr, "XCreateWindow() failed\n");
563	return 2;
564	} else
565	have_window = TRUE;
566
567	if (depth == 8)
568	XSetWindowColormap(display, window, colormap);
569
570	if (!XStringListToTextProperty(&window_name, 1, pWindowName))
571	pWindowName = NULL;
572	if (!XStringListToTextProperty(&icon_name, 1, pIconName))
573	pIconName = NULL;
574
575	/* OK if any hints allocation fails; XSetWMProperties() allows NULLs */
576
577	if ((size_hints = XAllocSizeHints()) != NULL) {
578	/* window will not be resizable */
579	size_hints->flags = PMinSize \| PMaxSize;
580	size_hints->min_width = size_hints->max_width = (int)image_width;
581	size_hints->min_height = size_hints->max_height = (int)image_height;
582	}
583
584	if ((wm_hints = XAllocWMHints()) != NULL) {
585	wm_hints->initial_state = NormalState;
586	wm_hints->input = True;
587	/* wm_hints->icon_pixmap = icon_pixmap; */
588	wm_hints->flags = StateHint \| InputHint /* \| IconPixmapHint */ ;
589	}
590
591	if ((class_hints = XAllocClassHint()) != NULL) {
592	class_hints->res_name = res_name;
593	class_hints->res_class = res_class;
594	}
595
596	XSetWMProperties(display, window, pWindowName, pIconName, NULL, 0,
597	size_hints, wm_hints, class_hints);
598
599	/* various properties and hints no longer needed; free memory */
600	if (pWindowName)
601	XFree(pWindowName->value);
602	if (pIconName)
603	XFree(pIconName->value);
604	if (size_hints)
605	XFree(size_hints);
606	if (wm_hints)
607	XFree(wm_hints);
608	if (class_hints)
609	XFree(class_hints);
610
611	XMapWindow(display, window);
612
613	gc = XCreateGC(display, window, 0, &gcvalues);
614	have_gc = TRUE;
615
616	/*---------------------------------------------------------------------------
617	Fill window with the specified background color.
618	---------------------------------------------------------------------------*/
619
620	if (depth == 24 \|\| depth == 32) {
621	bg_pixel = ((ulg)bg_red << RShift) \|
622	((ulg)bg_green << GShift) \|
623	((ulg)bg_blue << BShift);
624	} else if (depth == 16) {
625	bg_pixel = ((((ulg)bg_red << 8) >> RShift) & RMask) \|
626	((((ulg)bg_green << 8) >> GShift) & GMask) \|
627	((((ulg)bg_blue << 8) >> BShift) & BMask);
628	} else /* depth == 8 */ {
629
630	/* GRR: add 8-bit support */
631
632	}
633
634	XSetForeground(display, gc, bg_pixel);
635	XFillRectangle(display, window, gc, 0, 0, image_width, image_height);
636
637	/*---------------------------------------------------------------------------
638	Wait for first Expose event to do any drawing, then flush.
639	---------------------------------------------------------------------------*/
640
641	do
642	XNextEvent(display, &e);
643	while (e.type != Expose \|\| e.xexpose.count);
644
645	XFlush(display);
646
647	/*---------------------------------------------------------------------------
648	Allocate memory for the X- and display-specific version of the image.
649	---------------------------------------------------------------------------*/
650
651	if (depth == 24 \|\| depth == 32) {
652	xdata = (uch )malloc(4image_width*image_height);
653	pad = 32;
654	} else if (depth == 16) {
655	xdata = (uch )malloc(2image_width*image_height);
656	pad = 16;
657	} else /* depth == 8 */ {
658	xdata = (uch )malloc(image_widthimage_height);
659	pad = 8;
660	}
661
662	if (!xdata) {
663	fprintf(stderr, PROGNAME ": unable to allocate image memory\n");
664	return 4;
665	}
666
667	ximage = XCreateImage(display, visual, depth, ZPixmap, 0,
668	(char *)xdata, image_width, image_height, pad, 0);
669
670	if (!ximage) {
671	fprintf(stderr, PROGNAME ": XCreateImage() failed\n");
672	free(xdata);
673	return 3;
674	}
675
676	/* to avoid testing the byte order every pixel (or doubling the size of
677	* the drawing routine with a giant if-test), we arbitrarily set the byte
678	* order to MSBFirst and let Xlib worry about inverting things on little-
679	* endian machines (like Linux/x86, old VAXen, etc.)--this is not the most
680	* efficient approach (the giant if-test would be better), but in the
681	* interest of clarity, we take the easy way out... */
682
683	ximage->byte_order = MSBFirst;
684
685	return 0;
686
687	} /* end function rpng_x_create_window() */
688
689
690
691
692
693	static int rpng_x_display_image(void)
694	{
695	uch *src;
696	char *dest;
697	uch r, g, b, a;
698	ulg i, row, lastrow = 0;
699	ulg pixel;
700	int ximage_rowbytes = ximage->bytes_per_line;
701	/* int bpp = ximage->bits_per_pixel; */
702
703
704	Trace((stderr, "beginning display loop (image_channels == %d)\n",
705	image_channels))
706	Trace((stderr, " (width = %ld, rowbytes = %ld, ximage_rowbytes = %d)\n",
707	image_width, image_rowbytes, ximage_rowbytes))
708	Trace((stderr, " (bpp = %d)\n", ximage->bits_per_pixel))
709	Trace((stderr, " (byte_order = %s)\n", ximage->byte_order == MSBFirst?
710	"MSBFirst" : (ximage->byte_order == LSBFirst? "LSBFirst" : "unknown")))
711
712	if (depth == 24 \|\| depth == 32) {
713	ulg red, green, blue;
714
715	for (lastrow = row = 0; row < image_height; ++row) {
716	src = image_data + row*image_rowbytes;
717	dest = ximage->data + row*ximage_rowbytes;
718	if (image_channels == 3) {
719	for (i = image_width; i > 0; --i) {
720	red = *src++;
721	green = *src++;
722	blue = *src++;
723	#ifdef NO_24BIT_MASKS
724	pixel = (red << RShift) \|
725	(green << GShift) \|
726	(blue << BShift);
727	/* recall that we set ximage->byte_order = MSBFirst above */
728	/* GRR BUG: this assumes bpp == 32, but may be 24: */
729	*dest++ = (char)((pixel >> 24) & 0xff);
730	*dest++ = (char)((pixel >> 16) & 0xff);
731	*dest++ = (char)((pixel >> 8) & 0xff);
732	*dest++ = (char)( pixel & 0xff);
733	#else
734	red = (RShift < 0)? red << (-RShift) : red >> RShift;
735	green = (GShift < 0)? green << (-GShift) : green >> GShift;
736	blue = (BShift < 0)? blue << (-BShift) : blue >> BShift;
737	pixel = (red & RMask) \| (green & GMask) \| (blue & BMask);
738	/* recall that we set ximage->byte_order = MSBFirst above */
739	*dest++ = (char)((pixel >> 24) & 0xff);
740	*dest++ = (char)((pixel >> 16) & 0xff);
741	*dest++ = (char)((pixel >> 8) & 0xff);
742	*dest++ = (char)( pixel & 0xff);
743	#endif
744	}
745	} else /* if (image_channels == 4) */ {
746	for (i = image_width; i > 0; --i) {
747	r = *src++;
748	g = *src++;
749	b = *src++;
750	a = *src++;
751	if (a == 255) {
752	red = r;
753	green = g;
754	blue = b;
755	} else if (a == 0) {
756	red = bg_red;
757	green = bg_green;
758	blue = bg_blue;
759	} else {
760	/* this macro (from png.h) composites the foreground
761	* and background values and puts the result into the
762	* first argument */
763	alpha_composite(red, r, a, bg_red);
764	alpha_composite(green, g, a, bg_green);
765	alpha_composite(blue, b, a, bg_blue);
766	}
767	pixel = (red << RShift) \|
768	(green << GShift) \|
769	(blue << BShift);
770	/* recall that we set ximage->byte_order = MSBFirst above */
771	*dest++ = (char)((pixel >> 24) & 0xff);
772	*dest++ = (char)((pixel >> 16) & 0xff);
773	*dest++ = (char)((pixel >> 8) & 0xff);
774	*dest++ = (char)( pixel & 0xff);
775	}
776	}
777	/* display after every 16 lines */
778	if (((row+1) & 0xf) == 0) {
779	XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
780	(int)lastrow, image_width, 16);
781	XFlush(display);
782	lastrow = row + 1;
783	}
784	}
785
786	} else if (depth == 16) {
787	ush red, green, blue;
788
789	for (lastrow = row = 0; row < image_height; ++row) {
790	src = image_data + row*image_rowbytes;
791	dest = ximage->data + row*ximage_rowbytes;
792	if (image_channels == 3) {
793	for (i = image_width; i > 0; --i) {
794	red = ((ush)(*src) << 8);
795	++src;
796	green = ((ush)(*src) << 8);
797	++src;
798	blue = ((ush)(*src) << 8);
799	++src;
800	pixel = ((red >> RShift) & RMask) \|
801	((green >> GShift) & GMask) \|
802	((blue >> BShift) & BMask);
803	/* recall that we set ximage->byte_order = MSBFirst above */
804	*dest++ = (char)((pixel >> 8) & 0xff);
805	*dest++ = (char)( pixel & 0xff);
806	}
807	} else /* if (image_channels == 4) */ {
808	for (i = image_width; i > 0; --i) {
809	r = *src++;
810	g = *src++;
811	b = *src++;
812	a = *src++;
813	if (a == 255) {
814	red = ((ush)r << 8);
815	green = ((ush)g << 8);
816	blue = ((ush)b << 8);
817	} else if (a == 0) {
818	red = ((ush)bg_red << 8);
819	green = ((ush)bg_green << 8);
820	blue = ((ush)bg_blue << 8);
821	} else {
822	/* this macro (from png.h) composites the foreground
823	* and background values and puts the result back into
824	* the first argument (== fg byte here: safe) */
825	alpha_composite(r, r, a, bg_red);
826	alpha_composite(g, g, a, bg_green);
827	alpha_composite(b, b, a, bg_blue);
828	red = ((ush)r << 8);
829	green = ((ush)g << 8);
830	blue = ((ush)b << 8);
831	}
832	pixel = ((red >> RShift) & RMask) \|
833	((green >> GShift) & GMask) \|
834	((blue >> BShift) & BMask);
835	/* recall that we set ximage->byte_order = MSBFirst above */
836	*dest++ = (char)((pixel >> 8) & 0xff);
837	*dest++ = (char)( pixel & 0xff);
838	}
839	}
840	/* display after every 16 lines */
841	if (((row+1) & 0xf) == 0) {
842	XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
843	(int)lastrow, image_width, 16);
844	XFlush(display);
845	lastrow = row + 1;
846	}
847	}
848
849	} else /* depth == 8 */ {
850
851	/* GRR: add 8-bit support */
852
853	}
854
855	Trace((stderr, "calling final XPutImage()\n"))
856	if (lastrow < image_height) {
857	XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
858	(int)lastrow, image_width, image_height-lastrow);
859	XFlush(display);
860	}
861
862	return 0;
863	}
864
865
866
867
868	static void rpng_x_cleanup(void)
869	{
870	if (image_data) {
871	free(image_data);
872	image_data = NULL;
873	}
874
875	if (ximage) {
876	if (ximage->data) {
877	free(ximage->data); /* we allocated it, so we free it */
878	ximage->data = (char )NULL; / instead of XDestroyImage() */
879	}
880	XDestroyImage(ximage);
881	ximage = NULL;
882	}
883
884	if (have_gc)
885	XFreeGC(display, gc);
886
887	if (have_window)
888	XDestroyWindow(display, window);
889
890	if (have_colormap)
891	XFreeColormap(display, colormap);
892
893	if (have_nondefault_visual)
894	XFree(visual_list);
895	}
896
897
898
899
900
901	static int rpng_x_msb(ulg u32val)
902	{
903	int i;
904
905	for (i = 31; i >= 0; --i) {
906	if (u32val & 0x80000000L)
907	break;
908	u32val <<= 1;
909	}
910	return i;
911	}

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

source: vbox/trunk/src/libs/libpng-1.6.36/contrib/gregbook/rpng-x.c@ 90330

Download in other formats: