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

Comparing CV/CV.xs (file contents):
Revision 1.17 by root, Wed Jul 20 06:20:36 2005 UTC vs.
Revision 1.58 by root, Mon Jan 4 04:49:04 2021 UTC

…		…
1	#include "EXTERN.h"	1	#include "EXTERN.h"
2	#include "perl.h"	2	#include "perl.h"
3	#include "XSUB.h"	3	#include "XSUB.h"
4		4
		5	#include <string.h>
5	#include <setjmp.h>	6	#include <setjmp.h>
		7	#include <math.h>
		8
		9	#include <magic.h>
6		10
7	#include <jpeglib.h>	11	#include <jpeglib.h>
		12	#include <jerror.h>
		13
		14	#include <glib.h>
		15	#include <gtk/gtk.h>
		16	#include <gdk/gdkx.h>
8	#include <gdk-pixbuf/gdk-pixbuf.h>	17	#include <gdk-pixbuf/gdk-pixbuf.h>
9		18
10	#include <gperl.h>	19	#include <gperl.h>
11	#include <gtk2perl.h>	20	#include <gtk2perl.h>
12		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
13	#define IW 80 /* MUST match Schnauer.pm! */	36	#define IW 80 /* MUST match Schnauzer.pm! */
14	#define IH 60 /* MUST match Schnauer.pm! */	37	#define IH 60 /* MUST match Schnauzer.pm! */
15
16	#define RAND (seed = (seed + 7141) * 54773 % 134456)
17		38
18	#define LINELENGTH 240	39	#define LINELENGTH 240
19		40
20	#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 */
21		46
22	struct jpg_err_mgr	47	struct jpg_err_mgr
23	{	48	{
24	struct jpeg_error_mgr err;	49	struct jpeg_error_mgr err;
25	jmp_buf setjmp_buffer;	50	jmp_buf setjmp_buffer;
26	};	51	};
27		52
28	static void	53	static void
29	cv_error_exit (j_common_ptr cinfo)	54	cv_error_exit (j_common_ptr cinfo)
30	{	55	{
		56	cinfo->err->output_message (cinfo);
31	longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);	57	longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);
32	}	58	}
33		59
34	static void	60	static void
35	cv_error_output (j_common_ptr cinfo)	61	cv_error_output (j_common_ptr cinfo)
36	{	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);
37	return;	68	return;
38	}	69	}
39		70
40	static void	71	static void
41	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,
62		93
63	*h &= 255;	94	*h &= 255;
64	}	95	}
65	}	96	}
66		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
67	static guint32 a85_val;	153	static guint32 a85_val;
68	static guint a85_cnt;	154	static guint a85_cnt;
69	static guchar a85_buf[LINELENGTH], *a85_ptr;	155	static guchar a85_buf[LINELENGTH], *a85_ptr;
70		156
71	static void	157	static void
…		…
83	if (!--a85_cnt)	169	if (!--a85_cnt)
84	{	170	{
85	a85_cnt = 4;	171	a85_cnt = 4;
86	if (a85_val)	172	if (a85_val)
87	{	173	{
88	a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;	174	a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
89	a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;	175	a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
90	a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;	176	a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
91	a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;	177	a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
92	a85_ptr[0] = (a85_val ) + 33;	178	a85_ptr[0] = (a85_val ) + 33;
93		179
94	a85_ptr += 5;	180	a85_ptr += 5;
95	}	181	}
…		…
118		204
119	PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);	205	PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
120	}	206	}
121		207
122	/////////////////////////////////////////////////////////////////////////////	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	/////////////////////////////////////////////////////////////////////////////
123		303
124	MODULE = Gtk2::CV PACKAGE = Gtk2::CV	304	MODULE = Gtk2::CV PACKAGE = Gtk2::CV
125		305
126	PROTOTYPES: ENABLE	306	PROTOTYPES: ENABLE
127		307
		308	# calculate the common prefix length of two strings
		309	# missing function in perl. really :)
		310	int
		311	common_prefix_length (a, b)
		312	unsigned char a = (unsigned char )SvPVutf8_nolen ($arg);
		313	unsigned char b = (unsigned char )SvPVutf8_nolen ($arg);
		314	CODE:
		315	RETVAL = 0;
		316
		317	while (a == b && *a)
		318	{
		319	RETVAL += (*a & 0xc0) != 0x80;
		320	a++, b++;
		321	}
		322
		323	OUTPUT:
		324	RETVAL
		325
		326	const char *
		327	magic (SV *path_or_data)
		328	ALIAS:
		329	magic = 0
		330	magic_mime = 1
		331	magic_buffer = 2
		332	magic_buffer_mime = 3
		333	CODE:
		334	{
		335	STRLEN len;
		336	char *data = SvPVbyte (path_or_data, len);
		337
		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);
		344	}
		345
		346	perlinterp_release ();
		347
		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 ();
		353	}
		354	OUTPUT:
		355	RETVAL
		356
		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);
		363
		364	gboolean
		365	gdk_net_wm_supports (GdkAtom property)
		366	CODE:
		367	#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE)
		368	RETVAL = gdk_net_wm_supports (property);
		369	#else
		370	RETVAL = 0;
		371	#endif
		372	OUTPUT:
		373	RETVAL
		374
