restore ABI level 5 compatibility
[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
210 /* in general these functions aren't called by Imager internally, but
211    only via the pointers above, since faster macros that call the
212    image vtable pointers are used.
213
214    () are used around the function names to prevent macro replacement
215    on the function names.
216 */
217
218 /*
219 =item i_ppix(im, x, y, color)
220
221 =category Drawing
222
223 Sets the pixel at (x,y) to I<color>.
224
225 Returns 0 if the pixel was drawn, or -1 if not.
226
227 Does no alpha blending, just copies the channels from the supplied
228 color to the image.
229
230 =cut
231 */
232
233 int 
234 (i_ppix)(i_img *im, i_img_dim x, i_img_dim y, const i_color *val) {
235   return i_ppix(im, x, y, val);
236 }
237
238 /*
239 =item i_gpix(im, C<x>, C<y>, C<color>)
240
241 =category Drawing
242
243 Retrieves the C<color> of the pixel (x,y).
244
245 Returns 0 if the pixel was retrieved, or -1 if not.
246
247 =cut
248 */
249
250 int
251 (i_gpix)(i_img *im,i_img_dim x,i_img_dim y,i_color *val) {
252   return i_gpix(im, x, y, val);
253 }
254
255 /*
256 =item i_ppixf(im, C<x>, C<y>, C<fcolor>)
257
258 =category Drawing
259
260 Sets the pixel at (C<x>,C<y>) to the floating point color C<fcolor>.
261
262 Returns 0 if the pixel was drawn, or -1 if not.
263
264 Does no alpha blending, just copies the channels from the supplied
265 color to the image.
266
267 =cut
268 */
269 int
270 (i_ppixf)(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *val) {
271   return i_ppixf(im, x, y, val);
272 }
273
274 /*
275 =item i_gpixf(im, C<x>, C<y>, C<fcolor>)
276
277 =category Drawing
278
279 Retrieves the color of the pixel (x,y) as a floating point color into
280 C<fcolor>.
281
282 Returns 0 if the pixel was retrieved, or -1 if not.
283
284 =cut
285 */
286
287 int
288 (i_gpixf)(i_img *im,i_img_dim x,i_img_dim y,i_fcolor *val) {
289   return i_gpixf(im, x, y, val);
290 }
291
292 /*
293 =item i_plin(im, l, r, y, colors)
294
295 =category Drawing
296
297 Sets (r-l) pixels starting from (l,y) using (r-l) values from
298 I<colors>.
299
300 Returns the number of pixels set.
301
302 =cut
303 */
304
305 i_img_dim
306 (i_plin)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_color *vals) {
307   return i_plin(im, l, r, y, vals);
308 }
309
310 /*
311 =item i_glin(im, l, r, y, colors)
312
313 =category Drawing
314
315 Retrieves (r-l) pixels starting from (l,y) into I<colors>.
316
317 Returns the number of pixels retrieved.
318
319 =cut
320 */
321
322 i_img_dim
323 (i_glin)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_color *vals) {
324   return i_glin(im, l, r, y, vals);
325 }
326
327 /*
328 =item i_plinf(im, C<left>, C<right>, C<fcolors>)
329
330 =category Drawing
331
332 Sets (right-left) pixels starting from (left,y) using (right-left)
333 floating point colors from C<fcolors>.
334
335 Returns the number of pixels set.
336
337 =cut
338 */
339
340 i_img_dim
341 (i_plinf)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *vals) {
342   return i_plinf(im, l, r, y, vals);
343 }
344
345 /*
346 =item i_glinf(im, l, r, y, colors)
347
348 =category Drawing
349
350 Retrieves (r-l) pixels starting from (l,y) into I<colors> as floating
351 point colors.
352
353 Returns the number of pixels retrieved.
354
355 =cut
356 */
357
358 i_img_dim
359 (i_glinf)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *vals) {
360   return i_glinf(im, l, r, y, vals);
361 }
362
363 /*
364 =item i_gsamp(im, left, right, y, samples, channels, channel_count)
365
366 =category Drawing
367
368 Reads sample values from C<im> for the horizontal line (left, y) to
369 (right-1,y) for the channels specified by C<channels>, an array of int
370 with C<channel_count> elements.
371
372 If channels is NULL then the first channels_count channels are retrieved for
373 each pixel.
374
375 Returns the number of samples read (which should be (right-left) *
376 channel_count)
377
378 =cut
379 */
380 i_img_dim
381 (i_gsamp)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_sample_t *samp, 
382                    const int *chans, int chan_count) {
383   return i_gsamp(im, l, r, y, samp, chans, chan_count);
384 }
385
386 /*
387 =item i_gsampf(im, left, right, y, samples, channels, channel_count)
388
389 =category Drawing
390
391 Reads floating point sample values from C<im> for the horizontal line
392 (left, y) to (right-1,y) for the channels specified by C<channels>, an
393 array of int with channel_count elements.
394
395 If C<channels> is NULL then the first C<channel_count> channels are
396 retrieved for each pixel.
397
398 Returns the number of samples read (which should be (C<right>-C<left>)
399 * C<channel_count>)
400
401 =cut
402 */
403 i_img_dim
404 (i_gsampf)(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samp, 
405            const int *chans, int chan_count) {
406   return i_gsampf(im, l, r, y, samp, chans, chan_count);
407 }
408
409 /*
410 =item i_gsamp_bits(im, left, right, y, samples, channels, channel_count, bits)
411 =category Drawing
412
413 Reads integer samples scaled to C<bits> bits of precision into the
414 C<unsigned int> array C<samples>.
415
416 Expect this to be slow unless C<< bits == im->bits >>.
417
418 Returns the number of samples copied, or -1 on error.
419
420 Not all image types implement this method.
421
422 Pushes errors, but does not call C<i_clear_error()>.
423
424 =cut
425 */
426
427 /*
428 =item i_psamp_bits(im, left, right, y, samples, channels, channel_count, bits)
429 =category Drawing
430
431 Writes integer samples scaled to C<bits> bits of precision from the
432 C<unsigned int> array C<samples>.
433
434 Expect this to be slow unless C<< bits == im->bits >>.
435
436 Returns the number of samples copied, or -1 on error.
437
438 Not all image types implement this method.
439
440 Pushes errors, but does not call C<i_clear_error()>.
441
442 =cut
443 */
444
445 /*
446 =item i_gpal(im, left, right, y, indexes)
447
448 =category Drawing
449
450 Reads palette indexes for the horizontal line (left, y) to (right-1,
451 y) into C<indexes>.
452
453 Returns the number of indexes read.
454
455 Always returns 0 for direct color images.
456
457 =cut
458 */
459 i_img_dim
460 (i_gpal)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_palidx *vals) {
461   return i_gpal(im, x, r, y, vals);
462 }
463
464 /*
465 =item i_ppal(im, left, right, y, indexes)
466
467 =category Drawing
468
469 Writes palette indexes for the horizontal line (left, y) to (right-1,
470 y) from C<indexes>.
471
472 Returns the number of indexes written.
473
474 Always returns 0 for direct color images.
475
476 =cut
477 */
478 i_img_dim
479 (i_ppal)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, const i_palidx *vals) {
480   return i_ppal(im, x, r, y, vals);
481 }
482
483 /*
484 =item i_addcolors(im, colors, count)
485
486 =category Paletted images
487
488 Adds colors to the image's palette.
489
490 On success returns the index of the lowest color added.
491
492 On failure returns -1.
493
494 Always fails for direct color images.
495
496 =cut
497 */
498
499 int
500 (i_addcolors)(i_img *im, const i_color *colors, int count) {
501   return i_addcolors(im, colors, count);
502 }
503
504 /*
505 =item i_getcolors(im, index, colors, count)
506
507 =category Paletted images
508
509 Retrieves I<count> colors starting from I<index> in the image's
510 palette.
511
512 On success stores the colors into I<colors> and returns true.
513
514 On failure returns false.
515
516 Always fails for direct color images.
517
518 Fails if there are less than I<index>+I<count> colors in the image's
519 palette.
520
521 =cut
522 */
523
524 int
525 (i_getcolors)(i_img *im, int i, i_color *colors, int count) {
526   return i_getcolors(im, i, colors, count);
527 }
528
529 /*
530 =item i_colorcount(im)
531
532 =category Paletted images
533
534 Returns the number of colors in the image's palette.
535
536 Returns -1 for direct images.
537
538 =cut
539 */
540
541 int
542 (i_colorcount)(i_img *im) {
543   return i_colorcount(im);
544 }
545
546 /*
547 =item i_maxcolors(im)
548
549 =category Paletted images
550
551 Returns the maximum number of colors the palette can hold for the
552 image.
553
554 Returns -1 for direct color images.
555
556 =cut
557 */
558
559 int
560 (i_maxcolors)(i_img *im) {
561   return i_maxcolors(im);
562 }
563
564 /*
565 =item i_findcolor(im, color, &entry)
566
567 =category Paletted images
568
569 Searches the images palette for the given color.
570
571 On success sets *I<entry> to the index of the color, and returns true.
572
573 On failure returns false.
574
575 Always fails on direct color images.
576
577 =cut
578 */
579 int
580 (i_findcolor)(i_img *im, const i_color *color, i_palidx *entry) {
581   return i_findcolor(im, color, entry);
582 }
583
584 /*
585 =item i_setcolors(im, index, colors, count)
586
587 =category Paletted images
588
589 Sets I<count> colors starting from I<index> in the image's palette.
590
591 On success returns true.
592
593 On failure returns false.
594
595 The image must have at least I<index>+I<count> colors in it's palette
596 for this to succeed.
597
598 Always fails on direct color images.
599
600 =cut
601 */
602 int
603 (i_setcolors)(i_img *im, int index, const i_color *colors, int count) {
604   return i_setcolors(im, index, colors, count);
605 }
606
607 /*
608 =item im_get_context()
609
610 Retrieve the context object for the current thread.
611
612 Inside Imager itself this is just a function pointer, which the
613 F<Imager.xs> BOOT handler initializes for use within perl.  If you're
614 taking the Imager code and embedding it elsewhere you need to
615 initialize the C<im_get_context> pointer at some point.
616
617 =cut
618 */
619
620 static im_context_t
621 get_context(void) {
622   return im_get_context();
623 }
624
625 static i_img *
626 mathom_i_img_8_new(i_img_dim xsize, i_img_dim ysize, int channels) {
627   return i_img_8_new(xsize, ysize, channels);
628 }
629
630 static i_img *
631 mathom_i_img_16_new(i_img_dim xsize, i_img_dim ysize, int channels) {
632   return i_img_16_new(xsize, ysize, channels);
633 }
634
635 static i_img *
636 mathom_i_img_double_new(i_img_dim xsize, i_img_dim ysize, int channels) {
637   return i_img_double_new(xsize, ysize, channels);
638 }
639
640 static i_img *
641 mathom_i_img_pal_new(i_img_dim xsize, i_img_dim ysize, int channels,
642                      int maxpal) {
643   return i_img_pal_new(xsize, ysize, channels, maxpal);
644 }
645
646 static void
647 mathom_i_clear_error(void) {
648   i_clear_error();
649 }
650
651 static void
652 mathom_i_push_error(int code, const char *msg) {
653   i_push_error(code, msg);
654 }
655
656 static void
657 mathom_i_push_errorvf(int code, const char *fmt, va_list args) {
658   i_push_errorvf(code, fmt, args);
659 }
660
661 static int
662 mathom_i_set_image_file_limits(i_img_dim max_width, i_img_dim max_height,
663                                size_t max_bytes) {
664   return i_set_image_file_limits(max_width, max_height, max_bytes);
665 }
666
667 static int
668 mathom_i_get_image_file_limits(i_img_dim *pmax_width, i_img_dim *pmax_height,
669                                size_t *pmax_bytes) {
670   return i_get_image_file_limits(pmax_width, pmax_height, pmax_bytes);
671 }
672
673 static int
674 mathom_i_int_check_image_file_limits(i_img_dim width, i_img_dim height,
675                                      int channels, size_t sample_size) {
676   return i_int_check_image_file_limits(width, height, channels, sample_size);
677 }
678
679 static i_img *
680 mathom_i_img_alloc(void) {
681   return i_img_alloc();
682 }
683
684 static void
685 mathom_i_img_init(i_img *im) {
686   i_img_init(im);
687 }
688
689 static i_io_glue_t *
690 mathom_io_new_fd(int fd) {
691   return io_new_fd(fd);
692 }
693 static i_io_glue_t *
694 mathom_io_new_bufchain(void) {
695   return io_new_bufchain();
696 }
697
698 static i_io_glue_t *
699 mathom_io_new_buffer(const char *data, size_t size, i_io_closebufp_t closefp,
700                      void *close_data) {
701   return io_new_buffer(data, size, closefp, close_data);
702 }
703
704 static i_io_glue_t *
705 mathom_io_new_cb(void *p, i_io_readl_t readcb, i_io_writel_t writecb,
706                  i_io_seekl_t seekcb, i_io_closel_t closecb,
707                  i_io_destroyl_t destroycb) {
708   return io_new_cb(p, readcb, writecb, seekcb, closecb, destroycb);
709 }