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

Comparing CV/CV.xs (file contents):
Revision 1.15 by root, Tue Feb 8 16:27:10 2005 UTC vs.
Revision 1.62 by root, Sun Jul 25 11:32:46 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>
		6	#include <setjmp.h>
		7	#include <math.h>
		8
		9	#include <magic.h>
		10
		11	#include <jpeglib.h>
		12	#include <jerror.h>
		13
		14	#include <glib.h>
		15	#include <gtk/gtk.h>
		16	#include <gdk/gdkx.h>
5	#include <gdk-pixbuf/gdk-pixbuf.h>	17	#include <gdk-pixbuf/gdk-pixbuf.h>
6		18
7	#include <gperl.h>	19	#include <gperl.h>
8	#include <gtk2perl.h>	20	#include <gtk2perl.h>
9		21
10	#define IW 80	22	#include <assert.h>
11		23
12	#define RAND (seed = (seed + 7141) * 54773 % 134456)	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
		36	#define IW 80 /* MUST match Schnauzer.pm! */
		37	#define IH 60 /* MUST match Schnauzer.pm! */
13		38
14	#define LINELENGTH 240	39	#define LINELENGTH 240
15		40
16	#define ELLIPSIS "\xe2\x80\xa6"	41	#define ELLIPSIS "\xe2\x80\xa6"
17		42
18	static guint32 a85_val;	43	typedef char *octet_string;
19	static guint a85_cnt;	44
20	static guchar a85_buf[LINELENGTH], *a85_ptr;	45	static magic_t magic_cookie[2]; /* !mime, mime */
		46
		47	struct jpg_err_mgr
		48	{
		49	struct jpeg_error_mgr err;
		50	jmp_buf setjmp_buffer;
		51	};
21		52
22	static void	53	static void
23	a85_init (void)	54	cv_error_exit (j_common_ptr cinfo)
24	{	55	{
25	a85_cnt = 4;	56	cinfo->err->output_message (cinfo);
26	a85_ptr = a85_buf;	57	longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);
27	}	58	}
28		59
29	static void	60	static void
30	a85_push (PerlIO *fp, guchar c)	61	cv_error_output (j_common_ptr cinfo)
31	{	62	{
32	a85_val = a85_val << 8 \| c;	63	char msg[JMSG_LENGTH_MAX];
33		64
34	if (!--a85_cnt)	65	cinfo->err->format_message (cinfo, msg);
35	{
36	a85_cnt = 4;
37	if (a85_val)
38	{
39	a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
40	a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
41	a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
42	a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
43	a85_ptr[0] = (a85_val ) + 33;
44		66
45	a85_ptr += 5;	67	fprintf (stderr, "JPEG decoding error: %s\n", msg);
46	}	68	return;
47	else
48	*a85_ptr++ = 'z';
49
50	if (a85_ptr >= a85_buf + sizeof (a85_buf) - 7)
51	{
52	*a85_ptr++ = '\n';
53	PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
54	a85_ptr = a85_buf;
55	}
56	}
57
58	}
59
60	static void
61	a85_finish (PerlIO *fp)
62	{
63	while (a85_cnt != 4)
64	a85_push (fp, 0);
65
66	*a85_ptr++ = '~'; // probably buggy end-marker
67	*a85_ptr++ = '>'; // probably buggy end-marker
68	*a85_ptr++ = '\n';
69
70	PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
71	}	69	}
72		70
73	static void	71	static void
74	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,
75	unsigned int h, unsigned int s, unsigned int *v)	73	unsigned int h, unsigned int s, unsigned int *v)
95		93
96	*h &= 255;	94	*h &= 255;
97	}	95	}
98	}	96	}
99		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
		153	static guint32 a85_val;
		154	static guint a85_cnt;
		155	static guchar a85_buf[LINELENGTH], *a85_ptr;
		156
		157	static void
		158	a85_init (void)
		159	{
		160	a85_cnt = 4;
		161	a85_ptr = a85_buf;
		162	}
		163
		164	static void
		165	a85_push (PerlIO *fp, guchar c)
		166	{
		167	a85_val = a85_val << 8 \| c;
		168
		169	if (!--a85_cnt)
		170	{
		171	a85_cnt = 4;
		172	if (a85_val)
		173	{
		174	a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
		175	a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
		176	a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
		177	a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
		178	a85_ptr[0] = (a85_val ) + 33;
		179
		180	a85_ptr += 5;
		181	}
		182	else
		183	*a85_ptr++ = 'z';
		184
		185	if (a85_ptr >= a85_buf + sizeof (a85_buf) - 7)
		186	{
		187	*a85_ptr++ = '\n';
		188	PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
		189	a85_ptr = a85_buf;
		190	}
		191	}
		192
		193	}
		194
		195	static void
		196	a85_finish (PerlIO *fp)
		197	{
		198	while (a85_cnt != 4)
		199	a85_push (fp, 0);
		200
		201	*a85_ptr++ = '~'; // probably buggy end-marker
		202	*a85_ptr++ = '>'; // probably buggy end-marker
		203	*a85_ptr++ = '\n';
		204
		205	PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
		206	}
		207