128	GdkPixbuf_noinc *	375	GdkPixbuf_noinc *
129	transpose (GdkPixbuf *pb)	376	dealpha_expose (GdkPixbuf *pb)
130	CODE:	377	CODE:
		378	perlinterp_release ();
131	{	379	{
132	int w = gdk_pixbuf_get_width (pb);	380	int w = gdk_pixbuf_get_width (pb);
133	int h = gdk_pixbuf_get_height (pb);	381	int h = gdk_pixbuf_get_height (pb);
134	int bpp = gdk_pixbuf_get_n_channels (pb);	382	int bpp = gdk_pixbuf_get_n_channels (pb);
135	int x, y, i;	383	int x, y, i;
136	guchar src = gdk_pixbuf_get_pixels (pb), dst;	384	guchar src = gdk_pixbuf_get_pixels (pb), dst;
137	int sstr = gdk_pixbuf_get_rowstride (pb), dstr;	385	int sstr = gdk_pixbuf_get_rowstride (pb), dstr;
138		386
139	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, h, w);	387	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
140		388
141	dst = gdk_pixbuf_get_pixels (RETVAL);	389	dst = gdk_pixbuf_get_pixels (RETVAL);
142	dstr = gdk_pixbuf_get_rowstride (RETVAL);	390	dstr = gdk_pixbuf_get_rowstride (RETVAL);
143		391
144	for (y = 0; y < h; y++)
145	for (x = 0; x < w; x++)	392	for (x = 0; x < w; x++)
		393	for (y = 0; y < h; y++)
146	for (i = 0; i < bpp; i++)	394	for (i = 0; i < 3; i++)
147	dst[y * bpp + x * dstr + i] = src[x * bpp + y * sstr + i];	395	dst[x * 3 + y * dstr + i] = src[x * bpp + y * sstr + i];
148	}	396	}
		397	perlinterp_acquire ();
