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

Comparing CV/CV.xs (file contents):
Revision 1.46 by root, Sat Jul 4 05:31:17 2015 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
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
21#include "perlmulticore.h" 34#include "perlmulticore.h"
22 35
23#define IW 80 /* MUST match Schnauzer.pm! */ 36#define IW 80 /* MUST match Schnauzer.pm! */
24#define IH 60 /* MUST match Schnauzer.pm! */ 37#define IH 60 /* MUST match Schnauzer.pm! */
25 38
26#define RAND (seed = (seed + 7141) * 54773 % 134456)
27
28#define LINELENGTH 240 39#define LINELENGTH 240
29 40
30#define ELLIPSIS "\xe2\x80\xa6" 41#define ELLIPSIS "\xe2\x80\xa6"
31 42
32typedef char *octet_string; 43typedef char *octet_string;
44
45static magic_t magic_cookie[2]; /* !mime, mime */
33 46
34struct jpg_err_mgr 47struct jpg_err_mgr
35{ 48{
36 struct jpeg_error_mgr err; 49 struct jpeg_error_mgr err;
37 jmp_buf setjmp_buffer; 50 jmp_buf setjmp_buffer;
38}; 51};
39 52
40static void 53static void
41cv_error_exit (j_common_ptr cinfo) 54cv_error_exit (j_common_ptr cinfo)
42{ 55{
56 cinfo->err->output_message (cinfo);
43 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99); 57 longjmp (((struct jpg_err_mgr *)cinfo->err)->setjmp_buffer, 99);
44} 58}
45 59
46static void 60static void
47cv_error_output (j_common_ptr cinfo) 61cv_error_output (j_common_ptr cinfo)
48{ 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);
49 return; 68 return;
50} 69}
51 70
52static void 71static void
53rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b, 72rgb_to_hsv (unsigned int r, unsigned int g, unsigned int b,
… …
150 if (!--a85_cnt) 169 if (!--a85_cnt)
151 { 170 {
152 a85_cnt = 4; 171 a85_cnt = 4;
153 if (a85_val) 172 if (a85_val)
154 { 173 {
155 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85; 174 a85_ptr[4] = (a85_val % 85) + 33; a85_val /= 85;
156 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85; 175 a85_ptr[3] = (a85_val % 85) + 33; a85_val /= 85;
157 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85; 176 a85_ptr[2] = (a85_val % 85) + 33; a85_val /= 85;
158 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85; 177 a85_ptr[1] = (a85_val % 85) + 33; a85_val /= 85;
159 a85_ptr[0] = (a85_val ) + 33; 178 a85_ptr[0] = (a85_val ) + 33;
160 179
161 a85_ptr += 5; 180 a85_ptr += 5;
162 } 181 }
… …
185 204
186 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf); 205 PerlIO_write (fp, a85_buf, a85_ptr - a85_buf);
187} 206}
188 207
189///////////////////////////////////////////////////////////////////////////// 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/////////////////////////////////////////////////////////////////////////////
190 303
191MODULE = Gtk2::CV PACKAGE = Gtk2::CV 304MODULE = Gtk2::CV PACKAGE = Gtk2::CV
192 305
193PROTOTYPES: ENABLE 306PROTOTYPES: ENABLE
194 307
308# calculate the common prefix length of two strings
195# missing function in perl. really :) 309# missing function in perl. really :)
196int 310int
197common_prefix_length (a, b) 311common_prefix_length (a, b)
198 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg); 312 unsigned char *a = (unsigned char *)SvPVutf8_nolen ($arg);
199 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg); 313 unsigned char *b = (unsigned char *)SvPVutf8_nolen ($arg);
… …
208 322
209 OUTPUT: 323 OUTPUT:
210 RETVAL 324 RETVAL
211 325
212const char * 326const char *
213magic (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
214 CODE: 333 CODE:
215{ 334{
216 static magic_t cookie; 335 STRLEN len;
336 char *data = SvPVbyte (path_or_data, len);
217 337
218 if (!cookie) 338 if (!magic_cookie[0])
219 { 339 {
220 cookie = magic_open (MAGIC_SYMLINK); 340 magic_cookie[0] = magic_open (MAGIC_SYMLINK);
221 341 magic_cookie[1] = magic_open (MAGIC_SYMLINK | MAGIC_MIME_TYPE);
222 if (cookie)
223 magic_load (cookie, 0); 342 magic_load (magic_cookie[0], 0);
224 else
225 XSRETURN_UNDEF;
226 }
227
228 RETVAL = magic_file (cookie, path);
229}
230 OUTPUT:
231 RETVAL
232
233const char *
234magic_mime (octet_string path)
235 CODE:
236{
237 static magic_t cookie;
238
239 if (!cookie)
240 {
241 cookie = magic_open (MAGIC_MIME | MAGIC_SYMLINK);
242
243 if (cookie)
244 magic_load (cookie, 0); 343 magic_load (magic_cookie[1], 0);
245 else
246 XSRETURN_UNDEF;
247 } 344 }
248 345
249 perlinterp_release (); 346 perlinterp_release ();
250 RETVAL = magic_file (cookie, path); 347
348 RETVAL = ix & 2
349 ? magic_buffer (magic_cookie[ix & 1], data, len)
350 : magic_file (magic_cookie[ix & 1], data);
351
251 perlinterp_acquire (); 352 perlinterp_acquire ();
252} 353}
253 OUTPUT: 354 OUTPUT:
254 RETVAL 355 RETVAL
255 356
… …
310 : angle); 411 : angle);
311 perlinterp_acquire (); 412 perlinterp_acquire ();
312 OUTPUT: 413 OUTPUT:
313 RETVAL 414 RETVAL
314 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
315GdkPixbuf_noinc * 491GdkPixbuf_noinc *
316load_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)
317 CODE: 694 CODE:
318{ 695{
319 struct jpeg_decompress_struct cinfo; 696 struct jpeg_decompress_struct cinfo;
320 struct jpg_err_mgr jerr; 697 struct jpg_err_mgr jerr;
321 guchar *data;
322 int rs; 698 int rs;
323 FILE *fp;
324 volatile GdkPixbuf *pb = 0; 699 volatile GdkPixbuf *pb = 0;
700 STRLEN data_len;
701 guchar *data = SvPVbyte (image_data, data_len);
325 702
326 RETVAL = 0; 703 RETVAL = 0;
327
328 fp = fopen (SvPVbyte_nolen (path), "rb");
329
330 if (!fp)
331 XSRETURN_UNDEF;
332 704
333 perlinterp_release (); 705 perlinterp_release ();
334 706
335 cinfo.err = jpeg_std_error (&jerr.err); 707 cinfo.err = jpeg_std_error (&jerr.err);
336 708
337 jerr.err.error_exit = cv_error_exit; 709 jerr.err.error_exit = cv_error_exit;
338 jerr.err.output_message = cv_error_output; 710 jerr.err.output_message = cv_error_output;
339 711
340 if ((rs = setjmp (jerr.setjmp_buffer))) 712 if ((rs = setjmp (jerr.setjmp_buffer)))
341 { 713 {
342 fclose (fp);
343 jpeg_destroy_decompress (&cinfo); 714 jpeg_destroy_decompress (&cinfo);
344 715
345 if (pb) 716 if (pb)
346 g_object_unref ((gpointer)pb); 717 g_object_unref ((gpointer)pb);
347 718
348 perlinterp_acquire (); 719 perlinterp_acquire ();
349 XSRETURN_UNDEF; 720 XSRETURN_UNDEF;
350 } 721 }
351 722
723 if (!data_len)
724 longjmp (jerr.setjmp_buffer, 4);
725
352 jpeg_create_decompress (&cinfo); 726 jpeg_create_decompress (&cinfo);
727 cv_jpeg_mem_src (&cinfo, data, data_len);
353 728
354 jpeg_stdio_src (&cinfo, fp);
355 jpeg_read_header (&cinfo, TRUE); 729 jpeg_read_header (&cinfo, TRUE);
356 730
357 cinfo.dct_method = JDCT_DEFAULT; 731 cinfo.dct_method = JDCT_DEFAULT;
358 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 */
359 cinfo.do_block_smoothing = FALSE; 733 cinfo.do_block_smoothing = FALSE;
… …
369 { 743 {
370 cinfo.dct_method = JDCT_FASTEST; 744 cinfo.dct_method = JDCT_FASTEST;
371 cinfo.do_fancy_upsampling = FALSE; 745 cinfo.do_fancy_upsampling = FALSE;
372 746
373 while (cinfo.scale_denom < 8 747 while (cinfo.scale_denom < 8
374 && cinfo.output_width >= IW*4 748 && cinfo.output_width >= iw*4
375 && cinfo.output_height >= IH*4) 749 && cinfo.output_height >= ih*4)
376 { 750 {
377 cinfo.scale_denom <<= 1; 751 cinfo.scale_denom <<= 1;
378 jpeg_calc_output_dimensions (&cinfo); 752 jpeg_calc_output_dimensions (&cinfo);
379 } 753 }
380 } 754 }
381 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
382 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);
383 if (!RETVAL) 766 if (!RETVAL)
384 longjmp (jerr.setjmp_buffer, 2); 767 longjmp (jerr.setjmp_buffer, 2);
385 768
386 data = gdk_pixbuf_get_pixels (RETVAL); 769 data = gdk_pixbuf_get_pixels (RETVAL);
387 rs = gdk_pixbuf_get_rowstride (RETVAL); 770 rs = gdk_pixbuf_get_rowstride (RETVAL);
388
389 if (cinfo.output_components != 3)
390 longjmp (jerr.setjmp_buffer, 3);
391 771
392 jpeg_start_decompress (&cinfo); 772 jpeg_start_decompress (&cinfo);
393 773
394 while (cinfo.output_scanline < cinfo.output_height) 774 while (cinfo.output_scanline < cinfo.output_height)
395 { 775 {
… …
402 rp [3] = (guchar *)rp [2] + rs; 782 rp [3] = (guchar *)rp [2] + rs;
403 783
404 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4); 784 jpeg_read_scanlines (&cinfo, rp, remaining < 4 ? remaining : 4);
405 } 785 }
406 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
407 jpeg_finish_decompress (&cinfo); 816 jpeg_finish_decompress (&cinfo);
408 fclose (fp);
409 jpeg_destroy_decompress (&cinfo); 817 jpeg_destroy_decompress (&cinfo);
410 perlinterp_acquire (); 818 perlinterp_acquire ();
411} 819}
412 OUTPUT: 820 OUTPUT:
413 RETVAL 821 RETVAL
… …
472 CODE: 880 CODE:
473{ 881{
474 STRLEN plen; 882 STRLEN plen;
475 U8 *path = (U8 *)SvPV (pathsv, plen); 883 U8 *path = (U8 *)SvPV (pathsv, plen);
476 U8 *pend = path + plen; 884 U8 *pend = path + plen;
477 U8 dst [plen * 6 * 3], *dstp = dst; 885 U8 dst [plen * 8 * 3], *dstp = dst;
478 886
479 while (path < pend) 887 while (path < pend)
480 { 888 {
481 U8 ch = *path; 889 U8 ch = *path;
482 890
… …
484 *dstp++ = *path++; 892 *dstp++ = *path++;
485 else if (ch >= 'A' && ch <= 'Z') 893 else if (ch >= 'A' && ch <= 'Z')
486 *dstp++ = *path++ + ('a' - 'A'); 894 *dstp++ = *path++ + ('a' - 'A');
487 else if (ch >= '0' && ch <= '9') 895 else if (ch >= '0' && ch <= '9')
488 { 896 {
897 /* version sort, up to 8 digits */
489 STRLEN el, nl = 0; 898 STRLEN el, nl = 0;
490 while (*path >= '0' && *path <= '9' && path < pend) 899 while (*path >= '0' && *path <= '9' && path < pend)
491 path++, nl++; 900 path++, nl++;
492 901
493 for (el = nl; el < 6; el++) 902 for (el = nl; el < 8; el++)
494 *dstp++ = '0'; 903 *dstp++ = '0';
495 904
496 memcpy (dstp, path - nl, nl); 905 memcpy (dstp, path - nl, nl);
497 dstp += nl; 906 dstp += nl;
498 } 907 }

Diff Legend

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