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

Comparing CV/CV.xs (file contents):
Revision 1.32 by root, Wed Feb 15 08:36:55 2006 UTC vs.
Revision 1.59 by root, Sat Apr 10 03:32:09 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>
7 8
8#include <magic.h> 9#include <magic.h>
9 10
10#include <jpeglib.h> 11#include <jpeglib.h>
12#include <jerror.h>
13
11#include <glib.h> 14#include <glib.h>
12#include <gtk/gtk.h> 15#include <gtk/gtk.h>
16#include <gdk/gdkx.h>
13#include <gdk-pixbuf/gdk-pixbuf.h> 17#include <gdk-pixbuf/gdk-pixbuf.h>
14 18
15#include <gperl.h> 19#include <gperl.h>
16#include <gtk2perl.h> 20#include <gtk2perl.h>
17 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
18#define IW 80 /* MUST match Schnauer.pm! */ 36#define IW 80 /* MUST match Schnauzer.pm! */
19#define IH 60 /* MUST match Schnauer.pm! */ 37#define IH 60 /* MUST match Schnauzer.pm! */
20
21#define RAND (seed = (seed + 7141) * 54773 % 134456)
22 38
23#define LINELENGTH 240 39#define LINELENGTH 240
24 40
25#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 */
26 46
27struct jpg_err_mgr 47struct jpg_err_mgr
28{ 48{
29 struct jpeg_error_mgr err; 49 struct jpeg_error_mgr err;
30 jmp_buf setjmp_buffer; 50 jmp_buf setjmp_buffer;
31}; 51};
32 52
33static void 53static void
34cv_error_exit (j_common_ptr cinfo) 54cv_error_exit (j_common_ptr cinfo)
35{ 55{
56 cinfo->err->output_message (cinfo);
36 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99); 57 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);
37} 58}
38 59
39static void 60static void
40cv_error_output (j_common_ptr cinfo) 61cv_error_output (j_common_ptr cinfo)
41{ 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);
42 return; 68 return;
43} 69}
44 70
45static void 71static void
46rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b, 72rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b,
… …
67 93
68 *h &= 255; 94 *h &= 255;
69 } 95 }
70} 96}
71 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
72static guint32 a85_val; 153static guint32 a85_val;
73static guint a85_cnt; 154static guint a85_cnt;
74static guchar a85_buf[LINELENGTH], *a85_ptr; 155static guchar a85_buf[LINELENGTH], *a85_ptr;
75 156
76static void 157static void
… …
88 if (!--a85_cnt) 169 if (!--a85_cnt)
89 { 170 {
90 a85_cnt = 4; 171 a85_cnt = 4;
91 if (a85_val) 172 if (a85_val)
92 { 173 {
93 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85; 174 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
94 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85; 175 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
95 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85; 176 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
96 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85; 177 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
97 a85_ptr[0] = (a85_val ) + 33; 178 a85_ptr[0] = (a85_val ) + 33;
98 179
99 a85_ptr += 5; 180 a85_ptr += 5;
100 } 181 }
… …
123 204
124 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf); 205 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
125} 206}
126 207
127///////////////////////////////////////////////////////////////////////////// 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/////////////////////////////////////////////////////////////////////////////
128 303
129MODULE = Gtk2::CV PACKAGE = Gtk2::CV 304MODULE = Gtk2::CV PACKAGE = Gtk2::CV
130 305
131PROTOTYPES: ENABLE 306PROTOTYPES: ENABLE
132 307
308# calculate the common prefix length of two strings
133# missing function in perl. really :) 309# missing function in perl. really :)
134int 310int
135common_prefix_length (a, b) 311common_prefix_length (a, b)
136 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg); 312 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg);
137 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg); 313 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg);
… …
146 322
147 OUTPUT: 323 OUTPUT:
148 RETVAL 324 RETVAL
149 325
150const char * 326const char *
151magic (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
152 CODE: 333 CODE:
153{ 334{
154 static magic_t cookie; 335 STRLEN len;
336 char *data = SvPVbyte (path_or_data, len);
155 337
156 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);
157 { 344 }
158 cookie = magic_open (MAGIC_NONE);
159 345
160 if (cookie) 346 perlinterp_release ();
161 magic_load (cookie, 0);
162 else
163 XSRETURN_UNDEF;
164 }
165 347
166 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 ();
167} 353}
168 OUTPUT: 354 OUTPUT:
169 RETVAL 355 RETVAL
170 356
171const char *
172magic_mime (const char *path)
173 CODE:
174{
175 static magic_t cookie;
176
177 if (!cookie)
178 {
179 cookie = magic_open (MAGIC_MIME);
180
181 if (cookie)
182 magic_load (cookie, 0);
183 else
184 XSRETURN_UNDEF;
185 }
186
187 RETVAL = magic_file (cookie, path);
188}
189 OUTPUT:
190 RETVAL
191
192# 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);
193 363
194gboolean 364gboolean
195gdk_net_wm_supports (GdkAtom property) 365gdk_net_wm_supports (GdkAtom property)
196 CODE: 366 CODE:
197#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE) 367#if defined(GDK_WINDOWING_X11) && !defined(GDK_MULTIHEAD_SAFE)
… …
203 RETVAL 373 RETVAL
204 374
205GdkPixbuf_noinc * 375GdkPixbuf_noinc *
206dealpha_expose (GdkPixbuf *pb) 376dealpha_expose (GdkPixbuf *pb)
207 CODE: 377 CODE:
378 perlinterp_release ();
208{ 379{
209 int w = gdk_pixbuf_get_width (pb); 380 int w = gdk_pixbuf_get_width (pb);
210 int h = gdk_pixbuf_get_height (pb); 381 int h = gdk_pixbuf_get_height (pb);
211 int bpp = gdk_pixbuf_get_n_channels (pb); 382 int bpp = gdk_pixbuf_get_n_channels (pb);
212 int x, y, i; 383 int x, y, i;
… …
221 for (x = 0; x < w; x++) 392 for (x = 0; x < w; x++)
222 for (y = 0; y < h; y++) 393 for (y = 0; y < h; y++)
223 for (i = 0; i < 3; i++) 394 for (i = 0; i < 3; i++)
224 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];
225} 396}
397 perlinterp_acquire ();
226 OUTPUT: 398 OUTPUT:
227 RETVAL 399 RETVAL
228 400
229GdkPixbuf_noinc * 401GdkPixbuf_noinc *
230rotate (GdkPixbuf *pb, int angle) 402rotate (GdkPixbuf *pb, int angle)
231 CODE: 403 CODE:
404 perlinterp_release ();
405 if (angle < 0)
406 angle += 360;
232 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
233 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE 408 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
234 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN 409 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN
235 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE 410 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE
236 : angle); 411 : angle);
412 perlinterp_acquire ();
237 OUTPUT: 413 OUTPUT:
238 RETVAL 414 RETVAL
239 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
240GdkPixbuf_noinc * 462GdkPixbuf_noinc *
241load_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 | JXL_DEC_BASIC_INFO) != JXL_DEC_SUCCESS)
580 goto done;
581
582 error = "JxlDecoderSetInput failed";
583 if (JxlDecoderSetInput (dec, next_in, avail_in) != JXL_DEC_SUCCESS)
584 goto done;
585
586 for (;;)
587 {
588 JxlDecoderStatus status = JxlDecoderProcessInput (dec);
589
590 printf ("status %d\n",status);
591
592 switch (status)
593 {
594 case JXL_DEC_ERROR:
595 error = "JxlDecoderProcessInput failed";
596 goto done;
597
598 case JXL_DEC_NEED_MORE_INPUT:
599 error = "incomplete file";
600 goto done;
601
602 case JXL_DEC_SUCCESS:
603 goto done;
604
605 case JXL_DEC_NEED_IMAGE_OUT_BUFFER:
606 {
607 error = "JxlDecoderGetBasicInfo failed";
608 if (JxlDecoderGetBasicInfo (dec, &info) != JXL_DEC_SUCCESS)
609 goto done;
610
611 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, !!info.alpha_bits, 8, info.xsize, info.ysize);
612 error = "unable to allocate pixbuf";
613 if (!RETVAL)
614 goto done;
615
616 JxlPixelFormat format = {
617 info.alpha_bits ? 4 : 3,
618 JXL_TYPE_UINT8,
619 JXL_NATIVE_ENDIAN,
620 gdk_pixbuf_get_rowstride (RETVAL)
621 };
622
623 error = "JxlDecoderSetImageOutBuffer failed";
624 if (JxlDecoderSetImageOutBuffer (
625 dec,
626 &format,
627 gdk_pixbuf_get_pixels (RETVAL),
628 gdk_pixbuf_get_byte_length (RETVAL)
629 ) != JXL_DEC_SUCCESS)
630 goto done;
631 }
632 break;
633
634 default:
635 error = "unexpected event";
636 goto done;
637 }
638 }
639
640 done:
641 if (dec)
642 JxlDecoderDestroy (dec);
643
644 if (runner)
645 JxlThreadParallelRunnerDestroy (runner);
646
647 perlinterp_acquire ();
648
649 if (error)
650 {
651 if (RETVAL)
652 g_object_unref (RETVAL);
653
654 croak ("load_jxl: %s", error);
655 }
656#else
657 croak ("load_jxl: jpeg-xl not enabled at compile time");
658#endif
659}
660 OUTPUT:
661 RETVAL
662
663GdkPixbuf_noinc *
664decode_jpeg (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
242 CODE: 665 CODE:
243{ 666{
244 struct jpeg_decompress_struct cinfo; 667 struct jpeg_decompress_struct cinfo;
245 struct jpg_err_mgr jerr; 668 struct jpg_err_mgr jerr;
246 guchar *data;
247 int rs; 669 int rs;
248 FILE *fp;
249 volatile GdkPixbuf *pb = 0; 670 volatile GdkPixbuf *pb = 0;
671 STRLEN data_len;
672 guchar *data = SvPVbyte (image_data, data_len);
250 673
251 RETVAL = 0; 674 RETVAL = 0;
252 675
253 fp = fopen (SvPVbyte_nolen (path), "rb"); 676 perlinterp_release ();
254
255 if (!fp)
256 XSRETURN_UNDEF;
257 677
258 cinfo.err = jpeg_std_error (&jerr.err); 678 cinfo.err = jpeg_std_error (&jerr.err);
259 679
260 jerr.err.error_exit = cv_error_exit; 680 jerr.err.error_exit = cv_error_exit;
261 jerr.err.output_message = cv_error_output; 681 jerr.err.output_message = cv_error_output;
262 682
263 if ((rs = setjmp (jerr.setjmp_buffer))) 683 if ((rs = setjmp (jerr.setjmp_buffer)))
264 { 684 {
265 fclose (fp);
266 jpeg_destroy_decompress (&cinfo); 685 jpeg_destroy_decompress (&cinfo);
267 686
268 if (pb) 687 if (pb)
269 g_object_unref ((gpointer)pb); 688 g_object_unref ((gpointer)pb);
270 689
690 perlinterp_acquire ();
271 XSRETURN_UNDEF; 691 XSRETURN_UNDEF;
272 } 692 }
273 693
694 if (!data_len)
695 longjmp (jerr.setjmp_buffer, 4);
696
274 jpeg_create_decompress (&cinfo); 697 jpeg_create_decompress (&cinfo);
698 cv_jpeg_mem_src (&cinfo, data, data_len);
275 699
276 jpeg_stdio_src (&cinfo, fp);
277 jpeg_read_header (&cinfo, TRUE); 700 jpeg_read_header (&cinfo, TRUE);
278 701
279 cinfo.dct_method = JDCT_DEFAULT; 702 cinfo.dct_method = JDCT_DEFAULT;
280 cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */ 703 cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */
281 cinfo.do_block_smoothing = FALSE; 704 cinfo.do_block_smoothing = FALSE;
… …
291 { 714 {
292 cinfo.dct_method = JDCT_FASTEST; 715 cinfo.dct_method = JDCT_FASTEST;
293 cinfo.do_fancy_upsampling = FALSE; 716 cinfo.do_fancy_upsampling = FALSE;
294 717
295 while (cinfo.scale_denom < 8 718 while (cinfo.scale_denom < 8
296 && cinfo.output_width >= IW*4 719 && cinfo.output_width >= iw*4
297 && cinfo.output_height >= IH*4) 720 && cinfo.output_height >= ih*4)
298 { 721 {
299 cinfo.scale_denom <<= 1; 722 cinfo.scale_denom <<= 1;
300 jpeg_calc_output_dimensions (&cinfo); 723 jpeg_calc_output_dimensions (&cinfo);
301 } 724 }
302 } 725 }
303 726
727 if (cinfo.output_components != 3)
728 longjmp (jerr.setjmp_buffer, 3);
729
730 if (cinfo.jpeg_color_space == JCS_YCCK || cinfo.jpeg_color_space == JCS_CMYK)
731 {
732 cinfo.out_color_space = JCS_CMYK;
733 cinfo.output_components = 4;
734 }
735
304 pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, cinfo.output_width, cinfo.output_height); 736 pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, cinfo.output_components == 4, 8, cinfo.output_width, cinfo.output_height);
305 if (!RETVAL) 737 if (!RETVAL)
306 longjmp (jerr.setjmp_buffer, 2); 738 longjmp (jerr.setjmp_buffer, 2);
307 739
308 data = gdk_pixbuf_get_pixels (RETVAL); 740 data = gdk_pixbuf_get_pixels (RETVAL);
309 rs = gdk_pixbuf_get_rowstride (RETVAL); 741 rs = gdk_pixbuf_get_rowstride (RETVAL);
310
311 if (cinfo.output_components != 3)
312 longjmp (jerr.setjmp_buffer, 3);
313 742
314 jpeg_start_decompress (&cinfo); 743 jpeg_start_decompress (&cinfo);
315 744
316 while (cinfo.output_scanline < cinfo.output_height) 745 while (cinfo.output_scanline < cinfo.output_height)
317 { 746 {
… …
324 rp [3] = (guchar *)rp [2] + rs; 753 rp [3] = (guchar *)rp [2] + rs;
325 754
326 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4); 755 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);
327 } 756 }
328 757
758 if (cinfo.out_color_space == JCS_CMYK)
759 {
760 guchar *end = data + cinfo.output_height * rs;
761
762 while (data < end)
763 {
764 U32 c = data [0];
765 U32 m = data [1];
766 U32 y = data [2];
767 U32 k = data [3];
768
769 if (0)
770 if (cinfo.Adobe_transform == 2)
771 {
772 c ^= 0xff;
773 m ^= 0xff;
774 y ^= 0xff;
775 k ^= 0xff;
776 }
777
778 data [0] = (c * k + 0x80) / 0xff;
779 data [1] = (m * k + 0x80) / 0xff;
780 data [2] = (y * k + 0x80) / 0xff;
781 data [3] = 0xff;
782
783 data += 4;
784 }
785 }
786
329 jpeg_finish_decompress (&cinfo); 787 jpeg_finish_decompress (&cinfo);
330 fclose (fp);
331 jpeg_destroy_decompress (&cinfo); 788 jpeg_destroy_decompress (&cinfo);
789 perlinterp_acquire ();
332} 790}
333 OUTPUT: 791 OUTPUT:
334 RETVAL 792 RETVAL
335 793
794void
795compare (GdkPixbuf *a, GdkPixbuf *b)
796 PPCODE:
797 perlinterp_release ();
798{
799 int w = gdk_pixbuf_get_width (a);
800 int h = gdk_pixbuf_get_height (a);
801
802 int sa = gdk_pixbuf_get_rowstride (a);
803 int sb = gdk_pixbuf_get_rowstride (b);
804
805 guchar *pa = gdk_pixbuf_get_pixels (a);
806 guchar *pb = gdk_pixbuf_get_pixels (b);
807
808 int x, y;
809
810 assert (w == gdk_pixbuf_get_width (b));
811 assert (h == gdk_pixbuf_get_height (b));
812
813 assert (gdk_pixbuf_get_n_channels (a) == 3);
814 assert (gdk_pixbuf_get_n_channels (b) == 3);
815
816 double diff = 0.;
817 int peak = 0;
818
819 if (w && h)
820 for (y = 0; y < h; y++)
821 {
822 guchar *pa_ = pa + y * sa;
823 guchar *pb_ = pb + y * sb;
824
825 for (x = 0; x < w; x++)
826 {
827 int d;
828
829 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d));
830 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d));
831 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d));
832 }
833 }
834
835 perlinterp_acquire ();
836
837 EXTEND (SP, 2);
838 PUSHs (sv_2mortal (newSVnv (sqrt (diff / (w * h * 3. * 255. * 255.)))));
839 PUSHs (sv_2mortal (newSVnv (peak / 255.)));
840}
841
336############################################################################# 842#############################################################################
337 843
338MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer 844MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Schnauzer
845
846# currently only works for filenames (octet strings)
339 847
340SV * 848SV *
341foldcase (SV *pathsv) 849foldcase (SV *pathsv)
342 PROTOTYPE: $ 850 PROTOTYPE: $
343 CODE: 851 CODE:
344{ 852{
345 STRLEN plen; 853 STRLEN plen;
346 U8 *path = (U8 *)SvPVutf8 (pathsv, plen); 854 U8 *path = (U8 *)SvPV (pathsv, plen);
347 U8 *pend = path + plen; 855 U8 *pend = path + plen;
348 U8 dst [plen * 6 * 3], *dstp = dst; 856 U8 dst [plen * 6 * 3], *dstp = dst;
349 857
350 while (path < pend) 858 while (path < pend)
351 { 859 {
352 U8 ch = *path; 860 U8 ch = *path;
353 861
354 if (ch >= 'a' && ch <= 'z') 862 if (ch >= 'a' && ch <= 'z')
355 *dstp++ = *path++; 863 *dstp++ = *path++;
864 else if (ch >= 'A' && ch <= 'Z')
865 *dstp++ = *path++ + ('a' - 'A');
356 else if (ch >= '0' && ch <= '9') 866 else if (ch >= '0' && ch <= '9')
357 { 867 {
358 STRLEN el, nl = 0; 868 STRLEN el, nl = 0;
359 while (*path >= '0' && *path <= '9' && path < pend) 869 while (*path >= '0' && *path <= '9' && path < pend)
360 path++, nl++; 870 path++, nl++;
… …
363 *dstp++ = '0'; 873 *dstp++ = '0';
364 874
365 memcpy (dstp, path - nl, nl); 875 memcpy (dstp, path - nl, nl);
366 dstp += nl; 876 dstp += nl;
367 } 877 }
878 else
879 *dstp++ = *path++;
880#if 0
368 else 881 else
369 { 882 {
370 STRLEN cl; 883 STRLEN cl;
371 to_utf8_fold (path, dstp, &cl); 884 to_utf8_fold (path, dstp, &cl);
372 dstp += cl; 885 dstp += cl;
373 path += is_utf8_char (path); 886 path += is_utf8_char (path);
374 } 887 }
888#endif
375 } 889 }
376 890
377 RETVAL = newSVpvn ((const char *)dst, dstp - dst); 891 RETVAL = newSVpvn ((const char *)dst, dstp - dst);
378} 892}
379 OUTPUT: 893 OUTPUT:
… …
541############################################################################# 1055#############################################################################
542 1056
543MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster 1057MODULE = Gtk2::CV PACKAGE = Gtk2::CV::Plugin::RCluster
544 1058
545SV * 1059SV *
546make_histograms (SV *ar) 1060extract_features (SV *ar)
547 CODE: 1061 CODE:
548{ 1062{
549 int i; 1063 int i;
550 AV *av, *result; 1064 AV *av, *result;
551 1065
552 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV) 1066 if (!SvROK (ar) || SvTYPE (SvRV (ar)) != SVt_PVAV)
553 croak ("Not an array ref as first argument to make_histogram"); 1067 croak ("Not an array ref as first argument to extract_features");
554 1068
555 av = (AV *) SvRV (ar); 1069 av = (AV *) SvRV (ar);
556 result = newAV (); 1070 result = newAV ();
557 1071
558 for (i = 0; i <= av_len (av); ++i) 1072 for (i = 0; i <= av_len (av); ++i)
559 { 1073 {
560 const int HISTSIZE = 64;
561
562 int j;
563 SV *sv = *av_fetch (av, i, 1); 1074 SV *sv = *av_fetch (av, i, 1);
564 STRLEN len;
565 char *buf = SvPVbyte (sv, len);
566
567 int tmphist[HISTSIZE];
568 float *hist;
569
570 SV *histsv = newSV (HISTSIZE * sizeof (float) + 1); 1075 SV *histsv = newSV (9 * sizeof (float) + 1);
1076
571 SvPOK_on (histsv); 1077 SvPOK_on (histsv);
572 SvCUR_set (histsv, HISTSIZE * sizeof (float)); 1078 SvCUR_set (histsv, 9 * sizeof (float));
573 hist = (float *)SvPVX (histsv); 1079 float *hist = (float *)SvPVX (histsv);
574 1080
575 Zero (tmphist, sizeof (tmphist), char); 1081 struct feature f_h, f_s, f_v;
1082 feature_init (&f_h);
1083 feature_init (&f_s);
1084 feature_init (&f_v);
576 1085
577 for (j = len; j--; )
578 {
579 unsigned int idx
580 = ((*buf & 0xc0) >> 2)
581 | ((*buf & 0x18) >> 1)
582 | (*buf & 0x03);
583
584 ++tmphist[idx];
585 ++buf;
586 }
587 1086 {
588 for (j = 0; j < HISTSIZE; ++j) 1087 STRLEN len;
589 hist[j] = (float)tmphist[j] / (len + 1e-30); 1088 unsigned char *buf = (unsigned char *)SvPVbyte (sv, len);
1089 while (len >= 3)
1090 {
1091 unsigned int r, g, b, h, s, v;
1092 r = *buf++; g = *buf++; b = *buf++;
1093 rgb_to_hsv (r, g, b, &h, &s, &v);
1094
1095 feature_update_pass_1 (&f_h, h);
1096 feature_update_pass_1 (&f_s, s);
1097 feature_update_pass_1 (&f_v, v);
1098
1099 len -= 3;
1100 }
1101
1102 feature_finish_pass_1 (&f_h);
1103 feature_finish_pass_1 (&f_s);
1104 feature_finish_pass_1 (&f_v);
1105 }
1106
1107 {
1108 STRLEN len;
1109 unsigned char *buf = (unsigned char *)SvPVbyte (sv, len);
1110 while (len >= 3)
1111 {
1112 unsigned int r, g, b, h, s, v;
1113 r = *buf++; g = *buf++; b = *buf++;
1114 rgb_to_hsv (r, g, b, &h, &s, &v);
1115
1116 feature_update_pass_2 (&f_h, h);
1117 feature_update_pass_2 (&f_s, s);
1118 feature_update_pass_2 (&f_v, v);
1119
1120 len -= 3;
1121 }
1122
1123 feature_finish_pass_2 (&f_h);
1124 feature_finish_pass_2 (&f_s);
1125 feature_finish_pass_2 (&f_v);
1126 }
1127
1128 hist [0] = f_h.v1 * 2.; hist [1] = f_h.v2 * 2.; hist [2] = f_h.v3 * 2.;
1129 hist [3] = f_s.v1 ; hist [4] = f_s.v2 ; hist [5] = f_s.v3 ;
1130 hist [6] = f_v.v1 * .5; hist [7] = f_v.v2 * .5; hist [8] = f_v.v3 * .5;
590 1131
591 av_push (result, histsv); 1132 av_push (result, histsv);
592 } 1133 }
593 1134
594 RETVAL = newRV_noinc ((SV *)result); 1135 RETVAL = newRV_noinc ((SV *)result);
595} 1136}
596 OUTPUT: 1137 OUTPUT:
597 RETVAL 1138 RETVAL
598 1139
599

Diff Legend

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