imext.c

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