100	/////////////////////////////////////////////////////////////////////////////	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	/////////////////////////////////////////////////////////////////////////////
101		303
102	MODULE = Gtk2::CV PACKAGE = Gtk2::CV	304	MODULE = Gtk2::CV PACKAGE = Gtk2::CV
103		305
104	PROTOTYPES: ENABLE	306	PROTOTYPES: ENABLE
105		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
106	GdkPixbuf_noinc *	375	GdkPixbuf_noinc *
107	transpose (GdkPixbuf *pb)	376	dealpha_expose (GdkPixbuf *pb)
108	CODE:	377	CODE:
		378	perlinterp_release ();
109	{	379	{
110	int w = gdk_pixbuf_get_width (pb);	380	int w = gdk_pixbuf_get_width (pb);
111	int h = gdk_pixbuf_get_height (pb);	381	int h = gdk_pixbuf_get_height (pb);
112	int bpp = gdk_pixbuf_get_n_channels (pb);	382	int bpp = gdk_pixbuf_get_n_channels (pb);
113	int x, y, i;	383	int x, y, i;
114	guchar src = gdk_pixbuf_get_pixels (pb), dst;	384	guchar src = gdk_pixbuf_get_pixels (pb), dst;
115	int sstr = gdk_pixbuf_get_rowstride (pb), dstr;	385	int sstr = gdk_pixbuf_get_rowstride (pb), dstr;
116		386
117	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, h, w);	387	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
118		388
119	dst = gdk_pixbuf_get_pixels (RETVAL);	389	dst = gdk_pixbuf_get_pixels (RETVAL);
120	dstr = gdk_pixbuf_get_rowstride (RETVAL);	390	dstr = gdk_pixbuf_get_rowstride (RETVAL);
121		391
122	for (y = 0; y < h; y++)
123	for (x = 0; x < w; x++)	392	for (x = 0; x < w; x++)
		393	for (y = 0; y < h; y++)
124	for (i = 0; i < bpp; i++)	394	for (i = 0; i < 3; i++)
125	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];
126	}	396	}
		397	perlinterp_acquire ();
127	OUTPUT:	398	OUTPUT:
128	RETVAL	399	RETVAL
129		400
130	GdkPixbuf_noinc *	401	GdkPixbuf_noinc *
131	flop (GdkPixbuf *pb)	402	rotate (GdkPixbuf *pb, int angle)
132	CODE:	403	CODE:
133	{	404	perlinterp_release ();
134	int w = gdk_pixbuf_get_width (pb);	405	if (angle < 0)
135	int h = gdk_pixbuf_get_height (pb);	406	angle += 360;
136	int bpp = gdk_pixbuf_get_n_channels (pb);	407	RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE
137	int x, y, i;	408	: angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
138	guchar src = gdk_pixbuf_get_pixels (pb), dst;	409	: angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN
139	int sstr = gdk_pixbuf_get_rowstride (pb), dstr;	410	: angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE
140		411	: angle);
141	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, w, h);	412	perlinterp_acquire ();
142
143	dst = gdk_pixbuf_get_pixels (RETVAL);
144	dstr = gdk_pixbuf_get_rowstride (RETVAL);
145
146	for (y = 0; y < h; y++)
147	for (x = 0; x < w; x++)
148	for (i = 0; i < bpp; i++)
149	dst[(w - 1 - x) * bpp + y * dstr + i] = src[x * bpp + y * sstr + i];
150	}
151	OUTPUT:	413	OUTPUT:
152	RETVAL	414	RETVAL
153		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 if (data_len >= 13
		457	&& data[0] == 'G'
		458	&& data[1] == 'I'
		459	&& data[2] == 'F'
		460	&& data[3] == '8'
		461	//&& (data[4] == '7' \|\| data[4] == '9')
		462	&& data[5] == 'a')
		463	{
		464	RETVAL = "image/gif";
		465
		466	// now see if its animated - we require the netscape application header for this
		467	int ofs = 13;
		468
		469	if (data[10] & 0x80)
		470	ofs += (1 << ((data[10] & 7) + 1)) * 3;
		471
		472	if (data_len >= ofs + 2 + 1 + 11)
		473	{
		474
		475	// skip a graphic control extension block. we assume
		476	// there is at most one such block - while the NAB
		477	// has to come firstz, some files do not obey this
		478	if (data[ofs] == 0x21 && data[ofs + 1] == 0xf9)
		479	ofs += 3 + data[ofs + 2] + 1;
		480
		481	if (data_len >= ofs + 2 + 1 + 11)
		482	if (!memcmp (data + ofs, "\x21\xff\x0bNETSCAPE2.0", sizeof ("\x21\xff\x0bNETSCAPE2.0") - 1))
		483	RETVAL = "video/gif";
		484	}
		485	}
		486
		487	else
		488	XSRETURN_UNDEF;
		489	}
		490	OUTPUT:
		491	RETVAL
		492
		493	GdkPixbuf_noinc *
		494	decode_webp (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
		495	CODE:
		496	{
		497	#if WEBP
		498	STRLEN data_size;
		499	int alpha;
		500	WebPData data;
		501	WebPDemuxer *demux;
		502	WebPIterator iter;
		503	WebPDecoderConfig config;
		504	int inw, inh;
		505
		506	data.bytes = (uint8_t *)SvPVbyte (image_data, data_size);
		507	data.size = data_size;
		508
		509	perlinterp_release ();
		510
		511	RETVAL = 0;
		512
		513	if (!(demux = WebPDemux (&data)))
		514	goto err_demux;
		515
		516	if (!WebPDemuxGetFrame (demux, 1, &iter))
		517	goto err_iter;
		518
		519	if (!WebPInitDecoderConfig (&config))
		520	goto err_iter;
		521
		522	config.options.use_threads = 1;
		523
		524	if (WebPGetFeatures (iter.fragment.bytes, iter.fragment.size, &config.input) != VP8_STATUS_OK)
		525	goto err_iter;
		526
		527	inw = config.input.width;
		528	inh = config.input.height;
		529
		530	if (thumbnail)
		531	{
		532	if (inw * ih > inh * iw)
		533	ih = (iw * inh + inw - 1) / inw;
		534	else
		535	iw = (ih * inw + inh - 1) / inh;
		536
		537	config.options.bypass_filtering = 1;
		538	config.options.no_fancy_upsampling = 1;
		539
		540	config.options.use_scaling = 1;
		541	config.options.scaled_width = iw;
		542	config.options.scaled_height = ih;
		543	}
		544	else
		545	{
		546	iw = inw;
		547	ih = inh;
		548	}
		549
		550	alpha = !!config.input.has_alpha;
		551
		552	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, alpha, 8, iw, ih);
		553	if (!RETVAL)
		554	goto err_iter;
		555
		556	config.output.colorspace = alpha ? MODE_RGBA : MODE_RGB;
		557	config.output.u.RGBA.rgba = gdk_pixbuf_get_pixels (RETVAL);
		558	config.output.u.RGBA.stride = gdk_pixbuf_get_rowstride (RETVAL);
		559	config.output.u.RGBA.size = gdk_pixbuf_get_byte_length (RETVAL);
		560	config.output.is_external_memory = 1;
		561
		562	if (WebPDecode (iter.fragment.bytes, iter.fragment.size, &config) != VP8_STATUS_OK)
		563	{
		564	g_object_unref (RETVAL);
		565	RETVAL = 0;
		566	goto err_iter;
		567	}
		568
		569	err_iter:
		570	WebPDemuxReleaseIterator (&iter);
		571	err_demux:
		572	WebPDemuxDelete (demux);
		573
		574	perlinterp_acquire ();
		575	#else
		576	croak ("load_webp: webp not enabled at compile time");
		577	#endif
		578	}
		579	OUTPUT:
		580	RETVAL
		581
		582	GdkPixbuf_noinc *
		583	decode_jxl (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
		584	CODE:
		585	{
		586	#if JXL
		587	JxlDecoder *dec = JxlDecoderCreate (0);
		588	JxlBasicInfo info;
		589	const uint8_t next_in = (uint8_t )SvPVbyte_nolen (image_data);
		590	size_t avail_in = SvCUR (image_data);
		591	const char *error = 0;
		592	void *runner = 0;
		593	struct bmff_box box;
		594
		595	perlinterp_release ();
		596
		597	RETVAL = 0;
		598
		599	error = "JxlDecoderCreate failed";
		600	if (!dec)
		601	goto done;
		602
		603	runner = JxlThreadParallelRunnerCreate (0, JxlThreadParallelRunnerDefaultNumWorkerThreads ());
		604
		605	error = "JxlDecoderSetParallelRunner failed";
		606	if (JxlDecoderSetParallelRunner (dec, JxlThreadParallelRunner, runner) != JXL_DEC_SUCCESS)
		607	goto done;
		608
		609	error = "JxlDecoderSubscribeEvents failed";
		610	if (JxlDecoderSubscribeEvents (dec, JXL_DEC_FULL_IMAGE \| JXL_DEC_BASIC_INFO) != JXL_DEC_SUCCESS)
		611	goto done;
		612
		613	error = "JxlDecoderSetInput failed";
		614	if (JxlDecoderSetInput (dec, next_in, avail_in) != JXL_DEC_SUCCESS)
		615	goto done;
		616
		617	for (;;)
		618	{
		619	JxlDecoderStatus status = JxlDecoderProcessInput (dec);
		620
		621	printf ("status %d\n",status);
		622
		623	switch (status)
		624	{
		625	case JXL_DEC_ERROR:
		626	error = "JxlDecoderProcessInput failed";
		627	goto done;
		628
		629	case JXL_DEC_NEED_MORE_INPUT:
		630	error = "incomplete file";
		631	goto done;
		632
		633	case JXL_DEC_SUCCESS:
		634	goto done;
		635
		636	case JXL_DEC_NEED_IMAGE_OUT_BUFFER:
		637	{
		638	error = "JxlDecoderGetBasicInfo failed";
		639	if (JxlDecoderGetBasicInfo (dec, &info) != JXL_DEC_SUCCESS)
		640	goto done;
		641
		642	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, !!info.alpha_bits, 8, info.xsize, info.ysize);
		643	error = "unable to allocate pixbuf";
		644	if (!RETVAL)
		645	goto done;
		646
		647	JxlPixelFormat format = {
		648	info.alpha_bits ? 4 : 3,
		649	JXL_TYPE_UINT8,
		650	JXL_NATIVE_ENDIAN,
		651	gdk_pixbuf_get_rowstride (RETVAL)
		652	};
		653
		654	error = "JxlDecoderSetImageOutBuffer failed";
		655	if (JxlDecoderSetImageOutBuffer (
		656	dec,
		657	&format,
		658	gdk_pixbuf_get_pixels (RETVAL),
		659	gdk_pixbuf_get_byte_length (RETVAL)
		660	) != JXL_DEC_SUCCESS)
		661	goto done;
		662	}
		663	break;
		664
		665	default:
		666	error = "unexpected event";
		667	goto done;
		668	}
		669	}
		670
		671	done:
		672	if (dec)
		673	JxlDecoderDestroy (dec);
		674
		675	if (runner)
		676	JxlThreadParallelRunnerDestroy (runner);
		677
		678	perlinterp_acquire ();
		679
		680	if (error)
		681	{
		682	if (RETVAL)
		683	g_object_unref (RETVAL);
		684
		685	croak ("load_jxl: %s", error);
		686	}
		687	#else
		688	croak ("load_jxl: jpeg-xl not enabled at compile time");
		689	#endif
		690	}
		691	OUTPUT:
		692	RETVAL
		693
		694	GdkPixbuf_noinc *
		695	decode_jpeg (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
		696	CODE:
		697	{
		698	struct jpeg_decompress_struct cinfo;
		699	struct jpg_err_mgr jerr;
		700	int rs;
		701	volatile GdkPixbuf *pb = 0;
		702	STRLEN data_len;
		703	guchar *data = SvPVbyte (image_data, data_len);
		704
		705	RETVAL = 0;
		706
		707	perlinterp_release ();
		708
		709	cinfo.err = jpeg_std_error (&jerr.err);
		710
		711	jerr.err.error_exit = cv_error_exit;
		712	jerr.err.output_message = cv_error_output;
		713
		714	if ((rs = setjmp (jerr.setjmp_buffer)))
		715	{
		716	jpeg_destroy_decompress (&cinfo);
		717
		718	if (pb)
		719	g_object_unref ((gpointer)pb);
		720
		721	perlinterp_acquire ();
		722	XSRETURN_UNDEF;
		723	}
		724
		725	if (!data_len)
		726	longjmp (jerr.setjmp_buffer, 4);
		727
		728	jpeg_create_decompress (&cinfo);
		729	cv_jpeg_mem_src (&cinfo, data, data_len);
		730
		731	jpeg_read_header (&cinfo, TRUE);
		732
		733	cinfo.dct_method = JDCT_DEFAULT;
		734	cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */
		735	cinfo.do_block_smoothing = FALSE;
		736	cinfo.out_color_space = JCS_RGB;
		737	cinfo.quantize_colors = FALSE;
		738
		739	cinfo.scale_num = 1;
		740	cinfo.scale_denom = 1;
		741
		742	jpeg_calc_output_dimensions (&cinfo);
		743
		744	if (thumbnail)
		745	{
		746	cinfo.dct_method = JDCT_FASTEST;
		747	cinfo.do_fancy_upsampling = FALSE;
		748
		749	while (cinfo.scale_denom < 8
		750	&& cinfo.output_width >= iw*4
		751	&& cinfo.output_height >= ih*4)
		752	{
		753	cinfo.scale_denom <<= 1;
		754	jpeg_calc_output_dimensions (&cinfo);
		755	}
		756	}
		757
		758	if (cinfo.output_components != 3)
		759	longjmp (jerr.setjmp_buffer, 3);
		760
		761	if (cinfo.jpeg_color_space == JCS_YCCK \|\| cinfo.jpeg_color_space == JCS_CMYK)
		762	{
		763	cinfo.out_color_space = JCS_CMYK;
		764	cinfo.output_components = 4;
		765	}
		766
		767	pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, cinfo.output_components == 4, 8, cinfo.output_width, cinfo.output_height);
		768	if (!RETVAL)
		769	longjmp (jerr.setjmp_buffer, 2);
		770
		771	data = gdk_pixbuf_get_pixels (RETVAL);
		772	rs = gdk_pixbuf_get_rowstride (RETVAL);
		773
		774	jpeg_start_decompress (&cinfo);
		775
		776	while (cinfo.output_scanline < cinfo.output_height)
		777	{
		778	int remaining = cinfo.output_height - cinfo.output_scanline;
		779	JSAMPROW rp[4];
		780
		781	rp [0] = data + cinfo.output_scanline * rs;
		782	rp [1] = (guchar *)rp [0] + rs;
		783	rp [2] = (guchar *)rp [1] + rs;
		784	rp [3] = (guchar *)rp [2] + rs;
		785
		786	jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);
		787	}
		788
		789	if (cinfo.out_color_space == JCS_CMYK)
		790	{
		791	guchar end = data + cinfo.output_height rs;
		792
		793	while (data < end)
		794	{
		795	U32 c = data [0];
		796	U32 m = data [1];
		797	U32 y = data [2];
		798	U32 k = data [3];
		799
		800	if (0)
		801	if (cinfo.Adobe_transform == 2)
		802	{
		803	c ^= 0xff;
		804	m ^= 0xff;
		805	y ^= 0xff;
		806	k ^= 0xff;
		807	}
		808
		809	data [0] = (c * k + 0x80) / 0xff;
		810	data [1] = (m * k + 0x80) / 0xff;
		811	data [2] = (y * k + 0x80) / 0xff;
		812	data [3] = 0xff;
		813
		814	data += 4;
		815	}
		816	}
		817
		818	jpeg_finish_decompress (&cinfo);
		819	jpeg_destroy_decompress (&cinfo);
		820	perlinterp_acquire ();
		821	}
		822	OUTPUT:
		823	RETVAL
		824
		825	void
		826	compare (GdkPixbuf a, GdkPixbuf b)
		827	PPCODE:
		828	perlinterp_release ();
		829	{
		830	int w = gdk_pixbuf_get_width (a);
		831	int h = gdk_pixbuf_get_height (a);
		832
		833	int sa = gdk_pixbuf_get_rowstride (a);
		834	int sb = gdk_pixbuf_get_rowstride (b);
		835
		836	guchar *pa = gdk_pixbuf_get_pixels (a);
		837	guchar *pb = gdk_pixbuf_get_pixels (b);
		838
		839	int x, y;
		840
		841	assert (w == gdk_pixbuf_get_width (b));
		842	assert (h == gdk_pixbuf_get_height (b));
		843
		844	assert (gdk_pixbuf_get_n_channels (a) == 3);
		845	assert (gdk_pixbuf_get_n_channels (b) == 3);
		846
		847	double diff = 0.;
		848	int peak = 0;
		849
		850	if (w && h)
		851	for (y = 0; y < h; y++)
		852	{
		853	guchar pa_ = pa + y sa;
		854	guchar pb_ = pb + y sb;
		855
		856	for (x = 0; x < w; x++)
		857	{
		858	int d;
		859
		860	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));
		861	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));
		862	d = ((int)pa_++) - ((int)pb_++); diff += d*d; peak = MAX (peak, abs (d));
		863	}
		864	}
		865
		866	perlinterp_acquire ();
		867
		868	EXTEND (SP, 2);
		869	PUSHs (sv_2mortal (newSVnv (sqrt (diff / (w * h * 3. * 255. * 255.)))));
		870	PUSHs (sv_2mortal (newSVnv (peak / 255.)));
		871	}
		872
154	#############################################################################	873	#############################################################################
155		874
156	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer	875	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer
157		876
		877	# currently only works for filenames (octet strings)
		878
		879	SV *
		880	foldcase (SV *pathsv)
		881	PROTOTYPE: $
		882	CODE:
		883	{
		884	STRLEN plen;
		885	U8 path = (U8 )SvPV (pathsv, plen);
		886	U8 *pend = path + plen;
		887	U8 dst [plen * 8 * 3], *dstp = dst;
		888
		889	while (path < pend)
		890	{
		891	U8 ch = *path;
		892
		893	if (ch >= 'a' && ch <= 'z')
		894	dstp++ = path++;
		895	else if (ch >= 'A' && ch <= 'Z')
		896	dstp++ = path++ + ('a' - 'A');
		897	else if (ch >= '0' && ch <= '9')
		898	{
		899	/* version sort, up to 8 digits */
		900	STRLEN el, nl = 0;
		901	while (path >= '0' && path <= '9' && path < pend)
		902	path++, nl++;
		903
		904	for (el = nl; el < 8; el++)
		905	*dstp++ = '0';
		906
		907	memcpy (dstp, path - nl, nl);
		908	dstp += nl;
		909	}
		910	else
		911	dstp++ = path++;
		912	#if 0
		913	else
		914	{
		915	STRLEN cl;
		916	to_utf8_fold (path, dstp, &cl);
		917	dstp += cl;
		918	path += is_utf8_char (path);
		919	}
		920	#endif
		921	}
		922
		923	RETVAL = newSVpvn ((const char *)dst, dstp - dst);
		924	}
		925	OUTPUT:
		926	RETVAL
		927