149	OUTPUT:	398	OUTPUT:
150	RETVAL	399	RETVAL
151		400
152	GdkPixbuf_noinc *	401	GdkPixbuf_noinc *
153	flop (GdkPixbuf *pb)	402	rotate (GdkPixbuf *pb, int angle)
154	CODE:	403	CODE:
155	{	404	perlinterp_release ();
156	int w = gdk_pixbuf_get_width (pb);	405	if (angle < 0)
157	int h = gdk_pixbuf_get_height (pb);	406	angle += 360;
158	int bpp = gdk_pixbuf_get_n_channels (pb);	407	RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE
159	int x, y, i;	408	: angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
160	guchar src = gdk_pixbuf_get_pixels (pb), dst;	409	: angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN
161	int sstr = gdk_pixbuf_get_rowstride (pb), dstr;	410	: angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE
162		411	: angle);
163	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, w, h);	412	perlinterp_acquire ();
164
165	dst = gdk_pixbuf_get_pixels (RETVAL);
166	dstr = gdk_pixbuf_get_rowstride (RETVAL);
167
168	for (y = 0; y < h; y++)
169	for (x = 0; x < w; x++)
170	for (i = 0; i < bpp; i++)
171	dst[(w - 1 - x) * bpp + y * dstr + i] = src[x * bpp + y * sstr + i];
172	}
173	OUTPUT:	413	OUTPUT:
174	RETVAL	414	RETVAL
175		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
176	GdkPixbuf_noinc *	462	GdkPixbuf_noinc *
177	load_jpeg (char *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 \| 0xffc0) != JXL_DEC_SUCCESS)
		580	goto done;
		581
		582	for (;;)
		583	{
		584	JxlDecoderStatus status = JxlDecoderProcessInput (dec, &next_in, &avail_in);
		585
		586	printf ("status %d\n",status);
		587
		588	switch (status)
		589	{
		590	case JXL_DEC_ERROR:
		591	error = "JxlDecoderProcessInput failed";
		592	goto done;
		593
		594	case JXL_DEC_NEED_MORE_INPUT:
		595	error = "incomplete file";
		596	goto done;
		597
		598	case JXL_DEC_SUCCESS:
		599	goto done;
		600
		601	case JXL_DEC_NEED_IMAGE_OUT_BUFFER:
		602	{
		603	error = "JxlDecoderGetBasicInfo failed";
		604	if (JxlDecoderGetBasicInfo (dec, &info) != JXL_DEC_SUCCESS)
		605	goto done;
		606
		607	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, !!info.alpha_bits, 8, info.xsize, info.ysize);
		608	error = "unable to allocate pixbuf";
		609	if (!RETVAL)
		610	goto done;
		611
		612	JxlPixelFormat format = {
		613	info.alpha_bits ? 4 : 3,
		614	JXL_TYPE_UINT8,
		615	JXL_NATIVE_ENDIAN,
		616	gdk_pixbuf_get_rowstride (RETVAL)
		617	};
		618
		619	error = "JxlDecoderSetImageOutBuffer failed";
		620	if (JxlDecoderSetImageOutBuffer (
		621	dec,
		622	&format,
		623	gdk_pixbuf_get_pixels (RETVAL),
		624	gdk_pixbuf_get_byte_length (RETVAL)
		625	) != JXL_DEC_SUCCESS)
		626	goto done;
		627	}
		628	break;
		629
		630	default:
		631	error = "unexpected event";
		632	goto done;
		633	}
		634	}
		635
		636	done:
		637	if (dec)
		638	JxlDecoderDestroy (dec);
		639
		640	if (runner)
		641	JxlThreadParallelRunnerDestroy (runner);
		642
		643	perlinterp_acquire ();
		644
		645	if (error)
		646	{
		647	if (RETVAL)
		648	g_object_unref (RETVAL);
		649
		650	croak ("load_jxl: %s", error);
		651	}
		652	#else
		653	croak ("load_jxl: jpeg-xl not enabled at compile time");
		654	#endif
		655	}
		656	OUTPUT:
		657	RETVAL
		658
		659	GdkPixbuf_noinc *
		660	decode_jpeg (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
178	CODE:	661	CODE:
179	{	662	{
180	struct jpeg_decompress_struct cinfo;	663	struct jpeg_decompress_struct cinfo;
181	struct jpg_err_mgr jerr;	664	struct jpg_err_mgr jerr;
182	guchar *data;
183	int rs;	665	int rs;
184	FILE *fp;
185	volatile GdkPixbuf *pb = 0;	666	volatile GdkPixbuf *pb = 0;
		667	STRLEN data_len;
		668	guchar *data = SvPVbyte (image_data, data_len);
		669
186	RETVAL = 0;	670	RETVAL = 0;
187		671
188	if (!(fp = fopen (path, "rb")))	672	perlinterp_release ();
189	XSRETURN_UNDEF;
190		673
191	cinfo.err = jpeg_std_error (&jerr.err);	674	cinfo.err = jpeg_std_error (&jerr.err);
192		675
193	jerr.err.error_exit = cv_error_exit;	676	jerr.err.error_exit = cv_error_exit;
194	jerr.err.output_message = cv_error_output;	677	jerr.err.output_message = cv_error_output;
195		678
196	if ((rs = setjmp (jerr.setjmp_buffer)))	679	if ((rs = setjmp (jerr.setjmp_buffer)))
197	{	680	{
198	fclose (fp);
199	jpeg_destroy_decompress (&cinfo);	681	jpeg_destroy_decompress (&cinfo);
200		682
201	if (pb)	683	if (pb)
202	g_object_unref ((gpointer)pb);	684	g_object_unref ((gpointer)pb);
203		685
		686	perlinterp_acquire ();
204	XSRETURN_UNDEF;	687	XSRETURN_UNDEF;
205	}	688	}
206		689
		690	if (!data_len)
		691	longjmp (jerr.setjmp_buffer, 4);
		692
207	jpeg_create_decompress (&cinfo);	693	jpeg_create_decompress (&cinfo);
		694	cv_jpeg_mem_src (&cinfo, data, data_len);
208		695
209	jpeg_stdio_src (&cinfo, fp);
210	jpeg_read_header (&cinfo, TRUE);	696	jpeg_read_header (&cinfo, TRUE);
211		697
212	cinfo.dct_method = JDCT_DEFAULT;	698	cinfo.dct_method = JDCT_DEFAULT;
213	cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */	699	cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */
214	cinfo.do_block_smoothing = FALSE;	700	cinfo.do_block_smoothing = FALSE;
…		…
224	{	710	{
225	cinfo.dct_method = JDCT_FASTEST;	711	cinfo.dct_method = JDCT_FASTEST;
226	cinfo.do_fancy_upsampling = FALSE;	712	cinfo.do_fancy_upsampling = FALSE;
227		713
228	while (cinfo.scale_denom < 8	714	while (cinfo.scale_denom < 8
229	&& (cinfo.output_width >> 1) >= IW	715	&& cinfo.output_width >= iw*4
230	&& (cinfo.output_height >> 1) >= IH)	716	&& cinfo.output_height >= ih*4)
231	{	717	{
232	cinfo.scale_denom <<= 1;	718	cinfo.scale_denom <<= 1;
233	jpeg_calc_output_dimensions (&cinfo);	719	jpeg_calc_output_dimensions (&cinfo);
234	}	720	}
235	}	721	}
236		722
		723	if (cinfo.output_components != 3)
		724	longjmp (jerr.setjmp_buffer, 3);
		725
		726	if (cinfo.jpeg_color_space == JCS_YCCK \|\| cinfo.jpeg_color_space == JCS_CMYK)
		727	{
		728	cinfo.out_color_space = JCS_CMYK;
		729	cinfo.output_components = 4;
		730	}
		731
237	pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, cinfo.output_width, cinfo.output_height);	732	pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, cinfo.output_components == 4, 8, cinfo.output_width, cinfo.output_height);
238	if (!RETVAL)	733	if (!RETVAL)
239	longjmp (jerr.setjmp_buffer, 2);	734	longjmp (jerr.setjmp_buffer, 2);
240		735
241	data = gdk_pixbuf_get_pixels (RETVAL);	736	data = gdk_pixbuf_get_pixels (RETVAL);
242	rs = gdk_pixbuf_get_rowstride (RETVAL);	737	rs = gdk_pixbuf_get_rowstride (RETVAL);
243
244	if (cinfo.output_components != 3)
245	longjmp (jerr.setjmp_buffer, 3);
246		738
247	jpeg_start_decompress (&cinfo);	739	jpeg_start_decompress (&cinfo);
248		740
249	while (cinfo.output_scanline < cinfo.output_height)	741	while (cinfo.output_scanline < cinfo.output_height)
250	{	742	{
…		…
257	rp [3] = (guchar *)rp [2] + rs;	749	rp [3] = (guchar *)rp [2] + rs;
258		750
259	jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);	751	jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);
260	}	752	}
261		753
		754	if (cinfo.out_color_space == JCS_CMYK)
		755	{
		756	guchar end = data + cinfo.output_height rs;
		757
		758	while (data < end)
		759	{
		760	U32 c = data [0];
		761	U32 m = data [1];
		762	U32 y = data [2];
		763	U32 k = data [3];
		764
		765	if (0)
		766	if (cinfo.Adobe_transform == 2)
		767	{
		768	c ^= 0xff;
		769	m ^= 0xff;
		770	y ^= 0xff;
		771	k ^= 0xff;
		772	}
		773
		774	data [0] = (c * k + 0x80) / 0xff;
		775	data [1] = (m * k + 0x80) / 0xff;
		776	data [2] = (y * k + 0x80) / 0xff;
		777	data [3] = 0xff;
		778
		779	data += 4;
		780	}
		781	}
		782
