[ViewVC] Diff of: cvs/CV/CV.xs

Comparing CV/CV.xs (file contents):
Revision 1.33 by root, Fri Feb 17 08:48:06 2006 UTC vs.
Revision 1.59 by root, Sat Apr 10 03:32:09 2021 UTC

…		…
7	#include <math.h>	7	#include <math.h>
8		8
9	#include <magic.h>	9	#include <magic.h>
10		10
11	#include <jpeglib.h>	11	#include <jpeglib.h>
		12	#include <jerror.h>
		13
12	#include <glib.h>	14	#include <glib.h>
13	#include <gtk/gtk.h>	15	#include <gtk/gtk.h>
		16	#include <gdk/gdkx.h>
14	#include <gdk-pixbuf/gdk-pixbuf.h>	17	#include <gdk-pixbuf/gdk-pixbuf.h>
15		18
16	#include <gperl.h>	19	#include <gperl.h>
17	#include <gtk2perl.h>	20	#include <gtk2perl.h>
18		21
		22	#include <assert.h>
		23
		24	#if WEBP
		25	#include <webp/demux.h>
		26	#include <webp/decode.h>
		27	#endif
		28
		29	#if JXL
		30	#include <jxl/decode.h>
		31	#include "jxl/thread_parallel_runner.h"
		32	#endif
		33
		34	#include "perlmulticore.h"
		35
19	#define IW 80 /* MUST match Schnauzer.pm! */	36	#define IW 80 /* MUST match Schnauzer.pm! */
20	#define IH 60 /* MUST match Schnauzer.pm! */	37	#define IH 60 /* MUST match Schnauzer.pm! */
21		38
22	#define RAND (seed = (seed + 7141) * 54773 % 134456)
23
24	#define LINELENGTH 240	39	#define LINELENGTH 240
25		40
26	#define ELLIPSIS "\xe2\x80\xa6"	41	#define ELLIPSIS "\xe2\x80\xa6"
		42
		43	typedef char *octet_string;
		44
		45	static magic_t magic_cookie[2]; /* !mime, mime */
27		46
28	struct jpg_err_mgr	47	struct jpg_err_mgr
29	{	48	{
30	struct jpeg_error_mgr err;	49	struct jpeg_error_mgr err;
31	jmp_buf setjmp_buffer;	50	jmp_buf setjmp_buffer;
32	};	51	};
33		52
34	static void	53	static void
35	cv_error_exit (j_common_ptr cinfo)	54	cv_error_exit (j_common_ptr cinfo)
36	{	55	{
		56	cinfo->err->output_message (cinfo);
37	longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);	57	longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);
38	}	58	}
39		59
40	static void	60	static void
41	cv_error_output (j_common_ptr cinfo)	61	cv_error_output (j_common_ptr cinfo)
42	{	62	{
		63	char msg[JMSG_LENGTH_MAX];
		64
		65	cinfo->err->format_message (cinfo, msg);
		66
		67	fprintf (stderr, "JPEG decoding error: %s\n", msg);
43	return;	68	return;
44	}	69	}
45		70
46	static void	71	static void
47	rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b,	72	rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b,
…		…
68		93
69	*h &= 255;	94	*h &= 255;
70	}	95	}
71	}	96	}
72		97
		98	struct feature {
		99	float v1, v2, v3; // mean, square, cube
		100	int n;
		101	};
		102
		103	static void
		104	feature_init (struct feature *f)
		105	{
		106	f->v1 = 0.;
		107	f->v2 = 0.;
		108	f->v3 = 0.;
		109	f->n = 0;
		110	}
		111
		112	// didn't find an algorithm to neatly do mean, variance and skew in one pass.
		113	// elmex ist schuld.
		114	static void
		115	feature_update_pass_1 (struct feature *f, unsigned int v)
		116	{
		117	f->v1 += v;
		118	f->n += 1;
		119	}
		120
		121	static void
		122	feature_finish_pass_1 (struct feature *f)
		123	{
		124	if (f->n < 1)
		125	return;
		126
		127	f->v1 /= f->n;
		128	}
		129
		130	static void
		131	feature_update_pass_2 (struct feature *f, unsigned int v)
		132	{
		133	float d = v - f->v1;
		134
		135	f->v2 += d * d;
		136	f->v3 += d * d * d;
		137	}
		138
		139	static void
		140	feature_finish_pass_2 (struct feature *f)
		141	{
		142	if (f->n < 1)
		143	return;
		144
		145	f->v2 /= f->n;
		146	f->v3 /= f->n;
		147
		148	f->v1 /= 255.;
		149	f->v2 /= 255. * 255.; f->v2 = sqrtf (f->v2);
		150	f->v3 /= 255. * 255. * 255.; f->v3 = powf (fabsf (f->v3), 1./3.);
		151	}
		152
