WIP, it compiles
[imager.git] / lib / Imager / APIRef.pod
1 Do not edit this file, it is generated automatically by apidocs.perl
2 from Imager's source files.
3
4 Each function description has a comment listing the source file where
5 you can find the documentation.
6
7 =head1 NAME
8
9 Imager::APIRef - Imager's C API - reference.
10
11 =head1 SYNOPSIS
12
13   i_color color;
14   color.rgba.r = 255; color.rgba.g = 0; color.rgba.b = 255;
15
16
17   # Blit tools
18
19   # Data Types
20   i_img *img;
21   i_color black;
22   black.rgba.r = black.rgba.g = black.rgba.b = black.rgba.a = 0;
23   i_fill_t *fill;
24   i_img_dim x, y;
25   printf("left %" i_DF "\n", i_DFc(x));
26   printf("point (" i_DFp ")\n", i_DFcp(x, y));
27
28   # Drawing
29   i_arc(im, 50, 50, 20, 45, 135, &color);
30   i_arc_cfill(im, 50, 50, 35, 90, 135, fill);
31   i_arc_aa(im, 50, 50, 35, 90, 135, &color);
32   i_arc_aa_cfill(im, 50, 50, 35, 90, 135, fill);
33   i_circle_aa(im, 50, 50, 45, &color);
34   i_box(im, 0, 0, im->xsize-1, im->ysize-1, &color).
35   i_box_filled(im, 0, 0, im->xsize-1, im->ysize-1, &color);
36   i_box_cfill(im, 0, 0, im->xsize-1, im->ysize-1, fill);
37   i_flood_fill(im, 50, 50, &color);
38   i_flood_cfill(im, 50, 50, fill);
39   i_flood_fill_border(im, 50, 50, &color, &border);
40   i_flood_cfill_border(im, 50, 50, fill, border);
41
42   # Error handling
43   i_push_errorf(errno, "Cannot open file %s: %d", filename, errno);
44
45   # Files
46
47   # Fills
48   i_fill_t *fill = i_new_fill_solidf(&fcolor, combine);
49   i_fill_t *fill = i_new_fill_solid(&color, combine);
50   i_fill_t *fill = i_new_fill_hatch(&fg_color, &bg_color, combine, hatch, custom_hatch, dx, dy);
51   i_fill_t *fill = i_new_fill_hatchf(&fg_fcolor, &bg_fcolor, combine, hatch, custom_hatch, dx, dy);
52   i_fill_t *fill = i_new_fill_image(src_img, matrix, x_offset, y_offset, combine);
53   fill = i_new_fill_fount(0, 0, 100, 100, i_ft_linear, i_ft_linear, 
54                           i_fr_triangle, 0, i_fts_grid, 9, 1, segs);
55   i_fill_destroy(fill);
56
57   # I/O Layers
58   ssize_t count = i_io_peekn(ig, buffer, sizeof(buffer));
59   ssize_t result = i_io_write(io, buffer, size)
60   char buffer[BUFSIZ]
61   ssize_t len = i_io_gets(buffer, sizeof(buffer), '\n');
62   io_glue_destroy(ig);
63
64   # Image
65
66   # Image creation/destruction
67   i_img *img = i_sametype(src, width, height);
68   i_img *img = i_sametype_chans(src, width, height, channels);
69   i_img_destroy(img)
70
71   # Image Information
72   // only channel 0 writable 
73   i_img_setmask(img, 0x01);
74   int mask = i_img_getmask(img);
75   int channels = i_img_getchannels(img);
76   i_img_dim width = i_img_get_width(im);
77   i_img_dim height = i_img_get_height(im);
78
79   # Image quantization
80
81   # Logging
82
83   # Paletted images
84
85   # Tags
86   i_tags_set(&img->tags, "i_comment", -1);
87   i_tags_setn(&img->tags, "i_xres", 204);
88   i_tags_setn(&img->tags, "i_yres", 196);
89
90 =head1 DESCRIPTION
91
92 =head2 Blit tools
93
94 =over
95
96 =item i_render_color(r, x, y, width, source, color)
97
98 Render the given color with the coverage specified by C<source[0]> to
99 C<source[width-1]>.
100
101 Renders in normal combine mode.
102
103
104 =for comment
105 From: File render.im
106
107 =item i_render_delete(r)
108
109 Release an C<i_render> object.
110
111
112 =for comment
113 From: File render.im
114
115 =item i_render_fill(r, x, y, width, source, fill)
116
117 Render the given fill with the coverage in C<source[0]> through
118 C<source[width-1]>.
119
120
121 =for comment
122 From: File render.im
123
124 =item i_render_line(r, x, y, width, source, fill)
125
126 Render the given fill with the coverage in C<source[0]> through
127 C<source[width-1]>.
128
129
130 =for comment
131 From: File render.im
132
133 =item i_render_linef(r, x, y, width, source, fill)
134
135 Render the given fill with the coverage in C<source[0]> through
136 C<source[width-1]>.
137
138
139 =for comment
140 From: File render.im
141
142 =item i_render_new(im, width)
143
144 Allocate a new C<i_render> object and initialize it.
145
146
147 =for comment
148 From: File render.im
149
150
151 =back
152
153 =head2 Data Types
154
155 =over
156
157 =item i_img
158
159   i_img *img;
160
161 This is Imager's image type.
162
163 It contains the following members:
164
165 =over
166
167 =item *
168
169 C<channels> - the number of channels in the image
170
171 =item *
172
173 C<xsize>, C<ysize> - the width and height of the image in pixels
174
175 =item *
176
177 C<bytes> - the number of bytes used to store the image data.  Undefined
178 where virtual is non-zero.
179
180 =item *
181
182 C<ch_mask> - a mask of writable channels.  eg. if this is 6 then only
183 channels 1 and 2 are writable.  There may be bits set for which there
184 are no channels in the image.
185
186 =item *
187
188 C<bits> - the number of bits stored per sample.  Should be one of
189 i_8_bits, i_16_bits, i_double_bits.
190
191 =item *
192
193 C<type> - either i_direct_type for direct color images, or i_palette_type
194 for paletted images.
195
196 =item *
197
198 C<virtual> - if zero then this image is-self contained.  If non-zero
199 then this image could be an interface to some other implementation.
200
201 =item *
202
203 C<idata> - the image data.  This should not be directly accessed.  A new
204 image implementation can use this to store its image data.
205 i_img_destroy() will myfree() this pointer if it's non-null.
206
207 =item *
208
209 C<tags> - a structure storing the image's tags.  This should only be
210 accessed via the i_tags_*() functions.
211
212 =item *
213
214 C<ext_data> - a pointer for use internal to an image implementation.
215 This should be freed by the image's destroy handler.
216
217 =item *
218
219 C<im_data> - data internal to Imager.  This is initialized by
220 i_img_init().
221
222 =item *
223
224 i_f_ppix, i_f_ppixf, i_f_plin, i_f_plinf, i_f_gpix, i_f_gpixf,
225 i_f_glin, i_f_glinf, i_f_gsamp, i_f_gampf - implementations for each
226 of the required image functions.  An image implementation should
227 initialize these between calling i_img_alloc() and i_img_init().
228
229 =item *
230
231 i_f_gpal, i_f_ppal, i_f_addcolors, i_f_getcolors, i_f_colorcount,
232 i_f_maxcolors, i_f_findcolor, i_f_setcolors - implementations for each
233 paletted image function.
234
235 =item *
236
237 i_f_destroy - custom image destruction function.  This should be used
238 to release memory if necessary.
239
240 =item *
241
242 i_f_gsamp_bits - implements i_gsamp_bits() for this image.
243
244 =item *
245
246 i_f_psamp_bits - implements i_psamp_bits() for this image.
247
248 =item *
249
250 i_f_psamp - implements psamp() for this image.
251
252 =item *
253
254 i_f_psampf - implements psamp() for this image.
255
256 =item *
257
258 C<im_data> - image specific data internal to Imager.
259
260 =item *
261
262 C<context> - the Imager API context this image belongs to.
263
264 =back
265
266
267 =for comment
268 From: File imdatatypes.h
269
270 =item i_color
271
272   i_color black;
273   black.rgba.r = black.rgba.g = black.rgba.b = black.rgba.a = 0;
274
275 Type for 8-bit/sample color.
276
277 Samples as per;
278
279   i_color c;
280
281 i_color is a union of:
282
283 =over
284
285 =item *
286
287 gray - contains a single element gray_color, eg. C<c.gray.gray_color>
288
289 =item *
290
291 C<rgb> - contains three elements C<r>, C<g>, C<b>, eg. C<c.rgb.r>
292
293 =item *
294
295 C<rgba> - contains four elements C<r>, C<g>, C<b>, C<a>, eg. C<c.rgba.a>
296
297 =item *
298
299 C<cmyk> - contains four elements C<c>, C<m>, C<y>, C<k>,
300 eg. C<c.cmyk.y>.  Note that Imager never uses CMYK colors except when
301 reading/writing files.
302
303 =item *
304
305 channels - an array of four channels, eg C<c.channels[2]>.
306
307 =back
308
309
310 =for comment
311 From: File imdatatypes.h
312
313 =item i_fcolor
314
315 This is the double/sample color type.
316
317 Its layout exactly corresponds to i_color.
318
319
320 =for comment
321 From: File imdatatypes.h
322
323 =item i_fill_t
324
325   i_fill_t *fill;
326
327 This is the "abstract" base type for Imager's fill types.
328
329 Unless you're implementing a new fill type you'll typically treat this
330 as an opaque type.
331
332
333 =for comment
334 From: File imdatatypes.h
335
336 =item i_img_dim
337
338   i_img_dim x, y;
339
340 A signed integer type that represents an image dimension or ordinate.
341
342 May be larger than int on some platforms.
343
344
345 =for comment
346 From: File imdatatypes.h
347
348 =item i_DF
349
350   printf("left %" i_DF "\n", i_DFc(x));
351
352 This is a constant string that can be used with functions like
353 printf() to format i_img_dim values after they're been cast with i_DFc().
354
355 Does not include the leading C<%>.
356
357
358 =for comment
359 From: File imdatatypes.h
360
361 =item i_DFc
362
363 Cast an C<i_img_dim> value to a type for use with the i_DF format
364 string.
365
366
367 =for comment
368 From: File imdatatypes.h
369
370 =item i_DFcp
371
372 Casts two C<i_img_dim> values for use with the i_DF (or i_DFp) format.
373
374
375 =for comment
376 From: File imdatatypes.h
377
378 =item i_DFp
379
380   printf("point (" i_DFp ")\n", i_DFcp(x, y));
381
382 Format a pair of C<i_img_dim> values.  This format string I<does>
383 include the leading C<%>.
384
385
386 =for comment
387 From: File imdatatypes.h
388
389
390 =back
391
392 =head2 Drawing
393
394 =over
395
396 =item i_arc(im, x, y, rad, d1, d2, color)
397
398
399   i_arc(im, 50, 50, 20, 45, 135, &color);
400
401 Fills an arc centered at (x,y) with radius I<rad> covering the range
402 of angles in degrees from d1 to d2, with the color.
403
404
405 =for comment
406 From: File draw.c
407
408 =item i_arc_aa(im, x, y, rad, d1, d2, color)
409
410
411   i_arc_aa(im, 50, 50, 35, 90, 135, &color);
412
413 Anti-alias fills an arc centered at (x,y) with radius I<rad> covering
414 the range of angles in degrees from d1 to d2, with the color.
415
416
417 =for comment
418 From: File draw.c
419
420 =item i_arc_aa_cfill(im, x, y, rad, d1, d2, fill)
421
422
423   i_arc_aa_cfill(im, 50, 50, 35, 90, 135, fill);
424
425 Anti-alias fills an arc centered at (x,y) with radius I<rad> covering
426 the range of angles in degrees from d1 to d2, with the fill object.
427
428
429 =for comment
430 From: File draw.c
431
432 =item i_arc_cfill(im, x, y, rad, d1, d2, fill)
433
434
435   i_arc_cfill(im, 50, 50, 35, 90, 135, fill);
436
437 Fills an arc centered at (x,y) with radius I<rad> covering the range
438 of angles in degrees from d1 to d2, with the fill object.
439
440
441 =for comment
442 From: File draw.c
443
444 =item i_box(im, x1, y1, x2, y2, color)
445
446
447   i_box(im, 0, 0, im->xsize-1, im->ysize-1, &color).
448
449 Outlines the box from (x1,y1) to (x2,y2) inclusive with I<color>.
450
451
452 =for comment
453 From: File draw.c
454
455 =item i_box_cfill(im, x1, y1, x2, y2, fill)
456
457
458   i_box_cfill(im, 0, 0, im->xsize-1, im->ysize-1, fill);
459
460 Fills the box from (x1,y1) to (x2,y2) inclusive with fill.
461
462
463 =for comment
464 From: File draw.c
465
466 =item i_box_filled(im, x1, y1, x2, y2, color)
467
468
469   i_box_filled(im, 0, 0, im->xsize-1, im->ysize-1, &color);
470
471 Fills the box from (x1,y1) to (x2,y2) inclusive with color.
472
473
474 =for comment
475 From: File draw.c
476
477 =item i_circle_aa(im, x, y, rad, color)
478
479
480   i_circle_aa(im, 50, 50, 45, &color);
481
482 Anti-alias fills a circle centered at (x,y) for radius I<rad> with
483 color.
484
485
486 =for comment
487 From: File draw.c
488
489 =item i_flood_cfill(C<im>, C<seedx>, C<seedy>, C<fill>)
490
491
492   i_flood_cfill(im, 50, 50, fill);
493
494 Flood fills the 4-connected region starting from the point (C<seedx>,
495 C<seedy>) with C<fill>.
496
497 Returns false if (C<seedx>, C<seedy>) are outside the image.
498
499
500 =for comment
501 From: File draw.c
502
503 =item i_flood_cfill_border(C<im>, C<seedx>, C<seedy>, C<fill>, C<border>)
504
505
506   i_flood_cfill_border(im, 50, 50, fill, border);
507
508 Flood fills the 4-connected region starting from the point (C<seedx>,
509 C<seedy>) with C<fill>, the fill stops when it reaches pixels of color
510 C<border>.
511
512 Returns false if (C<seedx>, C<seedy>) are outside the image.
513
514
515 =for comment
516 From: File draw.c
517
518 =item i_flood_fill(C<im>, C<seedx>, C<seedy>, C<color>)
519
520
521   i_flood_fill(im, 50, 50, &color);
522
523 Flood fills the 4-connected region starting from the point (C<seedx>,
524 C<seedy>) with I<color>.
525
526 Returns false if (C<seedx>, C<seedy>) are outside the image.
527
528
529 =for comment
530 From: File draw.c
531
532 =item i_flood_fill_border(C<im>, C<seedx>, C<seedy>, C<color>, C<border>)
533
534
535   i_flood_fill_border(im, 50, 50, &color, &border);
536
537 Flood fills the 4-connected region starting from the point (C<seedx>,
538 C<seedy>) with C<color>, fill stops when the fill reaches a pixels
539 with color C<border>.
540
541 Returns false if (C<seedx>, C<seedy>) are outside the image.
542
543
544 =for comment
545 From: File draw.c
546
547 =item i_glin(im, l, r, y, colors)
548
549
550 Retrieves (r-l) pixels starting from (l,y) into I<colors>.
551
552 Returns the number of pixels retrieved.
553
554
555 =for comment
556 From: File imext.c
557
558 =item i_glinf(im, l, r, y, colors)
559
560
561 Retrieves (r-l) pixels starting from (l,y) into I<colors> as floating
562 point colors.
563
564 Returns the number of pixels retrieved.
565
566
567 =for comment
568 From: File imext.c
569
570 =item i_gpal(im, left, right, y, indexes)
571
572
573 Reads palette indexes for the horizontal line (left, y) to (right-1,
574 y) into C<indexes>.
575
576 Returns the number of indexes read.
577
578 Always returns 0 for direct color images.
579
580
581 =for comment
582 From: File imext.c
583
584 =item i_gpix(im, C<x>, C<y>, C<color>)
585
586
587 Retrieves the C<color> of the pixel (x,y).
588
589 Returns 0 if the pixel was retrieved, or -1 if not.
590
591
592 =for comment
593 From: File imext.c
594
595 =item i_gpixf(im, C<x>, C<y>, C<fcolor>)
596
597
598 Retrieves the color of the pixel (x,y) as a floating point color into
599 C<fcolor>.
600
601 Returns 0 if the pixel was retrieved, or -1 if not.
602
603
604 =for comment
605 From: File imext.c
606
607 =item i_gsamp(im, left, right, y, samples, channels, channel_count)
608
609
610 Reads sample values from C<im> for the horizontal line (left, y) to
611 (right-1,y) for the channels specified by C<channels>, an array of int
612 with C<channel_count> elements.
613
614 If channels is NULL then the first channels_count channels are retrieved for
615 each pixel.
616
617 Returns the number of samples read (which should be (right-left) *
618 channel_count)
619
620
621 =for comment
622 From: File imext.c
623
624 =item i_gsamp_bg(im, l, r, y, samples, out_channels, background)
625
626
627 Like C<i_gsampf()> but applies the source image color over a supplied
628 background color.
629
630 This is intended for output to image formats that don't support alpha
631 channels.
632
633
634 =for comment
635 From: File paste.im
636
637 =item i_gsamp_bits(im, left, right, y, samples, channels, channel_count, bits)
638
639 Reads integer samples scaled to C<bits> bits of precision into the
640 C<unsigned int> array C<samples>.
641
642 Expect this to be slow unless C<< bits == im->bits >>.
643
644 Returns the number of samples copied, or -1 on error.
645
646 Not all image types implement this method.
647
648 Pushes errors, but does not call C<i_clear_error()>.
649
650
651 =for comment
652 From: File imext.c
653
654 =item i_gsampf(im, left, right, y, samples, channels, channel_count)
655
656
657 Reads floating point sample values from C<im> for the horizontal line
658 (left, y) to (right-1,y) for the channels specified by C<channels>, an
659 array of int with channel_count elements.
660
661 If C<channels> is NULL then the first C<channel_count> channels are
662 retrieved for each pixel.
663
664 Returns the number of samples read (which should be (C<right>-C<left>)
665 * C<channel_count>)
666
667
668 =for comment
669 From: File imext.c
670
671 =item i_gsampf_bg(im, l, r, y, samples, out_channels, background)
672
673
674 Like C<i_gsampf()> but applies the source image color over a supplied
675 background color.
676
677 This is intended for output to image formats that don't support alpha
678 channels.
679
680
681 =for comment
682 From: File paste.im
683
684 =item i_line(C<im>, C<x1>, C<y1>, C<x2>, C<y2>, C<color>, C<endp>)
685
686
687 =for stopwords Bresenham's
688
689 Draw a line to image using Bresenham's line drawing algorithm
690
691    im    - image to draw to
692    x1    - starting x coordinate
693    y1    - starting x coordinate
694    x2    - starting x coordinate
695    y2    - starting x coordinate
696    color - color to write to image
697    endp  - endpoint flag (boolean)
698
699
700 =for comment
701 From: File draw.c
702
703 =item i_line_aa(C<im>, C<x1>, C<x2>, C<y1>, C<y2>, C<color>, C<endp>)
704
705
706 Anti-alias draws a line from (x1,y1) to (x2, y2) in color.
707
708 The point (x2, y2) is drawn only if C<endp> is set.
709
710
711 =for comment
712 From: File draw.c
713
714 =item i_plin(im, l, r, y, colors)
715
716
717 Sets (r-l) pixels starting from (l,y) using (r-l) values from
718 I<colors>.
719
720 Returns the number of pixels set.
721
722
723 =for comment
724 From: File imext.c
725
726 =item i_plinf(im, C<left>, C<right>, C<fcolors>)
727
728
729 Sets (right-left) pixels starting from (left,y) using (right-left)
730 floating point colors from C<fcolors>.
731
732 Returns the number of pixels set.
733
734
735 =for comment
736 From: File imext.c
737
738 =item i_ppal(im, left, right, y, indexes)
739
740
741 Writes palette indexes for the horizontal line (left, y) to (right-1,
742 y) from C<indexes>.
743
744 Returns the number of indexes written.
745
746 Always returns 0 for direct color images.
747
748
749 =for comment
750 From: File imext.c
751
752 =item i_ppix(im, x, y, color)
753
754
755 Sets the pixel at (x,y) to I<color>.
756
757 Returns 0 if the pixel was drawn, or -1 if not.
758
759 Does no alpha blending, just copies the channels from the supplied
760 color to the image.
761
762
763 =for comment
764 From: File imext.c
765
766 =item i_ppixf(im, C<x>, C<y>, C<fcolor>)
767
768
769 Sets the pixel at (C<x>,C<y>) to the floating point color C<fcolor>.
770
771 Returns 0 if the pixel was drawn, or -1 if not.
772
773 Does no alpha blending, just copies the channels from the supplied
774 color to the image.
775
776
777 =for comment
778 From: File imext.c
779
780 =item i_psamp(im, left, right, y, samples, channels, channel_count)
781
782 Writes sample values from C<samples> to C<im> for the horizontal line
783 (left, y) to (right-1, y) inclusive for the channels specified by
784 C<channels>, an array of C<int> with C<channel_count> elements.
785
786 If C<channels> is C<NULL> then the first C<channels_count> channels
787 are written to for each pixel.
788
789 Returns the number of samples written, which should be (right - left)
790 * channel_count.  If a channel not in the image is in channels, left
791 is negative, left is outside the image or y is outside the image,
792 returns -1 and pushes an error.
793
794
795 =for comment
796 From: File immacros.h
797
798 =item i_psamp_bits(im, left, right, y, samples, channels, channel_count, bits)
799
800 Writes integer samples scaled to C<bits> bits of precision from the
801 C<unsigned int> array C<samples>.
802
803 Expect this to be slow unless C<< bits == im->bits >>.
804
805 Returns the number of samples copied, or -1 on error.
806
807 Not all image types implement this method.
808
809 Pushes errors, but does not call C<i_clear_error()>.
810
811
812 =for comment
813 From: File imext.c
814
815 =item i_psampf(im, left, right, y, samples, channels, channel_count)
816
817 Writes floating point sample values from C<samples> to C<im> for the
818 horizontal line (left, y) to (right-1, y) inclusive for the channels
819 specified by C<channels>, an array of C<int> with C<channel_count>
820 elements.
821
822 If C<channels> is C<NULL> then the first C<channels_count> channels
823 are written to for each pixel.
824
825 Returns the number of samples written, which should be (right - left)
826 * channel_count.  If a channel not in the image is in channels, left
827 is negative, left is outside the image or y is outside the image,
828 returns -1 and pushes an error.
829
830
831 =for comment
832 From: File immacros.h
833
834
835 =back
836
837 =head2 Error handling
838
839 =over
840
841 =item i_push_errorf(int code, char const *fmt, ...)
842
843   i_push_errorf(errno, "Cannot open file %s: %d", filename, errno);
844
845 A version of i_push_error() that does printf() like formatting.
846
847 Does not support perl specific format codes.
848
849
850 =for comment
851 From: File error.c
852
853
854 =back
855
856 =head2 Files
857
858 =over
859
860 =item i_get_file_background(im, &bg)
861
862
863 Retrieve the file write background color tag from the image.
864
865 If not present, C<bg> is set to black.
866
867 Returns 1 if the C<i_background> tag was found and valid.
868
869
870 =for comment
871 From: File image.c
872
873 =item i_get_file_backgroundf(im, &bg)
874
875
876 Retrieve the file write background color tag from the image as a
877 floating point color.
878
879 Implemented in terms of i_get_file_background().
880
881 If not present, C<bg> is set to black.
882
883 Returns 1 if the C<i_background> tag was found and valid.
884
885
886 =for comment
887 From: File image.c
888
889
890 =back
891
892 =head2 Fills
893
894 =over
895
896 =item i_new_fill_fount(C<xa>, C<ya>, C<xb>, C<yb>, C<type>, C<repeat>, C<combine>, C<super_sample>, C<ssample_param>, C<count>, C<segs>)
897
898
899   fill = i_new_fill_fount(0, 0, 100, 100, i_ft_linear, i_ft_linear, 
900                           i_fr_triangle, 0, i_fts_grid, 9, 1, segs);
901
902
903 Creates a new general fill which fills with a fountain fill.
904
905
906 =for comment
907 From: File filters.im
908
909 =item i_new_fill_hatch(C<fg>, C<bg>, C<combine>, C<hatch>, C<cust_hatch>, C<dx>, C<dy>)
910
911
912   i_fill_t *fill = i_new_fill_hatch(&fg_color, &bg_color, combine, hatch, custom_hatch, dx, dy);
913
914 Creates a new hatched fill with the C<fg> color used for the 1 bits in
915 the hatch and C<bg> for the 0 bits.  If C<combine> is non-zero alpha
916 values will be combined.
917
918 If C<cust_hatch> is non-NULL it should be a pointer to 8 bytes of the
919 hash definition, with the high-bits to the left.
920
921 If C<cust_hatch> is NULL then one of the standard hatches is used.
922
923 (C<dx>, C<dy>) are an offset into the hatch which can be used to hatch
924 adjoining areas out of alignment, or to align the origin of a hatch
925 with the the side of a filled area.
926
927
928 =for comment
929 From: File fills.c
930
931 =item i_new_fill_hatchf(C<fg>, C<bg>, C<combine>, C<hatch>, C<cust_hatch>, C<dx>, C<dy>)
932
933
934   i_fill_t *fill = i_new_fill_hatchf(&fg_fcolor, &bg_fcolor, combine, hatch, custom_hatch, dx, dy);
935
936 Creates a new hatched fill with the C<fg> color used for the 1 bits in
937 the hatch and C<bg> for the 0 bits.  If C<combine> is non-zero alpha
938 values will be combined.
939
940 If C<cust_hatch> is non-NULL it should be a pointer to 8 bytes of the
941 hash definition, with the high-bits to the left.
942
943 If C<cust_hatch> is NULL then one of the standard hatches is used.
944
945 (C<dx>, C<dy>) are an offset into the hatch which can be used to hatch
946 adjoining areas out of alignment, or to align the origin of a hatch
947 with the the side of a filled area.
948
949
950 =for comment
951 From: File fills.c
952
953 =item i_new_fill_image(C<im>, C<matrix>, C<xoff>, C<yoff>, C<combine>)
954
955
956   i_fill_t *fill = i_new_fill_image(src_img, matrix, x_offset, y_offset, combine);
957
958 Create an image based fill.
959
960 matrix is an array of 9 doubles representing a transformation matrix.
961
962 C<xoff> and C<yoff> are the offset into the image to start filling from.
963
964
965 =for comment
966 From: File fills.c
967
968 =item i_new_fill_solid(color, combine)
969
970
971   i_fill_t *fill = i_new_fill_solid(&color, combine);
972
973 Create a solid fill based on an 8-bit color.
974
975 If combine is non-zero then alpha values will be combined.
976
977
978 =for comment
979 From: File fills.c
980
981 =item i_new_fill_solidf(color, combine)
982
983
984   i_fill_t *fill = i_new_fill_solidf(&fcolor, combine);
985
986 Create a solid fill based on a float color.
987
988 If combine is non-zero then alpha values will be combined.
989
990
991 =for comment
992 From: File fills.c
993
994 =item i_fill_destroy(fill)
995
996   i_fill_destroy(fill);
997
998 Call to destroy any fill object.
999
1000
1001 =for comment
1002 From: File fills.c
1003
1004
1005 =back
1006
1007 =head2 I/O Layers
1008
1009 =over
1010
1011 =item io_new_bufchain()
1012
1013 returns a new io_glue object that has the 'empty' source and but can
1014 be written to and read from later (like a pseudo file).
1015
1016
1017 =for comment
1018 From: File iolayer.c
1019
1020 =item io_new_buffer(data, length)
1021
1022 Returns a new io_glue object that has the source defined as reading
1023 from specified buffer.  Note that the buffer is not copied.
1024
1025    data - buffer to read from
1026    length - length of buffer
1027
1028
1029 =for comment
1030 From: File iolayer.c
1031
1032 =item io_new_cb(p, read_cb, write_cb, seek_cb, close_cb, destroy_cb)
1033
1034 Create a new I/O layer object that calls your supplied callbacks.
1035
1036 In general the callbacks should behave like the corresponding POSIX
1037 primitives.
1038
1039 =over
1040
1041 =item *
1042
1043 C<read_cb>(p, buffer, length) should read up to C<length> bytes into
1044 C<buffer> and return the number of bytes read.  At end of file, return
1045 0.  On error, return -1.
1046
1047 =item *
1048
1049 C<write_cb>(p, buffer, length) should write up to C<length> bytes from
1050 C<buffer> and return the number of bytes written.  A return value <= 0
1051 will be treated as an error.
1052
1053 =item *
1054
1055 C<seekcb>(p, offset, whence) should seek and return the new offset.
1056
1057 =item *
1058
1059 C<close_cb>(p) should return 0 on success, -1 on failure.
1060
1061 =item *
1062
1063 C<destroy_cb>(p) should release any memory specific to your callback
1064 handlers.
1065
1066 =back
1067
1068
1069 =for comment
1070 From: File iolayer.c
1071
1072 =item io_new_fd(fd)
1073
1074 returns a new io_glue object that has the source defined as reading
1075 from specified file descriptor.  Note that the the interface to receiving
1076 data from the io_glue callbacks hasn't been done yet.
1077
1078    fd - file descriptor to read/write from
1079
1080
1081 =for comment
1082 From: File iolayer.c
1083
1084 =item i_io_close(io)
1085
1086 Flush any pending output and perform the close action for the stream.
1087
1088 Returns 0 on success.
1089
1090
1091 =for comment
1092 From: File iolayer.c
1093
1094 =item i_io_flush(io)
1095
1096 Flush any buffered output.
1097
1098 Returns true on success,
1099
1100
1101 =for comment
1102 From: File iolayer.c
1103
1104 =item i_io_getc(ig)
1105
1106 A macro to read a single byte from a buffered I/O glue object.
1107
1108 Returns EOF on failure, or a byte.
1109
1110
1111 =for comment
1112 From: File iolayer.c
1113
1114 =item i_io_gets(ig, buffer, size, end_of_line)
1115
1116   char buffer[BUFSIZ]
1117   ssize_t len = i_io_gets(buffer, sizeof(buffer), '\n');
1118
1119 Read up to C<size>-1 bytes from the stream C<ig> into C<buffer>.
1120
1121 If the byte C<end_of_line> is seen then no further bytes will be read.
1122
1123 Returns the number of bytes read.
1124
1125 Always C<NUL> terminates the buffer.
1126
1127
1128 =for comment
1129 From: File iolayer.c
1130
1131 =item i_io_peekc(ig)
1132
1133 Read the next character from the stream without advancing the stream.
1134
1135 On error or end of file, return EOF.
1136
1137 For unbuffered streams a single character buffer will be setup.
1138
1139
1140 =for comment
1141 From: File iolayer.c
1142
1143 =item i_io_peekn(ig, buffer, size)
1144
1145   ssize_t count = i_io_peekn(ig, buffer, sizeof(buffer));
1146
1147 Buffer at least C<size> (at most C<< ig->buf_size >> bytes of data
1148 from the stream and return C<size> bytes of it to the caller in
1149 C<buffer>.
1150
1151 This ignores the buffered state of the stream, and will always setup
1152 buffering if needed.
1153
1154 If no C<type> parameter is provided to Imager::read() or
1155 Imager::read_multi(), Imager will call C<i_io_peekn()> when probing
1156 for the file format.
1157
1158 Returns -1 on error, 0 if there is no data before EOF, or the number
1159 of bytes read into C<buffer>.
1160
1161
1162 =for comment
1163 From: File iolayer.c
1164
1165 =item i_io_putc(ig, c)
1166
1167 Write a single character to the stream.
1168
1169 On success return c, on error returns EOF
1170
1171
1172 =for comment
1173 From: File iolayer.c
1174
1175 =item i_io_read(io, buffer, size)
1176
1177 Read up to C<size> bytes from the stream C<io> into C<buffer>.
1178
1179 Returns the number of bytes read.  Returns 0 on end of file.  Returns
1180 -1 on error.
1181
1182
1183 =for comment
1184 From: File iolayer.c
1185
1186 =item i_io_seek(io, offset, whence)
1187
1188 Seek within the stream.
1189
1190 Acts like perl's seek.
1191
1192
1193 =for comment
1194 From: File iolayer.c
1195
1196 =item i_io_set_buffered(io, buffered)
1197
1198 Set the buffering mode of the stream.
1199
1200 If you switch buffering off on a stream with buffering on:
1201
1202 =over
1203
1204 =item *
1205
1206 any buffered output will be flushed.
1207
1208 =item *
1209
1210 any existing buffered input will be consumed before reads become
1211 unbuffered.
1212
1213 =back
1214
1215 Returns true on success.  This may fail if any buffered output cannot
1216 be flushed.
1217
1218
1219 =for comment
1220 From: File iolayer.c
1221
1222 =item i_io_write(io, buffer, size)
1223
1224   ssize_t result = i_io_write(io, buffer, size)
1225
1226 Write to the given I/O stream.
1227
1228 Returns the number of bytes written.
1229
1230
1231 =for comment
1232 From: File iolayer.c
1233
1234 =item io_slurp(ig, c)
1235
1236 Takes the source that the io_glue is bound to and allocates space for
1237 a return buffer and returns the entire content in a single buffer.
1238 Note: This only works for io_glue objects created by
1239 io_new_bufchain().  It is useful for saving to scalars and such.
1240
1241    ig - io_glue object
1242    c  - pointer to a pointer to where data should be copied to
1243
1244   char *data;
1245   size_t size = io_slurp(ig, &data);
1246   ... do something with the data ...
1247   myfree(data);
1248
1249 io_slurp() will abort the program if the supplied I/O layer is not
1250 from io_new_bufchain().
1251
1252
1253 =for comment
1254 From: File iolayer.c
1255
1256 =item io_glue_destroy(ig)
1257
1258   io_glue_destroy(ig);
1259
1260 Destroy an io_glue objects.  Should clean up all related buffers.
1261
1262    ig - io_glue object to destroy.
1263
1264
1265 =for comment
1266 From: File iolayer.c
1267
1268
1269 =back
1270
1271 =head2 Image
1272
1273 =over
1274
1275 =item i_copy(source)
1276
1277
1278 Creates a new image that is a copy of the image C<source>.
1279
1280 Tags are not copied, only the image data.
1281
1282 Returns: i_img *
1283
1284
1285 =for comment
1286 From: File image.c
1287
1288 =item i_copyto(C<dest>, C<src>, C<x1>, C<y1>, C<x2>, C<y2>, C<tx>, C<ty>)
1289
1290
1291 Copies image data from the area (C<x1>,C<y1>)-[C<x2>,C<y2>] in the
1292 source image to a rectangle the same size with it's top-left corner at
1293 (C<tx>,C<ty>) in the destination image.
1294
1295 If C<x1> > C<x2> or C<y1> > C<y2> then the corresponding co-ordinates
1296 are swapped.
1297
1298
1299 =for comment
1300 From: File paste.im
1301
1302 =item i_copyto_trans(C<im>, C<src>, C<x1>, C<y1>, C<x2>, C<y2>, C<tx>, C<ty>, C<trans>)
1303
1304
1305 (C<x1>,C<y1>) (C<x2>,C<y2>) specifies the region to copy (in the
1306 source coordinates) (C<tx>,C<ty>) specifies the upper left corner for
1307 the target image.  pass NULL in C<trans> for non transparent i_colors.
1308
1309
1310 =for comment
1311 From: File image.c
1312
1313 =item i_img_info(im, info)
1314
1315
1316 Return image information
1317
1318    im - Image pointer
1319    info - pointer to array to return data
1320
1321 info is an array of 4 integers with the following values:
1322
1323  info[0] - width
1324  info[1] - height
1325  info[2] - channels
1326  info[3] - channel mask
1327
1328
1329 =for comment
1330 From: File image.c
1331
1332 =item i_rubthru(C<im>, C<src>, C<tx>, C<ty>, C<src_minx>, C<src_miny>, C<src_maxx>, C<src_maxy>)
1333
1334
1335 Takes the sub image C<src>[C<src_minx>, C<src_maxx>)[C<src_miny>, C<src_maxy>)> and
1336 overlays it at (C<tx>,C<ty>) on the image object.
1337
1338 The alpha channel of each pixel in C<src> is used to control how much
1339 the existing color in C<im> is replaced, if it is 255 then the color
1340 is completely replaced, if it is 0 then the original color is left
1341 unmodified.
1342
1343
1344 =for comment
1345 From: File rubthru.im
1346
1347
1348 =back
1349
1350 =head2 Image creation/destruction
1351
1352 =over
1353
1354 =item i_sametype(C<im>, C<xsize>, C<ysize>)
1355
1356
1357   i_img *img = i_sametype(src, width, height);
1358
1359 Returns an image of the same type (sample size, channels, paletted/direct).
1360
1361 For paletted images the palette is copied from the source.
1362
1363
1364 =for comment
1365 From: File image.c
1366
1367 =item i_sametype_chans(C<im>, C<xsize>, C<ysize>, C<channels>)
1368
1369
1370   i_img *img = i_sametype_chans(src, width, height, channels);
1371
1372 Returns an image of the same type (sample size).
1373
1374 For paletted images the equivalent direct type is returned.
1375
1376
1377 =for comment
1378 From: File image.c
1379
1380 =item i_img_destroy(C<img>)
1381
1382   i_img_destroy(img)
1383
1384 Destroy an image object
1385
1386
1387 =for comment
1388 From: File image.c
1389
1390
1391 =back
1392
1393 =head2 Image Information
1394
1395 =over
1396
1397 =item i_img_color_channels(C<im>)
1398
1399
1400 The number of channels holding color information.
1401
1402
1403 =for comment
1404 From: File immacros.h
1405
1406 =item i_img_get_height(C<im>)
1407
1408   i_img_dim height = i_img_get_height(im);
1409
1410 Returns the height in pixels of the image.
1411
1412
1413 =for comment
1414 From: File image.c
1415
1416 =item i_img_get_width(C<im>)
1417
1418   i_img_dim width = i_img_get_width(im);
1419
1420 Returns the width in pixels of the image.
1421
1422
1423 =for comment
1424 From: File image.c
1425
1426 =item i_img_getchannels(C<im>)
1427
1428   int channels = i_img_getchannels(img);
1429
1430 Get the number of channels in C<im>.
1431
1432
1433 =for comment
1434 From: File image.c
1435
1436 =item i_img_getmask(C<im>)
1437
1438   int mask = i_img_getmask(img);
1439
1440 Get the image channel mask for C<im>.
1441
1442
1443 =for comment
1444 From: File image.c
1445
1446 =item i_img_has_alpha(C<im>)
1447
1448
1449 Return true if the image has an alpha channel.
1450
1451
1452 =for comment
1453 From: File immacros.h
1454
1455 =item i_img_is_monochrome(img, &zero_is_white)
1456
1457
1458 Tests an image to check it meets our monochrome tests.
1459
1460 The idea is that a file writer can use this to test where it should
1461 write the image in whatever bi-level format it uses, eg. C<pbm> for
1462 C<pnm>.
1463
1464 For performance of encoders we require monochrome images:
1465
1466 =over
1467
1468 =item *
1469
1470 be paletted
1471
1472 =item *
1473
1474 have a palette of two colors, containing only C<(0,0,0)> and
1475 C<(255,255,255)> in either order.
1476
1477 =back
1478
1479 C<zero_is_white> is set to non-zero if the first palette entry is white.
1480
1481
1482 =for comment
1483 From: File image.c
1484
1485 =item i_img_setmask(C<im>, C<ch_mask>)
1486
1487   // only channel 0 writable 
1488   i_img_setmask(img, 0x01);
1489
1490 Set the image channel mask for C<im> to C<ch_mask>.
1491
1492 The image channel mask gives some control over which channels can be
1493 written to in the image.
1494
1495
1496 =for comment
1497 From: File image.c
1498
1499
1500 =back
1501
1502 =head2 Image quantization
1503
1504 =over
1505
1506 =item i_quant_makemap(C<quant>, C<imgs>, C<count>)
1507
1508
1509 Analyzes the C<count> images in C<imgs> according to the rules in
1510 C<quant> to build a color map (optimal or not depending on
1511 C<< quant->make_colors >>).
1512
1513
1514 =for comment
1515 From: File quant.c
1516
1517 =item i_quant_translate(C<quant>, C<img>)
1518
1519
1520 Quantize the image given the palette in C<quant>.
1521
1522 On success returns a pointer to a memory block of C<< img->xsize *
1523 img->ysize >> C<i_palidx> entries.
1524
1525 On failure returns NULL.
1526
1527 You should call myfree() on the returned block when you're done with
1528 it.
1529
1530 This function will fail if the supplied palette contains no colors.
1531
1532
1533 =for comment
1534 From: File quant.c
1535
1536 =item i_quant_transparent(C<quant>, C<data>, C<img>, C<trans_index>)
1537
1538
1539 Dither the alpha channel on C<img> into the palette indexes in
1540 C<data>.  Pixels to be transparent are replaced with C<trans_pixel>.
1541
1542 The method used depends on the tr_* members of C<quant>.
1543
1544
1545 =for comment
1546 From: File quant.c
1547
1548
1549 =back
1550
1551 =head2 Logging
1552
1553 =over
1554
1555 =item i_lhead(file, line)
1556
1557 This is an internal function called by the mm_log() macro.
1558
1559
1560 =for comment
1561 From: File log.c
1562
1563 =item i_loog(level, format, ...)
1564
1565 This is an internal function called by the mm_log() macro.
1566
1567
1568 =for comment
1569 From: File log.c
1570
1571 =item mm_log((level, format, ...))
1572
1573 This is the main entry point to logging. Note that the extra set of
1574 parentheses are required due to limitations in C89 macros.
1575
1576 This will format a string with the current file and line number to the
1577 log file if logging is enabled.
1578
1579
1580 =for comment
1581 From: File log.h
1582
1583
1584 =back
1585
1586 =head2 Paletted images
1587
1588 =over
1589
1590 =item i_addcolors(im, colors, count)
1591
1592
1593 Adds colors to the image's palette.
1594
1595 On success returns the index of the lowest color added.
1596
1597 On failure returns -1.
1598
1599 Always fails for direct color images.
1600
1601
1602 =for comment
1603 From: File imext.c
1604
1605 =item i_colorcount(im)
1606
1607
1608 Returns the number of colors in the image's palette.
1609
1610 Returns -1 for direct images.
1611
1612
1613 =for comment
1614 From: File imext.c
1615
1616 =item i_findcolor(im, color, &entry)
1617
1618
1619 Searches the images palette for the given color.
1620
1621 On success sets *I<entry> to the index of the color, and returns true.
1622
1623 On failure returns false.
1624
1625 Always fails on direct color images.
1626
1627
1628 =for comment
1629 From: File imext.c
1630
1631 =item i_getcolors(im, index, colors, count)
1632
1633
1634 Retrieves I<count> colors starting from I<index> in the image's
1635 palette.
1636
1637 On success stores the colors into I<colors> and returns true.
1638
1639 On failure returns false.
1640
1641 Always fails for direct color images.
1642
1643 Fails if there are less than I<index>+I<count> colors in the image's
1644 palette.
1645
1646
1647 =for comment
1648 From: File imext.c
1649
1650 =item i_maxcolors(im)
1651
1652
1653 Returns the maximum number of colors the palette can hold for the
1654 image.
1655
1656 Returns -1 for direct color images.
1657
1658
1659 =for comment
1660 From: File imext.c
1661
1662 =item i_setcolors(im, index, colors, count)
1663
1664
1665 Sets I<count> colors starting from I<index> in the image's palette.
1666
1667 On success returns true.
1668
1669 On failure returns false.
1670
1671 The image must have at least I<index>+I<count> colors in it's palette
1672 for this to succeed.
1673
1674 Always fails on direct color images.
1675
1676
1677 =for comment
1678 From: File imext.c
1679
1680
1681 =back
1682
1683 =head2 Tags
1684
1685 =over
1686
1687 =item i_tags_delbycode(tags, code)
1688
1689
1690 Delete any tags with the given code.
1691
1692 Returns the number of tags deleted.
1693
1694
1695 =for comment
1696 From: File tags.c
1697
1698 =item i_tags_delbyname(tags, name)
1699
1700
1701 Delete any tags with the given name.
1702
1703 Returns the number of tags deleted.
1704
1705
1706 =for comment
1707 From: File tags.c
1708
1709 =item i_tags_delete(tags, index)
1710
1711
1712 Delete a tag by index.
1713
1714 Returns true on success.
1715
1716
1717 =for comment
1718 From: File tags.c
1719
1720 =item i_tags_destroy(tags)
1721
1722
1723 Destroys the given tags structure.  Called by i_img_destroy().
1724
1725
1726 =for comment
1727 From: File tags.c
1728
1729 =item i_tags_find(tags, name, start, &entry)
1730
1731
1732 Searches for a tag of the given I<name> starting from index I<start>.
1733
1734 On success returns true and sets *I<entry>.
1735
1736 On failure returns false.
1737
1738
1739 =for comment
1740 From: File tags.c
1741
1742 =item i_tags_findn(tags, code, start, &entry)
1743
1744
1745 Searches for a tag of the given I<code> starting from index I<start>.
1746
1747 On success returns true and sets *I<entry>.
1748
1749 On failure returns false.
1750
1751
1752 =for comment
1753 From: File tags.c
1754
1755 =item i_tags_get_color(tags, name, code, &value)
1756
1757
1758 Retrieve a tag specified by name or code as color.
1759
1760 On success sets the i_color *I<value> to the color and returns true.
1761
1762 On failure returns false.
1763
1764
1765 =for comment
1766 From: File tags.c
1767
1768 =item i_tags_get_float(tags, name, code, value)
1769
1770
1771 Retrieves a tag as a floating point value.  
1772
1773 If the tag has a string value then that is parsed as a floating point
1774 number, otherwise the integer value of the tag is used.
1775
1776 On success sets *I<value> and returns true.
1777
1778 On failure returns false.
1779
1780
1781 =for comment
1782 From: File tags.c
1783
1784 =item i_tags_get_int(tags, name, code, &value)
1785
1786
1787 Retrieve a tag specified by name or code as an integer.
1788
1789 On success sets the int *I<value> to the integer and returns true.
1790
1791 On failure returns false.
1792
1793
1794 =for comment
1795 From: File tags.c
1796
1797 =item i_tags_get_string(tags, name, code, value, value_size)
1798
1799
1800 Retrieves a tag by name or code as a string.
1801
1802 On success copies the string to value for a max of value_size and
1803 returns true.
1804
1805 On failure returns false.
1806
1807 value_size must be at least large enough for a string representation
1808 of an integer.
1809
1810 The copied value is always C<NUL> terminated.
1811
1812
1813 =for comment
1814 From: File tags.c
1815
1816 =item i_tags_new(i_img_tags *tags)
1817
1818
1819 Initialize a tags structure.  Should not be used if the tags structure
1820 has been previously used.
1821
1822 This should be called tags member of an i_img object on creation (in
1823 i_img_*_new() functions).
1824
1825 To destroy the contents use i_tags_destroy()
1826
1827
1828 =for comment
1829 From: File tags.c
1830
1831 =item i_tags_set(tags, name, data, size)
1832
1833   i_tags_set(&img->tags, "i_comment", -1);
1834
1835 Sets the given tag to the string I<data>
1836
1837 If size is -1 then the strlen(I<data>) bytes are stored.
1838
1839 Even on failure, if an existing tag I<name> exists, it will be
1840 removed.
1841
1842
1843 =for comment
1844 From: File tags.c
1845
1846 =item i_tags_set_color(tags, name, code, &value)
1847
1848
1849 Stores the given color as a tag with the given name and code.
1850
1851
1852 =for comment
1853 From: File tags.c
1854
1855 =item i_tags_set_float(tags, name, code, value)
1856
1857
1858 Equivalent to i_tags_set_float2(tags, name, code, value, 30).
1859
1860
1861 =for comment
1862 From: File tags.c
1863
1864 =item i_tags_set_float2(tags, name, code, value, places)
1865
1866
1867 Sets the tag with the given name and code to the given floating point
1868 value.
1869
1870 Since tags are strings or ints, we convert the value to a string before
1871 storage at the precision specified by C<places>.
1872
1873
1874 =for comment
1875 From: File tags.c
1876
1877 =item i_tags_setn(C<tags>, C<name>, C<idata>)
1878
1879   i_tags_setn(&img->tags, "i_xres", 204);
1880   i_tags_setn(&img->tags, "i_yres", 196);
1881
1882 Sets the given tag to the integer C<idata>
1883
1884 Even on failure, if an existing tag C<name> exists, it will be
1885 removed.
1886
1887
1888 =for comment
1889 From: File tags.c
1890
1891
1892 =back
1893
1894 =head2 Uncategorized functions
1895
1896 =over
1897
1898 =item i_utf8_advance(char **p, size_t *len)
1899
1900 Retrieve a C<UTF-8> character from the stream.
1901
1902 Modifies *p and *len to indicate the consumed characters.
1903
1904 This doesn't support the extended C<UTF-8> encoding used by later
1905 versions of Perl.  Since this is typically used to implement text
1906 output by font drivers, the strings supplied shouldn't have such out
1907 of range characters.
1908
1909 This doesn't check that the C<UTF-8> character is using the shortest
1910 possible representation.
1911
1912 Returns ~0UL on failure.
1913
1914
1915 =for comment
1916 From: File io.c
1917
1918
1919
1920 =back
1921
1922
1923 =head1 AUTHOR
1924
1925 Tony Cook <tonyc@cpan.org>
1926
1927 =head1 SEE ALSO
1928
1929 Imager, Imager::ExtUtils, Imager::Inline
1930
1931 =cut