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

Comparing CV/CV.xs (file contents):
Revision 1.35 by root, Tue Mar 7 16:45:53 2006 UTC vs.
Revision 1.61 by root, Sun Jul 25 11:24:48 2021 UTC

… …
7#include <math.h> 7#include <math.h>
8 8
9#include <magic.h> 9#include <magic.h>
10 10
11#include <jpeglib.h> 11#include <jpeglib.h>
12#include <jerror.h>
13
12#include <glib.h> 14#include <glib.h>
13#include <gtk/gtk.h> 15#include <gtk/gtk.h>
16#include <gdk/gdkx.h>
14#include <gdk-pixbuf/gdk-pixbuf.h> 17#include <gdk-pixbuf/gdk-pixbuf.h>
15 18
16#include <gperl.h> 19#include <gperl.h>
17#include <gtk2perl.h> 20#include <gtk2perl.h>
18 21
22#include <assert.h>
23
24#if WEBP
25#include <webp/demux.h>
26#include <webp/decode.h>
27#endif
28
29#if JXL
30#include <jxl/decode.h>
31#include "jxl/thread_parallel_runner.h"
32#endif
33
34#include "perlmulticore.h"
35
19#define IW 80 /* MUST match Schnauzer.pm! */ 36#define IW 80 /* MUST match Schnauzer.pm! */
20#define IH 60 /* MUST match Schnauzer.pm! */ 37#define IH 60 /* MUST match Schnauzer.pm! */
21 38
22#define RAND (seed = (seed + 7141) * 54773 % 134456)
23
24#define LINELENGTH 240 39#define LINELENGTH 240
25 40
26#define ELLIPSIS "\xe2\x80\xa6" 41#define ELLIPSIS "\xe2\x80\xa6"
42
43typedef char *octet_string;
44
45static magic_t magic_cookie[2]; /* !mime, mime */
27 46
28struct jpg_err_mgr 47struct jpg_err_mgr
29{ 48{
30 struct jpeg_error_mgr err; 49 struct jpeg_error_mgr err;
31 jmp_buf setjmp_buffer; 50 jmp_buf setjmp_buffer;
32}; 51};
33 52
34static void 53static void
35cv_error_exit (j_common_ptr cinfo) 54cv_error_exit (j_common_ptr cinfo)
36{ 55{
56 cinfo->err->output_message (cinfo);
37 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99); 57 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);
38} 58}
39 59
40static void 60static void
41cv_error_output (j_common_ptr cinfo) 61cv_error_output (j_common_ptr cinfo)
42{ 62{
63 char msg[JMSG_LENGTH_MAX];
64
65 cinfo->err->format_message (cinfo, msg);
66
67 fprintf (stderr, "JPEG decoding error: %s\n", msg);
43 return; 68 return;
44} 69}
45 70
46static void 71static void
47rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b, 72rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b,
… …
68 93
69 *h &= 255; 94 *h &= 255;
70 } 95 }
71} 96}
72 97
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
73static guint32 a85_val; 153static guint32 a85_val;
74static guint a85_cnt; 154static guint a85_cnt;
75static guchar a85_buf[LINELENGTH], *a85_ptr; 155static guchar a85_buf[LINELENGTH], *a85_ptr;
76 156
77static void 157static void
… …
89 if (!--a85_cnt) 169 if (!--a85_cnt)
90 { 170 {
91 a85_cnt = 4; 171 a85_cnt = 4;
92 if (a85_val) 172 if (a85_val)
93 { 173 {
94 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85; 174 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
95 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85; 175 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
96 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85; 176 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
97 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85; 177 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
98 a85_ptr[0] = (a85_val ) + 33; 178 a85_ptr[0] = (a85_val ) + 33;
99 179
100 a85_ptr += 5; 180 a85_ptr += 5;
101 } 181 }
… …
124 204
125 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf); 205 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
126} 206}
127 207
128///////////////////////////////////////////////////////////////////////////// 208/////////////////////////////////////////////////////////////////////////////
209// memory source for libjpeg
210
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/////////////////////////////////////////////////////////////////////////////
129 303
130MODULE = Gtk2::CV PACKAGE = Gtk2::CV 304MODULE = Gtk2::CV PACKAGE = Gtk2::CV
131 305
132PROTOTYPES: ENABLE 306PROTOTYPES: ENABLE
133 307
308# calculate the common prefix length of two strings
134# missing function in perl. really :) 309# missing function in perl. really :)
135int 310int
136common_prefix_length (a, b) 311common_prefix_length (a, b)
137 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg); 312 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg);
138 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg); 313 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg);
… …
147 322
148 OUTPUT: 323 OUTPUT:
149 RETVAL 324 RETVAL
150 325
151const char * 326const char *
152magic (const char *path) 327magic (SV *path_or_data)
328 ALIAS:
329 magic = 0
330 magic_mime = 1
331 magic_buffer = 2
332 magic_buffer_mime = 3
153 CODE: 333 CODE:
154{ 334{
155 static magic_t cookie; 335 STRLEN len;
336 char *data = SvPVbyte (path_or_data, len);
156 337
157 if (!cookie) 338 if (!magic_cookie[0])
339 {
340 magic_cookie[0] = magic_open (MAGIC_SYMLINK);
341 magic_cookie[1] = magic_open (MAGIC_SYMLINK | MAGIC_MIME_TYPE);
342 magic_load (magic_cookie[0], 0);
343 magic_load (magic_cookie[1], 0);
158 { 344 }
159 cookie = magic_open (MAGIC_NONE);
160 345
161 if (cookie) 346 perlinterp_release ();
162 magic_load (cookie, 0);
163 else
164 XSRETURN_UNDEF;
165 }
166 347
167 RETVAL = magic_file (cookie, path); 348 RETVAL = ix & 2
349 ? magic_buffer (magic_cookie[ix & 1], data, len)
350 : magic_file (magic_cookie[ix & 1], data);
351
352 perlinterp_acquire ();
168} 353}
169 OUTPUT: 354 OUTPUT:
170 RETVAL 355 RETVAL
171 356
172const char *
173magic_mime (const char *path)
174 CODE:
175{
176 static magic_t cookie;
177
178 if (!cookie)
179 {
180 cookie = magic_open (MAGIC_MIME);
181
182 if (cookie)
183 magic_load (cookie, 0);
184 else
185 XSRETURN_UNDEF;
186 }
187
188 RETVAL = magic_file (cookie, path);
189}
190 OUTPUT:
191 RETVAL
192
193# missing in Gtk2 perl module 357# missing/broken in Gtk2 perl module
358
359void
360gdk_window_clear_hints (GdkWindow *window)
361 CODE:
362 gdk_window_set_geometry_hints (window, 0, 0);
194 363
195gboolean 364gboolean
196gdk_net_wm_supports (GdkAtom property) 365gdk_net_wm_supports (GdkAtom property)
197 CODE: 366 CODE:
198#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE) 367#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE)
… …
204 RETVAL 373 RETVAL
205 374
206GdkPixbuf_noinc * 375GdkPixbuf_noinc *
207dealpha_expose (GdkPixbuf *pb) 376dealpha_expose (GdkPixbuf *pb)
208 CODE: 377 CODE:
378 perlinterp_release ();
209{ 379{
210 int w = gdk_pixbuf_get_width (pb); 380 int w = gdk_pixbuf_get_width (pb);
211 int h = gdk_pixbuf_get_height (pb); 381 int h = gdk_pixbuf_get_height (pb);
212 int bpp = gdk_pixbuf_get_n_channels (pb); 382 int bpp = gdk_pixbuf_get_n_channels (pb);
213 int x, y, i; 383 int x, y, i;
… …
222 for (x = 0; x < w; x++) 392 for (x = 0; x < w; x++)
223 for (y = 0; y < h; y++) 393 for (y = 0; y < h; y++)
224 for (i = 0; i < 3; i++) 394 for (i = 0; i < 3; i++)
225 dst[x * 3 + y * dstr + i] = src[x * bpp + y * sstr + i]; 395 dst[x * 3 + y * dstr + i] = src[x * bpp + y * sstr + i];
226} 396}
397 perlinterp_acquire ();
227 OUTPUT: 398 OUTPUT:
228 RETVAL 399 RETVAL
229 400
230GdkPixbuf_noinc * 401GdkPixbuf_noinc *
231rotate (GdkPixbuf *pb, int angle) 402rotate (GdkPixbuf *pb, int angle)
232 CODE: 403 CODE:
404 perlinterp_release ();
405 if (angle < 0)
406 angle += 360;
233 RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE 407 RETVAL = gdk_pixbuf_rotate_simple (pb, angle == 0 ? GDK_PIXBUF_ROTATE_NONE
234 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE 408 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
235 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN 409 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN
236 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE 410 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE
237 : angle); 411 : angle);
412 perlinterp_acquire ();
238 OUTPUT: 413 OUTPUT:
239 RETVAL 414 RETVAL
240 415
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 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 // skip a rare first graphic control extension block
475 // we assume there is exactly one block
476 if (data[ofs] == 0x21 && data[ofs + 1] == 0xf9)
477 ofs += 3 + data[ofs + 2] + 1;
478
479 if (data_len >= ofs + 2 + 1 + 11)
480 if (!memcmp (data + ofs, "\x21\xff\x0bNETSCAPE2.0", sizeof ("\x21\xff\x0bNETSCAPE2.0") - 1))
481 RETVAL = "video/gif";
482 }
483 }
484
485 else
486 XSRETURN_UNDEF;
487}
488 OUTPUT:
489 RETVAL
490
241GdkPixbuf_noinc * 491GdkPixbuf_noinc *
242load_jpeg (SV *path, int thumbnail=0) 492decode_webp (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
493 CODE:
494{
495#if WEBP
496 STRLEN data_size;
497 int alpha;
498 WebPData data;
499 WebPDemuxer *demux;
500 WebPIterator iter;
501 WebPDecoderConfig config;
502 int inw, inh;
503
504 data.bytes = (uint8_t *)SvPVbyte (image_data, data_size);
505 data.size = data_size;
506
507 perlinterp_release ();
508
509 RETVAL = 0;
510
511 if (!(demux = WebPDemux (&data)))
512 goto err_demux;
513
514 if (!WebPDemuxGetFrame (demux, 1, &iter))
515 goto err_iter;
516
517 if (!WebPInitDecoderConfig (&config))
518 goto err_iter;
519
520 config.options.use_threads = 1;
521
522 if (WebPGetFeatures (iter.fragment.bytes, iter.fragment.size, &config.input) != VP8_STATUS_OK)
523 goto err_iter;
524
525 inw = config.input.width;
526 inh = config.input.height;
527
528 if (thumbnail)
529 {
530 if (inw * ih > inh * iw)
531 ih = (iw * inh + inw - 1) / inw;
532 else
533 iw = (ih * inw + inh - 1) / inh;
534
535 config.options.bypass_filtering = 1;
536 config.options.no_fancy_upsampling = 1;
537
538 config.options.use_scaling = 1;
539 config.options.scaled_width = iw;
540 config.options.scaled_height = ih;
541 }
542 else
543 {
544 iw = inw;
545 ih = inh;
546 }
547
548 alpha = !!config.input.has_alpha;
549
550 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, alpha, 8, iw, ih);
551 if (!RETVAL)
552 goto err_iter;
553
554 config.output.colorspace = alpha ? MODE_RGBA : MODE_RGB;
555 config.output.u.RGBA.rgba = gdk_pixbuf_get_pixels (RETVAL);
556 config.output.u.RGBA.stride = gdk_pixbuf_get_rowstride (RETVAL);
557 config.output.u.RGBA.size = gdk_pixbuf_get_byte_length (RETVAL);
558 config.output.is_external_memory = 1;
559
560 if (WebPDecode (iter.fragment.bytes, iter.fragment.size, &config) != VP8_STATUS_OK)
561 {
562 g_object_unref (RETVAL);
563 RETVAL = 0;
564 goto err_iter;
565 }
566
567 err_iter:
568 WebPDemuxReleaseIterator (&iter);
569 err_demux:
570 WebPDemuxDelete (demux);
571
572 perlinterp_acquire ();
573#else
574 croak ("load_webp: webp not enabled at compile time");
575#endif
576}
577 OUTPUT:
578 RETVAL
579
580GdkPixbuf_noinc *
581decode_jxl (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
582 CODE:
583{
584#if JXL
585 JxlDecoder *dec = JxlDecoderCreate (0);
586 JxlBasicInfo info;
587 const uint8_t *next_in = (uint8_t *)SvPVbyte_nolen (image_data);
588 size_t avail_in = SvCUR (image_data);
589 const char *error = 0;
590 void *runner = 0;
591 struct bmff_box box;
592
593 perlinterp_release ();
594
595 RETVAL = 0;
596
597 error = "JxlDecoderCreate failed";
598 if (!dec)
599 goto done;
600
601 runner = JxlThreadParallelRunnerCreate (0, JxlThreadParallelRunnerDefaultNumWorkerThreads ());
602
603 error = "JxlDecoderSetParallelRunner failed";
604 if (JxlDecoderSetParallelRunner (dec, JxlThreadParallelRunner, runner) != JXL_DEC_SUCCESS)
605 goto done;
606
607 error = "JxlDecoderSubscribeEvents failed";
608 if (JxlDecoderSubscribeEvents (dec, JXL_DEC_FULL_IMAGE | JXL_DEC_BASIC_INFO) != JXL_DEC_SUCCESS)
609 goto done;
610
611 error = "JxlDecoderSetInput failed";
612 if (JxlDecoderSetInput (dec, next_in, avail_in) != JXL_DEC_SUCCESS)
613 goto done;
614
615 for (;;)
616 {
617 JxlDecoderStatus status = JxlDecoderProcessInput (dec);
618
619 printf ("status %d\n",status);
620
621 switch (status)
622 {
623 case JXL_DEC_ERROR:
624 error = "JxlDecoderProcessInput failed";
625 goto done;
626
627 case JXL_DEC_NEED_MORE_INPUT:
628 error = "incomplete file";
629 goto done;
630
631 case JXL_DEC_SUCCESS:
632 goto done;
633
634 case JXL_DEC_NEED_IMAGE_OUT_BUFFER:
635 {
636 error = "JxlDecoderGetBasicInfo failed";
637 if (JxlDecoderGetBasicInfo (dec, &info) != JXL_DEC_SUCCESS)
638 goto done;
639
640 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, !!info.alpha_bits, 8, info.xsize, info.ysize);
641 error = "unable to allocate pixbuf";
642 if (!RETVAL)
643 goto done;
644
645 JxlPixelFormat format = {
646 info.alpha_bits ? 4 : 3,
647 JXL_TYPE_UINT8,
648 JXL_NATIVE_ENDIAN,
649 gdk_pixbuf_get_rowstride (RETVAL)
650 };
651
652 error = "JxlDecoderSetImageOutBuffer failed";
653 if (JxlDecoderSetImageOutBuffer (
654 dec,
655 &format,
656 gdk_pixbuf_get_pixels (RETVAL),
657 gdk_pixbuf_get_byte_length (RETVAL)
658 ) != JXL_DEC_SUCCESS)
659 goto done;
660 }
661 break;
662
663 default:
664 error = "unexpected event";
665 goto done;
666 }
667 }
668
669 done:
670 if (dec)
671 JxlDecoderDestroy (dec);
672
673 if (runner)
674 JxlThreadParallelRunnerDestroy (runner);
675
676 perlinterp_acquire ();
677
678 if (error)
679 {
680 if (RETVAL)
681 g_object_unref (RETVAL);
682
683 croak ("load_jxl: %s", error);
684 }
685#else
686 croak ("load_jxl: jpeg-xl not enabled at compile time");
687#endif
688}
689 OUTPUT:
690 RETVAL
691
692GdkPixbuf_noinc *
693decode_jpeg (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
243 CODE: 694 CODE:
244{ 695{
245 struct jpeg_decompress_struct cinfo; 696 struct jpeg_decompress_struct cinfo;
246 struct jpg_err_mgr jerr; 697 struct jpg_err_mgr jerr;
247 guchar *data;
248 int rs; 698 int rs;
249 FILE *fp;
250 volatile GdkPixbuf *pb = 0; 699 volatile GdkPixbuf *pb = 0;
700 STRLEN data_len;
701 guchar *data = SvPVbyte (image_data, data_len);
251 702
252 RETVAL = 0; 703 RETVAL = 0;
253 704
254 fp = fopen (SvPVbyte_nolen (path), "rb"); 705 perlinterp_release ();
255
256 if (!fp)
257 XSRETURN_UNDEF;
258 706
259 cinfo.err = jpeg_std_error (&jerr.err); 707 cinfo.err = jpeg_std_error (&jerr.err);
260 708
261 jerr.err.error_exit = cv_error_exit; 709 jerr.err.error_exit = cv_error_exit;
262 jerr.err.output_message = cv_error_output; 710 jerr.err.output_message = cv_error_output;
263 711
264 if ((rs = setjmp (jerr.setjmp_buffer))) 712 if ((rs = setjmp (jerr.setjmp_buffer)))
265 { 713 {
266 fclose (fp);
267 jpeg_destroy_decompress (&cinfo); 714 jpeg_destroy_decompress (&cinfo);
268 715
269 if (pb) 716 if (pb)
270 g_object_unref ((gpointer)pb); 717 g_object_unref ((gpointer)pb);
271 718
719 perlinterp_acquire ();
272 XSRETURN_UNDEF; 720 XSRETURN_UNDEF;
273 } 721 }
274 722
723 if (!data_len)
724 longjmp (jerr.setjmp_buffer, 4);
725
275 jpeg_create_decompress (&cinfo); 726 jpeg_create_decompress (&cinfo);
727 cv_jpeg_mem_src (&cinfo, data, data_len);
276 728
277 jpeg_stdio_src (&cinfo, fp);
278 jpeg_read_header (&cinfo, TRUE); 729 jpeg_read_header (&cinfo, TRUE);
279 730
280 cinfo.dct_method = JDCT_DEFAULT; 731 cinfo.dct_method = JDCT_DEFAULT;
281 cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */ 732 cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */
282 cinfo.do_block_smoothing = FALSE; 733 cinfo.do_block_smoothing = FALSE;
… …
292 { 743 {
293 cinfo.dct_method = JDCT_FASTEST; 744 cinfo.dct_method = JDCT_FASTEST;
294 cinfo.do_fancy_upsampling = FALSE; 745 cinfo.do_fancy_upsampling = FALSE;
295 746
296 while (cinfo.scale_denom < 8 747 while (cinfo.scale_denom < 8
297 && cinfo.output_width >= IW*4 748 && cinfo.output_width >= iw*4
298 && cinfo.output_height >= IH*4) 749 && cinfo.output_height >= ih*4)
299 { 750 {
300 cinfo.scale_denom <<= 1; 751 cinfo.scale_denom <<= 1;
301 jpeg_calc_output_dimensions (&cinfo); 752 jpeg_calc_output_dimensions (&cinfo);
302 } 753 }
303 } 754 }
304 755
756 if (cinfo.output_components != 3)
757 longjmp (jerr.setjmp_buffer, 3);
758
759 if (cinfo.jpeg_color_space == JCS_YCCK || cinfo.jpeg_color_space == JCS_CMYK)
760 {
761 cinfo.out_color_space = JCS_CMYK;
762 cinfo.output_components = 4;
763 }
764
305 pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, cinfo.output_width, cinfo.output_height); 765 pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, cinfo.output_components == 4, 8, cinfo.output_width, cinfo.output_height);
306 if (!RETVAL) 766 if (!RETVAL)
307 longjmp (jerr.setjmp_buffer, 2); 767 longjmp (jerr.setjmp_buffer, 2);
308 768
309 data = gdk_pixbuf_get_pixels (RETVAL); 769 data = gdk_pixbuf_get_pixels (RETVAL);
310 rs = gdk_pixbuf_get_rowstride (RETVAL); 770 rs = gdk_pixbuf_get_rowstride (RETVAL);
311
312 if (cinfo.output_components != 3)
313 longjmp (jerr.setjmp_buffer, 3);
314 771
315 jpeg_start_decompress (&cinfo); 772 jpeg_start_decompress (&cinfo);
316 773
317 while (cinfo.output_scanline < cinfo.output_height) 774 while (cinfo.output_scanline < cinfo.output_height)
318 { 775 {
… …
325 rp [3] = (guchar *)rp [2] + rs; 782 rp [3] = (guchar *)rp [2] + rs;
326 783
327 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4); 784 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);
328 } 785 }
329 786
787 if (cinfo.out_color_space == JCS_CMYK)
788 {
789 guchar *end = data + cinfo.output_height * rs;
790
791 while (data < end)
792 {
793 U32 c = data [0];
794 U32 m = data [1];
795 U32 y = data [2];
796 U32 k = data [3];
797
798 if (0)
799 if (cinfo.Adobe_transform == 2)
800 {
801 c ^= 0xff;
802 m ^= 0xff;
803 y ^= 0xff;
804 k ^= 0xff;
805 }
806
807 data [0] = (c * k + 0x80) / 0xff;
808 data [1] = (m * k + 0x80) / 0xff;
809 data [2] = (y * k + 0x80) / 0xff;
810 data [3] = 0xff;
811
812 data += 4;
813 }
814 }
815
330 jpeg_finish_decompress (&cinfo); 816 jpeg_finish_decompress (&cinfo);
331 fclose (fp);
332 jpeg_destroy_decompress (&cinfo); 817 jpeg_destroy_decompress (&cinfo);
818 perlinterp_acquire ();
333} 819}
334 OUTPUT: 820 OUTPUT:
335 RETVAL 821 RETVAL
336 822
337void 823void
338compare (GdkPixbuf *a, GdkPixbuf *b) 824compare (GdkPixbuf *a, GdkPixbuf *b)
339 PPCODE: 825 PPCODE:
826 perlinterp_release ();
340{ 827{
341 int w = gdk_pixbuf_get_width (a); 828 int w = gdk_pixbuf_get_width (a);
342 int h = gdk_pixbuf_get_height (a); 829 int h = gdk_pixbuf_get_height (a);
830
343 int sa = gdk_pixbuf_get_rowstride (a); 831 int sa = gdk_pixbuf_get_rowstride (a);
344 int sb = gdk_pixbuf_get_rowstride (b); 832 int sb = gdk_pixbuf_get_rowstride (b);
345 833
346 guchar *pa = gdk_pixbuf_get_pixels (a); 834 guchar *pa = gdk_pixbuf_get_pixels (a);
347 guchar *pb = gdk_pixbuf_get_pixels (b); 835 guchar *pb = gdk_pixbuf_get_pixels (b);
… …
371 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d)); 859 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d));
372 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d)); 860 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d));
373 } 861 }
374 } 862 }
375 863
864 perlinterp_acquire ();
865
376 EXTEND (SP, 2); 866 EXTEND (SP, 2);
377 PUSHs (sv_2mortal (newSVnv (sqrt (diff / (w * h * 3. * 255. * 255.))))); 867 PUSHs (sv_2mortal (newSVnv (sqrt (diff / (w * h * 3. * 255. * 255.)))));
378 PUSHs (sv_2mortal (newSVnv (peak / 255.))); 868 PUSHs (sv_2mortal (newSVnv (peak / 255.)));
379} 869}
380 870
381############################################################################# 871#############################################################################
382 872
383MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer 873MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer
384 874
875# currently only works for filenames (octet strings)
876
385SV * 877SV *
386foldcase (SV *pathsv) 878foldcase (SV *pathsv)
387 PROTOTYPE: $ 879 PROTOTYPE: $
388 CODE: 880 CODE:
389{ 881{
390 STRLEN plen; 882 STRLEN plen;
391 U8 *path = (U8 *)SvPVutf8 (pathsv, plen); 883 U8 *path = (U8 *)SvPV (pathsv, plen);
392 U8 *pend = path + plen; 884 U8 *pend = path + plen;
393 U8 dst [plen * 6 * 3], *dstp = dst; 885 U8 dst [plen * 8 * 3], *dstp = dst;
394 886
395 while (path < pend) 887 while (path < pend)
396 { 888 {
397 U8 ch = *path; 889 U8 ch = *path;
398 890
399 if (ch >= 'a' && ch <= 'z') 891 if (ch >= 'a' && ch <= 'z')
400 *dstp++ = *path++; 892 *dstp++ = *path++;
893 else if (ch >= 'A' && ch <= 'Z')
894 *dstp++ = *path++ + ('a' - 'A');
401 else if (ch >= '0' && ch <= '9') 895 else if (ch >= '0' && ch <= '9')
402 { 896 {
897 /* version sort, up to 8 digits */
403 STRLEN el, nl = 0; 898 STRLEN el, nl = 0;
404 while (*path >= '0' && *path <= '9' && path < pend) 899 while (*path >= '0' && *path <= '9' && path < pend)
405 path++, nl++; 900 path++, nl++;
406 901
407 for (el = nl; el < 6; el++) 902 for (el = nl; el < 8; el++)
408 *dstp++ = '0'; 903 *dstp++ = '0';
409 904
410 memcpy (dstp, path - nl, nl); 905 memcpy (dstp, path - nl, nl);
411 dstp += nl; 906 dstp += nl;
412 } 907 }
908 else
909 *dstp++ = *path++;
910#if 0
413 else 911 else
414 { 912 {
415 STRLEN cl; 913 STRLEN cl;
416 to_utf8_fold (path, dstp, &cl); 914 to_utf8_fold (path, dstp, &cl);
417 dstp += cl; 915 dstp += cl;
418 path += is_utf8_char (path); 916 path += is_utf8_char (path);
419 } 917 }
918#endif
420 } 919 }
421 920
422 RETVAL = newSVpvn ((const char *)dst, dstp - dst); 921 RETVAL = newSVpvn ((const char *)dst, dstp - dst);
423} 922}
424 OUTPUT: 923 OUTPUT:
… …
586############################################################################# 1085#############################################################################
587 1086
588MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster 1087MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster
589 1088
590SV * 1089SV *
591make_histograms (SV *ar) 1090extract_features (SV *ar)
592 CODE: 1091 CODE:
593{ 1092{
594 int i; 1093 int i;
595 AV *av, *result; 1094 AV *av, *result;
596 1095
597 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV) 1096 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV)
598 croak ("Not an array ref as first argument to make_histogram"); 1097 croak ("Not an array ref as first argument to extract_features");
599 1098
600 av = (AV *) SvRV (ar); 1099 av = (AV *) SvRV (ar);
601 result = newAV (); 1100 result = newAV ();
602 1101
603 for (i = 0; i <= av_len (av); ++i) 1102 for (i = 0; i <= av_len (av); ++i)
604 { 1103 {
605 const int HISTSIZE = 64;
606
607 int j;
608 SV *sv = *av_fetch (av, i, 1); 1104 SV *sv = *av_fetch (av, i, 1);
609 STRLEN len;
610 char *buf = SvPVbyte (sv, len);
611
612 int tmphist[HISTSIZE];
613 float *hist;
614
615 SV *histsv = newSV (HISTSIZE * sizeof (float) + 1); 1105 SV *histsv = newSV (9 * sizeof (float) + 1);
1106
616 SvPOK_on (histsv); 1107 SvPOK_on (histsv);
617 SvCUR_set (histsv, HISTSIZE * sizeof (float)); 1108 SvCUR_set (histsv, 9 * sizeof (float));
618 hist = (float *)SvPVX (histsv); 1109 float *hist = (float *)SvPVX (histsv);
619 1110
620 Zero (tmphist, sizeof (tmphist), char); 1111 struct feature f_h, f_s, f_v;
1112 feature_init (&f_h);
1113 feature_init (&f_s);
1114 feature_init (&f_v);
621 1115
622 for (j = len; j--; )
623 {
624 unsigned int idx
625 = ((*buf & 0xc0) >> 2)
626 | ((*buf & 0x18) >> 1)
627 | (*buf & 0x03);
628
629 ++tmphist[idx];
630 ++buf;
631 }
632 1116 {
633 for (j = 0; j < HISTSIZE; ++j) 1117 STRLEN len;
634 hist[j] = (float)tmphist[j] / (len + 1e-30); 1118 unsigned char *buf = (unsigned char *)SvPVbyte (sv, len);
1119 while (len >= 3)
1120 {
1121 unsigned int r, g, b, h, s, v;
1122 r = *buf++; g = *buf++; b = *buf++;
1123 rgb_to_hsv (r, g, b, &h, &s, &v);
1124
1125 feature_update_pass_1 (&f_h, h);
1126 feature_update_pass_1 (&f_s, s);
1127 feature_update_pass_1 (&f_v, v);
1128
1129 len -= 3;
1130 }
1131
1132 feature_finish_pass_1 (&f_h);
1133 feature_finish_pass_1 (&f_s);
1134 feature_finish_pass_1 (&f_v);
1135 }
1136
1137 {
1138 STRLEN len;
1139 unsigned char *buf = (unsigned char *)SvPVbyte (sv, len);
1140 while (len >= 3)
1141 {
1142 unsigned int r, g, b, h, s, v;
1143 r = *buf++; g = *buf++; b = *buf++;
1144 rgb_to_hsv (r, g, b, &h, &s, &v);
1145
1146 feature_update_pass_2 (&f_h, h);
1147 feature_update_pass_2 (&f_s, s);
1148 feature_update_pass_2 (&f_v, v);
1149
1150 len -= 3;
1151 }
1152
1153 feature_finish_pass_2 (&f_h);
1154 feature_finish_pass_2 (&f_s);
1155 feature_finish_pass_2 (&f_v);
1156 }
1157
1158 hist [0] = f_h.v1 * 2.; hist [1] = f_h.v2 * 2.; hist [2] = f_h.v3 * 2.;
1159 hist [3] = f_s.v1 ; hist [4] = f_s.v2 ; hist [5] = f_s.v3 ;
1160 hist [6] = f_v.v1 * .5; hist [7] = f_v.v2 * .5; hist [8] = f_v.v3 * .5;
635 1161
636 av_push (result, histsv); 1162 av_push (result, histsv);
637 } 1163 }
638 1164
639 RETVAL = newRV_noinc ((SV *)result); 1165 RETVAL = newRV_noinc ((SV *)result);
640} 1166}
641 OUTPUT: 1167 OUTPUT:
642 RETVAL 1168 RETVAL
643 1169
644

Diff Legend

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