73	static guint32 a85_val;	153	static guint32 a85_val;
74	static guint a85_cnt;	154	static guint a85_cnt;
75	static guchar a85_buf[LINELENGTH], *a85_ptr;	155	static guchar a85_buf[LINELENGTH], *a85_ptr;
76		156
77	static void	157	static void
…		…
89	if (!--a85_cnt)	169	if (!--a85_cnt)
90	{	170	{
91	a85_cnt = 4;	171	a85_cnt = 4;
92	if (a85_val)	172	if (a85_val)
93	{	173	{
94	a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;	174	a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
95	a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;	175	a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
96	a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;	176	a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
97	a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;	177	a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
98	a85_ptr[0] = (a85_val ) + 33;	178	a85_ptr[0] = (a85_val ) + 33;
99		179
100	a85_ptr += 5;	180	a85_ptr += 5;
101	}	181	}
…		…
124		204
125	PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);	205	PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
126	}	206	}
127		207
128	/////////////////////////////////////////////////////////////////////////////	208	/////////////////////////////////////////////////////////////////////////////
		209	// memory source for libjpeg
		210
		211	static void cv_ms_init (j_decompress_ptr cinfo)
		212	{
		213	}
		214
		215	static void cv_ms_term (j_decompress_ptr cinfo)
		216	{
		217	}
		218
		219	static boolean cv_ms_fill (j_decompress_ptr cinfo)
		220	{
		221	// unexpected EOF, warn and generate fake EOI marker
		222
		223	WARNMS (cinfo, JWRN_JPEG_EOF);
		224
		225	struct jpeg_source_mgr src = (struct jpeg_source_mgr )cinfo->src;
		226
		227	static const JOCTET eoi[] = { 0xFF, JPEG_EOI };
		228
		229	src->next_input_byte = eoi;
		230	src->bytes_in_buffer = sizeof (eoi);
		231
		232	return TRUE;
		233	}
		234
		235	static void cv_ms_skip (j_decompress_ptr cinfo, long num_bytes)
		236	{
		237	struct jpeg_source_mgr src = (struct jpeg_source_mgr )cinfo->src;
		238
		239	src->next_input_byte += num_bytes;
		240	src->bytes_in_buffer -= num_bytes;
		241	}
		242
		243	static void cv_jpeg_mem_src (j_decompress_ptr cinfo, void *buf, size_t buflen)
		244	{
		245	struct jpeg_source_mgr *src;
		246
		247	if (!cinfo->src)
		248	cinfo->src = (struct jpeg_source_mgr *)
		249	(*cinfo->mem->alloc_small) (
		250	(j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof (struct jpeg_source_mgr)
		251	);
		252
		253	src = (struct jpeg_source_mgr *)cinfo->src;
		254	src->init_source = cv_ms_init;
		255	src->fill_input_buffer = cv_ms_fill;
		256	src->skip_input_data = cv_ms_skip;
		257	src->resync_to_restart = jpeg_resync_to_restart;
		258	src->term_source = cv_ms_term;
		259	src->next_input_byte = (JOCTET *)buf;
		260	src->bytes_in_buffer = buflen;
		261	}
		262
		263	/////////////////////////////////////////////////////////////////////////////
		264
		265	/* great, the jpeg-xl reference implementaton requires us to parse bmff files */
		266
		267	struct bmff_box
		268	{
		269	char type[4];
		270	const uint8_t *ptr;
		271	size_t size;
		272	};
		273
		274	static int
		275	bmff_parse_box (struct bmff_box box, const uint8_t next_in, size_t avail_in)
		276	{
		277	if (*avail_in < 8)
		278	return 0;
		279
		280	box->size = ((*next_in)[0] << 24)
		281	\| ((*next_in)[1] << 16)
		282	\| ((*next_in)[2] << 8)
		283	\| ((*next_in)[3] );
		284
		285	if (box->size < 8)
		286	return 0;
		287
		288	if (*avail_in < box->size)
		289	return 0;
		290
		291	memcpy (box->type, *next_in + 4, 4);
		292	box->ptr = *next_in + 8;
		293
		294	*next_in += box->size;
		295	*avail_in -= box->size;
		296
		297	box->size -= 8;
		298
		299	return 1;
		300	}
		301
		302	/////////////////////////////////////////////////////////////////////////////
129		303
130	MODULE = Gtk2::CV PACKAGE = Gtk2::CV	304	MODULE = Gtk2::CV PACKAGE = Gtk2::CV
131		305
132	PROTOTYPES: ENABLE	306	PROTOTYPES: ENABLE
133		307
		308	# calculate the common prefix length of two strings
134	# missing function in perl. really :)	309	# missing function in perl. really :)
135	int	310	int
136	common_prefix_length (a, b)	311	common_prefix_length (a, b)
137	unsigned char a = (unsigned char )SvPVutf8_nolen ($arg);	312	unsigned char a = (unsigned char )SvPVutf8_nolen ($arg);
138	unsigned char b = (unsigned char )SvPVutf8_nolen ($arg);	313	unsigned char b = (unsigned char )SvPVutf8_nolen ($arg);
…		…
147		322
148	OUTPUT:	323	OUTPUT:
149	RETVAL	324	RETVAL
150		325
151	const char *	326	const char *
152	magic (const char *path)	327	magic (SV *path_or_data)
		328	ALIAS:
		329	magic = 0
		330	magic_mime = 1
		331	magic_buffer = 2
		332	magic_buffer_mime = 3
153	CODE:	333	CODE:
154	{	334	{
155	static magic_t cookie;	335	STRLEN len;
		336	char *data = SvPVbyte (path_or_data, len);
156		337
157	if (!cookie)	338	if (!magic_cookie[0])
		339	{
		340	magic_cookie[0] = magic_open (MAGIC_SYMLINK);
		341	magic_cookie[1] = magic_open (MAGIC_SYMLINK \| MAGIC_MIME_TYPE);
		342	magic_load (magic_cookie[0], 0);
		343	magic_load (magic_cookie[1], 0);
158	{	344	}
159	cookie = magic_open (MAGIC_NONE);
160		345
161	if (cookie)	346	perlinterp_release ();
162	magic_load (cookie, 0);
163	else
164	XSRETURN_UNDEF;
165	}
166		347
167	RETVAL = magic_file (cookie, path);	348	RETVAL = ix & 2
		349	? magic_buffer (magic_cookie[ix & 1], data, len)
		350	: magic_file (magic_cookie[ix & 1], data);
		351
		352	perlinterp_acquire ();
168	}	353	}
169	OUTPUT:	354	OUTPUT:
170	RETVAL	355	RETVAL
171		356
172	const char *
173	magic_mime (const char *path)
174	CODE:
175	{
176	static magic_t cookie;
177
178	if (!cookie)
179	{
180	cookie = magic_open (MAGIC_MIME);
181
182	if (cookie)
183	magic_load (cookie, 0);
184	else
185	XSRETURN_UNDEF;
186	}
187
188	RETVAL = magic_file (cookie, path);
189	}
190	OUTPUT:
191	RETVAL
192
193	# missing in Gtk2 perl module	357	# missing/broken in Gtk2 perl module
		358
		359	void
		360	gdk_window_clear_hints (GdkWindow *window)
		361	CODE:
		362	gdk_window_set_geometry_hints (window, 0, 0);
194		363
195	gboolean	364	gboolean
196	gdk_net_wm_supports (GdkAtom property)	365	gdk_net_wm_supports (GdkAtom property)
197	CODE:	366	CODE:
198	#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE)	367	#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE)
…		…
204	RETVAL	373	RETVAL
205		374
206	GdkPixbuf_noinc *	375	GdkPixbuf_noinc *
207	dealpha_expose (GdkPixbuf *pb)	376	dealpha_expose (GdkPixbuf *pb)
208	CODE:	377	CODE:
		378	perlinterp_release ();
209	{	379	{
210	int w = gdk_pixbuf_get_width (pb);	380	int w = gdk_pixbuf_get_width (pb);
211	int h = gdk_pixbuf_get_height (pb);	381	int h = gdk_pixbuf_get_height (pb);
212	int bpp = gdk_pixbuf_get_n_channels (pb);	382	int bpp = gdk_pixbuf_get_n_channels (pb);
213	int x, y, i;	383	int x, y, i;
…		…
222	for (x = 0; x < w; x++)	392	for (x = 0; x < w; x++)
223	for (y = 0; y < h; y++)	393	for (y = 0; y < h; y++)
224	for (i = 0; i < 3; i++)	394	for (i = 0; i < 3; i++)
225	dst[x * 3 + y * dstr + i] = src[x * bpp + y * sstr + i];	395	dst[x * 3 + y * dstr + i] = src[x * bpp + y * sstr + i];
226	}	396	}
		397	perlinterp_acquire ();
227	OUTPUT:	398	OUTPUT:
228	RETVAL	399	RETVAL
229		400
230	GdkPixbuf_noinc *	401	GdkPixbuf_noinc *
231	rotate (GdkPixbuf *pb, int angle)	402	rotate (GdkPixbuf *pb, int angle)
232	CODE:	403	CODE:
		404	perlinterp_release ();
		405	if (angle < 0)
		406	angle += 360;
233	RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE	407	RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE
234	: angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE	408	: angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
235	: angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN	409	: angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN
236	: angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE	410	: angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE
237	: angle);	411	: angle);
		412	perlinterp_acquire ();
