imext.c

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