262	jpeg_finish_decompress (&cinfo);	783	jpeg_finish_decompress (&cinfo);
263	fclose (fp);
264	jpeg_destroy_decompress (&cinfo);	784	jpeg_destroy_decompress (&cinfo);
		785	perlinterp_acquire ();
265	}	786	}
266	OUTPUT:	787	OUTPUT:
267	RETVAL	788	RETVAL
268		789
		790	void
		791	compare (GdkPixbuf a, GdkPixbuf b)
		792	PPCODE:
		793	perlinterp_release ();
		794	{
		795	int w = gdk_pixbuf_get_width (a);
		796	int h = gdk_pixbuf_get_height (a);
		797
		798	int sa = gdk_pixbuf_get_rowstride (a);
		799	int sb = gdk_pixbuf_get_rowstride (b);
		800
		801	guchar *pa = gdk_pixbuf_get_pixels (a);
		802	guchar *pb = gdk_pixbuf_get_pixels (b);
		803
		804	int x, y;
		805
		806	assert (w == gdk_pixbuf_get_width (b));
		807	assert (h == gdk_pixbuf_get_height (b));
		808
		809	assert (gdk_pixbuf_get_n_channels (a) == 3);
		810	assert (gdk_pixbuf_get_n_channels (b) == 3);
		811
		812	double diff = 0.;
		813	int peak = 0;
		814
		815	if (w && h)
		816	for (y = 0; y < h; y++)
		817	{
		818	guchar pa_ = pa + y sa;
		819	guchar pb_ = pb + y sb;
		820
		821	for (x = 0; x < w; x++)
		822	{
		823	int d;
		824
		825	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));
		826	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));
		827	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));
		828	}
		829	}
		830
		831	perlinterp_acquire ();
		832
		833	EXTEND (SP, 2);
		834	PUSHs (sv_2mortal (newSVnv (sqrt (diff / (w * h * 3. * 255. * 255.)))));
		835	PUSHs (sv_2mortal (newSVnv (peak / 255.)));
		836	}
		837