238	OUTPUT:	413	OUTPUT:
239	RETVAL	414	RETVAL
240		415
		416	const char *
		417	filetype (SV *image_data)
		418	CODE:
		419	{
		420	STRLEN data_len;
		421	U8 *data = SvPVbyte (image_data, data_len);
		422	static const unsigned char jxl_header[] = {
		423	0, 0, 0, 0x0c, 0x4a, 0x58, 0x4c, 0x20,
		424	0x0d, 0xa, 0x87, 0x0a, 0, 0, 0, 0x14,
		425	0x66, 0x74, 0x79, 0x70, 0x6a, 0x78, 0x6c, 0x20,
		426	0, 0, 0, 0, 0x6a, 0x78, 0x6c, 0x20,
		427	};
		428
		429	if (data_len >= 20
		430	&& data[0] == 0xff
		431	&& data[1] == 0xd8
		432	&& data[2] == 0xff)
		433	RETVAL = "image/jpeg";
		434	else if (data_len >= 12
		435	&& data[ 0] == (U8)'R'
		436	&& data[ 1] == (U8)'I'
		437	&& data[ 2] == (U8)'F'
		438	&& data[ 3] == (U8)'F'
		439	&& data[ 8] == (U8)'W'
		440	&& data[ 9] == (U8)'E'
		441	&& data[10] == (U8)'B'
		442	&& data[11] == (U8)'P')
		443	RETVAL = "image/webp";
		444	else if (data_len >= 16
		445	&& data[ 0] == 0x89
		446	&& data[ 1] == (U8)'P'
		447	&& data[ 2] == (U8)'N'
		448	&& data[ 3] == (U8)'G'
		449	&& data[ 4] == 0x0d
		450	&& data[ 5] == 0x0a
		451	&& data[ 6] == 0x1a
		452	&& data[ 7] == 0x0a)
		453	RETVAL = "image/png";
		454	else if (data_len >= sizeof (jxl_header) && memcmp (data, jxl_header, sizeof (jxl_header)) == 0)
		455	RETVAL = "image/jxl";
		456	else
		457	XSRETURN_UNDEF;
		458	}
		459	OUTPUT:
		460	RETVAL
		461
