add colorchannels(), alphachannel() and colormodel() methods
[imager.git] / imext.c
1 #include "imexttypes.h"
2 #include "imager.h"
3 #include "imio.h"
4
5 static im_context_t get_context(void);
6 static i_img *mathom_i_img_8_new(i_img_dim, i_img_dim, int);
7 static i_img *mathom_i_img_16_new(i_img_dim, i_img_dim, int);
8 static i_img *mathom_i_img_double_new(i_img_dim, i_img_dim, int);
9 static i_img *mathom_i_img_pal_new(i_img_dim, i_img_dim, int, int);
10 static void mathom_i_clear_error(void);
11 static void mathom_i_push_error(int, const char *);
12 static void mathom_i_push_errorvf(int, const char *, va_list);
13 static int mathom_i_set_image_file_limits(i_img_dim, i_img_dim, size_t);
14 static int mathom_i_get_image_file_limits(i_img_dim*, i_img_dim*, size_t*);
15 static int
16 mathom_i_int_check_image_file_limits(i_img_dim, i_img_dim, int, size_t);
17 static i_img *mathom_i_img_alloc(void);
18 static void mathom_i_img_init(i_img *);
19 static i_io_glue_t *mathom_io_new_fd(int);
20 static i_io_glue_t *mathom_io_new_bufchain(void);
21 static i_io_glue_t *
22 mathom_io_new_buffer(const char *data, size_t, i_io_closebufp_t, void *);
23 static i_io_glue_t *
24 mathom_io_new_cb(void *, i_io_readl_t, i_io_writel_t, i_io_seekl_t,
25                  i_io_closel_t, i_io_destroyl_t);
26
27 /*
28  DON'T ADD CASTS TO THESE
29 */
30 im_ext_funcs imager_function_table =
31   {
32     IMAGER_API_VERSION,
33     IMAGER_API_LEVEL,
34
35     mymalloc,
36     myfree,
37     myrealloc,
38
39     mymalloc_file_line,
40     myfree_file_line,
41     myrealloc_file_line,
42
43     mathom_i_img_8_new,
44     mathom_i_img_16_new,
45     mathom_i_img_double_new,
46     mathom_i_img_pal_new,
47     i_img_destroy,
48     i_sametype,
49     i_sametype_chans,
50     i_img_info,
51
52     i_ppix,
53     i_gpix,
54     i_ppixf,
55     i_gpixf,
56     i_plin,
57     i_glin,
58     i_plinf,
59     i_glinf,
60     i_gsamp,
61     i_gsampf,
62     i_gpal,
63     i_ppal,
64     i_addcolors,
65     i_getcolors,
66     i_colorcount,
67     i_maxcolors,
68     i_findcolor,
69     i_setcolors,
70
71     i_new_fill_solid,
72     i_new_fill_solidf,
73     i_new_fill_hatch,
74     i_new_fill_hatchf,
75     i_new_fill_image,
76     i_new_fill_fount,
77     i_fill_destroy,
78
79     i_quant_makemap,
80     i_quant_translate,
81     i_quant_transparent,
82
83     mathom_i_clear_error,
84     mathom_i_push_error,
85     i_push_errorf,
86     mathom_i_push_errorvf,
87
88     i_tags_new,
89     i_tags_set,
90     i_tags_setn,
91     i_tags_destroy,
92     i_tags_find,
93     i_tags_findn,
94     i_tags_delete,
95     i_tags_delbyname,
96     i_tags_delbycode,
97     i_tags_get_float,
98     i_tags_set_float,
99     i_tags_set_float2,
100     i_tags_get_int,
101     i_tags_get_string,
102     i_tags_get_color,
103     i_tags_set_color,
104
105     i_box,
106     i_box_filled,
107     i_box_cfill,
108     i_line,
109     i_line_aa,
110     i_arc,
111     i_arc_aa,
112     i_arc_cfill,
113     i_arc_aa_cfill,
114     i_circle_aa,
115     i_flood_fill,
116     i_flood_cfill,
117
118     i_copyto,
119     i_copyto_trans,
120     i_copy,
121     i_rubthru,
122
123     /* IMAGER_API_LEVEL 2 functions */
124     mathom_i_set_image_file_limits,
125     mathom_i_get_image_file_limits,
126     mathom_i_int_check_image_file_limits,
127
128     i_flood_fill_border,
129     i_flood_cfill_border,
130
131     /* IMAGER_API_LEVEL 3 functions */
132     i_img_setmask,
133     i_img_getmask,
134     i_img_getchannels,
135     i_img_get_width,
136     i_img_get_height,
137     i_lhead,
138     i_loog,
139
140     /* IMAGER_API_LEVEL 4 functions */
141     mathom_i_img_alloc,
142     mathom_i_img_init,
143
144     /* IMAGER_API_LEVEL 5 functions */
145     i_img_is_monochrome,
146     i_gsamp_bg,
147     i_gsampf_bg,
148     i_get_file_background,
149     i_get_file_backgroundf,
150     i_utf8_advance,
151     i_render_new,
152     i_render_delete,
153     i_render_color,
154     i_render_fill,
155     i_render_line,
156     i_render_linef,
157
158     /* level 6 */
159     i_io_getc_imp,
160     i_io_peekc_imp,
161     i_io_peekn,
162     i_io_putc_imp,
163     i_io_read,
164     i_io_write,
165     i_io_seek,
166     i_io_flush,
167     i_io_close,
168     i_io_set_buffered,
169     i_io_gets,
170     mathom_io_new_fd,
171     mathom_io_new_bufchain,
172     mathom_io_new_buffer,
173     mathom_io_new_cb,
174     io_slurp,
175     io_glue_destroy,
176
177     /* level 8 */
178     im_img_8_new,
179     im_img_16_new,
180     im_img_double_new,
181     im_img_pal_new,
182     im_clear_error,
183     im_push_error,
184     im_push_errorvf,
185     im_push_errorf,
186     im_set_image_file_limits,
187     im_get_image_file_limits,
188     im_int_check_image_file_limits,
189     im_img_alloc,
190     im_img_init,
191     im_io_new_fd,
192     im_io_new_bufchain,
193     im_io_new_buffer,
194     im_io_new_cb,
195     get_context,
196     im_lhead,
197     im_loog,
198     im_context_refinc,
199     im_context_refdec,
200     im_errors,
201     i_mutex_new,
202     i_mutex_destroy,
203     i_mutex_lock,
204     i_mutex_unlock,
205     im_context_slot_new,
206     im_context_slot_set,
207     im_context_slot_get,
208
209     /* level 9 */
210     i_poly_poly_aa,
211     i_poly_poly_aa_cfill,
212     i_poly_aa_m,
213     i_poly_aa_cfill_m,
214
215     /* level 10 */
216     i_img_alpha_channel,
217     i_img_color_model,
218     i_img_color_channels
219   };
220
221 /* in general these functions aren't called by Imager internally, but
222    only via the pointers above, since faster macros that call the
223    image vtable pointers are used.
224
225    () are used around the function names to prevent macro replacement
226    on the function names.
227 */
228
229 /*
230 =item i_ppix(im, x, y, color)
231
232 =category Drawing
233
234 Sets the pixel at (x,y) to I<color>.
235
236 Returns 0 if the pixel was drawn, or -1 if not.
237
238 Does no alpha blending, just copies the channels from the supplied
239 color to the image.
240
241 =cut
242 */
243
244 int 
245 (i_ppix)(i_img *im, i_img_dim x, i_img_dim y, const i_color *val) {
246   return i_ppix(im, x, y, val);
247 }
248
249 /*
250 =item i_gpix(im, C<x>, C<y>, C<color>)
251
252 =category Drawing
253
254 Retrieves the C<color> of the pixel (x,y).
255
256 Returns 0 if the pixel was retrieved, or -1 if not.
257
258 =cut
259 */
260
261 int
262 (i_gpix)(i_img *im,i_img_dim x,i_img_dim y,i_color *val) {
263   return i_gpix(im, x, y, val);
264 }
265
266 /*
267 =item i_ppixf(im, C<x>, C<y>, C<fcolor>)
268
269 =category Drawing
270
271 Sets the pixel at (C<x>,C<y>) to the floating point color C<fcolor>.
272
273 Returns 0 if the pixel was drawn, or -1 if not.
274
275 Does no alpha blending, just copies the channels from the supplied
276 color to the image.
277
278 =cut
279 */
280 int
281 (i_ppixf)(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *val) {
282   return i_ppixf(im, x, y, val);
283 }
284
285 /*
286 =item i_gpixf(im, C<x>, C<y>, C<fcolor>)
287
288 =category Drawing
289
290 Retrieves the color of the pixel (x,y) as a floating point color into
291 C<fcolor>.
292
293 Returns 0 if the pixel was retrieved, or -1 if not.
294
295 =cut
296 */
297
298 int
299 (i_gpixf)(i_img *im,i_img_dim x,i_img_dim y,i_fcolor *val) {
300   return i_gpixf(im, x, y, val);
301 }
302
303 /*
304 =item i_plin(im, l, r, y, colors)
305
306 =category Drawing
307
308 Sets (r-l) pixels starting from (l,y) using (r-l) values from
309 I<colors>.
310
311 Returns the number of pixels set.
312
313 =cut
314 */
315
316 i_img_dim
317 (i_plin)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_color *vals) {
318   return i_plin(im, l, r, y, vals);
319 }
320
321 /*
322 =item i_glin(im, l, r, y, colors)
323
324 =category Drawing
325
326 Retrieves (r-l) pixels starting from (l,y) into I<colors>.
327
328 Returns the number of pixels retrieved.
329
330 =cut
331 */
332
333 i_img_dim
334 (i_glin)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_color *vals) {
335   return i_glin(im, l, r, y, vals);
336 }
337
338 /*
339 =item i_plinf(im, C<left>, C<right>, C<fcolors>)
340
341 =category Drawing
342
343 Sets (right-left) pixels starting from (left,y) using (right-left)
344 floating point colors from C<fcolors>.
345
346 Returns the number of pixels set.
347
348 =cut
349 */
350
351 i_img_dim
352 (i_plinf)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *vals) {
353   return i_plinf(im, l, r, y, vals);
354 }
355
356 /*
357 =item i_glinf(im, l, r, y, colors)
358
359 =category Drawing
360
361 Retrieves (r-l) pixels starting from (l,y) into I<colors> as floating
362 point colors.
363
364 Returns the number of pixels retrieved.
365
366 =cut
367 */
368
369 i_img_dim
370 (i_glinf)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *vals) {
371   return i_glinf(im, l, r, y, vals);
372 }
373
374 /*
375 =item i_gsamp(im, left, right, y, samples, channels, channel_count)
376
377 =category Drawing
378
379 Reads sample values from C<im> for the horizontal line (left, y) to
380 (right-1,y) for the channels specified by C<channels>, an array of int
381 with C<channel_count> elements.
382
383 If channels is NULL then the first channels_count channels are retrieved for
384 each pixel.
385
386 Returns the number of samples read (which should be (right-left) *
387 channel_count)
388
389 =cut
390 */
391 i_img_dim
392 (i_gsamp)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_sample_t *samp, 
393                    const int *chans, int chan_count) {
394   return i_gsamp(im, l, r, y, samp, chans, chan_count);
395 }
396
397 /*
398 =item i_gsampf(im, left, right, y, samples, channels, channel_count)
399
400 =category Drawing
401
402 Reads floating point sample values from C<im> for the horizontal line
403 (left, y) to (right-1,y) for the channels specified by C<channels>, an
404 array of int with channel_count elements.
405
406 If C<channels> is NULL then the first C<channel_count> channels are
407 retrieved for each pixel.
408
409 Returns the number of samples read (which should be (C<right>-C<left>)
410 * C<channel_count>)
411
412 =cut
413 */
414 i_img_dim
415 (i_gsampf)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samp, 
416            const int *chans, int chan_count) {
417   return i_gsampf(im, l, r, y, samp, chans, chan_count);
418 }
419
420 /*
421 =item i_gsamp_bits(im, left, right, y, samples, channels, channel_count, bits)
422 =category Drawing
423
424 Reads integer samples scaled to C<bits> bits of precision into the
425 C<unsigned int> array C<samples>.
426
427 Expect this to be slow unless C<< bits == im->bits >>.
428
429 Returns the number of samples copied, or -1 on error.
430
431 Not all image types implement this method.
432
433 Pushes errors, but does not call C<i_clear_error()>.
434
435 =cut
436 */
437
438 /*
439 =item i_psamp_bits(im, left, right, y, samples, channels, channel_count, bits)
440 =category Drawing
441
442 Writes integer samples scaled to C<bits> bits of precision from the
443 C<unsigned int> array C<samples>.
444
445 Expect this to be slow unless C<< bits == im->bits >>.
446
447 Returns the number of samples copied, or -1 on error.
448
449 Not all image types implement this method.
450
451 Pushes errors, but does not call C<i_clear_error()>.
452
453 =cut
454 */
455
456 /*
457 =item i_gpal(im, left, right, y, indexes)
458
459 =category Drawing
460
461 Reads palette indexes for the horizontal line (left, y) to (right-1,
462 y) into C<indexes>.
463
464 Returns the number of indexes read.
465
466 Always returns 0 for direct color images.
467
468 =cut
469 */
470 i_img_dim
471 (i_gpal)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_palidx *vals) {
472   return i_gpal(im, x, r, y, vals);
473 }
474
475 /*
476 =item i_ppal(im, left, right, y, indexes)
477
478 =category Drawing
479
480 Writes palette indexes for the horizontal line (left, y) to (right-1,
481 y) from C<indexes>.
482
483 Returns the number of indexes written.
484
485 Always returns 0 for direct color images.
486
487 =cut
488 */
489 i_img_dim
490 (i_ppal)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, const i_palidx *vals) {
491   return i_ppal(im, x, r, y, vals);
492 }
493
494 /*
495 =item i_addcolors(im, colors, count)
496
497 =category Paletted images
498
499 Adds colors to the image's palette.
500
501 On success returns the index of the lowest color added.
502
503 On failure returns -1.
504
505 Always fails for direct color images.
506
507 =cut
508 */
509
510 int
511 (i_addcolors)(i_img *im, const i_color *colors, int count) {
512   return i_addcolors(im, colors, count);
513 }
514
515 /*
516 =item i_getcolors(im, index, colors, count)
517
518 =category Paletted images
519
520 Retrieves I<count> colors starting from I<index> in the image's
521 palette.
522
523 On success stores the colors into I<colors> and returns true.
524
525 On failure returns false.
526
527 Always fails for direct color images.
528
529 Fails if there are less than I<index>+I<count> colors in the image's
530 palette.
531
532 =cut
533 */
534
535 int
536 (i_getcolors)(i_img *im, int i, i_color *colors, int count) {
537   return i_getcolors(im, i, colors, count);
538 }
539
540 /*
541 =item i_colorcount(im)
542
543 =category Paletted images
544
545 Returns the number of colors in the image's palette.
546
547 Returns -1 for direct images.
548
549 =cut
550 */
551
552 int
553 (i_colorcount)(i_img *im) {
554   return i_colorcount(im);
555 }
556
557 /*
558 =item i_maxcolors(im)
559
560 =category Paletted images
561
562 Returns the maximum number of colors the palette can hold for the
563 image.
564
565 Returns -1 for direct color images.
566
567 =cut
568 */
569
570 int
571 (i_maxcolors)(i_img *im) {
572   return i_maxcolors(im);
573 }
574
575 /*
576 =item i_findcolor(im, color, &entry)
577
578 =category Paletted images
579
580 Searches the images palette for the given color.
581
582 On success sets *I<entry> to the index of the color, and returns true.
583
584 On failure returns false.
585
586 Always fails on direct color images.
587
588 =cut
589 */
590 int
591 (i_findcolor)(i_img *im, const i_color *color, i_palidx *entry) {
592   return i_findcolor(im, color, entry);
593 }
594
595 /*
596 =item i_setcolors(im, index, colors, count)
597
598 =category Paletted images
599
600 Sets I<count> colors starting from I<index> in the image's palette.
601
602 On success returns true.
603
604 On failure returns false.
605
606 The image must have at least I<index>+I<count> colors in it's palette
607 for this to succeed.
608
609 Always fails on direct color images.
610
611 =cut
612 */
613 int
614 (i_setcolors)(i_img *im, int index, const i_color *colors, int count) {
615   return i_setcolors(im, index, colors, count);
616 }
617
618 /*
619 =item im_get_context()
620
621 Retrieve the context object for the current thread.
622
623 Inside Imager itself this is just a function pointer, which the
624 F<Imager.xs> BOOT handler initializes for use within perl.  If you're
625 taking the Imager code and embedding it elsewhere you need to
626 initialize the C<im_get_context> pointer at some point.
627
628 =cut
629 */
630
631 static im_context_t
632 get_context(void) {
633   return im_get_context();
634 }
635
636 static i_img *
637 mathom_i_img_8_new(i_img_dim xsize, i_img_dim ysize, int channels) {
638   return i_img_8_new(xsize, ysize, channels);
639 }
640
641 static i_img *
642 mathom_i_img_16_new(i_img_dim xsize, i_img_dim ysize, int channels) {
643   return i_img_16_new(xsize, ysize, channels);
644 }
645
646 static i_img *
647 mathom_i_img_double_new(i_img_dim xsize, i_img_dim ysize, int channels) {
648   return i_img_double_new(xsize, ysize, channels);
649 }
650
651 static i_img *
652 mathom_i_img_pal_new(i_img_dim xsize, i_img_dim ysize, int channels,
653                      int maxpal) {
654   return i_img_pal_new(xsize, ysize, channels, maxpal);
655 }
656
657 static void
658 mathom_i_clear_error(void) {
659   i_clear_error();
660 }
661
662 static void
663 mathom_i_push_error(int code, const char *msg) {
664   i_push_error(code, msg);
665 }
666
667 static void
668 mathom_i_push_errorvf(int code, const char *fmt, va_list args) {
669   i_push_errorvf(code, fmt, args);
670 }
671
672 static int
673 mathom_i_set_image_file_limits(i_img_dim max_width, i_img_dim max_height,
674                                size_t max_bytes) {
675   return i_set_image_file_limits(max_width, max_height, max_bytes);
676 }
677
678 static int
679 mathom_i_get_image_file_limits(i_img_dim *pmax_width, i_img_dim *pmax_height,
680                                size_t *pmax_bytes) {
681   return i_get_image_file_limits(pmax_width, pmax_height, pmax_bytes);
682 }
683
684 static int
685 mathom_i_int_check_image_file_limits(i_img_dim width, i_img_dim height,
686                                      int channels, size_t sample_size) {
687   return i_int_check_image_file_limits(width, height, channels, sample_size);
688 }
689
690 static i_img *
691 mathom_i_img_alloc(void) {
692   return i_img_alloc();
693 }
694
695 static void
696 mathom_i_img_init(i_img *im) {
697   i_img_init(im);
698 }
699
700 static i_io_glue_t *
701 mathom_io_new_fd(int fd) {
702   return io_new_fd(fd);
703 }
704 static i_io_glue_t *
705 mathom_io_new_bufchain(void) {
706   return io_new_bufchain();
707 }
708
709 static i_io_glue_t *
710 mathom_io_new_buffer(const char *data, size_t size, i_io_closebufp_t closefp,
711                      void *close_data) {
712   return io_new_buffer(data, size, closefp, close_data);
713 }
714
715 static i_io_glue_t *
716 mathom_io_new_cb(void *p, i_io_readl_t readcb, i_io_writel_t writecb,
717                  i_io_seekl_t seekcb, i_io_closel_t closecb,
718                  i_io_destroyl_t destroycb) {
719   return io_new_cb(p, readcb, writecb, seekcb, closecb, destroycb);
720 }