use non-deprecated encoding ids for freetype 2
[imager.git] / imdatatypes.h
1 #ifndef _DATATYPES_H_
2 #define _DATATYPES_H_
3
4 #include <stddef.h>
5 #include "imconfig.h"
6
7 #define MAXCHANNELS 4
8
9 /*
10 =item im_context_t
11 =category Data Types
12
13 Imager's per-thread context.
14
15 =cut
16 */
17
18 typedef struct im_context_tag *im_context_t;
19
20 /*
21 =item im_slot_t
22 =category Data Types
23
24 Represents a slot in the context object.
25
26 =cut
27 */
28
29 typedef ptrdiff_t im_slot_t;
30 typedef void (*im_slot_destroy_t)(void *);
31
32 /* just so we can use our own input typemap */
33 typedef double im_double;
34 typedef float im_float;
35
36 /* used for palette indices in some internal code (which might be 
37    exposed at some point
38 */
39 typedef unsigned char i_palidx;
40
41 /* We handle 2 types of sample, this is hopefully the most common, and the
42    smaller of the ones we support */
43 typedef unsigned char i_sample_t;
44
45 typedef struct { i_sample_t gray_color; } gray_color;
46 typedef struct { i_sample_t r,g,b; } rgb_color;
47 typedef struct { i_sample_t r,g,b,a; } rgba_color;
48 typedef struct { i_sample_t c,m,y,k; } cmyk_color;
49
50 typedef int undef_int; /* special value to put in typemaps to retun undef on 0 and 1 on 1 */
51
52 /*
53 =item i_img_dim
54 =category Data Types
55 =synopsis i_img_dim x, y;
56 =order 90
57
58 A signed integer type that represents an image dimension or ordinate.
59
60 May be larger than int on some platforms.
61
62 =cut
63 */
64
65 typedef ptrdiff_t i_img_dim;
66
67 /*
68 =item i_img_dim_u
69 =category Data Types
70 =synopsis i_img_dim_u limit;
71 =order 90
72
73 An unsigned variant of L</i_img_dim>.
74
75 =cut
76 */
77
78 typedef size_t i_img_dim_u;
79
80 #define i_img_dim_MAX ((i_img_dim)(~(i_img_dim_u)0 >> 1))
81
82 /*
83 =item i_color
84 =category Data Types
85 =synopsis i_color black;
86 =synopsis black.rgba.r = black.rgba.g = black.rgba.b = black.rgba.a = 0;
87
88 Type for 8-bit/sample color.
89
90 Samples as per;
91
92   i_color c;
93
94 i_color is a union of:
95
96 =over
97
98 =item *
99
100 gray - contains a single element gray_color, eg. C<c.gray.gray_color>
101
102 =item *
103
104 C<rgb> - contains three elements C<r>, C<g>, C<b>, eg. C<c.rgb.r>
105
106 =item *
107
108 C<rgba> - contains four elements C<r>, C<g>, C<b>, C<a>, eg. C<c.rgba.a>
109
110 =item *
111
112 C<cmyk> - contains four elements C<c>, C<m>, C<y>, C<k>,
113 eg. C<c.cmyk.y>.  Note that Imager never uses CMYK colors except when
114 reading/writing files.
115
116 =item *
117
118 channels - an array of four channels, eg C<c.channels[2]>.
119
120 =back
121
122 =cut
123 */
124
125 typedef union {
126   gray_color gray;
127   rgb_color rgb;
128   rgba_color rgba;
129   cmyk_color cmyk;
130   i_sample_t channel[MAXCHANNELS];
131   unsigned int ui;
132 } i_color;
133
134 /* this is the larger sample type, it should be able to accurately represent
135    any sample size we use */
136 typedef double i_fsample_t;
137
138 typedef struct { i_fsample_t gray_color; } i_fgray_color_t;
139 typedef struct { i_fsample_t r, g, b; } i_frgb_color_t;
140 typedef struct { i_fsample_t r, g, b, a; } i_frgba_color_t;
141 typedef struct { i_fsample_t c, m, y, k; } i_fcmyk_color_t;
142
143 /*
144 =item i_fcolor
145 =category Data Types
146
147 This is the double/sample color type.
148
149 Its layout exactly corresponds to i_color.
150
151 =cut
152 */
153
154 typedef union {
155   i_fgray_color_t gray;
156   i_frgb_color_t rgb;
157   i_frgba_color_t rgba;
158   i_fcmyk_color_t cmyk;
159   i_fsample_t channel[MAXCHANNELS];
160 } i_fcolor;
161
162 typedef enum {
163   i_direct_type, /* direct colour, keeps RGB values per pixel */
164   i_palette_type /* keeps a palette index per pixel */
165 } i_img_type_t;
166
167 typedef enum { 
168   /* bits per sample, not per pixel */
169   /* a paletted image might have one bit per sample */
170   i_8_bits = 8,
171   i_16_bits = 16,
172   i_double_bits = sizeof(double) * 8
173 } i_img_bits_t;
174
175 typedef struct {
176   char *name; /* name of a given tag, might be NULL */
177   int code; /* number of a given tag, -1 if it has no meaning */
178   char *data; /* value of a given tag if it's not an int, may be NULL */
179   int size; /* size of the data */
180   int idata; /* value of a given tag if data is NULL */
181 } i_img_tag;
182
183 typedef struct {
184   int count; /* how many tags have been set */
185   int alloc; /* how many tags have been allocated for */
186   i_img_tag *tags;
187 } i_img_tags;
188
189 typedef struct i_img_ i_img;
190 typedef int (*i_f_ppix_t)(i_img *im, i_img_dim x, i_img_dim y, const i_color *pix);
191 typedef int (*i_f_ppixf_t)(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *pix);
192 typedef i_img_dim (*i_f_plin_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, const i_color *vals);
193 typedef i_img_dim (*i_f_plinf_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, const i_fcolor *vals);
194 typedef int (*i_f_gpix_t)(i_img *im, i_img_dim x, i_img_dim y, i_color *pix);
195 typedef int (*i_f_gpixf_t)(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix);
196 typedef i_img_dim (*i_f_glin_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_color *vals);
197 typedef i_img_dim (*i_f_glinf_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_fcolor *vals);
198
199 typedef i_img_dim (*i_f_gsamp_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_sample_t *samp,
200                            const int *chans, int chan_count);
201 typedef i_img_dim (*i_f_gsampf_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_fsample_t *samp,
202                             const int *chan, int chan_count);
203
204 typedef i_img_dim (*i_f_gpal_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_palidx *vals);
205 typedef i_img_dim (*i_f_ppal_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, const i_palidx *vals);
206 typedef int (*i_f_addcolors_t)(i_img *im, const i_color *colors, int count);
207 typedef int (*i_f_getcolors_t)(i_img *im, int i, i_color *, int count);
208 typedef int (*i_f_colorcount_t)(i_img *im);
209 typedef int (*i_f_maxcolors_t)(i_img *im);
210 typedef int (*i_f_findcolor_t)(i_img *im, const i_color *color, i_palidx *entry);
211 typedef int (*i_f_setcolors_t)(i_img *im, int index, const i_color *colors, 
212                               int count);
213
214 typedef void (*i_f_destroy_t)(i_img *im);
215
216 typedef i_img_dim (*i_f_gsamp_bits_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, unsigned *samp,
217                            const int *chans, int chan_count, int bits);
218 typedef i_img_dim (*i_f_psamp_bits_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, unsigned const *samp,
219                                  const int *chans, int chan_count, int bits);
220 typedef i_img_dim
221 (*i_f_psamp_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, 
222                 const i_sample_t *samp, const int *chan, int chan_count);
223 typedef i_img_dim
224 (*i_f_psampf_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y,
225                 const i_fsample_t *samp, const int *chan, int chan_count);
226
227 /*
228 =item i_img
229 =category Data Types
230 =synopsis i_img *img;
231 =order 10
232
233 This is Imager's image type.
234
235 It contains the following members:
236
237 =over
238
239 =item *
240
241 C<channels> - the number of channels in the image
242
243 =item *
244
245 C<xsize>, C<ysize> - the width and height of the image in pixels
246
247 =item *
248
249 C<bytes> - the number of bytes used to store the image data.  Undefined
250 where virtual is non-zero.
251
252 =item *
253
254 C<ch_mask> - a mask of writable channels.  eg. if this is 6 then only
255 channels 1 and 2 are writable.  There may be bits set for which there
256 are no channels in the image.
257
258 =item *
259
260 C<bits> - the number of bits stored per sample.  Should be one of
261 i_8_bits, i_16_bits, i_double_bits.
262
263 =item *
264
265 C<type> - either i_direct_type for direct color images, or i_palette_type
266 for paletted images.
267
268 =item *
269
270 C<virtual> - if zero then this image is-self contained.  If non-zero
271 then this image could be an interface to some other implementation.
272
273 =item *
274
275 C<idata> - the image data.  This should not be directly accessed.  A new
276 image implementation can use this to store its image data.
277 i_img_destroy() will myfree() this pointer if it's non-null.
278
279 =item *
280
281 C<tags> - a structure storing the image's tags.  This should only be
282 accessed via the i_tags_*() functions.
283
284 =item *
285
286 C<ext_data> - a pointer for use internal to an image implementation.
287 This should be freed by the image's destroy handler.
288
289 =item *
290
291 C<im_data> - data internal to Imager.  This is initialized by
292 i_img_init().
293
294 =item *
295
296 i_f_ppix, i_f_ppixf, i_f_plin, i_f_plinf, i_f_gpix, i_f_gpixf,
297 i_f_glin, i_f_glinf, i_f_gsamp, i_f_gampf - implementations for each
298 of the required image functions.  An image implementation should
299 initialize these between calling i_img_alloc() and i_img_init().
300
301 =item *
302
303 i_f_gpal, i_f_ppal, i_f_addcolors, i_f_getcolors, i_f_colorcount,
304 i_f_maxcolors, i_f_findcolor, i_f_setcolors - implementations for each
305 paletted image function.
306
307 =item *
308
309 i_f_destroy - custom image destruction function.  This should be used
310 to release memory if necessary.
311
312 =item *
313
314 i_f_gsamp_bits - implements i_gsamp_bits() for this image.
315
316 =item *
317
318 i_f_psamp_bits - implements i_psamp_bits() for this image.
319
320 =item *
321
322 i_f_psamp - implements psamp() for this image.
323
324 =item *
325
326 i_f_psampf - implements psamp() for this image.
327
328 =item *
329
330 C<im_data> - image specific data internal to Imager.
331
332 =item *
333
334 C<context> - the Imager API context this image belongs to.
335
336 =back
337
338 =cut
339 */
340
341 struct i_img_ {
342   int channels;
343   i_img_dim xsize,ysize;
344   size_t bytes;
345   unsigned int ch_mask;
346   i_img_bits_t bits;
347   i_img_type_t type;
348   int virtual; /* image might not keep any data, must use functions */
349   unsigned char *idata; /* renamed to force inspection of existing code */
350                         /* can be NULL if virtual is non-zero */
351   i_img_tags tags;
352
353   void *ext_data;
354
355   /* interface functions */
356   i_f_ppix_t i_f_ppix;
357   i_f_ppixf_t i_f_ppixf;
358   i_f_plin_t i_f_plin;
359   i_f_plinf_t i_f_plinf;
360   i_f_gpix_t i_f_gpix;
361   i_f_gpixf_t i_f_gpixf;
362   i_f_glin_t i_f_glin;
363   i_f_glinf_t i_f_glinf;
364   i_f_gsamp_t i_f_gsamp;
365   i_f_gsampf_t i_f_gsampf;
366   
367   /* only valid for type == i_palette_type */
368   i_f_gpal_t i_f_gpal;
369   i_f_ppal_t i_f_ppal;
370   i_f_addcolors_t i_f_addcolors;
371   i_f_getcolors_t i_f_getcolors;
372   i_f_colorcount_t i_f_colorcount;
373   i_f_maxcolors_t i_f_maxcolors;
374   i_f_findcolor_t i_f_findcolor;
375   i_f_setcolors_t i_f_setcolors;
376
377   i_f_destroy_t i_f_destroy;
378
379   /* as of 0.61 */
380   i_f_gsamp_bits_t i_f_gsamp_bits;
381   i_f_psamp_bits_t i_f_psamp_bits;
382
383   /* as of 0.88 */
384   i_f_psamp_t i_f_psamp;
385   i_f_psampf_t i_f_psampf;
386
387   void *im_data;
388
389   /* 0.91 */
390   im_context_t context;
391 };
392
393 /* ext_data for paletted images
394  */
395 typedef struct {
396   int count; /* amount of space used in palette (in entries) */
397   int alloc; /* amount of space allocated for palette (in entries) */
398   i_color *pal;
399   int last_found;
400 } i_img_pal_ext;
401
402 /* Helper datatypes
403   The types in here so far are:
404
405   doubly linked bucket list - pretty efficient
406   octtree - no idea about goodness
407   
408   needed: hashes.
409
410 */
411
412 /* bitmap mask */
413
414 struct i_bitmap {
415   i_img_dim xsize,ysize;
416   char *data;
417 };
418
419 struct i_bitmap* btm_new(i_img_dim xsize,i_img_dim ysize);
420 void btm_destroy(struct i_bitmap *btm);
421 int btm_test(struct i_bitmap *btm,i_img_dim x,i_img_dim y);
422 void btm_set(struct i_bitmap *btm,i_img_dim x,i_img_dim y);
423
424
425 /* Stack/Linked list */
426
427 struct llink {
428   struct llink *p,*n;
429   void *data;
430   int fill;             /* Number used in this link */
431 };
432
433 struct llist {
434   struct llink *h,*t;
435   int multip;           /* # of copies in a single chain  */
436   size_t ssize;         /* size of each small element     */
437   int count;           /* number of elements on the list */
438 };
439
440
441 /* Lists */
442
443 struct llist *llist_new( int multip, size_t ssize );
444 void llist_destroy( struct llist *l );
445 void llist_push( struct llist *l, const void *data );
446 void llist_dump( struct llist *l );
447 int llist_pop( struct llist *l,void *data );
448
449
450
451
452 /* Octtree */
453
454 struct octt {
455   struct octt *t[8]; 
456   int cnt;
457 };
458
459 struct octt *octt_new(void);
460 int octt_add(struct octt *ct,unsigned char r,unsigned char g,unsigned char b);
461 void octt_dump(struct octt *ct);
462 void octt_count(struct octt *ct,int *tot,int max,int *overflow);
463 void octt_delete(struct octt *ct);
464 void octt_histo(struct octt *ct, unsigned int **col_usage_it_adr);
465
466 /* font bounding box results */
467 enum bounding_box_index_t {
468   BBOX_NEG_WIDTH,
469   BBOX_GLOBAL_DESCENT,
470   BBOX_POS_WIDTH,
471   BBOX_GLOBAL_ASCENT,
472   BBOX_DESCENT,
473   BBOX_ASCENT,
474   BBOX_ADVANCE_WIDTH,
475   BBOX_RIGHT_BEARING,
476   BOUNDING_BOX_COUNT
477 };
478
479 /*
480 =item i_polygon_t
481 =category Data Types
482
483 Represents a polygon.  Has the following members:
484
485 =over
486
487 =item *
488
489 C<x>, C<y> - arrays of x and y locations of vertices.
490
491 =item *
492
493 C<count> - the number of entries in the C<x> and C<y> arrays.
494
495 =back
496
497 =cut
498 */
499
500 typedef struct i_polygon_tag {
501   const double *x;
502   const double *y;
503   size_t count;
504 } i_polygon_t;
505
506 /*
507 =item i_poly_fill_mode_t
508 =category Data Types
509
510 Control how polygons are filled.  Has the following values:
511
512 =over
513
514 =item *
515
516 C<i_pfm_evenodd> - simple even-odd fills.
517
518 =item *
519
520 C<i_pfm_nonzero> - non-zero winding rule fills.
521
522 =back
523
524 =cut
525 */
526
527 typedef enum i_poly_fill_mode_tag {
528   i_pfm_evenodd,
529   i_pfm_nonzero
530 } i_poly_fill_mode_t;
531
532 /* Generic fills */
533 struct i_fill_tag;
534
535 typedef void (*i_fill_with_color_f)
536 (struct i_fill_tag *fill, i_img_dim x, i_img_dim y, i_img_dim width, int channels, 
537       i_color *data);
538 typedef void (*i_fill_with_fcolor_f)
539      (struct i_fill_tag *fill, i_img_dim x, i_img_dim y, i_img_dim width, int channels,
540       i_fcolor *data);
541 typedef void (*i_fill_destroy_f)(struct i_fill_tag *fill);
542
543 /* combine functions modify their target and are permitted to modify
544    the source to prevent having to perform extra copying/memory
545    allocations, etc
546    The out array has I<channels> channels.
547
548    The in array has I<channels> channels + an alpha channel if one
549    isn't included in I<channels>.
550 */
551
552 typedef void (*i_fill_combine_f)(i_color *out, i_color *in, int channels, 
553                                  i_img_dim count);
554 typedef void (*i_fill_combinef_f)(i_fcolor *out, i_fcolor *in, int channels,
555                                   i_img_dim count);
556
557 /* fountain fill types */
558 typedef enum {
559   i_fst_linear,
560   i_fst_curved,
561   i_fst_sine,
562   i_fst_sphere_up,
563   i_fst_sphere_down,
564   i_fst_end
565 } i_fountain_seg_type;
566 typedef enum {
567   i_fc_direct,
568   i_fc_hue_up,
569   i_fc_hue_down,
570   i_fc_end
571 } i_fountain_color;
572 typedef struct {
573   double start, middle, end;
574   i_fcolor c[2];
575   i_fountain_seg_type type;
576   i_fountain_color color;
577 } i_fountain_seg;
578 typedef enum {
579   i_fr_none,
580   i_fr_sawtooth,
581   i_fr_triangle,
582   i_fr_saw_both,
583   i_fr_tri_both
584 } i_fountain_repeat;
585 typedef enum {
586   i_ft_linear,
587   i_ft_bilinear,
588   i_ft_radial,
589   i_ft_radial_square,
590   i_ft_revolution,
591   i_ft_conical,
592   i_ft_end
593 } i_fountain_type;
594 typedef enum {
595   i_fts_none,
596   i_fts_grid,
597   i_fts_random,
598   i_fts_circle
599 } i_ft_supersample;
600
601 /*
602 =item i_fill_t
603 =category Data Types
604 =synopsis i_fill_t *fill;
605
606 This is the "abstract" base type for Imager's fill types.
607
608 Unless you're implementing a new fill type you'll typically treat this
609 as an opaque type.
610
611 =cut
612 */
613
614 typedef struct i_fill_tag
615 {
616   /* called for 8-bit/sample image (and maybe lower) */
617   /* this may be NULL, if so call fill_with_fcolor */
618   i_fill_with_color_f f_fill_with_color;
619
620   /* called for other sample sizes */
621   /* this must be non-NULL */
622   i_fill_with_fcolor_f f_fill_with_fcolor;
623
624   /* called if non-NULL to release any extra resources */
625   i_fill_destroy_f destroy;
626
627   /* if non-zero the caller will fill data with the original data
628      from the image */
629   i_fill_combine_f combine;
630   i_fill_combinef_f combinef;
631 } i_fill_t;
632
633 typedef enum {
634   ic_none,
635   ic_normal,
636   ic_multiply,
637   ic_dissolve,
638   ic_add,
639   ic_subtract,
640   ic_diff,
641   ic_lighten,
642   ic_darken,
643   ic_hue,
644   ic_sat,
645   ic_value,
646   ic_color
647 } i_combine_t;
648
649 /*
650 =item i_mutex_t
651 X<i_mutex>
652 =category mutex
653 =synopsis i_mutex_t mutex;
654
655 Opaque type for Imager's mutex API.
656
657 =cut
658  */
659 typedef struct i_mutex_tag *i_mutex_t;
660
661 /*
662    describes an axis of a MM font.
663    Modelled on FT2's FT_MM_Axis.
664    It would be nice to have a default entry too, but FT2 
665    doesn't support it.
666 */
667 typedef struct i_font_mm_axis_tag {
668   char const *name;
669   int minimum;
670   int maximum;
671 } i_font_mm_axis;
672
673 #define IM_FONT_MM_MAX_AXES 4
674
675 /* 
676    multiple master information for a font, if any 
677    modelled on FT2's FT_Multi_Master.
678 */
679 typedef struct i_font_mm_tag {
680   int num_axis;
681   int num_designs; /* provided but not necessarily useful */
682   i_font_mm_axis axis[IM_FONT_MM_MAX_AXES];
683 } i_font_mm;
684
685 #ifdef HAVE_LIBTT
686
687 struct TT_Fonthandle_;
688
689 typedef struct TT_Fonthandle_ TT_Fonthandle;
690
691 #endif
692
693 /*
694 =item i_transp
695 =category Data Types
696
697 An enumerated type for controlling how transparency is handled during
698 quantization.
699
700 This has the following possible values:
701
702 =over
703
704 =item *
705
706 C<tr_none> - ignore the alpha channel
707
708 =item *
709
710 C<tr_threshold> - simple transparency thresholding.
711
712 =item *
713
714 C<tr_errdiff> - use error diffusion to control which pixels are
715 transparent.
716
717 =item *
718
719 C<tr_ordered> - use ordered dithering to control which pixels are
720 transparent.
721
722 =back
723
724 =cut
725 */
726
727 /* transparency handling for quantized output */
728 typedef enum i_transp_tag {
729   tr_none, /* ignore any alpha channel */
730   tr_threshold, /* threshold the transparency - uses tr_threshold */
731   tr_errdiff, /* error diffusion */
732   tr_ordered /* an ordered dither */
733 } i_transp;
734
735 /*
736 =item i_make_colors
737 =category Data Types
738
739 An enumerated type used to control the method used for produce the
740 color map:
741
742 =over
743
744 =item *
745
746 C<mc_none> - the user supplied map is used.
747
748 =item *
749
750 C<mc_web_map> - use the classic web map.  Any existing fixed colors
751 are ignored.
752
753 =item *
754
755 C<mc_median_cut> - use median cut
756
757 =item *
758
759 C<mono> - use a fixed black and white map.
760
761 =item *
762
763 C<gray> - 256 step gray map.
764
765 =item *
766
767 C<gray4> - 4 step gray map.
768
769 =item *
770
771 C<gray16> - 16 step gray map.
772
773 =back
774
775 =cut
776 */
777
778 typedef enum i_make_colors_tag {
779   mc_none, /* user supplied colour map only */
780   mc_web_map, /* Use the 216 colour web colour map */
781   mc_addi, /* Addi's algorithm */
782   mc_median_cut, /* median cut - similar to giflib, hopefully */
783   mc_mono, /* fixed mono color map */
784   mc_gray, /* 256 gray map */
785   mc_gray4, /* four step gray map */
786   mc_gray16, /* sixteen step gray map */
787   mc_mask = 0xFF /* (mask for generator) */
788 } i_make_colors;
789
790 /*
791 =item i_translate
792 =category Data Types
793
794 An enumerated type that controls how colors are translated:
795
796 =over
797
798 =item *
799
800 C<pt_giflib> - obsolete, forces C<make_colors> to use median cut and
801 acts like C<pt_closest>.
802
803 =item *
804
805 C<pt_closest> - always use the closest color.
806
807 =item *
808
809 C<pt_perturb> - add random values to each sample and find the closest
810 color.
811
812 =item *
813
814 C<pt_errdiff> - error diffusion dither.
815
816 =back
817
818 =cut
819 */
820
821 /* controls how we translate the colours */
822 typedef enum i_translate_tag {
823   pt_giflib, /* get gif lib to do it (ignores make_colours) */
824   pt_closest, /* just use the closest match within the hashbox */
825   pt_perturb, /* randomly perturb the data - uses perturb_size*/
826   pt_errdiff /* error diffusion dither - uses errdiff */
827 } i_translate;
828
829 /*
830 =item i_errdiff
831 =category Data Types
832
833 Controls the type of error diffusion to use:
834
835 =over
836
837 =item *
838
839 C<ed_floyd> - floyd-steinberg
840
841 =item *
842
843 C<ed_jarvis> - Jarvis, Judice and Ninke 
844
845 =item *
846
847 C<ed_stucki> - Stucki
848
849 =item *
850
851 C<ed_custom> - not usable for transparency dithering, allows a custom
852 error diffusion map to be used.
853
854 =item *
855
856 C<ed_bidir> - or with the error diffusion type to use alternate
857 directions on each line of the dither.
858
859 =back
860
861 =cut
862 */
863
864 /* Which error diffusion map to use */
865 typedef enum i_errdiff_tag {
866   ed_floyd, /* floyd-steinberg */
867   ed_jarvis, /* Jarvis, Judice and Ninke */
868   ed_stucki, /* Stucki */
869   ed_custom, /* the map found in ed_map|width|height|orig */
870   ed_mask = 0xFF, /* mask to get the map */
871   ed_bidir = 0x100 /* change direction for each row */
872 } i_errdiff;
873
874 /*
875 =item i_ord_dith
876 =category Data Types
877
878 Which ordered dither map to use, currently only available for
879 transparency.  Values are:
880
881 =over
882
883 =item *
884
885 C<od_random> - a pre-generated random map.
886
887 =item *
888
889 C<od_dot8> - large dot dither.
890
891 =item *
892
893 C<od_dot4> - smaller dot dither
894
895 =item *
896
897 C<od_hline> - horizontal line dither.
898
899 =item *
900
901 C<od_vline> - vertical line dither.
902
903 =item *
904
905 C<od_slashline> - C</> line dither.
906
907 =item *
908
909 C<od_backline> - C<\> line dither.
910
911 =item *
912
913 C<od_tiny> - small checkbox dither
914
915 =item *
916
917 C<od_custom> - custom dither map.
918
919 =back
920
921 =cut
922
923    I don't know of a way to do ordered dither of an image against some 
924    general palette
925  */
926 typedef enum i_ord_dith_tag
927 {
928   od_random, /* sort of random */
929   od_dot8, /* large dot */
930   od_dot4,
931   od_hline,
932   od_vline,
933   od_slashline, /* / line dither */
934   od_backline, /* \ line dither */
935   od_tiny, /* small checkerbox */
936   od_custom /* custom 8x8 map */
937 } i_ord_dith;
938
939 /*
940 =item i_quantize
941 =category Data Types
942
943 A structure type used to supply image quantization, ie. when
944 converting a direct color image to a paletted image.
945
946 This has the following members:
947
948 =over
949
950 =item *
951
952 C<transp> - how to handle transparency, see L</i_transp>.
953
954 =item *
955
956 C<threshold> - when C<transp> is C<tr_threshold>, this is the alpha
957 level at which pixels become transparent.
958
959 =item *
960
961 C<tr_errdiff> - when C<transp> is C<tr_errdiff> this controls the type
962 of error diffusion to be done.  This may not be C<ed_custom> for this
963 member.
964
965 =item *
966
967 C<tr_orddith> - when C<transp> is C<tr_ordered> this controls the
968 patten used for dithering transparency.
969
970 =item *
971
972 C<tr_custom> - when C<tr_orddith> is C<tr_custom> this is the ordered
973 dither mask.
974
975 =item *
976
977 C<make_colors> - the method used to generate the color palette, see
978 L</i_make_colors>.
979
980 =item *
981
982 C<mc_colors> - an array of C<mc_size> L</i_color> entries used to
983 define the fixed colors (controlled by C<mc_count> and to return the
984 generated color list.
985
986 =item *
987
988 C<mc_size> - the size of the buffer allocated to C<mc_colors> in
989 C<sizeof(i_color)> units.
990
991 =item *
992
993 C<mc_count> - the number of initialized colors in C<mc_colors>.
994
995 =item *
996
997 C<translate> - how RGB colors are translated to palette indexes, see
998 L</i_translate>.
999
1000 =item *
1001
1002 C<errdiff> - when C<translate> is C<pt_errdiff> this controls the type
1003 of error diffusion to be done.
1004
1005 =item *
1006
1007 C<ed_map>, C<ed_width>, C<ed_height>, C<ed_orig> - when C<errdiff> is
1008 C<ed_custom> this controls the error diffusion map.  C<ed_map> is an
1009 array of C<ed_width * ed_height> integers.  C<ed_orig> is the position
1010 of the current pixel in the error diffusion map, always on the top
1011 row.
1012
1013 =item *
1014
1015 C<perturb> - the amount to perturb pixels when C<translate> is
1016 C<mc_perturb>.
1017
1018 =back
1019
1020 =cut
1021 */
1022 typedef struct i_quantize_tag {
1023   int version;
1024
1025   /* how to handle transparency */
1026   i_transp transp;
1027   /* the threshold at which to make pixels opaque */
1028   int tr_threshold;
1029   i_errdiff tr_errdiff;
1030   i_ord_dith tr_orddith;
1031   unsigned char tr_custom[64];
1032   
1033   /* how to make the colour map */
1034   i_make_colors make_colors;
1035
1036   /* any existing colours 
1037      mc_existing is an existing colour table
1038      mc_count is the number of existing colours
1039      mc_size is the total size of the array that mc_existing points
1040      at - this must be at least 256
1041   */
1042   i_color *mc_colors;
1043   int mc_size;
1044   int mc_count;
1045
1046   /* how we translate the colours */
1047   i_translate translate;
1048
1049   /* the error diffusion map to use if translate is mc_errdiff */
1050   i_errdiff errdiff;
1051   /* the following define the error diffusion values to use if 
1052      errdiff is ed_custom.  ed_orig is the column on the top row that
1053      represents the current 
1054   */
1055   int *ed_map;
1056   int ed_width, ed_height, ed_orig;
1057
1058   /* the amount of perturbation to use for translate is mc_perturb */
1059   int perturb;
1060   /* version 2 members after here */
1061 } i_quantize;
1062
1063 /* distance measures used by some filters */
1064 enum {
1065   i_dmeasure_euclidean = 0,
1066   i_dmeasure_euclidean_squared = 1,
1067   i_dmeasure_manhatten = 2,
1068   i_dmeasure_limit = 2,
1069 };
1070
1071 #include "iolayert.h"
1072
1073 /* error message information returned by im_errors() */
1074
1075 typedef struct {
1076   char *msg;
1077   int code;
1078 } i_errmsg;
1079
1080 typedef struct i_render_tag i_render;
1081
1082 /*
1083 =item i_color_model_t
1084 =category Data Types
1085 =order 95
1086
1087 Returned by L</i_img_color_model(im)> to indicate the color model of
1088 the image.
1089
1090 An enumerated type with the following possible values:
1091
1092 =over
1093
1094 =item *
1095
1096 C<icm_unknown> - the image has no usable color data.  In future
1097 versions of Imager this will be returned in a few limited cases,
1098 eg. when the source image is CMYK and the user has requested no color
1099 translation is done.
1100
1101 =item *
1102
1103 C<icm_gray> - gray scale with no alpha channel.
1104
1105 =item *
1106
1107 C<icm_gray_alpha> - gray scale with an alpha channel.
1108
1109 =item *
1110
1111 C<icm_rgb> - RGB
1112
1113 =item *
1114
1115 C<icm_rgb_alpha> - RGB with an alpha channel.
1116
1117 =back
1118
1119 =cut
1120 */
1121
1122 typedef enum {
1123   icm_unknown,
1124   icm_gray,
1125   icm_gray_alpha,
1126   icm_rgb,
1127   icm_rgb_alpha
1128 } i_color_model_t;
1129
1130 #ifdef IMAGER_FORMAT_ATTR
1131 #define I_FORMAT_ATTR(format_index, va_index) \
1132   __attribute ((format (printf, format_index, va_index)))
1133 #else
1134 #define I_FORMAT_ATTR(format_index, va_index)
1135 #endif
1136
1137 #ifdef _MSC_VER
1138 #  ifndef vsnprintf
1139 #  define vsnprintf _vsnprintf
1140 #  endif
1141 #  ifndef snprintf
1142 #  define snprintf _snprintf
1143 #  endif
1144 #endif
1145
1146 /*
1147 =item i_DF
1148 =category Data Types
1149 =synopsis printf("left %" i_DF "\n", i_DFc(x));
1150 =order 95
1151
1152 This is a constant string that can be used with functions like
1153 printf() to format i_img_dim values after they're been cast with i_DFc().
1154
1155 Does not include the leading C<%>.
1156
1157 =cut
1158
1159 =item i_DFc
1160 =category Data Types
1161 =order 95
1162
1163 Cast an C<i_img_dim> value to a type for use with the i_DF format
1164 string.
1165
1166 =cut
1167
1168 =item i_DFp
1169 =category Data Types
1170 =synopsis printf("point (" i_DFp ")\n", i_DFcp(x, y));
1171 =order 95
1172
1173 Format a pair of C<i_img_dim> values.  This format string I<does>
1174 include the leading C<%>.
1175
1176 =cut
1177
1178 =item i_DFcp
1179 =category Data Types
1180 =order 95
1181
1182 Casts two C<i_img_dim> values for use with the i_DF (or i_DFp) format.
1183
1184 =cut
1185  */
1186
1187 #define i_DFc(x) ((i_dim_format_t)(x))
1188 #define i_DFcp(x, y) i_DFc(x), i_DFc(y)
1189 #define i_DFp "%" i_DF ", %" i_DF
1190
1191 #endif
1192