241	GdkPixbuf_noinc *	462	GdkPixbuf_noinc *
242	load_jpeg (SV *path, int thumbnail=0)	463	decode_webp (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
		464	CODE:
		465	{
		466	#if WEBP
		467	STRLEN data_size;
		468	int alpha;
		469	WebPData data;
		470	WebPDemuxer *demux;
		471	WebPIterator iter;
		472	WebPDecoderConfig config;
		473	int inw, inh;
		474
		475	data.bytes = (uint8_t *)SvPVbyte (image_data, data_size);
		476	data.size = data_size;
		477
		478	perlinterp_release ();
		479
		480	RETVAL = 0;
		481
		482	if (!(demux = WebPDemux (&data)))
		483	goto err_demux;
		484
		485	if (!WebPDemuxGetFrame (demux, 1, &iter))
		486	goto err_iter;
		487
		488	if (!WebPInitDecoderConfig (&config))
		489	goto err_iter;
		490
		491	config.options.use_threads = 1;
		492
		493	if (WebPGetFeatures (iter.fragment.bytes, iter.fragment.size, &config.input) != VP8_STATUS_OK)
		494	goto err_iter;
		495
		496	inw = config.input.width;
		497	inh = config.input.height;
		498
		499	if (thumbnail)
		500	{
		501	if (inw * ih > inh * iw)
		502	ih = (iw * inh + inw - 1) / inw;
		503	else
		504	iw = (ih * inw + inh - 1) / inh;
		505
		506	config.options.bypass_filtering = 1;
		507	config.options.no_fancy_upsampling = 1;
		508
		509	config.options.use_scaling = 1;
		510	config.options.scaled_width = iw;
		511	config.options.scaled_height = ih;
		512	}
		513	else
		514	{
		515	iw = inw;
		516	ih = inh;
		517	}
		518
		519	alpha = !!config.input.has_alpha;
		520
		521	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, alpha, 8, iw, ih);
		522	if (!RETVAL)
		523	goto err_iter;
		524
		525	config.output.colorspace = alpha ? MODE_RGBA : MODE_RGB;
		526	config.output.u.RGBA.rgba = gdk_pixbuf_get_pixels (RETVAL);
		527	config.output.u.RGBA.stride = gdk_pixbuf_get_rowstride (RETVAL);
		528	config.output.u.RGBA.size = gdk_pixbuf_get_byte_length (RETVAL);
		529	config.output.is_external_memory = 1;
		530
		531	if (WebPDecode (iter.fragment.bytes, iter.fragment.size, &config) != VP8_STATUS_OK)
		532	{
		533	g_object_unref (RETVAL);
		534	RETVAL = 0;
		535	goto err_iter;
		536	}
		537
		538	err_iter:
		539	WebPDemuxReleaseIterator (&iter);
		540	err_demux:
		541	WebPDemuxDelete (demux);
		542
		543	perlinterp_acquire ();
		544	#else
		545	croak ("load_webp: webp not enabled at compile time");
		546	#endif
		547	}
		548	OUTPUT:
		549	RETVAL
		550
		551	GdkPixbuf_noinc *
		552	decode_jxl (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
		553	CODE:
		554	{
		555	#if JXL
		556	JxlDecoder *dec = JxlDecoderCreate (0);
		557	JxlBasicInfo info;
		558	const uint8_t next_in = (uint8_t )SvPVbyte_nolen (image_data);
		559	size_t avail_in = SvCUR (image_data);
		560	const char *error = 0;
		561	void *runner = 0;
		562	struct bmff_box box;
		563
		564	perlinterp_release ();
		565
		566	RETVAL = 0;
		567
		568	error = "JxlDecoderCreate failed";
		569	if (!dec)
		570	goto done;
		571
		572	runner = JxlThreadParallelRunnerCreate (0, JxlThreadParallelRunnerDefaultNumWorkerThreads ());
		573
		574	error = "JxlDecoderSetParallelRunner failed";
		575	if (JxlDecoderSetParallelRunner (dec, JxlThreadParallelRunner, runner) != JXL_DEC_SUCCESS)
		576	goto done;
		577
		578	error = "JxlDecoderSubscribeEvents failed";
		579	if (JxlDecoderSubscribeEvents (dec, JXL_DEC_FULL_IMAGE \| JXL_DEC_BASIC_INFO) != JXL_DEC_SUCCESS)
		580	goto done;
		581
		582	error = "JxlDecoderSetInput failed";
		583	if (JxlDecoderSetInput (dec, next_in, avail_in) != JXL_DEC_SUCCESS)
		584	goto done;
		585
		586	for (;;)
		587	{
		588	JxlDecoderStatus status = JxlDecoderProcessInput (dec);
		589
		590	printf ("status %d\n",status);
		591
		592	switch (status)
		593	{
		594	case JXL_DEC_ERROR:
		595	error = "JxlDecoderProcessInput failed";
		596	goto done;
		597
		598	case JXL_DEC_NEED_MORE_INPUT:
		599	error = "incomplete file";
		600	goto done;
		601
		602	case JXL_DEC_SUCCESS:
		603	goto done;
		604
		605	case JXL_DEC_NEED_IMAGE_OUT_BUFFER:
		606	{
		607	error = "JxlDecoderGetBasicInfo failed";
		608	if (JxlDecoderGetBasicInfo (dec, &info) != JXL_DEC_SUCCESS)
		609	goto done;
		610
		611	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, !!info.alpha_bits, 8, info.xsize, info.ysize);
		612	error = "unable to allocate pixbuf";
		613	if (!RETVAL)
		614	goto done;
		615
		616	JxlPixelFormat format = {
		617	info.alpha_bits ? 4 : 3,
		618	JXL_TYPE_UINT8,
		619	JXL_NATIVE_ENDIAN,
		620	gdk_pixbuf_get_rowstride (RETVAL)
		621	};
		622
		623	error = "JxlDecoderSetImageOutBuffer failed";
		624	if (JxlDecoderSetImageOutBuffer (
		625	dec,
		626	&format,
		627	gdk_pixbuf_get_pixels (RETVAL),
		628	gdk_pixbuf_get_byte_length (RETVAL)
		629	) != JXL_DEC_SUCCESS)
		630	goto done;
		631	}
		632	break;
		633
		634	default:
		635	error = "unexpected event";
		636	goto done;
		637	}
		638	}
		639
		640	done:
		641	if (dec)
		642	JxlDecoderDestroy (dec);
		643
		644	if (runner)
		645	JxlThreadParallelRunnerDestroy (runner);
		646
		647	perlinterp_acquire ();
		648
		649	if (error)
		650	{
		651	if (RETVAL)
		652	g_object_unref (RETVAL);
		653
		654	croak ("load_jxl: %s", error);
		655	}
		656	#else
		657	croak ("load_jxl: jpeg-xl not enabled at compile time");
		658	#endif
		659	}
		660	OUTPUT:
		661	RETVAL
		662
		663	GdkPixbuf_noinc *
		664	decode_jpeg (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
243	CODE:	665	CODE:
244	{	666	{
245	struct jpeg_decompress_struct cinfo;	667	struct jpeg_decompress_struct cinfo;
246	struct jpg_err_mgr jerr;	668	struct jpg_err_mgr jerr;
247	guchar *data;
248	int rs;	669	int rs;
249	FILE *fp;
250	volatile GdkPixbuf *pb = 0;	670	volatile GdkPixbuf *pb = 0;
		671	STRLEN data_len;
		672	guchar *data = SvPVbyte (image_data, data_len);
251		673
252	RETVAL = 0;	674	RETVAL = 0;
253		675
254	fp = fopen (SvPVbyte_nolen (path), "rb");	676	perlinterp_release ();
255
256	if (!fp)
257	XSRETURN_UNDEF;
258		677
259	cinfo.err = jpeg_std_error (&jerr.err);	678	cinfo.err = jpeg_std_error (&jerr.err);
260		679
261	jerr.err.error_exit = cv_error_exit;	680	jerr.err.error_exit = cv_error_exit;
262	jerr.err.output_message = cv_error_output;	681	jerr.err.output_message = cv_error_output;
263		682
264	if ((rs = setjmp (jerr.setjmp_buffer)))	683	if ((rs = setjmp (jerr.setjmp_buffer)))
265	{	684	{
266	fclose (fp);
267	jpeg_destroy_decompress (&cinfo);	685	jpeg_destroy_decompress (&cinfo);
268		686
269	if (pb)	687	if (pb)
270	g_object_unref ((gpointer)pb);	688	g_object_unref ((gpointer)pb);
271		689
		690	perlinterp_acquire ();
272	XSRETURN_UNDEF;	691	XSRETURN_UNDEF;
273	}	692	}
274		693
		694	if (!data_len)
		695	longjmp (jerr.setjmp_buffer, 4);
		696
275	jpeg_create_decompress (&cinfo);	697	jpeg_create_decompress (&cinfo);
		698	cv_jpeg_mem_src (&cinfo, data, data_len);
276		699
277	jpeg_stdio_src (&cinfo, fp);
278	jpeg_read_header (&cinfo, TRUE);	700	jpeg_read_header (&cinfo, TRUE);
279		701
280	cinfo.dct_method = JDCT_DEFAULT;	702	cinfo.dct_method = JDCT_DEFAULT;
281	cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */	703	cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */
282	cinfo.do_block_smoothing = FALSE;	704	cinfo.do_block_smoothing = FALSE;
…		…
292	{	714	{
293	cinfo.dct_method = JDCT_FASTEST;	715	cinfo.dct_method = JDCT_FASTEST;
294	cinfo.do_fancy_upsampling = FALSE;	716	cinfo.do_fancy_upsampling = FALSE;
295		717
296	while (cinfo.scale_denom < 8	718	while (cinfo.scale_denom < 8
297	&& cinfo.output_width >= IW*4	719	&& cinfo.output_width >= iw*4
298	&& cinfo.output_height >= IH*4)	720	&& cinfo.output_height >= ih*4)
299	{	721	{
300	cinfo.scale_denom <<= 1;	722	cinfo.scale_denom <<= 1;
301	jpeg_calc_output_dimensions (&cinfo);	723	jpeg_calc_output_dimensions (&cinfo);
302	}	724	}
303	}	725	}
304		726
		727	if (cinfo.output_components != 3)
		728	longjmp (jerr.setjmp_buffer, 3);
		729
		730	if (cinfo.jpeg_color_space == JCS_YCCK \|\| cinfo.jpeg_color_space == JCS_CMYK)
		731	{
		732	cinfo.out_color_space = JCS_CMYK;
		733	cinfo.output_components = 4;
		734	}
		735
305	pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, cinfo.output_width, cinfo.output_height);	736	pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, cinfo.output_components == 4, 8, cinfo.output_width, cinfo.output_height);
306	if (!RETVAL)	737	if (!RETVAL)
307	longjmp (jerr.setjmp_buffer, 2);	738	longjmp (jerr.setjmp_buffer, 2);
308		739
309	data = gdk_pixbuf_get_pixels (RETVAL);	740	data = gdk_pixbuf_get_pixels (RETVAL);
310	rs = gdk_pixbuf_get_rowstride (RETVAL);	741	rs = gdk_pixbuf_get_rowstride (RETVAL);
311
312	if (cinfo.output_components != 3)
313	longjmp (jerr.setjmp_buffer, 3);
314		742
315	jpeg_start_decompress (&cinfo);	743	jpeg_start_decompress (&cinfo);
316		744
317	while (cinfo.output_scanline < cinfo.output_height)	745	while (cinfo.output_scanline < cinfo.output_height)
318	{	746	{
…		…
325	rp [3] = (guchar *)rp [2] + rs;	753	rp [3] = (guchar *)rp [2] + rs;
326		754
327	jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);	755	jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);
328	}	756	}
329		757
		758	if (cinfo.out_color_space == JCS_CMYK)
		759	{
		760	guchar end = data + cinfo.output_height rs;
		761
		762	while (data < end)
		763	{
		764	U32 c = data [0];
		765	U32 m = data [1];
		766	U32 y = data [2];
		767	U32 k = data [3];
		768
		769	if (0)
		770	if (cinfo.Adobe_transform == 2)
		771	{
		772	c ^= 0xff;
		773	m ^= 0xff;
		774	y ^= 0xff;
		775	k ^= 0xff;
		776	}
		777
		778	data [0] = (c * k + 0x80) / 0xff;
		779	data [1] = (m * k + 0x80) / 0xff;
		780	data [2] = (y * k + 0x80) / 0xff;
		781	data [3] = 0xff;
		782
		783	data += 4;
		784	}
		785	}
		786