269	#############################################################################	838	#############################################################################
270		839
271	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer	840	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer
272		841
		842	# currently only works for filenames (octet strings)
		843
		844	SV *
		845	foldcase (SV *pathsv)
		846	PROTOTYPE: $
		847	CODE:
		848	{
		849	STRLEN plen;
		850	U8 path = (U8 )SvPV (pathsv, plen);
		851	U8 *pend = path + plen;
		852	U8 dst [plen * 6 * 3], *dstp = dst;
		853
		854	while (path < pend)
		855	{
		856	U8 ch = *path;
		857
		858	if (ch >= 'a' && ch <= 'z')
		859	dstp++ = path++;
		860	else if (ch >= 'A' && ch <= 'Z')
		861	dstp++ = path++ + ('a' - 'A');
		862	else if (ch >= '0' && ch <= '9')
		863	{
		864	STRLEN el, nl = 0;
		865	while (path >= '0' && path <= '9' && path < pend)
		866	path++, nl++;
		867
		868	for (el = nl; el < 6; el++)
		869	*dstp++ = '0';
		870
		871	memcpy (dstp, path - nl, nl);
		872	dstp += nl;
		873	}
		874	else
		875	dstp++ = path++;
		876	#if 0
		877	else
		878	{
		879	STRLEN cl;
		880	to_utf8_fold (path, dstp, &cl);
		881	dstp += cl;
		882	path += is_utf8_char (path);
		883	}
		884	#endif
		885	}
		886
		887	RETVAL = newSVpvn ((const char *)dst, dstp - dst);
		888	}
		889	OUTPUT:
		890	RETVAL
		891
273	GdkPixbuf_noinc *	892	GdkPixbuf_noinc *
274	p7_to_pb (int w, int h, guchar *src)	893	p7_to_pb (int w, int h, SV *src_sv)
		894	PROTOTYPE: @
