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 typedef struct im_context_tag *im_context_t;
  10
  11 typedef ptrdiff_t im_slot_t;
  12 typedef void (*im_slot_destroy_t)(void *);
  13
  14 /* used for palette indices in some internal code (which might be
  15    exposed at some point
  16 */
  17 typedef unsigned char i_palidx;
  18
  19 /* We handle 2 types of sample, this is hopefully the most common, and the
  20    smaller of the ones we support */
  21 typedef unsigned char i_sample_t;
  22
  23 typedef struct { i_sample_t gray_color; } gray_color;
  24 typedef struct { i_sample_t r,g,b; } rgb_color;
  25 typedef struct { i_sample_t r,g,b,a; } rgba_color;
  26 typedef struct { i_sample_t c,m,y,k; } cmyk_color;
  27
  28 typedef int undef_int; /* special value to put in typemaps to retun undef on 0 and 1 on 1 */
  29
  30 /*
  31 =item i_img_dim
  32 =category Data Types
  33 =synopsis i_img_dim x, y;
  34 =order 90
  35
  36 A signed integer type that represents an image dimension or ordinate.
  37
  38 May be larger than int on some platforms.
  39
  40 =cut
  41 */
  42
  43 typedef ptrdiff_t i_img_dim;
  44 typedef size_t i_img_dim_u;
  45
  46 #define i_img_dim_MAX ((i_img_dim)(~(i_img_dim_u)0 >> 1))
  47
  48 /*
  49 =item i_color
  50 =category Data Types
  51 =synopsis i_color black;
  52 =synopsis black.rgba.r = black.rgba.g = black.rgba.b = black.rgba.a = 0;
  53
  54 Type for 8-bit/sample color.
  55
  56 Samples as per;
  57
  58   i_color c;
  59
  60 i_color is a union of:
  61
  62 =over
  63
  64 =item *
  65
  66 gray - contains a single element gray_color, eg. C<c.gray.gray_color>
  67
  68 =item *
  69
  70 C<rgb> - contains three elements C<r>, C<g>, C<b>, eg. C<c.rgb.r>
  71
  72 =item *
  73
  74 C<rgba> - contains four elements C<r>, C<g>, C<b>, C<a>, eg. C<c.rgba.a>
  75
  76 =item *
  77
  78 C<cmyk> - contains four elements C<c>, C<m>, C<y>, C<k>,
  79 eg. C<c.cmyk.y>.  Note that Imager never uses CMYK colors except when
  80 reading/writing files.
  81
  82 =item *
  83
  84 channels - an array of four channels, eg C<c.channels[2]>.
  85
  86 =back
  87
  88 =cut
  89 */
  90
  91 typedef union {
  92   gray_color gray;
  93   rgb_color rgb;
  94   rgba_color rgba;
  95   cmyk_color cmyk;
  96   i_sample_t channel[MAXCHANNELS];
  97   unsigned int ui;
  98 } i_color;
  99
 100 /* this is the larger sample type, it should be able to accurately represent
 101    any sample size we use */
 102 typedef double i_fsample_t;
 103
 104 typedef struct { i_fsample_t gray_color; } i_fgray_color_t;
 105 typedef struct { i_fsample_t r, g, b; } i_frgb_color_t;
 106 typedef struct { i_fsample_t r, g, b, a; } i_frgba_color_t;
 107 typedef struct { i_fsample_t c, m, y, k; } i_fcmyk_color_t;
 108
 109 /*
 110 =item i_fcolor
 111 =category Data Types
 112
 113 This is the double/sample color type.
 114
 115 Its layout exactly corresponds to i_color.
 116
 117 =cut
 118 */
 119
 120 typedef union {
 121   i_fgray_color_t gray;
 122   i_frgb_color_t rgb;
 123   i_frgba_color_t rgba;
 124   i_fcmyk_color_t cmyk;
 125   i_fsample_t channel[MAXCHANNELS];
 126 } i_fcolor;
 127
 128 typedef enum {
 129   i_direct_type, /* direct colour, keeps RGB values per pixel */
 130   i_palette_type /* keeps a palette index per pixel */
 131 } i_img_type_t;
 132
 133 typedef enum {
 134   /* bits per sample, not per pixel */
 135   /* a paletted image might have one bit per sample */
 136   i_8_bits = 8,
 137   i_16_bits = 16,
 138   i_double_bits = sizeof(double) * 8
 139 } i_img_bits_t;
 140
 141 typedef struct {
 142   char *name; /* name of a given tag, might be NULL */
 143   int code; /* number of a given tag, -1 if it has no meaning */
 144   char *data; /* value of a given tag if it's not an int, may be NULL */
 145   int size; /* size of the data */
 146   int idata; /* value of a given tag if data is NULL */
 147 } i_img_tag;
 148
 149 typedef struct {
 150   int count; /* how many tags have been set */
 151   int alloc; /* how many tags have been allocated for */
 152   i_img_tag *tags;
 153 } i_img_tags;
 154
 155 typedef struct i_img_ i_img;
 156 typedef int (*i_f_ppix_t)(i_img *im, i_img_dim x, i_img_dim y, const i_color *pix);
 157 typedef int (*i_f_ppixf_t)(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *pix);
 158 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);
 159 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);
 160 typedef int (*i_f_gpix_t)(i_img *im, i_img_dim x, i_img_dim y, i_color *pix);
 161 typedef int (*i_f_gpixf_t)(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix);
 162 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);
 163 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);
 164
 165 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,
 166                            const int *chans, int chan_count);
 167 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,
 168                             const int *chan, int chan_count);
 169
 170 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);
 171 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);
 172 typedef int (*i_f_addcolors_t)(i_img *im, const i_color *colors, int count);
 173 typedef int (*i_f_getcolors_t)(i_img *im, int i, i_color *, int count);
 174 typedef int (*i_f_colorcount_t)(i_img *im);
 175 typedef int (*i_f_maxcolors_t)(i_img *im);
 176 typedef int (*i_f_findcolor_t)(i_img *im, const i_color *color, i_palidx *entry);
 177 typedef int (*i_f_setcolors_t)(i_img *im, int index, const i_color *colors,
 178                               int count);
 179
 180 typedef void (*i_f_destroy_t)(i_img *im);
 181
 182 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,
 183                            const int *chans, int chan_count, int bits);
 184 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,
 185                                  const int *chans, int chan_count, int bits);
 186 typedef i_img_dim
 187 (*i_f_psamp_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y,
 188                 const i_sample_t *samp, const int *chan, int chan_count);
 189 typedef i_img_dim
 190 (*i_f_psampf_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y,
 191                 const i_fsample_t *samp, const int *chan, int chan_count);
 192
 193 /*
 194 =item i_img
 195 =category Data Types
 196 =synopsis i_img *img;
 197 =order 10
 198
 199 This is Imager's image type.
 200
 201 It contains the following members:
 202
 203 =over
 204
 205 =item *
 206
 207 C<channels> - the number of channels in the image
 208
 209 =item *
 210
 211 C<xsize>, C<ysize> - the width and height of the image in pixels
 212
 213 =item *
 214
 215 C<bytes> - the number of bytes used to store the image data.  Undefined
 216 where virtual is non-zero.
 217
 218 =item *
 219
 220 C<ch_mask> - a mask of writable channels.  eg. if this is 6 then only
 221 channels 1 and 2 are writable.  There may be bits set for which there
 222 are no channels in the image.
 223
 224 =item *
 225
 226 C<bits> - the number of bits stored per sample.  Should be one of
 227 i_8_bits, i_16_bits, i_double_bits.
 228
 229 =item *
 230
 231 C<type> - either i_direct_type for direct color images, or i_palette_type
 232 for paletted images.
 233
 234 =item *
 235
 236 C<virtual> - if zero then this image is-self contained.  If non-zero
 237 then this image could be an interface to some other implementation.
 238
 239 =item *
 240
 241 C<idata> - the image data.  This should not be directly accessed.  A new
 242 image implementation can use this to store its image data.
 243 i_img_destroy() will myfree() this pointer if it's non-null.
 244
 245 =item *
 246
 247 C<tags> - a structure storing the image's tags.  This should only be
 248 accessed via the i_tags_*() functions.
 249
 250 =item *
 251
 252 C<ext_data> - a pointer for use internal to an image implementation.
 253 This should be freed by the image's destroy handler.
 254
 255 =item *
 256
 257 C<im_data> - data internal to Imager.  This is initialized by
 258 i_img_init().
 259
 260 =item *
 261
 262 i_f_ppix, i_f_ppixf, i_f_plin, i_f_plinf, i_f_gpix, i_f_gpixf,
 263 i_f_glin, i_f_glinf, i_f_gsamp, i_f_gampf - implementations for each
 264 of the required image functions.  An image implementation should
 265 initialize these between calling i_img_alloc() and i_img_init().
 266
 267 =item *
 268
 269 i_f_gpal, i_f_ppal, i_f_addcolors, i_f_getcolors, i_f_colorcount,
 270 i_f_maxcolors, i_f_findcolor, i_f_setcolors - implementations for each
 271 paletted image function.
 272
 273 =item *
 274
 275 i_f_destroy - custom image destruction function.  This should be used
 276 to release memory if necessary.
 277
 278 =item *
 279
 280 i_f_gsamp_bits - implements i_gsamp_bits() for this image.
 281
 282 =item *
 283
 284 i_f_psamp_bits - implements i_psamp_bits() for this image.
 285
 286 =item *
 287
 288 i_f_psamp - implements psamp() for this image.
 289
 290 =item *
 291
 292 i_f_psampf - implements psamp() for this image.
 293
 294 =item *
 295
 296 C<im_data> - image specific data internal to Imager.
 297
 298 =item *
 299
 300 C<context> - the Imager API context this image belongs to.
 301
 302 =back
 303
 304 =cut
 305 */
 306
 307 struct i_img_ {
 308   int channels;
 309   i_img_dim xsize,ysize;
 310   size_t bytes;
 311   unsigned int ch_mask;
 312   i_img_bits_t bits;
 313   i_img_type_t type;
 314   int virtual; /* image might not keep any data, must use functions */
 315   unsigned char *idata; /* renamed to force inspection of existing code */
 316                         /* can be NULL if virtual is non-zero */
 317   i_img_tags tags;
 318
 319   void *ext_data;
 320
 321   /* interface functions */
 322   i_f_ppix_t i_f_ppix;
 323   i_f_ppixf_t i_f_ppixf;
 324   i_f_plin_t i_f_plin;
 325   i_f_plinf_t i_f_plinf;
 326   i_f_gpix_t i_f_gpix;
 327   i_f_gpixf_t i_f_gpixf;
 328   i_f_glin_t i_f_glin;
 329   i_f_glinf_t i_f_glinf;
 330   i_f_gsamp_t i_f_gsamp;
 331   i_f_gsampf_t i_f_gsampf;
 332
 333   /* only valid for type == i_palette_type */
 334   i_f_gpal_t i_f_gpal;
 335   i_f_ppal_t i_f_ppal;
 336   i_f_addcolors_t i_f_addcolors;
 337   i_f_getcolors_t i_f_getcolors;
 338   i_f_colorcount_t i_f_colorcount;
 339   i_f_maxcolors_t i_f_maxcolors;
 340   i_f_findcolor_t i_f_findcolor;
 341   i_f_setcolors_t i_f_setcolors;
 342
 343   i_f_destroy_t i_f_destroy;
 344
 345   /* as of 0.61 */
 346   i_f_gsamp_bits_t i_f_gsamp_bits;
 347   i_f_psamp_bits_t i_f_psamp_bits;
 348
 349   /* as of 0.88 */
 350   i_f_psamp_t i_f_psamp;
 351   i_f_psampf_t i_f_psampf;
 352
 353   void *im_data;
 354
 355   /* 0.91 */
 356   im_context_t context;
 357 };
 358
 359 /* ext_data for paletted images
 360  */
 361 typedef struct {
 362   int count; /* amount of space used in palette (in entries) */
 363   int alloc; /* amount of space allocated for palette (in entries) */
 364   i_color *pal;
 365   int last_found;
 366 } i_img_pal_ext;
 367
 368 /* Helper datatypes
 369   The types in here so far are:
 370
 371   doubly linked bucket list - pretty efficient
 372   octtree - no idea about goodness
 373
 374   needed: hashes.
 375
 376 */
 377
 378 /* bitmap mask */
 379
 380 struct i_bitmap {
 381   i_img_dim xsize,ysize;
 382   char *data;
 383 };
 384
 385 struct i_bitmap* btm_new(i_img_dim xsize,i_img_dim ysize);
 386 void btm_destroy(struct i_bitmap *btm);
 387 int btm_test(struct i_bitmap *btm,i_img_dim x,i_img_dim y);
 388 void btm_set(struct i_bitmap *btm,i_img_dim x,i_img_dim y);
 389
 390
 391 /* Stack/Linked list */
 392
 393 struct llink {
 394   struct llink *p,*n;
 395   void *data;
 396   int fill;             /* Number used in this link */
 397 };
 398
 399 struct llist {
 400   struct llink *h,*t;
 401   int multip;           /* # of copies in a single chain  */
 402   size_t ssize;         /* size of each small element     */
 403   int count;           /* number of elements on the list */
 404 };
 405
 406
 407 /* Lists */
 408
 409 struct llist *llist_new( int multip, size_t ssize );
 410 void llist_destroy( struct llist *l );
 411 void llist_push( struct llist *l, const void *data );
 412 void llist_dump( struct llist *l );
 413 int llist_pop( struct llist *l,void *data );
 414
 415
 416
 417
 418 /* Octtree */
 419
 420 struct octt {
 421   struct octt *t[8];
 422   int cnt;
 423 };
 424
 425 struct octt *octt_new(void);
 426 int octt_add(struct octt *ct,unsigned char r,unsigned char g,unsigned char b);
 427 void octt_dump(struct octt *ct);
 428 void octt_count(struct octt *ct,int *tot,int max,int *overflow);
 429 void octt_delete(struct octt *ct);
 430 void octt_histo(struct octt *ct, unsigned int **col_usage_it_adr);
 431
 432 /* font bounding box results */
 433 enum bounding_box_index_t {
 434   BBOX_NEG_WIDTH,
 435   BBOX_GLOBAL_DESCENT,
 436   BBOX_POS_WIDTH,
 437   BBOX_GLOBAL_ASCENT,
 438   BBOX_DESCENT,
 439   BBOX_ASCENT,
 440   BBOX_ADVANCE_WIDTH,
 441   BBOX_RIGHT_BEARING,
 442   BOUNDING_BOX_COUNT
 443 };
 444
 445 /* Generic fills */
 446 struct i_fill_tag;
 447
 448 typedef void (*i_fill_with_color_f)
 449 (struct i_fill_tag *fill, i_img_dim x, i_img_dim y, i_img_dim width, int channels,
 450       i_color *data);
 451 typedef void (*i_fill_with_fcolor_f)
 452      (struct i_fill_tag *fill, i_img_dim x, i_img_dim y, i_img_dim width, int channels,
 453       i_fcolor *data);
 454 typedef void (*i_fill_destroy_f)(struct i_fill_tag *fill);
 455
 456 /* combine functions modify their target and are permitted to modify
 457    the source to prevent having to perform extra copying/memory
 458    allocations, etc
 459    The out array has I<channels> channels.
 460
 461    The in array has I<channels> channels + an alpha channel if one
 462    isn't included in I<channels>.
 463 */
 464
 465 typedef void (*i_fill_combine_f)(i_color *out, i_color *in, int channels,
 466                                  i_img_dim count);
 467 typedef void (*i_fill_combinef_f)(i_fcolor *out, i_fcolor *in, int channels,
 468                                   i_img_dim count);
 469
 470 /* fountain fill types */
 471 typedef enum {
 472   i_fst_linear,
 473   i_fst_curved,
 474   i_fst_sine,
 475   i_fst_sphere_up,
 476   i_fst_sphere_down,
 477   i_fst_end
 478 } i_fountain_seg_type;
 479 typedef enum {
 480   i_fc_direct,
 481   i_fc_hue_up,
 482   i_fc_hue_down,
 483   i_fc_end
 484 } i_fountain_color;
 485 typedef struct {
 486   double start, middle, end;
 487   i_fcolor c[2];
 488   i_fountain_seg_type type;
 489   i_fountain_color color;
 490 } i_fountain_seg;
 491 typedef enum {
 492   i_fr_none,
 493   i_fr_sawtooth,
 494   i_fr_triangle,
 495   i_fr_saw_both,
 496   i_fr_tri_both
 497 } i_fountain_repeat;
 498 typedef enum {
 499   i_ft_linear,
 500   i_ft_bilinear,
 501   i_ft_radial,
 502   i_ft_radial_square,
 503   i_ft_revolution,
 504   i_ft_conical,
 505   i_ft_end
 506 } i_fountain_type;
 507 typedef enum {
 508   i_fts_none,
 509   i_fts_grid,
 510   i_fts_random,
 511   i_fts_circle
 512 } i_ft_supersample;
 513
 514 /*
 515 =item i_fill_t
 516 =category Data Types
 517 =synopsis i_fill_t *fill;
 518
 519 This is the "abstract" base type for Imager's fill types.
 520
 521 Unless you're implementing a new fill type you'll typically treat this
 522 as an opaque type.
 523
 524 =cut
 525 */
 526
 527 typedef struct i_fill_tag
 528 {
 529   /* called for 8-bit/sample image (and maybe lower) */
 530   /* this may be NULL, if so call fill_with_fcolor */
 531   i_fill_with_color_f f_fill_with_color;
 532
 533   /* called for other sample sizes */
 534   /* this must be non-NULL */
 535   i_fill_with_fcolor_f f_fill_with_fcolor;
 536
 537   /* called if non-NULL to release any extra resources */
 538   i_fill_destroy_f destroy;
 539
 540   /* if non-zero the caller will fill data with the original data
 541      from the image */
 542   i_fill_combine_f combine;
 543   i_fill_combinef_f combinef;
 544 } i_fill_t;
 545
 546 typedef enum {
 547   ic_none,
 548   ic_normal,
 549   ic_multiply,
 550   ic_dissolve,
 551   ic_add,
 552   ic_subtract,
 553   ic_diff,
 554   ic_lighten,
 555   ic_darken,
 556   ic_hue,
 557   ic_sat,
 558   ic_value,
 559   ic_color
 560 } i_combine_t;
 561
 562 /*
 563 =item i_mutex_t
 564 X<i_mutex>
 565 =category mutex
 566 =synopsis i_mutex_t mutex;
 567
 568 Opaque type for Imager's mutex API.
 569
 570 =cut
 571  */
 572 typedef struct i_mutex_tag *i_mutex_t;
 573
 574 /*
 575    describes an axis of a MM font.
 576    Modelled on FT2's FT_MM_Axis.
 577    It would be nice to have a default entry too, but FT2
 578    doesn't support it.
 579 */
 580 typedef struct i_font_mm_axis_tag {
 581   char const *name;
 582   int minimum;
 583   int maximum;
 584 } i_font_mm_axis;
 585
 586 #define IM_FONT_MM_MAX_AXES 4
 587
 588 /*
 589    multiple master information for a font, if any
 590    modelled on FT2's FT_Multi_Master.
 591 */
 592 typedef struct i_font_mm_tag {
 593   int num_axis;
 594   int num_designs; /* provided but not necessarily useful */
 595   i_font_mm_axis axis[IM_FONT_MM_MAX_AXES];
 596 } i_font_mm;
 597
 598 #ifdef HAVE_LIBTT
 599
 600 struct TT_Fonthandle_;
 601
 602 typedef struct TT_Fonthandle_ TT_Fonthandle;
 603
 604 #endif
 605
 606 /* transparency handling for quantized output */
 607 typedef enum i_transp_tag {
 608   tr_none, /* ignore any alpha channel */
 609   tr_threshold, /* threshold the transparency - uses tr_threshold */
 610   tr_errdiff, /* error diffusion */
 611   tr_ordered /* an ordered dither */
 612 } i_transp;
 613
 614 /* controls how we build the colour map */
 615 typedef enum i_make_colors_tag {
 616   mc_none, /* user supplied colour map only */
 617   mc_web_map, /* Use the 216 colour web colour map */
 618   mc_addi, /* Addi's algorithm */
 619   mc_median_cut, /* median cut - similar to giflib, hopefully */
 620   mc_mono, /* fixed mono color map */
 621   mc_gray, /* 256 gray map */
 622   mc_gray4, /* four step gray map */
 623   mc_gray16, /* sixteen step gray map */
 624   mc_mask = 0xFF /* (mask for generator) */
 625 } i_make_colors;
 626
 627 /* controls how we translate the colours */
 628 typedef enum i_translate_tag {
 629   pt_giflib, /* get gif lib to do it (ignores make_colours) */
 630   pt_closest, /* just use the closest match within the hashbox */
 631   pt_perturb, /* randomly perturb the data - uses perturb_size*/
 632   pt_errdiff /* error diffusion dither - uses errdiff */
 633 } i_translate;
 634
 635 /* Which error diffusion map to use */
 636 typedef enum i_errdiff_tag {
 637   ed_floyd, /* floyd-steinberg */
 638   ed_jarvis, /* Jarvis, Judice and Ninke */
 639   ed_stucki, /* Stucki */
 640   ed_custom, /* the map found in ed_map|width|height|orig */
 641   ed_mask = 0xFF, /* mask to get the map */
 642   ed_bidir = 0x100 /* change direction for each row */
 643 } i_errdiff;
 644
 645 /* which ordered dither map to use
 646    currently only available for transparency
 647    I don't know of a way to do ordered dither of an image against some
 648    general palette
 649  */
 650 typedef enum i_ord_dith_tag
 651 {
 652   od_random, /* sort of random */
 653   od_dot8, /* large dot */
 654   od_dot4,
 655   od_hline,
 656   od_vline,
 657   od_slashline, /* / line dither */
 658   od_backline, /* \ line dither */
 659   od_tiny, /* small checkerbox */
 660   od_custom /* custom 8x8 map */
 661 } i_ord_dith;
 662
 663 /* passed into i_writegif_gen() to control quantization */
 664 typedef struct i_quantize_tag {
 665   int version;
 666
 667   /* how to handle transparency */
 668   i_transp transp;
 669   /* the threshold at which to make pixels opaque */
 670   int tr_threshold;
 671   i_errdiff tr_errdiff;
 672   i_ord_dith tr_orddith;
 673   unsigned char tr_custom[64];
 674
 675   /* how to make the colour map */
 676   i_make_colors make_colors;
 677
 678   /* any existing colours
 679      mc_existing is an existing colour table
 680      mc_count is the number of existing colours
 681      mc_size is the total size of the array that mc_existing points
 682      at - this must be at least 256
 683   */
 684   i_color *mc_colors;
 685   int mc_size;
 686   int mc_count;
 687
 688   /* how we translate the colours */
 689   i_translate translate;
 690
 691   /* the error diffusion map to use if translate is mc_errdiff */
 692   i_errdiff errdiff;
 693   /* the following define the error diffusion values to use if
 694      errdiff is ed_custom.  ed_orig is the column on the top row that
 695      represents the current
 696   */
 697   int *ed_map;
 698   int ed_width, ed_height, ed_orig;
 699
 700   /* the amount of perturbation to use for translate is mc_perturb */
 701   int perturb;
 702   /* version 2 members after here */
 703 } i_quantize;
 704
 705 /* distance measures used by some filters */
 706 enum {
 707   i_dmeasure_euclidean = 0,
 708   i_dmeasure_euclidean_squared = 1,
 709   i_dmeasure_manhatten = 2,
 710   i_dmeasure_limit = 2,
 711 };
 712
 713 #include "iolayert.h"
 714
 715 /* error message information returned by im_errors() */
 716
 717 typedef struct {
 718   char *msg;
 719   int code;
 720 } i_errmsg;
 721
 722 typedef struct i_render_tag i_render;
 723
 724 #ifdef IMAGER_FORMAT_ATTR
 725 #define I_FORMAT_ATTR(format_index, va_index) \
 726   __attribute ((format (printf, format_index, va_index)))
 727 #else
 728 #define I_FORMAT_ATTR(format_index, va_index)
 729 #endif
 730
 731 #ifdef _MSC_VER
 732 #  ifndef vsnprintf
 733 #  define vsnprintf _vsnprintf
 734 #  endif
 735 #  ifndef snprintf
 736 #  define snprintf _snprintf
 737 #  endif
 738 #endif
 739
 740 /*
 741 =item i_DF
 742 =category Data Types
 743 =synopsis printf("left %" i_DF "\n", i_DFc(x));
 744 =order 95
 745
 746 This is a constant string that can be used with functions like
 747 printf() to format i_img_dim values after they're been cast with i_DFc().
 748
 749 Does not include the leading C<%>.
 750
 751 =cut
 752
 753 =item i_DFc
 754 =category Data Types
 755 =order 95
 756
 757 Cast an C<i_img_dim> value to a type for use with the i_DF format
 758 string.
 759
 760 =cut
 761
 762 =item i_DFp
 763 =category Data Types
 764 =synopsis printf("point (" i_DFp ")\n", i_DFcp(x, y));
 765 =order 95
 766
 767 Format a pair of C<i_img_dim> values.  This format string I<does>
 768 include the leading C<%>.
 769
 770 =cut
 771
 772 =item i_DFcp
 773 =category Data Types
 774 =order 95
 775
 776 Casts two C<i_img_dim> values for use with the i_DF (or i_DFp) format.
 777
 778 =cut
 779  */
 780
 781 #define i_DFc(x) ((i_dim_format_t)(x))
 782 #define i_DFcp(x, y) i_DFc(x), i_DFc(y)
 783 #define i_DFp "%" i_DF ", %" i_DF
 784
 785 #endif
 786