rpng2-win.c@ 103025

最後變更在這個檔案從103025是 96425,由 vboxsync 提交於 2 年前
src/libs: Switch to libpng-1.6.37, bugref:8515 [re-export]
屬性 svn:eol-style 設為 `native`
檔案大小: 44.6 KB

行
1	/*---------------------------------------------------------------------------
2
3	rpng2 - progressive-model PNG display program rpng2-win.c
4
5	This program decodes and displays PNG files progressively, as if it were
6	a web browser (though the front end is only set up to read from files).
7	It supports gamma correction, user-specified background colors, and user-
8	specified background patterns (for transparent images). This version is
9	for 32-bit Windows; it may compile under 16-bit Windows with a little
10	tweaking (or maybe not). Thanks to Adam Costello and Pieter S. van der
11	Meulen for the "diamond" and "radial waves" patterns, respectively.
12
13	to do (someday, maybe):
14	- handle quoted command-line args (especially filenames with spaces)
15	- finish resizable checkerboard-gradient (sizes 4-128?)
16	- use %.1023s to simplify truncation of title-bar string?
17	- have minimum window width: oh well
18
19	---------------------------------------------------------------------------
20
21	Changelog:
22	- 1.01: initial public release
23	- 1.02: fixed cut-and-paste error in usage screen (oops...)
24	- 1.03: modified to allow abbreviated options
25	- 1.04: removed bogus extra argument from usage fprintf() [Glenn R-P?];
26	fixed command-line parsing bug
27	- 1.10: enabled "message window"/console (thanks to David Geldreich)
28	- 1.20: added runtime MMX-enabling/disabling and new -mmx* options
29	- 1.21: made minor tweak to usage screen to fit within 25-line console
30	- 1.22: added AMD64/EM64T support (__x86_64__)
31	- 2.00: dual-licensed (added GNU GPL)
32	- 2.01: fixed 64-bit typo in readpng2.c
33	- 2.02: fixed improper display of usage screen on PNG error(s); fixed
34	unexpected-EOF and file-read-error cases
35	- 2.03: removed runtime MMX-enabling/disabling and obsolete -mmx* options
36	- 2.04: check for integer overflow (Glenn R-P)
37
38	---------------------------------------------------------------------------
39
40	Copyright (c) 1998-2008, 2017 Greg Roelofs. All rights reserved.
41
42	This software is provided "as is," without warranty of any kind,
43	express or implied. In no event shall the author or contributors
44	be held liable for any damages arising in any way from the use of
45	this software.
46
47	The contents of this file are DUAL-LICENSED. You may modify and/or
48	redistribute this software according to the terms of one of the
49	following two licenses (at your option):
50
51
52	LICENSE 1 ("BSD-like with advertising clause"):
53
54	Permission is granted to anyone to use this software for any purpose,
55	including commercial applications, and to alter it and redistribute
56	it freely, subject to the following restrictions:
57
58	1. Redistributions of source code must retain the above copyright
59	notice, disclaimer, and this list of conditions.
60	2. Redistributions in binary form must reproduce the above copyright
61	notice, disclaimer, and this list of conditions in the documenta-
62	tion and/or other materials provided with the distribution.
63	3. All advertising materials mentioning features or use of this
64	software must display the following acknowledgment:
65
66	This product includes software developed by Greg Roelofs
67	and contributors for the book, "PNG: The Definitive Guide,"
68	published by O'Reilly and Associates.
69
70
71	LICENSE 2 (GNU GPL v2 or later):
72
73	This program is free software; you can redistribute it and/or modify
74	it under the terms of the GNU General Public License as published by
75	the Free Software Foundation; either version 2 of the License, or
76	(at your option) any later version.
77
78	This program is distributed in the hope that it will be useful,
79	but WITHOUT ANY WARRANTY; without even the implied warranty of
80	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
81	GNU General Public License for more details.
82
83	You should have received a copy of the GNU General Public License
84	along with this program; if not, write to the Free Software Foundation,
85	Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
86
87	---------------------------------------------------------------------------*/
88
89	#define PROGNAME "rpng2-win"
90	#define LONGNAME "Progressive PNG Viewer for Windows"
91	#define VERSION "2.02 of 16 March 2008"
92
93	#include <stdio.h>
94	#include <stdlib.h>
95	#include <string.h>
96	#include <setjmp.h> /* for jmpbuf declaration in readpng2.h */
97	#include <time.h>
98	#include <math.h> /* only for PvdM background code */
99	#include <windows.h>
100	#ifdef __CYGWIN__
101	/* getch replacement. Turns out, we don't really need this,
102	* but leave it here if we ever enable any of the uses of
103	* _getch in the main code
104	*/
105	#include <unistd.h>
106	#include <termio.h>
107	#include <sys/ioctl.h>
108	int repl_getch( void )
109	{
110	char ch;
111	int fd = fileno(stdin);
112	struct termio old_tty, new_tty;
113
114	ioctl(fd, TCGETA, &old_tty);
115	new_tty = old_tty;
116	new_tty.c_lflag &= ~(ICANON \| ECHO \| ISIG);
117	ioctl(fd, TCSETA, &new_tty);
118	fread(&ch, 1, sizeof(ch), stdin);
119	ioctl(fd, TCSETA, &old_tty);
120
121	return ch;
122	}
123	#define _getch repl_getch
124	#else
125	#include <conio.h> /* only for _getch() */
126	#endif
127
128	/* all for PvdM background code: */
129	#ifndef PI
130	# define PI 3.141592653589793238
131	#endif
132	#define PI_2 (PI*0.5)
133	#define INV_PI_360 (360.0 / PI)
134	#define MAX(a,b) (a>b?a:b)
135	#define MIN(a,b) (a<b?a:b)
136	#define CLIP(a,min,max) MAX(min,MIN((a),max))
137	#define ABS(a) ((a)<0?-(a):(a))
138	#define CLIP8P(c) MAX(0,(MIN((c),255))) /* 8-bit pos. integer (uch) */
139	#define ROUNDF(f) ((int)(f + 0.5))
140
141	#define rgb1_max bg_freq
142	#define rgb1_min bg_gray
143	#define rgb2_max bg_bsat
144	#define rgb2_min bg_brot
145
146	/* #define DEBUG / / this enables the Trace() macros */
147
148	#include "readpng2.h" /* typedefs, common macros, readpng2 prototypes */
149
150
151	/* could just include png.h, but this macro is the only thing we need
152	* (name and typedefs changed to local versions); note that side effects
153	* only happen with alpha (which could easily be avoided with
154	* "ush acopy = (alpha);") */
155
156	#define alpha_composite(composite, fg, alpha, bg) { \
157	ush temp = ((ush)(fg)*(ush)(alpha) + \
158	(ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128); \
159	(composite) = (uch)((temp + (temp >> 8)) >> 8); \
160	}
161
162
163	#define INBUFSIZE 4096 /* with pseudo-timing on (1 sec delay/block), this
164	* block size corresponds roughly to a download
165	* speed 10% faster than theoretical 33.6K maximum
166	* (assuming 8 data bits, 1 stop bit and no other
167	* overhead) */
168
169	/* local prototypes */
170	static void rpng2_win_init(void);
171	static int rpng2_win_create_window(void);
172	static int rpng2_win_load_bg_image(void);
173	static void rpng2_win_display_row(ulg row);
174	static void rpng2_win_finish_display(void);
175	static void rpng2_win_cleanup(void);
176	LRESULT CALLBACK rpng2_win_wndproc(HWND, UINT, WPARAM, LPARAM);
177
178
179	static char titlebar[1024];
180	static char *progname = PROGNAME;
181	static char *appname = LONGNAME;
182	static char *filename;
183	static FILE *infile;
184
185	static mainprog_info rpng2_info;
186
187	static uch inbuf[INBUFSIZE];
188	static int incount;
189
190	static int pat = 6; /* must be less than num_bgpat */
191	static int bg_image = 0;
192	static int bgscale = 16;
193	static ulg bg_rowbytes;
194	static uch *bg_data;
195
196	static struct rgb_color {
197	uch r, g, b;
198	} rgb[] = {
199	{ 0, 0, 0}, /* 0: black */
200	{255, 255, 255}, /* 1: white */
201	{173, 132, 57}, /* 2: tan */
202	{ 64, 132, 0}, /* 3: medium green */
203	{189, 117, 1}, /* 4: gold */
204	{253, 249, 1}, /* 5: yellow */
205	{ 0, 0, 255}, /* 6: blue */
206	{ 0, 0, 120}, /* 7: medium blue */
207	{255, 0, 255}, /* 8: magenta */
208	{ 64, 0, 64}, /* 9: dark magenta */
209	{255, 0, 0}, /* 10: red */
210	{ 64, 0, 0}, /* 11: dark red */
211	{255, 127, 0}, /* 12: orange */
212	{192, 96, 0}, /* 13: darker orange */
213	{ 24, 60, 0}, /* 14: dark green-yellow */
214	{ 85, 125, 200} /* 15: ice blue */
215	};
216	/* not used for now, but should be for error-checking:
217	static int num_rgb = sizeof(rgb) / sizeof(struct rgb_color);
218	*/
219
220	/*
221	This whole struct is a fairly cheesy way to keep the number of
222	command-line options to a minimum. The radial-waves background
223	type is a particularly poor fit to the integer elements of the
224	struct...but a few macros and a little fixed-point math will do
225	wonders for ya.
226
227	type bits:
228	F E D C B A 9 8 7 6 5 4 3 2 1 0
229	\| \| \| \| \|
230	\| \| +-+-+-- 0 = sharp-edged checkerboard
231	\| \| 1 = soft diamonds
232	\| \| 2 = radial waves
233	\| \| 3-7 = undefined
234	\| +-- gradient #2 inverted?
235	+-- alternating columns inverted?
236	*/
237	static struct background_pattern {
238	ush type;
239	int rgb1_max, rgb1_min; /* or bg_freq, bg_gray */
240	int rgb2_max, rgb2_min; /* or bg_bsat, bg_brot (both scaled by 10)*/
241	} bg[] = {
242	{0+8, 2,0, 1,15}, /* checkered: tan/black vs. white/ice blue */
243	{0+24, 2,0, 1,0}, /* checkered: tan/black vs. white/black */
244	{0+8, 4,5, 0,2}, /* checkered: gold/yellow vs. black/tan */
245	{0+8, 4,5, 0,6}, /* checkered: gold/yellow vs. black/blue */
246	{0, 7,0, 8,9}, /* checkered: deep blue/black vs. magenta */
247	{0+8, 13,0, 5,14}, /* checkered: orange/black vs. yellow */
248	{0+8, 12,0, 10,11}, /* checkered: orange/black vs. red */
249	{1, 7,0, 8,0}, /* diamonds: deep blue/black vs. magenta */
250	{1, 12,0, 11,0}, /* diamonds: orange vs. dark red */
251	{1, 10,0, 7,0}, /* diamonds: red vs. medium blue */
252	{1, 4,0, 5,0}, /* diamonds: gold vs. yellow */
253	{1, 3,0, 0,0}, /* diamonds: medium green vs. black */
254	{2, 16, 100, 20, 0}, /* radial: ~hard radial color-beams */
255	{2, 18, 100, 10, 2}, /* radial: soft, curved radial color-beams */
256	{2, 16, 256, 100, 250}, /* radial: very tight spiral */
257	{2, 10000, 256, 11, 0} /* radial: dipole-moire' (almost fractal) */
258	};
259	static int num_bgpat = sizeof(bg) / sizeof(struct background_pattern);
260
261
262	/* Windows-specific global variables (could go in struct, but messy...) */
263	static ulg wimage_rowbytes;
264	static uch *dib;
265	static uch *wimage_data;
266	static BITMAPINFOHEADER *bmih;
267
268	static HWND global_hwnd;
269	static HINSTANCE global_hInst;
270	static int global_showmode;
271
272
273
274
275	int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
276	{
277	char args[1024]; / arbitrary limit, but should suffice */
278	char **argv = args;
279	char p, q, *bgstr = NULL;
280	int argc = 0;
281	int rc, alen, flen;
282	int error = 0;
283	int timing = FALSE;
284	int have_bg = FALSE;
285	double LUT_exponent; /* just the lookup table */
286	double CRT_exponent = 2.2; /* just the monitor */
287	double default_display_exponent; /* whole display system */
288	MSG msg;
289
290
291	/* First initialize a few things, just to be sure--memset takes care of
292	* default background color (black), booleans (FALSE), pointers (NULL),
293	* etc. */
294
295	global_hInst = hInst;
296	global_showmode = showmode;
297	filename = (char *)NULL;
298	memset(&rpng2_info, 0, sizeof(mainprog_info));
299
300	#ifndef __CYGWIN__
301	/* Next reenable console output, which normally goes to the bit bucket
302	* for windowed apps. Closing the console window will terminate the
303	* app. Thanks to David.Geldreich at realviz.com for supplying the magical
304	* incantation. */
305
306	AllocConsole();
307	freopen("CONOUT$", "a", stderr);
308	freopen("CONOUT$", "a", stdout);
309	#endif
310
311	/* Set the default value for our display-system exponent, i.e., the
312	* product of the CRT exponent and the exponent corresponding to
313	* the frame-buffer's lookup table (LUT), if any. This is not an
314	* exhaustive list of LUT values (e.g., OpenStep has a lot of weird
315	* ones), but it should cover 99% of the current possibilities. And
316	* yes, these ifdefs are completely wasted in a Windows program... */
317
318	#if defined(NeXT)
319	/* third-party utilities can modify the default LUT exponent */
320	LUT_exponent = 1.0 / 2.2;
321	/*
322	if (some_next_function_that_returns_gamma(&next_gamma))
323	LUT_exponent = 1.0 / next_gamma;
324	*/
325	#elif defined(sgi)
326	LUT_exponent = 1.0 / 1.7;
327	/* there doesn't seem to be any documented function to
328	* get the "gamma" value, so we do it the hard way */
329	infile = fopen("/etc/config/system.glGammaVal", "r");
330	if (infile) {
331	double sgi_gamma;
332
333	fgets(tmpline, 80, infile);
334	fclose(infile);
335	sgi_gamma = atof(tmpline);
336	if (sgi_gamma > 0.0)
337	LUT_exponent = 1.0 / sgi_gamma;
338	}
339	#elif defined(Macintosh)
340	LUT_exponent = 1.8 / 2.61;
341	/*
342	if (some_mac_function_that_returns_gamma(&mac_gamma))
343	LUT_exponent = mac_gamma / 2.61;
344	*/
345	#else
346	LUT_exponent = 1.0; /* assume no LUT: most PCs */
347	#endif
348
349	/* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
350	default_display_exponent = LUT_exponent * CRT_exponent;
351
352
353	/* If the user has set the SCREEN_GAMMA environment variable as suggested
354	* (somewhat imprecisely) in the libpng documentation, use that; otherwise
355	* use the default value we just calculated. Either way, the user may
356	* override this via a command-line option. */
357
358	if ((p = getenv("SCREEN_GAMMA")) != NULL)
359	rpng2_info.display_exponent = atof(p);
360	else
361	rpng2_info.display_exponent = default_display_exponent;
362
363
364	/* Windows really hates command lines, so we have to set up our own argv.
365	* Note that we do NOT bother with quoted arguments here, so don't use
366	* filenames with spaces in 'em! */
367
368	argv[argc++] = PROGNAME;
369	p = cmd;
370	for (;;) {
371	if (*p == ' ')
372	while (*++p == ' ')
373	;
374	/* now p points at the first non-space after some spaces */
375	if (*p == '\0')
376	break; /* nothing after the spaces: done */
377	argv[argc++] = q = p;
378	while (q && q != ' ')
379	++q;
380	/* now q points at a space or the end of the string */
381	if (*q == '\0')
382	break; /* last argv already terminated; quit */
383	q = '\0'; / change space to terminator */
384	p = q + 1;
385	}
386	argv[argc] = NULL; /* terminate the argv array itself */
387
388
389	/* Now parse the command line for options and the PNG filename. */
390
391	while (*++argv && !error) {
392	if (!strncmp(*argv, "-gamma", 2)) {
393	if (!*++argv)
394	++error;
395	else {
396	rpng2_info.display_exponent = atof(*argv);
397	if (rpng2_info.display_exponent <= 0.0)
398	++error;
399	}
400	} else if (!strncmp(*argv, "-bgcolor", 4)) {
401	if (!*++argv)
402	++error;
403	else {
404	bgstr = *argv;
405	if (strlen(bgstr) != 7 \|\| bgstr[0] != '#')
406	++error;
407	else {
408	have_bg = TRUE;
409	bg_image = FALSE;
410	}
411	}
412	} else if (!strncmp(*argv, "-bgpat", 4)) {
413	if (!*++argv)
414	++error;
415	else {
416	pat = atoi(*argv) - 1;
417	if (pat < 0 \|\| pat >= num_bgpat)
418	++error;
419	else {
420	bg_image = TRUE;
421	have_bg = FALSE;
422	}
423	}
424	} else if (!strncmp(*argv, "-timing", 2)) {
425	timing = TRUE;
426	} else {
427	if (**argv != '-') {
428	filename = *argv;
429	if (argv[1]) /* shouldn't be any more args after filename */
430	++error;
431	} else
432	++error; /* not expecting any other options */
433	}
434	}
435
436	if (!filename)
437	++error;
438
439
440	/* print usage screen if any errors up to this point */
441
442	if (error) {
443	#ifndef __CYGWIN__
444	int ch;
445	#endif
446
447	fprintf(stderr, "\n%s %s: %s\n\n", PROGNAME, VERSION, appname);
448	readpng2_version_info();
449	fprintf(stderr, "\n"
450	"Usage: %s [-gamma exp] [-bgcolor bg \| -bgpat pat] [-timing]\n"
451	" %*s file.png\n\n"
452	" exp \ttransfer-function exponent (``gamma'') of the display\n"
453	"\t\t system in floating-point format (e.g., ``%.1f''); equal\n"
454	"\t\t to the product of the lookup-table exponent (varies)\n"
455	"\t\t and the CRT exponent (usually 2.2); must be positive\n"
456	" bg \tdesired background color in 7-character hex RGB format\n"
457	"\t\t (e.g., ``#ff7700'' for orange: same as HTML colors);\n"
458	"\t\t used with transparent images; overrides -bgpat option\n"
459	" pat \tdesired background pattern number (1-%d); used with\n"
460	"\t\t transparent images; overrides -bgcolor option\n"
461	" -timing\tenables delay for every block read, to simulate modem\n"
462	"\t\t download of image (~36 Kbps)\n"
463	"\nPress Q, Esc or mouse button 1 after image is displayed to quit.\n"
464	#ifndef __CYGWIN__
465	"Press Q or Esc to quit this usage screen. ",
466	#else
467	,
468	#endif
469	PROGNAME,
470	#if (defined(__i386__) \|\| defined(_M_IX86) \|\| defined(__x86_64__)) && \
471	!(defined(__CYGWIN__) \|\| defined(__MINGW32__))
472	(int)strlen(PROGNAME), " ",
473	#endif
474	(int)strlen(PROGNAME), " ", default_display_exponent, num_bgpat);
475	fflush(stderr);
476	#ifndef __CYGWIN__
477	do
478	ch = _getch();
479	while (ch != 'q' && ch != 'Q' && ch != 0x1B);
480	#endif
481	exit(1);
482	}
483
484
485	if (!(infile = fopen(filename, "rb"))) {
486	fprintf(stderr, PROGNAME ": can't open PNG file [%s]\n", filename);
487	++error;
488	} else {
489	incount = fread(inbuf, 1, INBUFSIZE, infile);
490	if (incount < 8 \|\| !readpng2_check_sig(inbuf, 8)) {
491	fprintf(stderr, PROGNAME
492	": [%s] is not a PNG file: incorrect signature\n",
493	filename);
494	++error;
495	} else if ((rc = readpng2_init(&rpng2_info)) != 0) {
496	switch (rc) {
497	case 2:
498	fprintf(stderr, PROGNAME
499	": [%s] has bad IHDR (libpng longjmp)\n", filename);
500	break;
501	case 4:
502	fprintf(stderr, PROGNAME ": insufficient memory\n");
503	break;
504	default:
505	fprintf(stderr, PROGNAME
506	": unknown readpng2_init() error\n");
507	break;
508	}
509	++error;
510	}
511	if (error)
512	fclose(infile);
513	}
514
515
516	if (error) {
517	#ifndef __CYGWIN__
518	int ch;
519	#endif
520
521	fprintf(stderr, PROGNAME ": aborting.\n");
522	#ifndef __CYGWIN__
523	do
524	ch = _getch();
525	while (ch != 'q' && ch != 'Q' && ch != 0x1B);
526	#endif
527	exit(2);
528	} else {
529	fprintf(stderr, "\n%s %s: %s\n", PROGNAME, VERSION, appname);
530	#ifndef __CYGWIN__
531	fprintf(stderr,
532	"\n [console window: closing this window will terminate %s]\n\n",
533	PROGNAME);
534	#endif
535	fflush(stderr);
536	}
537
538
539	/* set the title-bar string, but make sure buffer doesn't overflow */
540
541	alen = strlen(appname);
542	flen = strlen(filename);
543	if (alen + flen + 3 > 1023)
544	sprintf(titlebar, "%s: ...%s", appname, filename+(alen+flen+6-1023));
545	else
546	sprintf(titlebar, "%s: %s", appname, filename);
547
548
549	/* set some final rpng2_info variables before entering main data loop */
550
551	if (have_bg) {
552	unsigned r, g, b; /* this approach quiets compiler warnings */
553
554	sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
555	rpng2_info.bg_red = (uch)r;
556	rpng2_info.bg_green = (uch)g;
557	rpng2_info.bg_blue = (uch)b;
558	} else
559	rpng2_info.need_bgcolor = TRUE;
560
561	rpng2_info.state = kPreInit;
562	rpng2_info.mainprog_init = rpng2_win_init;
563	rpng2_info.mainprog_display_row = rpng2_win_display_row;
564	rpng2_info.mainprog_finish_display = rpng2_win_finish_display;
565
566
567	/* OK, this is the fun part: call readpng2_decode_data() at the start of
568	* the loop to deal with our first buffer of data (read in above to verify
569	* that the file is a PNG image), then loop through the file and continue
570	* calling the same routine to handle each chunk of data. It in turn
571	* passes the data to libpng, which will invoke one or more of our call-
572	* backs as decoded data become available. We optionally call Sleep() for
573	* one second per iteration to simulate downloading the image via an analog
574	* modem. */
575
576	for (;;) {
577	Trace((stderr, "about to call readpng2_decode_data()\n"))
578	if (readpng2_decode_data(&rpng2_info, inbuf, incount))
579	++error;
580	Trace((stderr, "done with readpng2_decode_data()\n"))
581
582	if (error \|\| incount != INBUFSIZE \|\| rpng2_info.state == kDone) {
583	if (rpng2_info.state == kDone) {
584	Trace((stderr, "done decoding PNG image\n"))
585	} else if (ferror(infile)) {
586	fprintf(stderr, PROGNAME
587	": error while reading PNG image file\n");
588	exit(3);
589	} else if (feof(infile)) {
590	fprintf(stderr, PROGNAME ": end of file reached "
591	"(unexpectedly) while reading PNG image file\n");
592	exit(3);
593	} else /* if (error) */ {
594	/* will print error message below */
595	}
596	break;
597	}
598
599	if (timing)
600	Sleep(1000L);
601
602	incount = fread(inbuf, 1, INBUFSIZE, infile);
603	}
604
605
606	/* clean up PNG stuff and report any decoding errors */
607
608	fclose(infile);
609	Trace((stderr, "about to call readpng2_cleanup()\n"))
610	readpng2_cleanup(&rpng2_info);
611
612	if (error) {
613	fprintf(stderr, PROGNAME ": libpng error while decoding PNG image\n");
614	exit(3);
615	}
616
617
618	/* wait for the user to tell us when to quit */
619
620	while (GetMessage(&msg, NULL, 0, 0)) {
621	TranslateMessage(&msg);
622	DispatchMessage(&msg);
623	}
624
625
626	/* we're done: clean up all image and Windows resources and go away */
627
628	Trace((stderr, "about to call rpng2_win_cleanup()\n"))
629	rpng2_win_cleanup();
630
631	return msg.wParam;
632	}
633
634
635
636
637
638	/* this function is called by readpng2_info_callback() in readpng2.c, which
639	* in turn is called by libpng after all of the pre-IDAT chunks have been
640	* read and processed--i.e., we now have enough info to finish initializing */
641
642	static void rpng2_win_init()
643	{
644	ulg i;
645	ulg rowbytes = rpng2_info.rowbytes;
646
647	Trace((stderr, "beginning rpng2_win_init()\n"))
648	Trace((stderr, " rowbytes = %d\n", rpng2_info.rowbytes))
649	Trace((stderr, " width = %ld\n", rpng2_info.width))
650	Trace((stderr, " height = %ld\n", rpng2_info.height))
651
652	/* Guard against integer overflow */
653	if (rpng2_info.height > ((size_t)(-1))/rowbytes) {
654	fprintf(stderr, PROGNAME ": image_data buffer would be too large\n",
655	readpng2_cleanup(&rpng2_info);
656	return;
657	}
658
659	rpng2_info.image_data = (uch )malloc(rowbytes rpng2_info.height);
660	if (!rpng2_info.image_data) {
661	readpng2_cleanup(&rpng2_info);
662	return;
663	}
664
665	rpng2_info.row_pointers = (uch *)malloc(rpng2_info.height sizeof(uch *));
666	if (!rpng2_info.row_pointers) {
667	free(rpng2_info.image_data);
668	rpng2_info.image_data = NULL;
669	readpng2_cleanup(&rpng2_info);
670	return;
671	}
672
673	for (i = 0; i < rpng2_info.height; ++i)
674	rpng2_info.row_pointers[i] = rpng2_info.image_data + i*rowbytes;
675
676	/*---------------------------------------------------------------------------
677	Do the basic Windows initialization stuff, make the window, and fill it
678	with the user-specified, file-specified or default background color.
679	---------------------------------------------------------------------------*/
680
681	if (rpng2_win_create_window()) {
682	readpng2_cleanup(&rpng2_info);
683	return;
684	}
685
686	rpng2_info.state = kWindowInit;
687	}
688
689
690
691
692
693	static int rpng2_win_create_window()
694	{
695	uch bg_red = rpng2_info.bg_red;
696	uch bg_green = rpng2_info.bg_green;
697	uch bg_blue = rpng2_info.bg_blue;
698	uch *dest;
699	int extra_width, extra_height;
700	ulg i, j;
701	WNDCLASSEX wndclass;
702	RECT rect;
703
704
705	/*---------------------------------------------------------------------------
706	Allocate memory for the display-specific version of the image (round up
707	to multiple of 4 for Windows DIB).
708	---------------------------------------------------------------------------*/
709
710	wimage_rowbytes = ((3*rpng2_info.width + 3L) >> 2) << 2;
711
712	if (!(dib = (uch *)malloc(sizeof(BITMAPINFOHEADER) +
713	wimage_rowbytes*rpng2_info.height)))
714	{
715	return 4; /* fail */
716	}
717
718	/*---------------------------------------------------------------------------
719	Initialize the DIB. Negative height means to use top-down BMP ordering
720	(must be uncompressed, but that's what we want). Bit count of 1, 4 or 8
721	implies a colormap of RGBX quads, but 24-bit BMPs just use B,G,R values
722	directly => wimage_data begins immediately after BMP header.
723	---------------------------------------------------------------------------*/
724
725	memset(dib, 0, sizeof(BITMAPINFOHEADER));
726	bmih = (BITMAPINFOHEADER *)dib;
727	bmih->biSize = sizeof(BITMAPINFOHEADER);
728	bmih->biWidth = rpng2_info.width;
729	bmih->biHeight = -((long)rpng2_info.height);
730	bmih->biPlanes = 1;
731	bmih->biBitCount = 24;
732	bmih->biCompression = 0;
733	wimage_data = dib + sizeof(BITMAPINFOHEADER);
734
735	/*---------------------------------------------------------------------------
736	Fill window with the specified background color (default is black), but
737	defer loading faked "background image" until window is displayed (may be
738	slow to compute). Data are in BGR order.
739	---------------------------------------------------------------------------*/
740
741	if (bg_image) { /* just fill with black for now */
742	memset(wimage_data, 0, wimage_rowbytes*rpng2_info.height);
743	} else {
744	for (j = 0; j < rpng2_info.height; ++j) {
745	dest = wimage_data + j*wimage_rowbytes;
746	for (i = rpng2_info.width; i > 0; --i) {
747	*dest++ = bg_blue;
748	*dest++ = bg_green;
749	*dest++ = bg_red;
750	}
751	}
752	}
753
754	/*---------------------------------------------------------------------------
755	Set the window parameters.
756	---------------------------------------------------------------------------*/
757
758	memset(&wndclass, 0, sizeof(wndclass));
759
760	wndclass.cbSize = sizeof(wndclass);
761	wndclass.style = CS_HREDRAW \| CS_VREDRAW;
762	wndclass.lpfnWndProc = rpng2_win_wndproc;
763	wndclass.hInstance = global_hInst;
764	wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
765	wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
766	wndclass.hbrBackground = (HBRUSH)GetStockObject(DKGRAY_BRUSH);
767	wndclass.lpszMenuName = NULL;
768	wndclass.lpszClassName = progname;
769	wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
770
771	RegisterClassEx(&wndclass);
772
773	/*---------------------------------------------------------------------------
774	Finally, create the window.
775	---------------------------------------------------------------------------*/
776
777	extra_width = 2*(GetSystemMetrics(SM_CXBORDER) +
778	GetSystemMetrics(SM_CXDLGFRAME));
779	extra_height = 2*(GetSystemMetrics(SM_CYBORDER) +
780	GetSystemMetrics(SM_CYDLGFRAME)) +
781	GetSystemMetrics(SM_CYCAPTION);
782
783	global_hwnd = CreateWindow(progname, titlebar, WS_OVERLAPPEDWINDOW,
784	CW_USEDEFAULT, CW_USEDEFAULT, rpng2_info.width+extra_width,
785	rpng2_info.height+extra_height, NULL, NULL, global_hInst, NULL);
786
787	ShowWindow(global_hwnd, global_showmode);
788	UpdateWindow(global_hwnd);
789
790	/*---------------------------------------------------------------------------
791	Now compute the background image and display it. If it fails (memory
792	allocation), revert to a plain background color.
793	---------------------------------------------------------------------------*/
794
795	if (bg_image) {
796	static const char *msg = "Computing background image...";
797	int x, y, len = strlen(msg);
798	HDC hdc = GetDC(global_hwnd);
799	TEXTMETRIC tm;
800
801	GetTextMetrics(hdc, &tm);
802	x = (rpng2_info.width - len*tm.tmAveCharWidth)/2;
803	y = (rpng2_info.height - tm.tmHeight)/2;
804	SetBkMode(hdc, TRANSPARENT);
805	SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
806	/* this can still begin out of bounds even if x is positive (???): */
807	TextOut(hdc, ((x < 0)? 0 : x), ((y < 0)? 0 : y), msg, len);
808	ReleaseDC(global_hwnd, hdc);
809
810	rpng2_win_load_bg_image(); /* resets bg_image if fails */
811	}
812
813	if (!bg_image) {
814	for (j = 0; j < rpng2_info.height; ++j) {
815	dest = wimage_data + j*wimage_rowbytes;
816	for (i = rpng2_info.width; i > 0; --i) {
817	*dest++ = bg_blue;
818	*dest++ = bg_green;
819	*dest++ = bg_red;
820	}
821	}
822	}
823
824	rect.left = 0L;
825	rect.top = 0L;
826	rect.right = (LONG)rpng2_info.width; /* possibly off by one? */
827	rect.bottom = (LONG)rpng2_info.height; /* possibly off by one? */
828	InvalidateRect(global_hwnd, &rect, FALSE);
829	UpdateWindow(global_hwnd); /* similar to XFlush() */
830
831	return 0;
832
833	} /* end function rpng2_win_create_window() */
834
835
836
837
838
839	static int rpng2_win_load_bg_image()
840	{
841	uch src, dest;
842	uch r1, r2, g1, g2, b1, b2;
843	uch r1_inv, r2_inv, g1_inv, g2_inv, b1_inv, b2_inv;
844	int k, hmax, max;
845	int xidx, yidx, yidx_max = (bgscale-1);
846	int even_odd_vert, even_odd_horiz, even_odd;
847	int invert_gradient2 = (bg[pat].type & 0x08);
848	int invert_column;
849	ulg i, row;
850
851	/*---------------------------------------------------------------------------
852	Allocate buffer for fake background image to be used with transparent
853	images; if this fails, revert to plain background color.
854	---------------------------------------------------------------------------*/
855
856	bg_rowbytes = 3 * rpng2_info.width;
857	bg_data = (uch )malloc(bg_rowbytes rpng2_info.height);
858	if (!bg_data) {
859	fprintf(stderr, PROGNAME
860	": unable to allocate memory for background image\n");
861	bg_image = 0;
862	return 1;
863	}
864
865	/*---------------------------------------------------------------------------
866	Vertical gradients (ramps) in NxN squares, alternating direction and
867	colors (N == bgscale).
868	---------------------------------------------------------------------------*/
869
870	if ((bg[pat].type & 0x07) == 0) {
871	uch r1_min = rgb[bg[pat].rgb1_min].r;
872	uch g1_min = rgb[bg[pat].rgb1_min].g;
873	uch b1_min = rgb[bg[pat].rgb1_min].b;
874	uch r2_min = rgb[bg[pat].rgb2_min].r;
875	uch g2_min = rgb[bg[pat].rgb2_min].g;
876	uch b2_min = rgb[bg[pat].rgb2_min].b;
877	int r1_diff = rgb[bg[pat].rgb1_max].r - r1_min;
878	int g1_diff = rgb[bg[pat].rgb1_max].g - g1_min;
879	int b1_diff = rgb[bg[pat].rgb1_max].b - b1_min;
880	int r2_diff = rgb[bg[pat].rgb2_max].r - r2_min;
881	int g2_diff = rgb[bg[pat].rgb2_max].g - g2_min;
882	int b2_diff = rgb[bg[pat].rgb2_max].b - b2_min;
883
884	for (row = 0; row < rpng2_info.height; ++row) {
885	yidx = row % bgscale;
886	even_odd_vert = (row / bgscale) & 1;
887
888	r1 = r1_min + (r1_diff * yidx) / yidx_max;
889	g1 = g1_min + (g1_diff * yidx) / yidx_max;
890	b1 = b1_min + (b1_diff * yidx) / yidx_max;
891	r1_inv = r1_min + (r1_diff * (yidx_max-yidx)) / yidx_max;
892	g1_inv = g1_min + (g1_diff * (yidx_max-yidx)) / yidx_max;
893	b1_inv = b1_min + (b1_diff * (yidx_max-yidx)) / yidx_max;
894
895	r2 = r2_min + (r2_diff * yidx) / yidx_max;
896	g2 = g2_min + (g2_diff * yidx) / yidx_max;
897	b2 = b2_min + (b2_diff * yidx) / yidx_max;
898	r2_inv = r2_min + (r2_diff * (yidx_max-yidx)) / yidx_max;
899	g2_inv = g2_min + (g2_diff * (yidx_max-yidx)) / yidx_max;
900	b2_inv = b2_min + (b2_diff * (yidx_max-yidx)) / yidx_max;
901
902	dest = bg_data + row*bg_rowbytes;
903	for (i = 0; i < rpng2_info.width; ++i) {
904	even_odd_horiz = (i / bgscale) & 1;
905	even_odd = even_odd_vert ^ even_odd_horiz;
906	invert_column =
907	(even_odd_horiz && (bg[pat].type & 0x10));
908	if (even_odd == 0) { /* gradient #1 */
909	if (invert_column) {
910	*dest++ = r1_inv;
911	*dest++ = g1_inv;
912	*dest++ = b1_inv;
913	} else {
914	*dest++ = r1;
915	*dest++ = g1;
916	*dest++ = b1;
917	}
918	} else { /* gradient #2 */
919	if ((invert_column && invert_gradient2) \|\|
920	(!invert_column && !invert_gradient2))
921	{
922	dest++ = r2; / not inverted or */
923	dest++ = g2; / doubly inverted */
924	*dest++ = b2;
925	} else {
926	*dest++ = r2_inv;
927	dest++ = g2_inv; / singly inverted */
928	*dest++ = b2_inv;
929	}
930	}
931	}
932	}
933
934	/*---------------------------------------------------------------------------
935	Soft gradient-diamonds with scale = bgscale. Code contributed by Adam
936	M. Costello.
937	---------------------------------------------------------------------------*/
938
939	} else if ((bg[pat].type & 0x07) == 1) {
940
941	hmax = (bgscale-1)/2; /* half the max weight of a color */
942	max = 2hmax; / the max weight of a color */
943
944	r1 = rgb[bg[pat].rgb1_max].r;
945	g1 = rgb[bg[pat].rgb1_max].g;
946	b1 = rgb[bg[pat].rgb1_max].b;
947	r2 = rgb[bg[pat].rgb2_max].r;
948	g2 = rgb[bg[pat].rgb2_max].g;
949	b2 = rgb[bg[pat].rgb2_max].b;
950
951	for (row = 0; row < rpng2_info.height; ++row) {
952	yidx = row % bgscale;
953	if (yidx > hmax)
954	yidx = bgscale-1 - yidx;
955	dest = bg_data + row*bg_rowbytes;
956	for (i = 0; i < rpng2_info.width; ++i) {
957	xidx = i % bgscale;
958	if (xidx > hmax)
959	xidx = bgscale-1 - xidx;
960	k = xidx + yidx;
961	dest++ = (kr1 + (max-k)*r2) / max;
962	dest++ = (kg1 + (max-k)*g2) / max;
963	dest++ = (kb1 + (max-k)*b2) / max;
964	}
965	}
966
967	/*---------------------------------------------------------------------------
968	Radial "starburst" with azimuthal sinusoids; [eventually number of sinu-
969	soids will equal bgscale?]. This one is slow but very cool. Code con-
970	tributed by Pieter S. van der Meulen (originally in Smalltalk).
971	---------------------------------------------------------------------------*/
972
973	} else if ((bg[pat].type & 0x07) == 2) {
974	uch ch;
975	int ii, x, y, hw, hh, grayspot;
976	double freq, rotate, saturate, gray, intensity;
977	double angle=0.0, aoffset=0.0, maxDist, dist;
978	double red=0.0, green=0.0, blue=0.0, hue, s, v, f, p, q, t;
979
980	fprintf(stderr, "%s: computing radial background...",
981	PROGNAME);
982	fflush(stderr);
983
984	hh = rpng2_info.height / 2;
985	hw = rpng2_info.width / 2;
986
987	/* variables for radial waves:
988	* aoffset: number of degrees to rotate hue [CURRENTLY NOT USED]
989	* freq: number of color beams originating from the center
990	* grayspot: size of the graying center area (anti-alias)
991	* rotate: rotation of the beams as a function of radius
992	* saturate: saturation of beams' shape azimuthally
993	*/
994	angle = CLIP(angle, 0.0, 360.0);
995	grayspot = CLIP(bg[pat].bg_gray, 1, (hh + hw));
996	freq = MAX((double)bg[pat].bg_freq, 0.0);
997	saturate = (double)bg[pat].bg_bsat * 0.1;
998	rotate = (double)bg[pat].bg_brot * 0.1;
999	gray = 0.0;
1000	intensity = 0.0;
1001	maxDist = (double)((hwhw) + (hhhh));
1002
1003	for (row = 0; row < rpng2_info.height; ++row) {
1004	y = row - hh;
1005	dest = bg_data + row*bg_rowbytes;
1006	for (i = 0; i < rpng2_info.width; ++i) {
1007	x = i - hw;
1008	angle = (x == 0)? PI_2 : atan((double)y / (double)x);
1009	gray = (double)MAX(ABS(y), ABS(x)) / grayspot;
1010	gray = MIN(1.0, gray);
1011	dist = (double)((xx) + (yy)) / maxDist;
1012	intensity = cos((angle+(rotatedistPI)) * freq) *
1013	gray * saturate;
1014	intensity = (MAX(MIN(intensity,1.0),-1.0) + 1.0) * 0.5;
1015	hue = (angle + PI) * INV_PI_360 + aoffset;
1016	s = gray * ((double)(ABS(x)+ABS(y)) / (double)(hw + hh));
1017	s = MIN(MAX(s,0.0), 1.0);
1018	v = MIN(MAX(intensity,0.0), 1.0);
1019
1020	if (s == 0.0) {
1021	ch = (uch)(v * 255.0);
1022	*dest++ = ch;
1023	*dest++ = ch;
1024	*dest++ = ch;
1025	} else {
1026	if ((hue < 0.0) \|\| (hue >= 360.0))
1027	hue -= (((int)(hue / 360.0)) * 360.0);
1028	hue /= 60.0;
1029	ii = (int)hue;
1030	f = hue - (double)ii;
1031	p = (1.0 - s) * v;
1032	q = (1.0 - (s * f)) * v;
1033	t = (1.0 - (s * (1.0 - f))) * v;
1034	if (ii == 0) { red = v; green = t; blue = p; }
1035	else if (ii == 1) { red = q; green = v; blue = p; }
1036	else if (ii == 2) { red = p; green = v; blue = t; }
1037	else if (ii == 3) { red = p; green = q; blue = v; }
1038	else if (ii == 4) { red = t; green = p; blue = v; }
1039	else if (ii == 5) { red = v; green = p; blue = q; }
1040	dest++ = (uch)(red 255.0);
1041	dest++ = (uch)(green 255.0);
1042	dest++ = (uch)(blue 255.0);
1043	}
1044	}
1045	}
1046	fprintf(stderr, "done.\n");
1047	fflush(stderr);
1048	}
1049
1050	/*---------------------------------------------------------------------------
1051	Blast background image to display buffer before beginning PNG decode;
1052	calling function will handle invalidation and UpdateWindow() call.
1053	---------------------------------------------------------------------------*/
1054
1055	for (row = 0; row < rpng2_info.height; ++row) {
1056	src = bg_data + row*bg_rowbytes;
1057	dest = wimage_data + row*wimage_rowbytes;
1058	for (i = rpng2_info.width; i > 0; --i) {
1059	r1 = *src++;
1060	g1 = *src++;
1061	b1 = *src++;
1062	*dest++ = b1;
1063	dest++ = g1; / note reverse order */
1064	*dest++ = r1;
1065	}
1066	}
1067
1068	return 0;
1069
1070	} /* end function rpng2_win_load_bg_image() */
1071
1072
1073
1074
1075
1076	static void rpng2_win_display_row(ulg row)
1077	{
1078	uch bg_red = rpng2_info.bg_red;
1079	uch bg_green = rpng2_info.bg_green;
1080	uch bg_blue = rpng2_info.bg_blue;
1081	uch src, src2=NULL, *dest;
1082	uch r, g, b, a;
1083	ulg i;
1084	static int rows=0;
1085	static ulg firstrow;
1086
1087	/*---------------------------------------------------------------------------
1088	rows and firstrow simply track how many rows (and which ones) have not
1089	yet been displayed; alternatively, we could call InvalidateRect() for
1090	every row and not bother with the records-keeping.
1091	---------------------------------------------------------------------------*/
1092
1093	Trace((stderr, "beginning rpng2_win_display_row()\n"))
1094
1095	if (rows == 0)
1096	firstrow = row; /* first row not yet displayed */
1097
1098	++rows; /* count of rows received but not yet displayed */
1099
1100	/*---------------------------------------------------------------------------
1101	Aside from the use of the rpng2_info struct and the lack of an outer
1102	loop (over rows), this routine is identical to rpng_win_display_image()
1103	in the non-progressive version of the program.
1104	---------------------------------------------------------------------------*/
1105
1106	src = rpng2_info.image_data + row*rpng2_info.rowbytes;
1107	if (bg_image)
1108	src2 = bg_data + row*bg_rowbytes;
1109	dest = wimage_data + row*wimage_rowbytes;
1110
1111	if (rpng2_info.channels == 3) {
1112	for (i = rpng2_info.width; i > 0; --i) {
1113	r = *src++;
1114	g = *src++;
1115	b = *src++;
1116	*dest++ = b;
1117	dest++ = g; / note reverse order */
1118	*dest++ = r;
1119	}
1120	} else /* if (rpng2_info.channels == 4) */ {
1121	for (i = rpng2_info.width; i > 0; --i) {
1122	r = *src++;
1123	g = *src++;
1124	b = *src++;
1125	a = *src++;
1126	if (bg_image) {
1127	bg_red = *src2++;
1128	bg_green = *src2++;
1129	bg_blue = *src2++;
1130	}
1131	if (a == 255) {
1132	*dest++ = b;
1133	*dest++ = g;
1134	*dest++ = r;
1135	} else if (a == 0) {
1136	*dest++ = bg_blue;
1137	*dest++ = bg_green;
1138	*dest++ = bg_red;
1139	} else {
1140	/* this macro (copied from png.h) composites the
1141	* foreground and background values and puts the
1142	* result into the first argument; there are no
1143	* side effects with the first argument */
1144	alpha_composite(*dest++, b, a, bg_blue);
1145	alpha_composite(*dest++, g, a, bg_green);
1146	alpha_composite(*dest++, r, a, bg_red);
1147	}
1148	}
1149	}
1150
1151	/*---------------------------------------------------------------------------
1152	Display after every 16 rows or when on last row. (Region may include
1153	previously displayed lines due to interlacing--i.e., not contiguous.)
1154	---------------------------------------------------------------------------*/
1155
1156	if ((rows & 0xf) == 0 \|\| row == rpng2_info.height-1) {
1157	RECT rect;
1158
1159	rect.left = 0L;
1160	rect.top = (LONG)firstrow;
1161	rect.right = (LONG)rpng2_info.width; /* possibly off by one? */
1162	rect.bottom = (LONG)row + 1L; /* possibly off by one? */
1163	InvalidateRect(global_hwnd, &rect, FALSE);
1164	UpdateWindow(global_hwnd); /* similar to XFlush() */
1165	rows = 0;
1166	}
1167
1168	} /* end function rpng2_win_display_row() */
1169
1170
1171
1172
1173
1174	static void rpng2_win_finish_display()
1175	{
1176	Trace((stderr, "beginning rpng2_win_finish_display()\n"))
1177
1178	/* last row has already been displayed by rpng2_win_display_row(), so
1179	* we have nothing to do here except set a flag and let the user know
1180	* that the image is done */
1181
1182	rpng2_info.state = kDone;
1183	printf(
1184	#ifndef __CYGWIN__
1185	"Done. Press Q, Esc or mouse button 1 (within image window) to quit.\n"
1186	#else
1187	"Done. Press mouse button 1 (within image window) to quit.\n"
1188	#endif
1189	);
1190	fflush(stdout);
1191	}
1192
1193
1194
1195
1196
1197	static void rpng2_win_cleanup()
1198	{
1199	if (bg_image && bg_data) {
1200	free(bg_data);
1201	bg_data = NULL;
1202	}
1203
1204	if (rpng2_info.image_data) {
1205	free(rpng2_info.image_data);
1206	rpng2_info.image_data = NULL;
1207	}
1208
1209	if (rpng2_info.row_pointers) {
1210	free(rpng2_info.row_pointers);
1211	rpng2_info.row_pointers = NULL;
1212	}
1213
1214	if (dib) {
1215	free(dib);
1216	dib = NULL;
1217	}
1218	}
1219
1220
1221
1222
1223
1224	LRESULT CALLBACK rpng2_win_wndproc(HWND hwnd, UINT iMsg, WPARAM wP, LPARAM lP)
1225	{
1226	HDC hdc;
1227	PAINTSTRUCT ps;
1228	int rc;
1229
1230	switch (iMsg) {
1231	case WM_CREATE:
1232	/* one-time processing here, if any */
1233	return 0;
1234
1235	case WM_PAINT:
1236	hdc = BeginPaint(hwnd, &ps);
1237	rc = StretchDIBits(hdc, 0, 0, rpng2_info.width, rpng2_info.height,
1238	0, 0, rpng2_info.width, rpng2_info.height,
1239	wimage_data, (BITMAPINFO *)bmih,
1240	0, SRCCOPY);
1241	EndPaint(hwnd, &ps);
1242	return 0;
1243
1244	/* wait for the user to tell us when to quit */
1245	case WM_CHAR:
1246	switch (wP) { /* only need one, so ignore repeat count */
1247	case 'q':
1248	case 'Q':
1249	case 0x1B: /* Esc key */
1250	PostQuitMessage(0);
1251	}
1252	return 0;
1253
1254	case WM_LBUTTONDOWN: /* another way of quitting */
1255	case WM_DESTROY:
1256	PostQuitMessage(0);
1257	return 0;
1258	}
1259
1260	return DefWindowProc(hwnd, iMsg, wP, lP);
1261	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/libpng-1.6.37/contrib/gregbook/rpng2-win.c@ 103025

以其他格式下載: