ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/CV/CV.xs
(Generate patch)

Comparing CV/CV.xs (file contents):
Revision 1.22 by root, Sun Aug 14 02:25:44 2005 UTC vs.
Revision 1.58 by root, Mon Jan 4 04:49:04 2021 UTC

… …
2#include "perl.h" 2#include "perl.h"
3#include "XSUB.h" 3#include "XSUB.h"
4 4
5#include <string.h> 5#include <string.h>
6#include <setjmp.h> 6#include <setjmp.h>
7#include <math.h>
8
9#include <magic.h>
7 10
8#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>
9#include <gdk-pixbuf/gdk-pixbuf.h> 17#include <gdk-pixbuf/gdk-pixbuf.h>
10 18
11#include <gperl.h> 19#include <gperl.h>
12#include <gtk2perl.h> 20#include <gtk2perl.h>
13 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
14#define IW 80 /* MUST match Schnauer.pm! */ 36#define IW 80 /* MUST match Schnauzer.pm! */
15#define IH 60 /* MUST match Schnauer.pm! */ 37#define IH 60 /* MUST match Schnauzer.pm! */
16
17#define RAND (seed = (seed + 7141) * 54773 % 134456)
18 38
19#define LINELENGTH 240 39#define LINELENGTH 240
20 40
21#define ELLIPSIS "\xe2\x80\xa6" 41#define ELLIPSIS "\xe2\x80\xa6"
42
43typedef char *octet_string;
44
45static magic_t magic_cookie[2]; /* !mime, mime */
22 46
23struct jpg_err_mgr 47struct jpg_err_mgr
24{ 48{
25 struct jpeg_error_mgr err; 49 struct jpeg_error_mgr err;
26 jmp_buf setjmp_buffer; 50 jmp_buf setjmp_buffer;
27}; 51};
28 52
29static void 53static void
30cv_error_exit (j_common_ptr cinfo) 54cv_error_exit (j_common_ptr cinfo)
31{ 55{
56 cinfo->err->output_message (cinfo);
32 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99); 57 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);
33} 58}
34 59
35static void 60static void
36cv_error_output (j_common_ptr cinfo) 61cv_error_output (j_common_ptr cinfo)
37{ 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);
38 return; 68 return;
39} 69}
40 70
41static void 71static void
42rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b, 72rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b,
… …
63 93
64 *h &= 255; 94 *h &= 255;
65 } 95 }
66} 96}
67 97
98struct feature {
99 float v1, v2, v3; // mean, square, cube
100 int n;
101};
102
103static void
104feature_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.
114static void
115feature_update_pass_1 (struct feature *f, unsigned int v)
116{
117 f->v1 += v;
118 f->n += 1;
119}
120
121static void
122feature_finish_pass_1 (struct feature *f)
123{
124 if (f->n < 1)
125 return;
126
127 f->v1 /= f->n;
128}
129
130static void
131feature_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
139static void
140feature_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
68static guint32 a85_val; 153static guint32 a85_val;
69static guint a85_cnt; 154static guint a85_cnt;
70static guchar a85_buf[LINELENGTH], *a85_ptr; 155static guchar a85_buf[LINELENGTH], *a85_ptr;
71 156
72static void 157static void
… …
84 if (!--a85_cnt) 169 if (!--a85_cnt)
85 { 170 {
86 a85_cnt = 4; 171 a85_cnt = 4;
87 if (a85_val) 172 if (a85_val)
88 { 173 {
89 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85; 174 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
90 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85; 175 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
91 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85; 176 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
92 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85; 177 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
93 a85_ptr[0] = (a85_val ) + 33; 178 a85_ptr[0] = (a85_val ) + 33;
94 179
95 a85_ptr += 5; 180 a85_ptr += 5;
96 } 181 }
… …
119 204
120 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf); 205 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
121} 206}
122 207
123///////////////////////////////////////////////////////////////////////////// 208/////////////////////////////////////////////////////////////////////////////
209// memory source for libjpeg
210
211static void cv_ms_init (j_decompress_ptr cinfo)
212{
213}
214
215static void cv_ms_term (j_decompress_ptr cinfo)
216{
217}
218
219static 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
235static 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
243static 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
267struct bmff_box
268{
269 char type[4];
270 const uint8_t *ptr;
271 size_t size;
272};
273
274static int
275bmff_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/////////////////////////////////////////////////////////////////////////////
124 303
125MODULE = Gtk2::CV PACKAGE = Gtk2::CV 304MODULE = Gtk2::CV PACKAGE = Gtk2::CV
126 305
127PROTOTYPES: ENABLE 306PROTOTYPES: ENABLE
128 307
308# calculate the common prefix length of two strings
309# missing function in perl. really :)
310int
311common_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
326const char *
327magic (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
129# missing in Gtk2 perl module 357# missing/broken in Gtk2 perl module
358
359void
360gdk_window_clear_hints (GdkWindow *window)
361 CODE:
362 gdk_window_set_geometry_hints (window, 0, 0);
130 363
131gboolean 364gboolean
132gdk_net_wm_supports (GdkAtom property) 365gdk_net_wm_supports (GdkAtom property)
133 CODE: 366 CODE:
134#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE) 367#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE)
… …
138#endif 371#endif
139 OUTPUT: 372 OUTPUT:
140 RETVAL 373 RETVAL
141 374
142GdkPixbuf_noinc * 375GdkPixbuf_noinc *
143transpose (GdkPixbuf *pb) 376dealpha_expose (GdkPixbuf *pb)
144 CODE: 377 CODE:
378 perlinterp_release ();
145{ 379{
146 int w = gdk_pixbuf_get_width (pb); 380 int w = gdk_pixbuf_get_width (pb);
147 int h = gdk_pixbuf_get_height (pb); 381 int h = gdk_pixbuf_get_height (pb);
148 int bpp = gdk_pixbuf_get_n_channels (pb); 382 int bpp = gdk_pixbuf_get_n_channels (pb);
149 int x, y, i; 383 int x, y, i;
150 guchar *src = gdk_pixbuf_get_pixels (pb), *dst; 384 guchar *src = gdk_pixbuf_get_pixels (pb), *dst;
151 int sstr = gdk_pixbuf_get_rowstride (pb), dstr; 385 int sstr = gdk_pixbuf_get_rowstride (pb), dstr;
152 386
153 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, h, w); 387 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
154 388
155 dst = gdk_pixbuf_get_pixels (RETVAL); 389 dst = gdk_pixbuf_get_pixels (RETVAL);
156 dstr = gdk_pixbuf_get_rowstride (RETVAL); 390 dstr = gdk_pixbuf_get_rowstride (RETVAL);
157 391
158 for (y = 0; y < h; y++)
159 for (x = 0; x < w; x++) 392 for (x = 0; x < w; x++)
393 for (y = 0; y < h; y++)
160 for (i = 0; i < bpp; i++) 394 for (i = 0; i < 3; i++)
161 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];
162} 396}
397 perlinterp_acquire ();
163 OUTPUT: 398 OUTPUT:
164 RETVAL 399 RETVAL
165 400
166GdkPixbuf_noinc * 401GdkPixbuf_noinc *
167flop (GdkPixbuf *pb) 402rotate (GdkPixbuf *pb, int angle)
168 CODE: 403 CODE:
169{ 404 perlinterp_release ();
170 int w = gdk_pixbuf_get_width (pb); 405 if (angle < 0)
171 int h = gdk_pixbuf_get_height (pb); 406 angle += 360;
172 int bpp = gdk_pixbuf_get_n_channels (pb); 407 RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE
173 int x, y, i; 408 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
174 guchar *src = gdk_pixbuf_get_pixels (pb), *dst; 409 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN
175 int sstr = gdk_pixbuf_get_rowstride (pb), dstr; 410 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE
176 411 : angle);
177 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, bpp == 4, 8, w, h); 412 perlinterp_acquire ();
178
179 dst = gdk_pixbuf_get_pixels (RETVAL);
180 dstr = gdk_pixbuf_get_rowstride (RETVAL);
181
182 for (y = 0; y < h; y++)
183 for (x = 0; x < w; x++)
184 for (i = 0; i < bpp; i++)
185 dst[(w - 1 - x) * bpp + y * dstr + i] = src[x * bpp + y * sstr + i];
186}
187 OUTPUT: 413 OUTPUT:
188 RETVAL 414 RETVAL
189 415
416const char *
417filetype (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
190GdkPixbuf_noinc * 462GdkPixbuf_noinc *
191load_jpeg (char *path, int thumbnail=0) 463decode_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
551GdkPixbuf_noinc *
552decode_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
659GdkPixbuf_noinc *
660decode_jpeg (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
192 CODE: 661 CODE:
193{ 662{
194 struct jpeg_decompress_struct cinfo; 663 struct jpeg_decompress_struct cinfo;
195 struct jpg_err_mgr jerr; 664 struct jpg_err_mgr jerr;
196 guchar *data;
197 int rs; 665 int rs;
198 FILE *fp;
199 volatile GdkPixbuf *pb = 0; 666 volatile GdkPixbuf *pb = 0;
667 STRLEN data_len;
668 guchar *data = SvPVbyte (image_data, data_len);
669
200 RETVAL = 0; 670 RETVAL = 0;
201 671
202 if (!(fp = fopen (path, "rb"))) 672 perlinterp_release ();
203 XSRETURN_UNDEF;
204 673
205 cinfo.err = jpeg_std_error (&jerr.err); 674 cinfo.err = jpeg_std_error (&jerr.err);
206 675
207 jerr.err.error_exit = cv_error_exit; 676 jerr.err.error_exit = cv_error_exit;
208 jerr.err.output_message = cv_error_output; 677 jerr.err.output_message = cv_error_output;
209 678
210 if ((rs = setjmp (jerr.setjmp_buffer))) 679 if ((rs = setjmp (jerr.setjmp_buffer)))
211 { 680 {
212 fclose (fp);
213 jpeg_destroy_decompress (&cinfo); 681 jpeg_destroy_decompress (&cinfo);
214 682
215 if (pb) 683 if (pb)
216 g_object_unref ((gpointer)pb); 684 g_object_unref ((gpointer)pb);
217 685
686 perlinterp_acquire ();
218 XSRETURN_UNDEF; 687 XSRETURN_UNDEF;
219 } 688 }
220 689
690 if (!data_len)
691 longjmp (jerr.setjmp_buffer, 4);
692
221 jpeg_create_decompress (&cinfo); 693 jpeg_create_decompress (&cinfo);
694 cv_jpeg_mem_src (&cinfo, data, data_len);
222 695
223 jpeg_stdio_src (&cinfo, fp);
224 jpeg_read_header (&cinfo, TRUE); 696 jpeg_read_header (&cinfo, TRUE);
225 697
226 cinfo.dct_method = JDCT_DEFAULT; 698 cinfo.dct_method = JDCT_DEFAULT;
227 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 */
228 cinfo.do_block_smoothing = FALSE; 700 cinfo.do_block_smoothing = FALSE;
… …
238 { 710 {
239 cinfo.dct_method = JDCT_FASTEST; 711 cinfo.dct_method = JDCT_FASTEST;
240 cinfo.do_fancy_upsampling = FALSE; 712 cinfo.do_fancy_upsampling = FALSE;
241 713
242 while (cinfo.scale_denom < 8 714 while (cinfo.scale_denom < 8
243 && cinfo.output_width >= IW*4 715 && cinfo.output_width >= iw*4
244 && cinfo.output_height >= IH*4) 716 && cinfo.output_height >= ih*4)
245 { 717 {
246 cinfo.scale_denom <<= 1; 718 cinfo.scale_denom <<= 1;
247 jpeg_calc_output_dimensions (&cinfo); 719 jpeg_calc_output_dimensions (&cinfo);
248 } 720 }
249 } 721 }
250 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
251 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);
252 if (!RETVAL) 733 if (!RETVAL)
253 longjmp (jerr.setjmp_buffer, 2); 734 longjmp (jerr.setjmp_buffer, 2);
254 735
255 data = gdk_pixbuf_get_pixels (RETVAL); 736 data = gdk_pixbuf_get_pixels (RETVAL);
256 rs = gdk_pixbuf_get_rowstride (RETVAL); 737 rs = gdk_pixbuf_get_rowstride (RETVAL);
257
258 if (cinfo.output_components != 3)
259 longjmp (jerr.setjmp_buffer, 3);
260 738
261 jpeg_start_decompress (&cinfo); 739 jpeg_start_decompress (&cinfo);
262 740
263 while (cinfo.output_scanline < cinfo.output_height) 741 while (cinfo.output_scanline < cinfo.output_height)
264 { 742 {
… …
271 rp [3] = (guchar *)rp [2] + rs; 749 rp [3] = (guchar *)rp [2] + rs;
272 750
273 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4); 751 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);
274 } 752 }
275 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
276 jpeg_finish_decompress (&cinfo); 783 jpeg_finish_decompress (&cinfo);
277 fclose (fp);
278 jpeg_destroy_decompress (&cinfo); 784 jpeg_destroy_decompress (&cinfo);
785 perlinterp_acquire ();
279} 786}
280 OUTPUT: 787 OUTPUT:
281 RETVAL 788 RETVAL
282 789
790void
791compare (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
283############################################################################# 838#############################################################################
284 839
285MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer 840MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer
841
842# currently only works for filenames (octet strings)
286 843
287SV * 844SV *
288foldcase (SV *pathsv) 845foldcase (SV *pathsv)
289 PROTOTYPE: $ 846 PROTOTYPE: $
290 CODE: 847 CODE:
291{ 848{
292 STRLEN plen; 849 STRLEN plen;
293 U8 *path = SvPVutf8 (pathsv, plen); 850 U8 *path = (U8 *)SvPV (pathsv, plen);
294 U8 *pend = path + plen; 851 U8 *pend = path + plen;
295 U8 dst [plen * 6 * 3], *dstp = dst; 852 U8 dst [plen * 6 * 3], *dstp = dst;
296 853
297 while (path < pend) 854 while (path < pend)
298 { 855 {
299 U8 ch = *path; 856 U8 ch = *path;
300 857
301 if (ch >= 'a' && ch <= 'z') 858 if (ch >= 'a' && ch <= 'z')
302 *dstp++ = *path++; 859 *dstp++ = *path++;
860 else if (ch >= 'A' && ch <= 'Z')
861 *dstp++ = *path++ + ('a' - 'A');
303 else if (ch >= '0' && ch <= '9') 862 else if (ch >= '0' && ch <= '9')
304 { 863 {
305 STRLEN el, nl = 0; 864 STRLEN el, nl = 0;
306 while (*path >= '0' && *path <= '9' && path < pend) 865 while (*path >= '0' && *path <= '9' && path < pend)
307 path++, nl++; 866 path++, nl++;
… …
310 *dstp++ = '0'; 869 *dstp++ = '0';
311 870
312 memcpy (dstp, path - nl, nl); 871 memcpy (dstp, path - nl, nl);
313 dstp += nl; 872 dstp += nl;
314 } 873 }
874 else
875 *dstp++ = *path++;
876#if 0
315 else 877 else
316 { 878 {
317 STRLEN cl; 879 STRLEN cl;
318 to_utf8_fold (path, dstp, &cl); 880 to_utf8_fold (path, dstp, &cl);
319 dstp += cl; 881 dstp += cl;
320 path += is_utf8_char (path); 882 path += is_utf8_char (path);
321 } 883 }
884#endif
322 } 885 }
323 886
324 RETVAL = newSVpvn (dst, dstp - dst); 887 RETVAL = newSVpvn ((const char *)dst, dstp - dst);
325} 888}
326 OUTPUT: 889 OUTPUT:
327 RETVAL 890 RETVAL
328 891
329GdkPixbuf_noinc * 892GdkPixbuf_noinc *
330p7_to_pb (int w, int h, guchar *src) 893p7_to_pb (int w, int h, SV *src_sv)
331 PROTOTYPE: @ 894 PROTOTYPE: @
332 CODE: 895 CODE:
333{ 896{
334 int x, y; 897 int x, y;
335 guchar *dst, *d; 898 guchar *dst, *d;
336 int dstr; 899 int dstr;
900 guchar *src = (guchar *)SvPVbyte_nolen (src_sv);
337 901
338 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h); 902 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, w, h);
339 dst = gdk_pixbuf_get_pixels (RETVAL); 903 dst = gdk_pixbuf_get_pixels (RETVAL);
340 dstr = gdk_pixbuf_get_rowstride (RETVAL); 904 dstr = gdk_pixbuf_get_rowstride (RETVAL);
341 905
… …
350 } 914 }
351} 915}
352 OUTPUT: 916 OUTPUT:
353 RETVAL 917 RETVAL
354 918
919#############################################################################
920
921MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
922
923void
924dump_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
945void
946dump_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
965MODULE = Gtk2::CV PACKAGE = Gtk2::CV
966
355SV * 967SV *
356pb_to_p7 (GdkPixbuf *pb) 968pb_to_hv84 (GdkPixbuf *pb)
357 CODE: 969 CODE:
358{ 970{
359 int w = gdk_pixbuf_get_width (pb); 971 int w = gdk_pixbuf_get_width (pb);
360 int h = gdk_pixbuf_get_height (pb); 972 int h = gdk_pixbuf_get_height (pb);
361 int x, y; 973 int x, y;
362 guchar *dst; 974 guchar *dst;
363 int bpp = gdk_pixbuf_get_n_channels (pb); 975 int bpp = gdk_pixbuf_get_n_channels (pb);
364 guchar *src = gdk_pixbuf_get_pixels (pb); 976 guchar *src = gdk_pixbuf_get_pixels (pb);
365 int sstr = gdk_pixbuf_get_rowstride (pb); 977 int sstr = gdk_pixbuf_get_rowstride (pb);
366 int Er[IW], Eg[IW], Eb[IW];
367 int seed = 77;
368
369 RETVAL = newSV (w * h);
370 SvPOK_only (RETVAL);
371 SvCUR_set (RETVAL, w * h);
372
373 dst = SvPVX (RETVAL);
374
375 memset (Er, 0, sizeof (int) * IW);
376 memset (Eg, 0, sizeof (int) * IW);
377 memset (Eb, 0, sizeof (int) * IW);
378
379 /* some primitive error distribution + random dithering */
380
381 for (y = 0; y < h; y++)
382 {
383 int er = 0, eg = 0, eb = 0;
384
385 for (x = 0; x < w; x++)
386 {
387 int r, g, b;
388 guchar *p = src + x * bpp + y * sstr;
389
390 r = ((p[0] + er + Er[x]) * 7 + (RAND & 127) + 64) / 255;
391 g = ((p[1] + eg + Eg[x]) * 7 + (RAND & 127) + 64) / 255;
392 b = ((p[2] + eb + Eb[x]) * 3 + (RAND & 127) + 64) / 255;
393
394 r = r > 7 ? 7 : r < 0 ? 0 : r;
395 g = g > 7 ? 7 : g < 0 ? 0 : g;
396 b = b > 3 ? 3 : b < 0 ? 0 : b;
397
398 er += p[0] - (r * 255 + 4) / 7;
399 eg += p[1] - (g * 255 + 4) / 7;
400 eb += p[2] - (b * 255 + 2) / 3;
401
402 Er[x] = er >> 1; er -= (er + 1) >> 1;
403 Eg[x] = eg >> 1; eg -= (eg + 1) >> 1;
404 Eb[x] = eb >> 1; eb -= (eb + 1) >> 1;
405
406 *dst++ = r << 5 | g << 2 | b;
407 }
408 }
409}
410 OUTPUT:
411 RETVAL
412
413#############################################################################
414
415MODULE = Gtk2::CV PACKAGE = Gtk2::CV::PostScript
416
417void
418dump_ascii85 (PerlIO *fp, GdkPixbuf *pb)
419 CODE:
420{
421 int w = gdk_pixbuf_get_width (pb);
422 int h = gdk_pixbuf_get_height (pb);
423 int x, y, i;
424 guchar *dst;
425 int bpp = gdk_pixbuf_get_n_channels (pb);
426 guchar *src = gdk_pixbuf_get_pixels (pb);
427 int sstr = gdk_pixbuf_get_rowstride (pb);
428
429 a85_init ();
430
431 for (y = 0; y < h; y++)
432 for (x = 0; x < w; x++)
433 for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
434 a85_push (fp, src [x * bpp + y * sstr + i]);
435
436 a85_finish (fp);
437}
438
439void
440dump_binary (PerlIO *fp, GdkPixbuf *pb)
441 CODE:
442{
443 int w = gdk_pixbuf_get_width (pb);
444 int h = gdk_pixbuf_get_height (pb);
445 int x, y, i;
446 guchar *dst;
447 int bpp = gdk_pixbuf_get_n_channels (pb);
448 guchar *src = gdk_pixbuf_get_pixels (pb);
449 int sstr = gdk_pixbuf_get_rowstride (pb);
450
451 for (y = 0; y < h; y++)
452 for (x = 0; x < w; x++)
453 for (i = 0; i < (bpp < 3 ? 1 : 3); i++)
454 PerlIO_putc (fp, src [x * bpp + y * sstr + i]);
455}
456
457#############################################################################
458
459MODULE = Gtk2::CV PACKAGE = Gtk2::CV
460
461SV *
462pb_to_hv84 (GdkPixbuf *pb)
463 CODE:
464{
465 int w = gdk_pixbuf_get_width (pb);
466 int h = gdk_pixbuf_get_height (pb);
467 int x, y;
468 guchar *dst;
469 int bpp = gdk_pixbuf_get_n_channels (pb);
470 guchar *src = gdk_pixbuf_get_pixels (pb);
471 int sstr = gdk_pixbuf_get_rowstride (pb);
472 978
473 RETVAL = newSV (6 * 8 * 12 / 8); 979 RETVAL = newSV (6 * 8 * 12 / 8);
474 SvPOK_only (RETVAL); 980 SvPOK_only (RETVAL);
475 SvCUR_set (RETVAL, 6 * 8 * 12 / 8); 981 SvCUR_set (RETVAL, 6 * 8 * 12 / 8);
476 982
477 dst = SvPVX (RETVAL); 983 dst = (guchar *)SvPVX (RETVAL);
478 984
479 /* some primitive error distribution + random dithering */ 985 /* some primitive error distribution + random dithering */
480 986
481 for (y = 0; y < h; y++) 987 for (y = 0; y < h; y++)
482 { 988 {
… …
545############################################################################# 1051#############################################################################
546 1052
547MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster 1053MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster
548 1054
549SV * 1055SV *
550make_histograms (SV *ar) 1056extract_features (SV *ar)
551 CODE: 1057 CODE:
552{ 1058{
553 int i; 1059 int i;
554 AV *av, *result; 1060 AV *av, *result;
555 1061
556 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV) 1062 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV)
557 croak ("Not an array ref as first argument to make_histogram"); 1063 croak ("Not an array ref as first argument to extract_features");
558 1064
559 av = (AV *) SvRV (ar); 1065 av = (AV *) SvRV (ar);
560 result = newAV (); 1066 result = newAV ();
561 1067
562 for (i = 0; i <= av_len (av); ++i) 1068 for (i = 0; i <= av_len (av); ++i)
563 { 1069 {
564 const int HISTSIZE = 64;
565
566 int j;
567 SV *sv = *av_fetch (av, i, 1); 1070 SV *sv = *av_fetch (av, i, 1);
568 STRLEN len;
569 char *buf = SvPVbyte (sv, len);
570
571 int tmphist[HISTSIZE];
572 float *hist;
573
574 SV *histsv = newSV (HISTSIZE * sizeof (float) + 1); 1071 SV *histsv = newSV (9 * sizeof (float) + 1);
1072
575 SvPOK_on (histsv); 1073 SvPOK_on (histsv);
576 SvCUR_set (histsv, HISTSIZE * sizeof (float)); 1074 SvCUR_set (histsv, 9 * sizeof (float));
577 hist = (float *)SvPVX (histsv); 1075 float *hist = (float *)SvPVX (histsv);
578 1076
579 Zero (tmphist, sizeof (tmphist), char); 1077 struct feature f_h, f_s, f_v;
1078 feature_init (&f_h);
1079 feature_init (&f_s);
1080 feature_init (&f_v);
580 1081
581 for (j = len; j--; )
582 {
583 unsigned int idx
584 = ((*buf & 0xc0) >> 2)
585 | ((*buf & 0x18) >> 1)
586 | (*buf & 0x03);
587
588 ++tmphist[idx];
589 ++buf;
590 }
591 1082 {
592 for (j = 0; j < HISTSIZE; ++j) 1083 STRLEN len;
593 hist[j] = (float)tmphist[j] / (len + 1e-30); 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;
594 1127
595 av_push (result, histsv); 1128 av_push (result, histsv);
596 } 1129 }
597 1130
598 RETVAL = newRV_noinc ((SV *)result); 1131 RETVAL = newRV_noinc ((SV *)result);
599} 1132}
600 OUTPUT: 1133 OUTPUT:
601 RETVAL 1134 RETVAL
602 1135
603

Diff Legend

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