275	CODE:	895	CODE:
276	{	896	{
277	int x, y;	897	int x, y;
278	guchar dst, d;	898	guchar dst, d;
279	int dstr;	899	int dstr;
		900	guchar src = (guchar )SvPVbyte_nolen (src_sv);
280		901
281	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);	902	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
282	dst = gdk_pixbuf_get_pixels (RETVAL);	903	dst = gdk_pixbuf_get_pixels (RETVAL);
283	dstr = gdk_pixbuf_get_rowstride (RETVAL);	904	dstr = gdk_pixbuf_get_rowstride (RETVAL);
284		905
…		…
293	}	914	}
294	}	915	}
295	OUTPUT:	916	OUTPUT:
296	RETVAL	917	RETVAL
297		918
		919	#############################################################################
		920
		921	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
		922
		923	void
		924	dump_ascii85 (PerlIO fp, GdkPixbuf pb)
		925	CODE:
		926	{
		927	int w = gdk_pixbuf_get_width (pb);
		928	int h = gdk_pixbuf_get_height (pb);
		929	int x, y, i;
		930	guchar *dst;
		931	int bpp = gdk_pixbuf_get_n_channels (pb);
		932	guchar *src = gdk_pixbuf_get_pixels (pb);
		933	int sstr = gdk_pixbuf_get_rowstride (pb);
		934
		935	a85_init ();
		936
		937	for (y = 0; y < h; y++)
		938	for (x = 0; x < w; x++)
		939	for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
		940	a85_push (fp, src [x * bpp + y * sstr + i]);
		941
		942	a85_finish (fp);
		943	}
		944
		945	void
		946	dump_binary (PerlIO fp, GdkPixbuf pb)
		947	CODE:
		948	{
		949	int w = gdk_pixbuf_get_width (pb);
		950	int h = gdk_pixbuf_get_height (pb);
		951	int x, y, i;
		952	guchar *dst;
		953	int bpp = gdk_pixbuf_get_n_channels (pb);
		954	guchar *src = gdk_pixbuf_get_pixels (pb);
		955	int sstr = gdk_pixbuf_get_rowstride (pb);
		956
		957	for (y = 0; y < h; y++)
		958	for (x = 0; x < w; x++)
		959	for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
		960	PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
		961	}
		962
		963	#############################################################################
		964
		965	MODULE = Gtk2::CV PACKAGE = Gtk2::CV
		966
