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 }