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

Comparing CV/CV.xs (file contents):
Revision 1.29 by root, Sat Sep 24 01:25:17 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
9#include <glib.h> 14#include <glib.h>
10#include <gtk/gtk.h> 15#include <gtk/gtk.h>
16#include <gdk/gdkx.h>
11#include <gdk-pixbuf/gdk-pixbuf.h> 17#include <gdk-pixbuf/gdk-pixbuf.h>
12 18
13#include <gperl.h> 19#include <gperl.h>
14#include <gtk2perl.h> 20#include <gtk2perl.h>
15 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
16#define IW 80 /* MUST match Schnauer.pm! */ 36#define IW 80 /* MUST match Schnauzer.pm! */
17#define IH 60 /* MUST match Schnauer.pm! */ 37#define IH 60 /* MUST match Schnauzer.pm! */
18
19#define RAND (seed = (seed + 7141) * 54773 % 134456)
20 38
21#define LINELENGTH 240 39#define LINELENGTH 240
22 40
23#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 */
24 46
25struct jpg_err_mgr 47struct jpg_err_mgr
26{ 48{
27 struct jpeg_error_mgr err; 49 struct jpeg_error_mgr err;
28 jmp_buf setjmp_buffer; 50 jmp_buf setjmp_buffer;
29}; 51};
30 52
31static void 53static void
32cv_error_exit (j_common_ptr cinfo) 54cv_error_exit (j_common_ptr cinfo)
33{ 55{
56 cinfo->err->output_message (cinfo);
34 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99); 57 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);
35} 58}
36 59
37static void 60static void
38cv_error_output (j_common_ptr cinfo) 61cv_error_output (j_common_ptr cinfo)
39{ 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);
40 return; 68 return;
41} 69}
42 70
43static void 71static void
44rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b, 72rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b,
… …
65 93
66 *h &= 255; 94 *h &= 255;
67 } 95 }
68} 96}
69 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
70static guint32 a85_val; 153static guint32 a85_val;
71static guint a85_cnt; 154static guint a85_cnt;
72static guchar a85_buf[LINELENGTH], *a85_ptr; 155static guchar a85_buf[LINELENGTH], *a85_ptr;
73 156
74static void 157static void
… …
86 if (!--a85_cnt) 169 if (!--a85_cnt)
87 { 170 {
88 a85_cnt = 4; 171 a85_cnt = 4;
89 if (a85_val) 172 if (a85_val)
90 { 173 {
91 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85; 174 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
92 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85; 175 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
93 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85; 176 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
94 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85; 177 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
95 a85_ptr[0] = (a85_val ) + 33; 178 a85_ptr[0] = (a85_val ) + 33;
96 179
97 a85_ptr += 5; 180 a85_ptr += 5;
98 } 181 }
… …
121 204
122 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf); 205 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
123} 206}
124 207
125///////////////////////////////////////////////////////////////////////////// 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/////////////////////////////////////////////////////////////////////////////
126 303
127MODULE = Gtk2::CV PACKAGE = Gtk2::CV 304MODULE = Gtk2::CV PACKAGE = Gtk2::CV
128 305
129PROTOTYPES: ENABLE 306PROTOTYPES: ENABLE
130 307
308# calculate the common prefix length of two strings
131# missing function in perl. really :) 309# missing function in perl. really :)
132int 310int
133common_prefix_length (a, b) 311common_prefix_length (a, b)
134 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg); 312 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg);
135 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg); 313 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg);
… …
143 } 321 }
144 322
145 OUTPUT: 323 OUTPUT:
146 RETVAL 324 RETVAL
147 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
148# 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);
149 363
150gboolean 364gboolean
151gdk_net_wm_supports (GdkAtom property) 365gdk_net_wm_supports (GdkAtom property)
152 CODE: 366 CODE:
153#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE) 367#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE)
… …
159 RETVAL 373 RETVAL
160 374
161GdkPixbuf_noinc * 375GdkPixbuf_noinc *
162dealpha_expose (GdkPixbuf *pb) 376dealpha_expose (GdkPixbuf *pb)
163 CODE: 377 CODE:
378 perlinterp_release ();
164{ 379{
165 int w = gdk_pixbuf_get_width (pb); 380 int w = gdk_pixbuf_get_width (pb);
166 int h = gdk_pixbuf_get_height (pb); 381 int h = gdk_pixbuf_get_height (pb);
167 int bpp = gdk_pixbuf_get_n_channels (pb); 382 int bpp = gdk_pixbuf_get_n_channels (pb);
168 int x, y, i; 383 int x, y, i;
… …
177 for (x = 0; x < w; x++) 392 for (x = 0; x < w; x++)
178 for (y = 0; y < h; y++) 393 for (y = 0; y < h; y++)
179 for (i = 0; i < 3; i++) 394 for (i = 0; i < 3; i++)
180 dst[x * 3 + y * dstr + i] = src[x * bpp + y * sstr + i]; 395 dst[x * 3 + y * dstr + i] = src[x * bpp + y * sstr + i];
181} 396}
397 perlinterp_acquire ();
182 OUTPUT: 398 OUTPUT:
183 RETVAL 399 RETVAL
184 400
185GdkPixbuf_noinc * 401GdkPixbuf_noinc *
186rotate (GdkPixbuf *pb, int angle) 402rotate (GdkPixbuf *pb, int angle)
187 CODE: 403 CODE:
404 perlinterp_release ();
405 if (angle < 0)
406 angle += 360;
188 RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE 407 RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE
189 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE 408 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
190 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN 409 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN
191 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE 410 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE
192 : angle); 411 : angle);
412 perlinterp_acquire ();
193 OUTPUT: 413 OUTPUT:
194 RETVAL 414 RETVAL
195 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
196GdkPixbuf_noinc * 462GdkPixbuf_noinc *
197load_jpeg (SV *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)
198 CODE: 661 CODE:
199{ 662{
200 struct jpeg_decompress_struct cinfo; 663 struct jpeg_decompress_struct cinfo;
201 struct jpg_err_mgr jerr; 664 struct jpg_err_mgr jerr;
202 guchar *data;
203 int rs; 665 int rs;
204 FILE *fp;
205 volatile GdkPixbuf *pb = 0; 666 volatile GdkPixbuf *pb = 0;
206 gchar *filename; 667 STRLEN data_len;
668 guchar *data = SvPVbyte (image_data, data_len);
207 669
208 RETVAL = 0; 670 RETVAL = 0;
209 671
210 filename = g_filename_from_utf8 (SvPVutf8_nolen (path), -1, 0, 0, 0); 672 perlinterp_release ();
211 fp = fopen (filename, "rb");
212 g_free (filename);
213
214 if (!fp)
215 XSRETURN_UNDEF;
216 673
217 cinfo.err = jpeg_std_error (&jerr.err); 674 cinfo.err = jpeg_std_error (&jerr.err);
218 675
219 jerr.err.error_exit = cv_error_exit; 676 jerr.err.error_exit = cv_error_exit;
220 jerr.err.output_message = cv_error_output; 677 jerr.err.output_message = cv_error_output;
221 678
222 if ((rs = setjmp (jerr.setjmp_buffer))) 679 if ((rs = setjmp (jerr.setjmp_buffer)))
223 { 680 {
224 fclose (fp);
225 jpeg_destroy_decompress (&cinfo); 681 jpeg_destroy_decompress (&cinfo);
226 682
227 if (pb) 683 if (pb)
228 g_object_unref ((gpointer)pb); 684 g_object_unref ((gpointer)pb);
229 685
686 perlinterp_acquire ();
230 XSRETURN_UNDEF; 687 XSRETURN_UNDEF;
231 } 688 }
232 689
690 if (!data_len)
691 longjmp (jerr.setjmp_buffer, 4);
692
233 jpeg_create_decompress (&cinfo); 693 jpeg_create_decompress (&cinfo);
694 cv_jpeg_mem_src (&cinfo, data, data_len);
234 695
235 jpeg_stdio_src (&cinfo, fp);
236 jpeg_read_header (&cinfo, TRUE); 696 jpeg_read_header (&cinfo, TRUE);
237 697
238 cinfo.dct_method = JDCT_DEFAULT; 698 cinfo.dct_method = JDCT_DEFAULT;
239 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 */
240 cinfo.do_block_smoothing = FALSE; 700 cinfo.do_block_smoothing = FALSE;
… …
250 { 710 {
251 cinfo.dct_method = JDCT_FASTEST; 711 cinfo.dct_method = JDCT_FASTEST;
252 cinfo.do_fancy_upsampling = FALSE; 712 cinfo.do_fancy_upsampling = FALSE;
253 713
254 while (cinfo.scale_denom < 8 714 while (cinfo.scale_denom < 8
255 && cinfo.output_width >= IW*4 715 && cinfo.output_width >= iw*4
256 && cinfo.output_height >= IH*4) 716 && cinfo.output_height >= ih*4)
257 { 717 {
258 cinfo.scale_denom <<= 1; 718 cinfo.scale_denom <<= 1;
259 jpeg_calc_output_dimensions (&cinfo); 719 jpeg_calc_output_dimensions (&cinfo);
260 } 720 }
261 } 721 }
262 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
263 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);
264 if (!RETVAL) 733 if (!RETVAL)
265 longjmp (jerr.setjmp_buffer, 2); 734 longjmp (jerr.setjmp_buffer, 2);
266 735
267 data = gdk_pixbuf_get_pixels (RETVAL); 736 data = gdk_pixbuf_get_pixels (RETVAL);
268 rs = gdk_pixbuf_get_rowstride (RETVAL); 737 rs = gdk_pixbuf_get_rowstride (RETVAL);
269
270 if (cinfo.output_components != 3)
271 longjmp (jerr.setjmp_buffer, 3);
272 738
273 jpeg_start_decompress (&cinfo); 739 jpeg_start_decompress (&cinfo);
274 740
275 while (cinfo.output_scanline < cinfo.output_height) 741 while (cinfo.output_scanline < cinfo.output_height)
276 { 742 {
… …
283 rp [3] = (guchar *)rp [2] + rs; 749 rp [3] = (guchar *)rp [2] + rs;
284 750
285 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4); 751 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);
286 } 752 }
287 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
288 jpeg_finish_decompress (&cinfo); 783 jpeg_finish_decompress (&cinfo);
289 fclose (fp);
290 jpeg_destroy_decompress (&cinfo); 784 jpeg_destroy_decompress (&cinfo);
785 perlinterp_acquire ();
291} 786}
292 OUTPUT: 787 OUTPUT:
293 RETVAL 788 RETVAL
294 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
295############################################################################# 838#############################################################################
296 839
297MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer 840MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer
841
842# currently only works for filenames (octet strings)
298 843
299SV * 844SV *
300foldcase (SV *pathsv) 845foldcase (SV *pathsv)
301 PROTOTYPE: $ 846 PROTOTYPE: $
302 CODE: 847 CODE:
303{ 848{
304 STRLEN plen; 849 STRLEN plen;
305 U8 *path = (U8 *)SvPVutf8 (pathsv, plen); 850 U8 *path = (U8 *)SvPV (pathsv, plen);
306 U8 *pend = path + plen; 851 U8 *pend = path + plen;
307 U8 dst [plen * 6 * 3], *dstp = dst; 852 U8 dst [plen * 6 * 3], *dstp = dst;
308 853
309 while (path < pend) 854 while (path < pend)
310 { 855 {
311 U8 ch = *path; 856 U8 ch = *path;
312 857
313 if (ch >= 'a' && ch <= 'z') 858 if (ch >= 'a' && ch <= 'z')
314 *dstp++ = *path++; 859 *dstp++ = *path++;
860 else if (ch >= 'A' && ch <= 'Z')
861 *dstp++ = *path++ + ('a' - 'A');
315 else if (ch >= '0' && ch <= '9') 862 else if (ch >= '0' && ch <= '9')
316 { 863 {
317 STRLEN el, nl = 0; 864 STRLEN el, nl = 0;
318 while (*path >= '0' && *path <= '9' && path < pend) 865 while (*path >= '0' && *path <= '9' && path < pend)
319 path++, nl++; 866 path++, nl++;
… …
322 *dstp++ = '0'; 869 *dstp++ = '0';
323 870
324 memcpy (dstp, path - nl, nl); 871 memcpy (dstp, path - nl, nl);
325 dstp += nl; 872 dstp += nl;
326 } 873 }
874 else
875 *dstp++ = *path++;
876#if 0
327 else 877 else
328 { 878 {
329 STRLEN cl; 879 STRLEN cl;
330 to_utf8_fold (path, dstp, &cl); 880 to_utf8_fold (path, dstp, &cl);
331 dstp += cl; 881 dstp += cl;
332 path += is_utf8_char (path); 882 path += is_utf8_char (path);
333 } 883 }
884#endif
334 } 885 }
335 886
336 RETVAL = newSVpvn ((const char *)dst, dstp - dst); 887 RETVAL = newSVpvn ((const char *)dst, dstp - dst);
337} 888}
338 OUTPUT: 889 OUTPUT:
… …
500############################################################################# 1051#############################################################################
501 1052
502MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster 1053MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster
503 1054
504SV * 1055SV *
505make_histograms (SV *ar) 1056extract_features (SV *ar)
506 CODE: 1057 CODE:
507{ 1058{
508 int i; 1059 int i;
509 AV *av, *result; 1060 AV *av, *result;
510 1061
511 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV) 1062 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV)
512 croak ("Not an array ref as first argument to make_histogram"); 1063 croak ("Not an array ref as first argument to extract_features");
513 1064
514 av = (AV *) SvRV (ar); 1065 av = (AV *) SvRV (ar);
515 result = newAV (); 1066 result = newAV ();
516 1067
517 for (i = 0; i <= av_len (av); ++i) 1068 for (i = 0; i <= av_len (av); ++i)
518 { 1069 {
519 const int HISTSIZE = 64;
520
521 int j;
522 SV *sv = *av_fetch (av, i, 1); 1070 SV *sv = *av_fetch (av, i, 1);
523 STRLEN len;
524 char *buf = SvPVbyte (sv, len);
525
526 int tmphist[HISTSIZE];
527 float *hist;
528
529 SV *histsv = newSV (HISTSIZE * sizeof (float) + 1); 1071 SV *histsv = newSV (9 * sizeof (float) + 1);
1072
530 SvPOK_on (histsv); 1073 SvPOK_on (histsv);
531 SvCUR_set (histsv, HISTSIZE * sizeof (float)); 1074 SvCUR_set (histsv, 9 * sizeof (float));
532 hist = (float *)SvPVX (histsv); 1075 float *hist = (float *)SvPVX (histsv);
533 1076
534 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);
535 1081
536 for (j = len; j--; )
537 {
538 unsigned int idx
539 = ((*buf & 0xc0) >> 2)
540 | ((*buf & 0x18) >> 1)
541 | (*buf & 0x03);
542
543 ++tmphist[idx];
544 ++buf;
545 }
546 1082 {
547 for (j = 0; j < HISTSIZE; ++j) 1083 STRLEN len;
548 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;
549 1127
550 av_push (result, histsv); 1128 av_push (result, histsv);
551 } 1129 }
552 1130
553 RETVAL = newRV_noinc ((SV *)result); 1131 RETVAL = newRV_noinc ((SV *)result);
554} 1132}
555 OUTPUT: 1133 OUTPUT:
556 RETVAL 1134 RETVAL
557 1135
558

Diff Legend

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