298	SV *	967	SV *
299	pb_to_p7 (GdkPixbuf *pb)	968	pb_to_hv84 (GdkPixbuf *pb)
300	CODE:	969	CODE:
301	{	970	{
302	int w = gdk_pixbuf_get_width (pb);	971	int w = gdk_pixbuf_get_width (pb);
303	int h = gdk_pixbuf_get_height (pb);	972	int h = gdk_pixbuf_get_height (pb);
304	int x, y;	973	int x, y;
305	guchar *dst;	974	guchar *dst;
306	int bpp = gdk_pixbuf_get_n_channels (pb);	975	int bpp = gdk_pixbuf_get_n_channels (pb);
307	guchar *src = gdk_pixbuf_get_pixels (pb);	976	guchar *src = gdk_pixbuf_get_pixels (pb);
308	int sstr = gdk_pixbuf_get_rowstride (pb);	977	int sstr = gdk_pixbuf_get_rowstride (pb);
309	int Er[IW], Eg[IW], Eb[IW];
310	int seed = 77;
311
312	RETVAL = newSV (w * h);
313	SvPOK_only (RETVAL);
314	SvCUR_set (RETVAL, w * h);
315
316	dst = SvPVX (RETVAL);
317
318	memset (Er, 0, sizeof (int) * IW);
319	memset (Eg, 0, sizeof (int) * IW);
320	memset (Eb, 0, sizeof (int) * IW);
321
322	/* some primitive error distribution + random dithering */
323
324	for (y = 0; y < h; y++)
325	{
326	int er = 0, eg = 0, eb = 0;
327
328	for (x = 0; x < w; x++)
329	{
330	int r, g, b;
331	guchar p = src + x bpp + y * sstr;
332
333	r = ((p[0] + er + Er[x]) * 7 + (RAND & 127) + 64) / 255;
334	g = ((p[1] + eg + Eg[x]) * 7 + (RAND & 127) + 64) / 255;
335	b = ((p[2] + eb + Eb[x]) * 3 + (RAND & 127) + 64) / 255;
336
337	r = r > 7 ? 7 : r < 0 ? 0 : r;
338	g = g > 7 ? 7 : g < 0 ? 0 : g;
339	b = b > 3 ? 3 : b < 0 ? 0 : b;
340
341	er += p[0] - (r * 255 + 4) / 7;
342	eg += p[1] - (g * 255 + 4) / 7;
343	eb += p[2] - (b * 255 + 2) / 3;
344
345	Er[x] = er >> 1; er -= (er + 1) >> 1;
346	Eg[x] = eg >> 1; eg -= (eg + 1) >> 1;
347	Eb[x] = eb >> 1; eb -= (eb + 1) >> 1;
348
349	*dst++ = r << 5 \| g << 2 \| b;
350	}
351	}
352	}
353	OUTPUT:
354	RETVAL
355
356	SV *
357	make_histogram (SV *ar)
358	CODE:
359	{
360	int i;
361	AV av, result;
362
363	if (!SvROK (ar) \|\| SvTYPE (SvRV (ar)) != SVt_PVAV)
364	croak ("Not an array ref as first argument to make_histogram");
365
366	av = (AV *) SvRV (ar);
367	result = newAV ();
368
369	for (i = 0; i <= av_len (av); ++i)
370	{
371	const int HISTSIZE = 64;
372
373	int j;
374	SV sv = av_fetch (av, i, 1);
375	STRLEN len;
376	char *buf = SvPVbyte (sv, len);
377
378	int tmphist[HISTSIZE];
379	float *hist;
380
381	SV histsv = newSV (HISTSIZE sizeof (float) + 1);
382	SvPOK_on (histsv);
383	SvCUR_set (histsv, HISTSIZE * sizeof (float));
384	hist = (float *)SvPVX (histsv);
385
386	Zero (tmphist, sizeof (tmphist), char);
387
388	for (j = len; j--; )
389	{
390	unsigned int idx
391	= ((*buf & 0xc0) >> 2)
392	\| ((*buf & 0x18) >> 1)
393	\| (*buf & 0x03);
394
395	++tmphist[idx];
396	++buf;
397	}
398
399	for (j = 0; j < HISTSIZE; ++j)
400	hist[j] = (float)tmphist[j] / (len + 1e-30);
401
402	av_push (result, histsv);
403	}
404
405	RETVAL = newRV_noinc ((SV *)result);
406	}
407	OUTPUT:
408	RETVAL
409
410	#############################################################################
411
412	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
413
414	void
415	dump_ascii85 (PerlIO fp, GdkPixbuf pb)
416	CODE:
417	{
418	int w = gdk_pixbuf_get_width (pb);
419	int h = gdk_pixbuf_get_height (pb);
420	int x, y, i;
421	guchar *dst;
422	int bpp = gdk_pixbuf_get_n_channels (pb);
423	guchar *src = gdk_pixbuf_get_pixels (pb);
424	int sstr = gdk_pixbuf_get_rowstride (pb);
425
426	a85_init ();
427
428	for (y = 0; y < h; y++)
429	for (x = 0; x < w; x++)
430	for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
431	a85_push (fp, src [x * bpp + y * sstr + i]);
432
433	a85_finish (fp);
434	}
435
436	void
437	dump_binary (PerlIO fp, GdkPixbuf pb)
438	CODE:
439	{
440	int w = gdk_pixbuf_get_width (pb);
441	int h = gdk_pixbuf_get_height (pb);
442	int x, y, i;
443	guchar *dst;
444	int bpp = gdk_pixbuf_get_n_channels (pb);
445	guchar *src = gdk_pixbuf_get_pixels (pb);
446	int sstr = gdk_pixbuf_get_rowstride (pb);
447
448	for (y = 0; y < h; y++)
449	for (x = 0; x < w; x++)
450	for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
451	PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
452	}
453
454	#############################################################################
455
456	MODULE = Gtk2::CV PACKAGE = Gtk2::CV
457
458	SV *
459	pb_to_hv84 (GdkPixbuf *pb)
460	CODE:
461	{
462	int w = gdk_pixbuf_get_width (pb);
463	int h = gdk_pixbuf_get_height (pb);
464	int x, y;
465	guchar *dst;
466	int bpp = gdk_pixbuf_get_n_channels (pb);
467	guchar *src = gdk_pixbuf_get_pixels (pb);
468	int sstr = gdk_pixbuf_get_rowstride (pb);
469		978
470	RETVAL = newSV (6 * 8 * 12 / 8);	979	RETVAL = newSV (6 * 8 * 12 / 8);
471	SvPOK_only (RETVAL);	980	SvPOK_only (RETVAL);
472	SvCUR_set (RETVAL, 6 * 8 * 12 / 8);	981	SvCUR_set (RETVAL, 6 * 8 * 12 / 8);
473		982
474	dst = SvPVX (RETVAL);	983	dst = (guchar *)SvPVX (RETVAL);
475		984
476	/* some primitive error distribution + random dithering */	985	/* some primitive error distribution + random dithering */
477		986
478	for (y = 0; y < h; y++)	987	for (y = 0; y < h; y++)
479	{	988	{
…		…
537	}	1046	}
538	}	1047	}
539	OUTPUT:	1048	OUTPUT:
540	RETVAL	1049	RETVAL
541		1050
		1051	#############################################################################