330	jpeg_finish_decompress (&cinfo);	787	jpeg_finish_decompress (&cinfo);
331	fclose (fp);
332	jpeg_destroy_decompress (&cinfo);	788	jpeg_destroy_decompress (&cinfo);
		789	perlinterp_acquire ();
333	}	790	}
334	OUTPUT:	791	OUTPUT:
335	RETVAL	792	RETVAL
336		793
337	void	794	void
338	compare (GdkPixbuf a, GdkPixbuf b)	795	compare (GdkPixbuf a, GdkPixbuf b)
339	PPCODE:	796	PPCODE:
		797	perlinterp_release ();
340	{	798	{
341	int w = gdk_pixbuf_get_width (a);	799	int w = gdk_pixbuf_get_width (a);
342	int h = gdk_pixbuf_get_height (a);	800	int h = gdk_pixbuf_get_height (a);
		801
343	int sa = gdk_pixbuf_get_rowstride (a);	802	int sa = gdk_pixbuf_get_rowstride (a);
344	int sb = gdk_pixbuf_get_rowstride (b);	803	int sb = gdk_pixbuf_get_rowstride (b);
345		804
346	guchar *pa = gdk_pixbuf_get_pixels (a);	805	guchar *pa = gdk_pixbuf_get_pixels (a);
347	guchar *pb = gdk_pixbuf_get_pixels (b);	806	guchar *pb = gdk_pixbuf_get_pixels (b);
…		…
355	assert (gdk_pixbuf_get_n_channels (b) == 3);	814	assert (gdk_pixbuf_get_n_channels (b) == 3);
356		815
357	double diff = 0.;	816	double diff = 0.;
358	int peak = 0;	817	int peak = 0;
359		818
		819	if (w && h)
360	for (y = 0; y < h; y++)	820	for (y = 0; y < h; y++)
361	{	821	{
362	guchar pa_ = pa + y sa;	822	guchar pa_ = pa + y sa;
363	guchar pb_ = pb + y sb;	823	guchar pb_ = pb + y sb;
364		824
365	for (x = 0; x < w; x ++)	825	for (x = 0; x < w; x++)
366	{	826	{
367	int d;	827	int d;
368		828
369	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));	829	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));
370	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));	830	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));
371	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));	831	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));
372	}	832	}
373	}	833	}
		834
		835	perlinterp_acquire ();