158	GdkPixbuf_noinc *	928	GdkPixbuf_noinc *
159	p7_to_pb (int w, int h, guchar *src)	929	p7_to_pb (int w, int h, SV *src_sv)
		930	PROTOTYPE: @
160	CODE:	931	CODE:
161	{	932	{
162	int x, y;	933	int x, y;
163	guchar dst, d;	934	guchar dst, d;
164	int dstr;	935	int dstr;
		936	guchar src = (guchar )SvPVbyte_nolen (src_sv);
165		937
166	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);	938	RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
167	dst = gdk_pixbuf_get_pixels (RETVAL);	939	dst = gdk_pixbuf_get_pixels (RETVAL);
168	dstr = gdk_pixbuf_get_rowstride (RETVAL);	940	dstr = gdk_pixbuf_get_rowstride (RETVAL);
169		941
…		…
178	}	950	}
179	}	951	}
180	OUTPUT:	952	OUTPUT:
181	RETVAL	953	RETVAL
182		954
		955	#############################################################################
		956
		957	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
		958
		959	void
		960	dump_ascii85 (PerlIO fp, GdkPixbuf pb)
		961	CODE:
		962	{
		963	int w = gdk_pixbuf_get_width (pb);
		964	int h = gdk_pixbuf_get_height (pb);
		965	int x, y, i;
		966	guchar *dst;
		967	int bpp = gdk_pixbuf_get_n_channels (pb);
		968	guchar *src = gdk_pixbuf_get_pixels (pb);
		969	int sstr = gdk_pixbuf_get_rowstride (pb);
		970
		971	a85_init ();
		972
		973	for (y = 0; y < h; y++)
		974	for (x = 0; x < w; x++)
		975	for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
		976	a85_push (fp, src [x * bpp + y * sstr + i]);
		977
		978	a85_finish (fp);
		979	}
		980
		981	void
		982	dump_binary (PerlIO fp, GdkPixbuf pb)
		983	CODE:
		984	{
		985	int w = gdk_pixbuf_get_width (pb);
		986	int h = gdk_pixbuf_get_height (pb);
		987	int x, y, i;
		988	guchar *dst;
		989	int bpp = gdk_pixbuf_get_n_channels (pb);
		990	guchar *src = gdk_pixbuf_get_pixels (pb);
		991	int sstr = gdk_pixbuf_get_rowstride (pb);
		992
		993	for (y = 0; y < h; y++)
		994	for (x = 0; x < w; x++)
		995	for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
		996	PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
		997	}
		998
		999	#############################################################################
		1000
		1001	MODULE = Gtk2::CV PACKAGE = Gtk2::CV
		1002
183	SV *	1003	SV *
184	pb_to_p7 (GdkPixbuf *pb)	1004	pb_to_hv84 (GdkPixbuf *pb)
185	CODE:	1005	CODE:
186	{	1006	{
187	int w = gdk_pixbuf_get_width (pb);	1007	int w = gdk_pixbuf_get_width (pb);
188	int h = gdk_pixbuf_get_height (pb);	1008	int h = gdk_pixbuf_get_height (pb);
189	int x, y;	1009	int x, y;
190	guchar *dst;	1010	guchar *dst;
191	int bpp = gdk_pixbuf_get_n_channels (pb);	1011	int bpp = gdk_pixbuf_get_n_channels (pb);
192	guchar *src = gdk_pixbuf_get_pixels (pb);	1012	guchar *src = gdk_pixbuf_get_pixels (pb);
193	int sstr = gdk_pixbuf_get_rowstride (pb);	1013	int sstr = gdk_pixbuf_get_rowstride (pb);
194	int Er[IW], Eg[IW], Eb[IW];
195	int seed = 77;
196
197	RETVAL = newSV (w * h);
198	SvPOK_only (RETVAL);
199	SvCUR_set (RETVAL, w * h);
200
201	dst = SvPVX (RETVAL);
202
203	memset (Er, 0, sizeof (int) * IW);
204	memset (Eg, 0, sizeof (int) * IW);
205	memset (Eb, 0, sizeof (int) * IW);
206
207	/* some primitive error distribution + random dithering */
208
209	for (y = 0; y < h; y++)
210	{
211	int er = 0, eg = 0, eb = 0;
212
213	for (x = 0; x < w; x++)
214	{
215	int r, g, b;
216	guchar p = src + x bpp + y * sstr;
217
218	r = ((p[0] + er + Er[x]) * 7 + 128) / 255;
219	g = ((p[1] + eg + Eg[x]) * 7 + 128) / 255;
220	b = ((p[2] + eb + Eb[x]) * 3 + 128) / 255;
221
222	r = r > 7 ? 7 : r < 0 ? 0 : r;
223	g = g > 7 ? 7 : g < 0 ? 0 : g;
224	b = b > 3 ? 3 : b < 0 ? 0 : b;
225
226	er += p[0] - (r * 255 + 4) / 7;
227	eg += p[1] - (g * 255 + 4) / 7;
228	eb += p[2] - (b * 255 + 2) / 3;
229
230	Er[x] = er / 2; er -= er / 2 + RAND % 7 - 3;
231	Eg[x] = eg / 2; eg -= eg / 2 + RAND % 7 - 3;
232	Eb[x] = eb / 2; eb -= eb / 2 + RAND % 7 - 3;
233
234	*dst++ = r << 5 \| g << 2 \| b;
235	}
236	}
237	}
238	OUTPUT:
239	RETVAL
240
241	SV *
242	make_histogram (SV *ar)
243	CODE:
244	{
245	int i;
246	AV av, result;
247
248	if (!SvROK (ar) \|\| SvTYPE (SvRV (ar)) != SVt_PVAV)
249	croak ("Not an array ref as first argument to make_histogram");
250
251	av = (AV *) SvRV (ar);
252	result = newAV ();
253
254	for (i = 0; i <= av_len (av); ++i)
255	{
256	const int HISTSIZE = 64;
257
258	int j;
259	SV sv = av_fetch (av, i, 1);
260	STRLEN len;
261	char *buf = SvPVbyte (sv, len);
262
263	int tmphist[HISTSIZE];
264	float *hist;
265
266	SV histsv = newSV (HISTSIZE sizeof (float) + 1);
267	SvPOK_on (histsv);
268	SvCUR_set (histsv, HISTSIZE * sizeof (float));
269	hist = (float *)SvPVX (histsv);
270
271	Zero (tmphist, sizeof (tmphist), char);
272
273	for (j = len; j--; )
274	{
275	unsigned int idx
276	= ((*buf & 0xc0) >> 2)
277	\| ((*buf & 0x18) >> 1)
278	\| (*buf & 0x03);
279
280	++tmphist[idx];
281	++buf;
282	}
283
284	for (j = 0; j < HISTSIZE; ++j)
285	hist[j] = (float)tmphist[j] / (len + 1e-30);
286
287	av_push (result, histsv);
288	}
289
290	RETVAL = newRV_noinc ((SV *)result);
291	}
292	OUTPUT:
293	RETVAL
294
295
296
297	#############################################################################
298
299	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
300
301	void
302	dump_ascii85 (PerlIO fp, GdkPixbuf pb)
303	CODE:
304	{
305	int w = gdk_pixbuf_get_width (pb);
306	int h = gdk_pixbuf_get_height (pb);
307	int x, y, i;
308	guchar *dst;
309	int bpp = gdk_pixbuf_get_n_channels (pb);
310	guchar *src = gdk_pixbuf_get_pixels (pb);
311	int sstr = gdk_pixbuf_get_rowstride (pb);
312
313	a85_init ();
314
315	for (y = 0; y < h; y++)
316	for (x = 0; x < w; x++)
317	for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
318	a85_push (fp, src [x * bpp + y * sstr + i]);
319
320	a85_finish (fp);
321	}
322
323	void
324	dump_binary (PerlIO fp, GdkPixbuf pb)
325	CODE:
326	{
327	int w = gdk_pixbuf_get_width (pb);
328	int h = gdk_pixbuf_get_height (pb);
329	int x, y, i;
330	guchar *dst;
331	int bpp = gdk_pixbuf_get_n_channels (pb);
332	guchar *src = gdk_pixbuf_get_pixels (pb);
333	int sstr = gdk_pixbuf_get_rowstride (pb);
334
335	for (y = 0; y < h; y++)
336	for (x = 0; x < w; x++)
337	for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
338	PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
339	}
340
341	#############################################################################
342
343	MODULE = Gtk2::CV PACKAGE = Gtk2::CV
344
345	SV *
346	pb_to_hv84 (GdkPixbuf *pb)
347	CODE:
348	{
349	int w = gdk_pixbuf_get_width (pb);
350	int h = gdk_pixbuf_get_height (pb);
351	int x, y;
352	guchar *dst;
353	int bpp = gdk_pixbuf_get_n_channels (pb);
354	guchar *src = gdk_pixbuf_get_pixels (pb);
355	int sstr = gdk_pixbuf_get_rowstride (pb);
356		1014
357	RETVAL = newSV (6 * 8 * 12 / 8);	1015	RETVAL = newSV (6 * 8 * 12 / 8);
358	SvPOK_only (RETVAL);	1016	SvPOK_only (RETVAL);
359	SvCUR_set (RETVAL, 6 * 8 * 12 / 8);	1017	SvCUR_set (RETVAL, 6 * 8 * 12 / 8);
360		1018
361	dst = SvPVX (RETVAL);	1019	dst = (guchar *)SvPVX (RETVAL);
362		1020
363	/* some primitive error distribution + random dithering */	1021	/* some primitive error distribution + random dithering */
364		1022
365	for (y = 0; y < h; y++)	1023	for (y = 0; y < h; y++)
366	{	1024	{
…		…
424	}	1082	}
425	}	1083	}
426	OUTPUT:	1084	OUTPUT:
427	RETVAL	1085	RETVAL
428		1086
		1087	#############################################################################
429		1088
		1089	MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster
430		1090
		1091	SV *
		1092	extract_features (SV *ar)
		1093	CODE:
		1094	{
		1095	int i;
		1096	AV av, result;
		1097
		1098	if (!SvROK (ar) \|\| SvTYPE (SvRV (ar)) != SVt_PVAV)
		1099	croak ("Not an array ref as first argument to extract_features");
		1100
		1101	av = (AV *) SvRV (ar);
		1102	result = newAV ();
		1103
		1104	for (i = 0; i <= av_len (av); ++i)
		1105	{
		1106	SV sv = av_fetch (av, i, 1);
		1107	SV histsv = newSV (9 sizeof (float) + 1);
		1108
		1109	SvPOK_on (histsv);
		1110	SvCUR_set (histsv, 9 * sizeof (float));
		1111	float hist = (float )SvPVX (histsv);
		1112
		1113	struct feature f_h, f_s, f_v;
		1114	feature_init (&f_h);
		1115	feature_init (&f_s);
		1116	feature_init (&f_v);
		1117
		1118	{
		1119	STRLEN len;
		1120	unsigned char buf = (unsigned char )SvPVbyte (sv, len);
		1121	while (len >= 3)
		1122	{
		1123	unsigned int r, g, b, h, s, v;
		1124	r = buf++; g = buf++; b = *buf++;
		1125	rgb_to_hsv (r, g, b, &h, &s, &v);
		1126
		1127	feature_update_pass_1 (&f_h, h);
		1128	feature_update_pass_1 (&f_s, s);
		1129	feature_update_pass_1 (&f_v, v);
		1130
		1131	len -= 3;
		1132	}
		1133
		1134	feature_finish_pass_1 (&f_h);
		1135	feature_finish_pass_1 (&f_s);
		1136	feature_finish_pass_1 (&f_v);
		1137	}
		1138
		1139	{
		1140	STRLEN len;
		1141	unsigned char buf = (unsigned char )SvPVbyte (sv, len);
		1142	while (len >= 3)
		1143	{
		1144	unsigned int r, g, b, h, s, v;
		1145	r = buf++; g = buf++; b = *buf++;
		1146	rgb_to_hsv (r, g, b, &h, &s, &v);
		1147
		1148	feature_update_pass_2 (&f_h, h);
		1149	feature_update_pass_2 (&f_s, s);
		1150	feature_update_pass_2 (&f_v, v);
		1151
		1152	len -= 3;
		1153	}
		1154
		1155	feature_finish_pass_2 (&f_h);
		1156	feature_finish_pass_2 (&f_s);
		1157	feature_finish_pass_2 (&f_v);
		1158	}
		1159
		1160	hist [0] = f_h.v1 * 2.; hist [1] = f_h.v2 * 2.; hist [2] = f_h.v3 * 2.;
		1161	hist [3] = f_s.v1 ; hist [4] = f_s.v2 ; hist [5] = f_s.v3 ;
		1162	hist [6] = f_v.v1 * .5; hist [7] = f_v.v2 * .5; hist [8] = f_v.v3 * .5;
		1163
		1164	av_push (result, histsv);
		1165	}
		1166
		1167	RETVAL = newRV_noinc ((SV *)result);
		1168	}
		1169	OUTPUT:
		1170	RETVAL
		1171

Diff Legend

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

Comparing CV/CV.xs (file contents): Revision 1.15 by root, Tue Feb 8 16:27:10 2005 UTC vs. Revision 1.62 by root, Sun Jul 25 11:32:46 2021 UTC

Diff Legend

Comparing CV/CV.xs (file contents):
Revision 1.15 by root, Tue Feb 8 16:27:10 2005 UTC vs.
Revision 1.62 by root, Sun Jul 25 11:32:46 2021 UTC