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

Comparing CV/CV.xs (file contents):
Revision 1.44 by root, Sun Dec 30 16:23:23 2012 UTC vs.
Revision 1.62 by root, Sun Jul 25 11:32:46 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
19#include <assert.h> 22#include <assert.h>
20 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
21#define IW 80 /* MUST match Schnauzer.pm! */ 36#define IW 80 /* MUST match Schnauzer.pm! */
22#define IH 60 /* MUST match Schnauzer.pm! */ 37#define IH 60 /* MUST match Schnauzer.pm! */
23 38
24#define RAND (seed = (seed + 7141) * 54773 % 134456)
25
26#define LINELENGTH 240 39#define LINELENGTH 240
27 40
28#define ELLIPSIS "\xe2\x80\xa6" 41#define ELLIPSIS "\xe2\x80\xa6"
29 42
30typedef char *octet_string; 43typedef char *octet_string;
44
45static magic_t magic_cookie[2]; /* !mime, mime */
31 46
32struct jpg_err_mgr 47struct jpg_err_mgr
33{ 48{
34 struct jpeg_error_mgr err; 49 struct jpeg_error_mgr err;
35 jmp_buf setjmp_buffer; 50 jmp_buf setjmp_buffer;
36}; 51};
37 52
38static void 53static void
39cv_error_exit (j_common_ptr cinfo) 54cv_error_exit (j_common_ptr cinfo)
40{ 55{
56 cinfo->err->output_message (cinfo);
41 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99); 57 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);
42} 58}
43 59
44static void 60static void
45cv_error_output (j_common_ptr cinfo) 61cv_error_output (j_common_ptr cinfo)
46{ 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);
47 return; 68 return;
48} 69}
49 70
50static void 71static void
51rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b, 72rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b,
… …
148 if (!--a85_cnt) 169 if (!--a85_cnt)
149 { 170 {
150 a85_cnt = 4; 171 a85_cnt = 4;
151 if (a85_val) 172 if (a85_val)
152 { 173 {
153 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85; 174 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
154 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85; 175 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
155 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85; 176 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
156 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85; 177 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
157 a85_ptr[0] = (a85_val ) + 33; 178 a85_ptr[0] = (a85_val ) + 33;
158 179
159 a85_ptr += 5; 180 a85_ptr += 5;
160 } 181 }
… …
183 204
184 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf); 205 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
185} 206}
186 207
187///////////////////////////////////////////////////////////////////////////// 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/////////////////////////////////////////////////////////////////////////////
188 303
189MODULE = Gtk2::CV PACKAGE = Gtk2::CV 304MODULE = Gtk2::CV PACKAGE = Gtk2::CV
190 305
191PROTOTYPES: ENABLE 306PROTOTYPES: ENABLE
192 307
308# calculate the common prefix length of two strings
193# missing function in perl. really :) 309# missing function in perl. really :)
194int 310int
195common_prefix_length (a, b) 311common_prefix_length (a, b)
196 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg); 312 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg);
197 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg); 313 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg);
… …
206 322
207 OUTPUT: 323 OUTPUT:
208 RETVAL 324 RETVAL
209 325
210const char * 326const char *
211magic (octet_string path) 327magic (SV *path_or_data)
328 ALIAS:
329 magic = 0
330 magic_mime = 1
331 magic_buffer = 2
332 magic_buffer_mime = 3
212 CODE: 333 CODE:
213{ 334{
214 static magic_t cookie; 335 STRLEN len;
336 char *data = SvPVbyte (path_or_data, len);
215 337
216 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);
217 { 344 }
218 cookie = magic_open (MAGIC_NONE);
219 345
220 if (cookie) 346 perlinterp_release ();
221 magic_load (cookie, 0);
222 else
223 XSRETURN_UNDEF;
224 }
225 347
226 RETVAL = magic_file (cookie, path);
227}
228 OUTPUT:
229 RETVAL 348 RETVAL = ix & 2
349 ? magic_buffer (magic_cookie[ix & 1], data, len)
350 : magic_file (magic_cookie[ix & 1], data);
230 351
231const char * 352 perlinterp_acquire ();
232magic_mime (octet_string path)
233 CODE:
234{
235 static magic_t cookie;
236
237 if (!cookie)
238 {
239 cookie = magic_open (MAGIC_MIME);
240
241 if (cookie)
242 magic_load (cookie, 0);
243 else
244 XSRETURN_UNDEF;
245 }
246
247 RETVAL = magic_file (cookie, path);
248} 353}
249 OUTPUT: 354 OUTPUT:
250 RETVAL 355 RETVAL
251 356
252# missing/broken in Gtk2 perl module 357# missing/broken in Gtk2 perl module
… …
268 RETVAL 373 RETVAL
269 374
270GdkPixbuf_noinc * 375GdkPixbuf_noinc *
271dealpha_expose (GdkPixbuf *pb) 376dealpha_expose (GdkPixbuf *pb)
272 CODE: 377 CODE:
378 perlinterp_release ();
273{ 379{
274 int w = gdk_pixbuf_get_width (pb); 380 int w = gdk_pixbuf_get_width (pb);
275 int h = gdk_pixbuf_get_height (pb); 381 int h = gdk_pixbuf_get_height (pb);
276 int bpp = gdk_pixbuf_get_n_channels (pb); 382 int bpp = gdk_pixbuf_get_n_channels (pb);
277 int x, y, i; 383 int x, y, i;
… …
286 for (x = 0; x < w; x++) 392 for (x = 0; x < w; x++)
287 for (y = 0; y < h; y++) 393 for (y = 0; y < h; y++)
288 for (i = 0; i < 3; i++) 394 for (i = 0; i < 3; i++)
289 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];
290} 396}
397 perlinterp_acquire ();
291 OUTPUT: 398 OUTPUT:
292 RETVAL 399 RETVAL
293 400
294GdkPixbuf_noinc * 401GdkPixbuf_noinc *
295rotate (GdkPixbuf *pb, int angle) 402rotate (GdkPixbuf *pb, int angle)
296 CODE: 403 CODE:
404 perlinterp_release ();
297 if (angle < 0) 405 if (angle < 0)
298 angle += 360; 406 angle += 360;
299 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
300 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE 408 : angle == 90 ? GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
301 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN 409 : angle == 180 ? GDK_PIXBUF_ROTATE_UPSIDEDOWN
302 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE 410 : angle == 270 ? GDK_PIXBUF_ROTATE_CLOCKWISE
303 : angle); 411 : angle);
412 perlinterp_acquire ();
304 OUTPUT: 413 OUTPUT:
305 RETVAL 414 RETVAL
306 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
475 // skip a graphic control extension block. we assume
476 // there is at most one such block - while the NAB
477 // has to come firstz, some files do not obey this
478 if (data[ofs] == 0x21 && data[ofs + 1] == 0xf9)
479 ofs += 3 + data[ofs + 2] + 1;
480
481 if (data_len >= ofs + 2 + 1 + 11)
482 if (!memcmp (data + ofs, "\x21\xff\x0bNETSCAPE2.0", sizeof ("\x21\xff\x0bNETSCAPE2.0") - 1))
483 RETVAL = "video/gif";
484 }
485 }
486
487 else
488 XSRETURN_UNDEF;
489}
490 OUTPUT:
491 RETVAL
492
307GdkPixbuf_noinc * 493GdkPixbuf_noinc *
308load_jpeg (SV *path, int thumbnail=0) 494decode_webp (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
495 CODE:
496{
497#if WEBP
498 STRLEN data_size;
499 int alpha;
500 WebPData data;
501 WebPDemuxer *demux;
502 WebPIterator iter;
503 WebPDecoderConfig config;
504 int inw, inh;
505
506 data.bytes = (uint8_t *)SvPVbyte (image_data, data_size);
507 data.size = data_size;
508
509 perlinterp_release ();
510
511 RETVAL = 0;
512
513 if (!(demux = WebPDemux (&data)))
514 goto err_demux;
515
516 if (!WebPDemuxGetFrame (demux, 1, &iter))
517 goto err_iter;
518
519 if (!WebPInitDecoderConfig (&config))
520 goto err_iter;
521
522 config.options.use_threads = 1;
523
524 if (WebPGetFeatures (iter.fragment.bytes, iter.fragment.size, &config.input) != VP8_STATUS_OK)
525 goto err_iter;
526
527 inw = config.input.width;
528 inh = config.input.height;
529
530 if (thumbnail)
531 {
532 if (inw * ih > inh * iw)
533 ih = (iw * inh + inw - 1) / inw;
534 else
535 iw = (ih * inw + inh - 1) / inh;
536
537 config.options.bypass_filtering = 1;
538 config.options.no_fancy_upsampling = 1;
539
540 config.options.use_scaling = 1;
541 config.options.scaled_width = iw;
542 config.options.scaled_height = ih;
543 }
544 else
545 {
546 iw = inw;
547 ih = inh;
548 }
549
550 alpha = !!config.input.has_alpha;
551
552 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, alpha, 8, iw, ih);
553 if (!RETVAL)
554 goto err_iter;
555
556 config.output.colorspace = alpha ? MODE_RGBA : MODE_RGB;
557 config.output.u.RGBA.rgba = gdk_pixbuf_get_pixels (RETVAL);
558 config.output.u.RGBA.stride = gdk_pixbuf_get_rowstride (RETVAL);
559 config.output.u.RGBA.size = gdk_pixbuf_get_byte_length (RETVAL);
560 config.output.is_external_memory = 1;
561
562 if (WebPDecode (iter.fragment.bytes, iter.fragment.size, &config) != VP8_STATUS_OK)
563 {
564 g_object_unref (RETVAL);
565 RETVAL = 0;
566 goto err_iter;
567 }
568
569 err_iter:
570 WebPDemuxReleaseIterator (&iter);
571 err_demux:
572 WebPDemuxDelete (demux);
573
574 perlinterp_acquire ();
575#else
576 croak ("load_webp: webp not enabled at compile time");
577#endif
578}
579 OUTPUT:
580 RETVAL
581
582GdkPixbuf_noinc *
583decode_jxl (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
584 CODE:
585{
586#if JXL
587 JxlDecoder *dec = JxlDecoderCreate (0);
588 JxlBasicInfo info;
589 const uint8_t *next_in = (uint8_t *)SvPVbyte_nolen (image_data);
590 size_t avail_in = SvCUR (image_data);
591 const char *error = 0;
592 void *runner = 0;
593 struct bmff_box box;
594
595 perlinterp_release ();
596
597 RETVAL = 0;
598
599 error = "JxlDecoderCreate failed";
600 if (!dec)
601 goto done;
602
603 runner = JxlThreadParallelRunnerCreate (0, JxlThreadParallelRunnerDefaultNumWorkerThreads ());
604
605 error = "JxlDecoderSetParallelRunner failed";
606 if (JxlDecoderSetParallelRunner (dec, JxlThreadParallelRunner, runner) != JXL_DEC_SUCCESS)
607 goto done;
608
609 error = "JxlDecoderSubscribeEvents failed";
610 if (JxlDecoderSubscribeEvents (dec, JXL_DEC_FULL_IMAGE | JXL_DEC_BASIC_INFO) != JXL_DEC_SUCCESS)
611 goto done;
612
613 error = "JxlDecoderSetInput failed";
614 if (JxlDecoderSetInput (dec, next_in, avail_in) != JXL_DEC_SUCCESS)
615 goto done;
616
617 for (;;)
618 {
619 JxlDecoderStatus status = JxlDecoderProcessInput (dec);
620
621 printf ("status %d\n",status);
622
623 switch (status)
624 {
625 case JXL_DEC_ERROR:
626 error = "JxlDecoderProcessInput failed";
627 goto done;
628
629 case JXL_DEC_NEED_MORE_INPUT:
630 error = "incomplete file";
631 goto done;
632
633 case JXL_DEC_SUCCESS:
634 goto done;
635
636 case JXL_DEC_NEED_IMAGE_OUT_BUFFER:
637 {
638 error = "JxlDecoderGetBasicInfo failed";
639 if (JxlDecoderGetBasicInfo (dec, &info) != JXL_DEC_SUCCESS)
640 goto done;
641
642 RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, !!info.alpha_bits, 8, info.xsize, info.ysize);
643 error = "unable to allocate pixbuf";
644 if (!RETVAL)
645 goto done;
646
647 JxlPixelFormat format = {
648 info.alpha_bits ? 4 : 3,
649 JXL_TYPE_UINT8,
650 JXL_NATIVE_ENDIAN,
651 gdk_pixbuf_get_rowstride (RETVAL)
652 };
653
654 error = "JxlDecoderSetImageOutBuffer failed";
655 if (JxlDecoderSetImageOutBuffer (
656 dec,
657 &format,
658 gdk_pixbuf_get_pixels (RETVAL),
659 gdk_pixbuf_get_byte_length (RETVAL)
660 ) != JXL_DEC_SUCCESS)
661 goto done;
662 }
663 break;
664
665 default:
666 error = "unexpected event";
667 goto done;
668 }
669 }
670
671 done:
672 if (dec)
673 JxlDecoderDestroy (dec);
674
675 if (runner)
676 JxlThreadParallelRunnerDestroy (runner);
677
678 perlinterp_acquire ();
679
680 if (error)
681 {
682 if (RETVAL)
683 g_object_unref (RETVAL);
684
685 croak ("load_jxl: %s", error);
686 }
687#else
688 croak ("load_jxl: jpeg-xl not enabled at compile time");
689#endif
690}
691 OUTPUT:
692 RETVAL
693
694GdkPixbuf_noinc *
695decode_jpeg (SV *image_data, int thumbnail = 0, int iw = 0, int ih = 0)
309 CODE: 696 CODE:
310{ 697{
311 struct jpeg_decompress_struct cinfo; 698 struct jpeg_decompress_struct cinfo;
312 struct jpg_err_mgr jerr; 699 struct jpg_err_mgr jerr;
313 guchar *data;
314 int rs; 700 int rs;
315 FILE *fp;
316 volatile GdkPixbuf *pb = 0; 701 volatile GdkPixbuf *pb = 0;
702 STRLEN data_len;
703 guchar *data = SvPVbyte (image_data, data_len);
317 704
318 RETVAL = 0; 705 RETVAL = 0;
319 706
320 fp = fopen (SvPVbyte_nolen (path), "rb"); 707 perlinterp_release ();
321
322 if (!fp)
323 XSRETURN_UNDEF;
324 708
325 cinfo.err = jpeg_std_error (&jerr.err); 709 cinfo.err = jpeg_std_error (&jerr.err);
326 710
327 jerr.err.error_exit = cv_error_exit; 711 jerr.err.error_exit = cv_error_exit;
328 jerr.err.output_message = cv_error_output; 712 jerr.err.output_message = cv_error_output;
329 713
330 if ((rs = setjmp (jerr.setjmp_buffer))) 714 if ((rs = setjmp (jerr.setjmp_buffer)))
331 { 715 {
332 fclose (fp);
333 jpeg_destroy_decompress (&cinfo); 716 jpeg_destroy_decompress (&cinfo);
334 717
335 if (pb) 718 if (pb)
336 g_object_unref ((gpointer)pb); 719 g_object_unref ((gpointer)pb);
337 720
721 perlinterp_acquire ();
338 XSRETURN_UNDEF; 722 XSRETURN_UNDEF;
339 } 723 }
340 724
725 if (!data_len)
726 longjmp (jerr.setjmp_buffer, 4);
727
341 jpeg_create_decompress (&cinfo); 728 jpeg_create_decompress (&cinfo);
729 cv_jpeg_mem_src (&cinfo, data, data_len);
342 730
343 jpeg_stdio_src (&cinfo, fp);
344 jpeg_read_header (&cinfo, TRUE); 731 jpeg_read_header (&cinfo, TRUE);
345 732
346 cinfo.dct_method = JDCT_DEFAULT; 733 cinfo.dct_method = JDCT_DEFAULT;
347 cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */ 734 cinfo.do_fancy_upsampling = FALSE; /* worse quality, but nobody compained so far, and gdk-pixbuf does the same */
348 cinfo.do_block_smoothing = FALSE; 735 cinfo.do_block_smoothing = FALSE;
… …
358 { 745 {
359 cinfo.dct_method = JDCT_FASTEST; 746 cinfo.dct_method = JDCT_FASTEST;
360 cinfo.do_fancy_upsampling = FALSE; 747 cinfo.do_fancy_upsampling = FALSE;
361 748
362 while (cinfo.scale_denom < 8 749 while (cinfo.scale_denom < 8
363 && cinfo.output_width >= IW*4 750 && cinfo.output_width >= iw*4
364 && cinfo.output_height >= IH*4) 751 && cinfo.output_height >= ih*4)
365 { 752 {
366 cinfo.scale_denom <<= 1; 753 cinfo.scale_denom <<= 1;
367 jpeg_calc_output_dimensions (&cinfo); 754 jpeg_calc_output_dimensions (&cinfo);
368 } 755 }
369 } 756 }
370 757
758 if (cinfo.output_components != 3)
759 longjmp (jerr.setjmp_buffer, 3);
760
761 if (cinfo.jpeg_color_space == JCS_YCCK || cinfo.jpeg_color_space == JCS_CMYK)
762 {
763 cinfo.out_color_space = JCS_CMYK;
764 cinfo.output_components = 4;
765 }
766
371 pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 0, 8, cinfo.output_width, cinfo.output_height); 767 pb = RETVAL = gdk_pixbuf_new (GDK_COLORSPACE_RGB, cinfo.output_components == 4, 8, cinfo.output_width, cinfo.output_height);
372 if (!RETVAL) 768 if (!RETVAL)
373 longjmp (jerr.setjmp_buffer, 2); 769 longjmp (jerr.setjmp_buffer, 2);
374 770
375 data = gdk_pixbuf_get_pixels (RETVAL); 771 data = gdk_pixbuf_get_pixels (RETVAL);
376 rs = gdk_pixbuf_get_rowstride (RETVAL); 772 rs = gdk_pixbuf_get_rowstride (RETVAL);
377
378 if (cinfo.output_components != 3)
379 longjmp (jerr.setjmp_buffer, 3);
380 773
381 jpeg_start_decompress (&cinfo); 774 jpeg_start_decompress (&cinfo);
382 775
383 while (cinfo.output_scanline < cinfo.output_height) 776 while (cinfo.output_scanline < cinfo.output_height)
384 { 777 {
… …
391 rp [3] = (guchar *)rp [2] + rs; 784 rp [3] = (guchar *)rp [2] + rs;
392 785
393 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4); 786 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);
394 } 787 }
395 788
789 if (cinfo.out_color_space == JCS_CMYK)
790 {
791 guchar *end = data + cinfo.output_height * rs;
792
793 while (data < end)
794 {
795 U32 c = data [0];
796 U32 m = data [1];
797 U32 y = data [2];
798 U32 k = data [3];
799
800 if (0)
801 if (cinfo.Adobe_transform == 2)
802 {
803 c ^= 0xff;
804 m ^= 0xff;
805 y ^= 0xff;
806 k ^= 0xff;
807 }
808
809 data [0] = (c * k + 0x80) / 0xff;
810 data [1] = (m * k + 0x80) / 0xff;
811 data [2] = (y * k + 0x80) / 0xff;
812 data [3] = 0xff;
813
814 data += 4;
815 }
816 }
817
396 jpeg_finish_decompress (&cinfo); 818 jpeg_finish_decompress (&cinfo);
397 fclose (fp);
398 jpeg_destroy_decompress (&cinfo); 819 jpeg_destroy_decompress (&cinfo);
820 perlinterp_acquire ();
399} 821}
400 OUTPUT: 822 OUTPUT:
401 RETVAL 823 RETVAL
402 824
403void 825void
404compare (GdkPixbuf *a, GdkPixbuf *b) 826compare (GdkPixbuf *a, GdkPixbuf *b)
405 PPCODE: 827 PPCODE:
828 perlinterp_release ();
406{ 829{
407 int w = gdk_pixbuf_get_width (a); 830 int w = gdk_pixbuf_get_width (a);
408 int h = gdk_pixbuf_get_height (a); 831 int h = gdk_pixbuf_get_height (a);
409 832
410 int sa = gdk_pixbuf_get_rowstride (a); 833 int sa = gdk_pixbuf_get_rowstride (a);
… …
438 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d)); 861 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d));
439 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d)); 862 d = ((int)*pa_++) - ((int)*pb_++); diff += d*d; peak = MAX (peak, abs (d));
440 } 863 }
441 } 864 }
442 865
866 perlinterp_acquire ();
867
443 EXTEND (SP, 2); 868 EXTEND (SP, 2);
444 PUSHs (sv_2mortal (newSVnv (sqrt (diff / (w * h * 3. * 255. * 255.))))); 869 PUSHs (sv_2mortal (newSVnv (sqrt (diff / (w * h * 3. * 255. * 255.)))));
445 PUSHs (sv_2mortal (newSVnv (peak / 255.))); 870 PUSHs (sv_2mortal (newSVnv (peak / 255.)));
446} 871}
447 872
… …
457 CODE: 882 CODE:
458{ 883{
459 STRLEN plen; 884 STRLEN plen;
460 U8 *path = (U8 *)SvPV (pathsv, plen); 885 U8 *path = (U8 *)SvPV (pathsv, plen);
461 U8 *pend = path + plen; 886 U8 *pend = path + plen;
462 U8 dst [plen * 6 * 3], *dstp = dst; 887 U8 dst [plen * 8 * 3], *dstp = dst;
463 888
464 while (path < pend) 889 while (path < pend)
465 { 890 {
466 U8 ch = *path; 891 U8 ch = *path;
467 892
… …
469 *dstp++ = *path++; 894 *dstp++ = *path++;
470 else if (ch >= 'A' && ch <= 'Z') 895 else if (ch >= 'A' && ch <= 'Z')
471 *dstp++ = *path++ + ('a' - 'A'); 896 *dstp++ = *path++ + ('a' - 'A');
472 else if (ch >= '0' && ch <= '9') 897 else if (ch >= '0' && ch <= '9')
473 { 898 {
899 /* version sort, up to 8 digits */
474 STRLEN el, nl = 0; 900 STRLEN el, nl = 0;
475 while (*path >= '0' && *path <= '9' && path < pend) 901 while (*path >= '0' && *path <= '9' && path < pend)
476 path++, nl++; 902 path++, nl++;
477 903
478 for (el = nl; el < 6; el++) 904 for (el = nl; el < 8; el++)
479 *dstp++ = '0'; 905 *dstp++ = '0';
480 906
481 memcpy (dstp, path - nl, nl); 907 memcpy (dstp, path - nl, nl);
482 dstp += nl; 908 dstp += nl;
483 } 909 }

Diff Legend

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