374		836
375	EXTEND (SP, 2);	837	EXTEND (SP, 2);
376	PUSHs (sv_2mortal (newSVnv (sqrt (diff / (w * h * 3. * 255. * 255.)))));	838	PUSHs (sv_2mortal (newSVnv (sqrt (diff / (w * h * 3. * 255. * 255.)))));
377	PUSHs (sv_2mortal (newSVnv (peak / 255.)));	839	PUSHs (sv_2mortal (newSVnv (peak / 255.)));
378	}	840	}
379		841
380	#############################################################################	842	#############################################################################
381		843
382	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer	844	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer
383		845
		846	# currently only works for filenames (octet strings)
		847
384	SV *	848	SV *
385	foldcase (SV *pathsv)	849	foldcase (SV *pathsv)
386	PROTOTYPE: $	850	PROTOTYPE: $
387	CODE:	851	CODE:
388	{	852	{
389	STRLEN plen;	853	STRLEN plen;
390	U8 path = (U8 )SvPVutf8 (pathsv, plen);	854	U8 path = (U8 )SvPV (pathsv, plen);
391	U8 *pend = path + plen;	855	U8 *pend = path + plen;
392	U8 dst [plen * 6 * 3], *dstp = dst;	856	U8 dst [plen * 6 * 3], *dstp = dst;
393		857
394	while (path < pend)	858	while (path < pend)
395	{	859	{
396	U8 ch = *path;	860	U8 ch = *path;
397		861
398	if (ch >= 'a' && ch <= 'z')	862	if (ch >= 'a' && ch <= 'z')
399	dstp++ = path++;	863	dstp++ = path++;
		864	else if (ch >= 'A' && ch <= 'Z')
		865	dstp++ = path++ + ('a' - 'A');
400	else if (ch >= '0' && ch <= '9')	866	else if (ch >= '0' && ch <= '9')
401	{	867	{
402	STRLEN el, nl = 0;	868	STRLEN el, nl = 0;
403	while (path >= '0' && path <= '9' && path < pend)	869	while (path >= '0' && path <= '9' && path < pend)
404	path++, nl++;	870	path++, nl++;
…		…
407	*dstp++ = '0';	873	*dstp++ = '0';
408		874
409	memcpy (dstp, path - nl, nl);	875	memcpy (dstp, path - nl, nl);
410	dstp += nl;	876	dstp += nl;
411	}	877	}
		878	else
		879	dstp++ = path++;
		880	#if 0
412	else	881	else
413	{	882	{
414	STRLEN cl;	883	STRLEN cl;
415	to_utf8_fold (path, dstp, &cl);	884	to_utf8_fold (path, dstp, &cl);
416	dstp += cl;	885	dstp += cl;
417	path += is_utf8_char (path);	886	path += is_utf8_char (path);
418	}	887	}
		888	#endif
419	}	889	}
420		890
421	RETVAL = newSVpvn ((const char *)dst, dstp - dst);	891	RETVAL = newSVpvn ((const char *)dst, dstp - dst);
422	}	892	}
423	OUTPUT:	893	OUTPUT:
…		…
585	#############################################################################	1055	#############################################################################
586		1056
587	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster	1057	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster
588		1058
589	SV *	1059	SV *
590	make_histograms (SV *ar)	1060	extract_features (SV *ar)
591	CODE:	1061	CODE:
592	{	1062	{
593	int i;	1063	int i;
594	AV av, result;	1064	AV av, result;
595		1065
596	if (!SvROK (ar) \|\| SvTYPE (SvRV (ar)) != SVt_PVAV)	1066	if (!SvROK (ar) \|\| SvTYPE (SvRV (ar)) != SVt_PVAV)
597	croak ("Not an array ref as first argument to make_histogram");	1067	croak ("Not an array ref as first argument to extract_features");
598		1068
599	av = (AV *) SvRV (ar);	1069	av = (AV *) SvRV (ar);
600	result = newAV ();	1070	result = newAV ();
601		1071
602	for (i = 0; i <= av_len (av); ++i)	1072	for (i = 0; i <= av_len (av); ++i)
603	{	1073	{
604	const int HISTSIZE = 64;
605
606	int j;
607	SV sv = av_fetch (av, i, 1);	1074	SV sv = av_fetch (av, i, 1);
608	STRLEN len;
609	char *buf = SvPVbyte (sv, len);
610
611	int tmphist[HISTSIZE];
612	float *hist;
613
614	SV histsv = newSV (HISTSIZE sizeof (float) + 1);	1075	SV histsv = newSV (9 sizeof (float) + 1);
		1076
615	SvPOK_on (histsv);	1077	SvPOK_on (histsv);
616	SvCUR_set (histsv, HISTSIZE * sizeof (float));	1078	SvCUR_set (histsv, 9 * sizeof (float));
617	hist = (float *)SvPVX (histsv);	1079	float hist = (float )SvPVX (histsv);
618		1080
619	Zero (tmphist, sizeof (tmphist), char);	1081	struct feature f_h, f_s, f_v;
		1082	feature_init (&f_h);
		1083	feature_init (&f_s);
		1084	feature_init (&f_v);
620		1085
621	for (j = len; j--; )
622	{
623	unsigned int idx
624	= ((*buf & 0xc0) >> 2)
625	\| ((*buf & 0x18) >> 1)
626	\| (*buf & 0x03);
627
628	++tmphist[idx];
629	++buf;
630	}
631		1086	{
632	for (j = 0; j < HISTSIZE; ++j)	1087	STRLEN len;
633	hist[j] = (float)tmphist[j] / (len + 1e-30);	1088	unsigned char buf = (unsigned char )SvPVbyte (sv, len);
		1089	while (len >= 3)
		1090	{
		1091	unsigned int r, g, b, h, s, v;
		1092	r = buf++; g = buf++; b = *buf++;
		1093	rgb_to_hsv (r, g, b, &h, &s, &v);
		1094
		1095	feature_update_pass_1 (&f_h, h);
		1096	feature_update_pass_1 (&f_s, s);
		1097	feature_update_pass_1 (&f_v, v);
		1098
		1099	len -= 3;
		1100	}
		1101
		1102	feature_finish_pass_1 (&f_h);
		1103	feature_finish_pass_1 (&f_s);
		1104	feature_finish_pass_1 (&f_v);
		1105	}
		1106
		1107	{
		1108	STRLEN len;
		1109	unsigned char buf = (unsigned char )SvPVbyte (sv, len);
		1110	while (len >= 3)
		1111	{
		1112	unsigned int r, g, b, h, s, v;
		1113	r = buf++; g = buf++; b = *buf++;
		1114	rgb_to_hsv (r, g, b, &h, &s, &v);
		1115
		1116	feature_update_pass_2 (&f_h, h);
		1117	feature_update_pass_2 (&f_s, s);
		1118	feature_update_pass_2 (&f_v, v);
		1119
		1120	len -= 3;
		1121	}
		1122
		1123	feature_finish_pass_2 (&f_h);
		1124	feature_finish_pass_2 (&f_s);
		1125	feature_finish_pass_2 (&f_v);
		1126	}
		1127
		1128	hist [0] = f_h.v1 * 2.; hist [1] = f_h.v2 * 2.; hist [2] = f_h.v3 * 2.;
		1129	hist [3] = f_s.v1 ; hist [4] = f_s.v2 ; hist [5] = f_s.v3 ;
		1130	hist [6] = f_v.v1 * .5; hist [7] = f_v.v2 * .5; hist [8] = f_v.v3 * .5;
634		1131
635	av_push (result, histsv);	1132	av_push (result, histsv);
636	}	1133	}
637		1134
638	RETVAL = newRV_noinc ((SV *)result);	1135	RETVAL = newRV_noinc ((SV *)result);
639	}	1136	}
640	OUTPUT:	1137	OUTPUT:
641	RETVAL	1138	RETVAL
642		1139
643

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing CV/CV.xs (file contents): Revision 1.33 by root, Fri Feb 17 08:48:06 2006 UTC vs. Revision 1.59 by root, Sat Apr 10 03:32:09 2021 UTC

Diff Legend

Comparing CV/CV.xs (file contents):
Revision 1.33 by root, Fri Feb 17 08:48:06 2006 UTC vs.
Revision 1.59 by root, Sat Apr 10 03:32:09 2021 UTC