542		1052
		1053	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster
543		1054
		1055	SV *
		1056	extract_features (SV *ar)
		1057	CODE:
		1058	{
		1059	int i;
		1060	AV av, result;
		1061
		1062	if (!SvROK (ar) \|\| SvTYPE (SvRV (ar)) != SVt_PVAV)
		1063	croak ("Not an array ref as first argument to extract_features");
		1064
		1065	av = (AV *) SvRV (ar);
		1066	result = newAV ();
		1067
		1068	for (i = 0; i <= av_len (av); ++i)
		1069	{
		1070	SV sv = av_fetch (av, i, 1);
		1071	SV histsv = newSV (9 sizeof (float) + 1);
		1072
		1073	SvPOK_on (histsv);
		1074	SvCUR_set (histsv, 9 * sizeof (float));
		1075	float hist = (float )SvPVX (histsv);
		1076
		1077	struct feature f_h, f_s, f_v;
		1078	feature_init (&f_h);
		1079	feature_init (&f_s);
		1080	feature_init (&f_v);
		1081
		1082	{
		1083	STRLEN len;
		1084	unsigned char buf = (unsigned char )SvPVbyte (sv, len);
		1085	while (len >= 3)
		1086	{
		1087	unsigned int r, g, b, h, s, v;
		1088	r = buf++; g = buf++; b = *buf++;
		1089	rgb_to_hsv (r, g, b, &h, &s, &v);
		1090
		1091	feature_update_pass_1 (&f_h, h);
		1092	feature_update_pass_1 (&f_s, s);
		1093	feature_update_pass_1 (&f_v, v);
		1094
		1095	len -= 3;
		1096	}
		1097
		1098	feature_finish_pass_1 (&f_h);
		1099	feature_finish_pass_1 (&f_s);
		1100	feature_finish_pass_1 (&f_v);
		1101	}
		1102
		1103	{
		1104	STRLEN len;
		1105	unsigned char buf = (unsigned char )SvPVbyte (sv, len);
		1106	while (len >= 3)
		1107	{
		1108	unsigned int r, g, b, h, s, v;
		1109	r = buf++; g = buf++; b = *buf++;
		1110	rgb_to_hsv (r, g, b, &h, &s, &v);
		1111
		1112	feature_update_pass_2 (&f_h, h);
		1113	feature_update_pass_2 (&f_s, s);
		1114	feature_update_pass_2 (&f_v, v);
		1115
		1116	len -= 3;
		1117	}
		1118
		1119	feature_finish_pass_2 (&f_h);
		1120	feature_finish_pass_2 (&f_s);
		1121	feature_finish_pass_2 (&f_v);
		1122	}
		1123
		1124	hist [0] = f_h.v1 * 2.; hist [1] = f_h.v2 * 2.; hist [2] = f_h.v3 * 2.;
		1125	hist [3] = f_s.v1 ; hist [4] = f_s.v2 ; hist [5] = f_s.v3 ;
		1126	hist [6] = f_v.v1 * .5; hist [7] = f_v.v2 * .5; hist [8] = f_v.v3 * .5;
		1127
		1128	av_push (result, histsv);
		1129	}
		1130
		1131	RETVAL = newRV_noinc ((SV *)result);
		1132	}
		1133	OUTPUT:
		1134	RETVAL
		1135

Diff Legend

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

Comparing CV/CV.xs (file contents): Revision 1.17 by root, Wed Jul 20 06:20:36 2005 UTC vs. Revision 1.58 by root, Mon Jan 4 04:49:04 2021 UTC

Diff Legend

Comparing CV/CV.xs (file contents):
Revision 1.17 by root, Wed Jul 20 06:20:36 2005 UTC vs.
Revision 1.58 by root, Mon Jan 4 04:49:04 2021 UTC