gd.h

#ifndef GD_H
#define GD_H 1
 
#include <stdlib.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Version information.  This gets parsed by build scripts as well as
 * gcc so each #define line in this group must also be splittable on
 * whitespace, take the form GD_*_VERSION and contain the magical
 * trailing comment. */
#define GD_MAJOR_VERSION 2      /*version605b5d1778*/
#define GD_MINOR_VERSION 4      /*version605b5d1778*/
#define GD_RELEASE_VERSION 0    /*version605b5d1778*/
#define GD_EXTRA_VERSION "-dev" /*version605b5d1778*/
 
/* End parsable section. */
 
/* The version string.  This is constructed from the version number
 * parts above via macro abuse^Wtrickery. */
#define GDXXX_VERSION_STR(mjr, mnr, rev, ext) mjr "." mnr "." rev ext
#define GDXXX_STR(s) GDXXX_SSTR(s) /* Two levels needed to expand args. */
#define GDXXX_SSTR(s) #s
 
#define GD_VERSION_STRING                                                                          \
    GDXXX_VERSION_STR(GDXXX_STR(GD_MAJOR_VERSION), GDXXX_STR(GD_MINOR_VERSION),                    \
                      GDXXX_STR(GD_RELEASE_VERSION), GD_EXTRA_VERSION)
 
/* Do the DLL dance: dllexport when building the DLL,
   dllimport when importing from it, nothing when
   not on Silly Silly Windows (tm Aardman Productions). */
 
/* 2.0.20: for headers */
 
/* 2.0.24: __stdcall also needed for Visual BASIC
   and other languages. This breaks ABI compatibility
   with previous DLL revs, but it's necessary. */
 
/* 2.0.29: WIN32 programmers can declare the NONDLL macro if they
   wish to build gd as a static library or by directly including
   the gd sources in a project. */
 
/* http://gcc.gnu.org/wiki/Visibility */
#if defined(_WIN32) || defined(CYGWIN) || defined(_WIN32_WCE)
#ifdef BGDWIN32
#ifdef NONDLL
#define BGD_EXPORT_DATA_PROT
#else
#ifdef __GNUC__
#define BGD_EXPORT_DATA_PROT __attribute__((__dllexport__))
#else
#define BGD_EXPORT_DATA_PROT __declspec(dllexport)
#endif
#endif
#else
#ifdef __GNUC__
#define BGD_EXPORT_DATA_PROT __attribute__((__dllimport__))
#else
#define BGD_EXPORT_DATA_PROT __declspec(dllimport)
#endif
#endif
#define BGD_STDCALL __stdcall
#define BGD_EXPORT_DATA_IMPL
#define BGD_MALLOC
#else
#if defined(__GNUC__) || defined(__clang__)
#define BGD_EXPORT_DATA_PROT __attribute__((__visibility__("default")))
#define BGD_EXPORT_DATA_IMPL __attribute__((__visibility__("hidden")))
#else
#define BGD_EXPORT_DATA_PROT
#define BGD_EXPORT_DATA_IMPL
#endif
#define BGD_STDCALL
#define BGD_MALLOC __attribute__((__malloc__))
#endif
 
#define BGD_DECLARE(rt) BGD_EXPORT_DATA_PROT rt BGD_STDCALL
 
/* VS2012+ disable keyword macroizing unless _ALLOW_KEYWORD_MACROS is set
   We define inline, and strcasecmp if they're missing
*/
#ifdef _MSC_VER
#define _ALLOW_KEYWORD_MACROS
#ifndef inline
#define inline __inline
#endif
#ifndef strcasecmp
#define strcasecmp _stricmp
#endif
#endif
 
#undef ARG_NOT_USED
#define ARG_NOT_USED(arg) (void)arg
 
/* gd.h: declarations file for the graphic-draw module.
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose and without fee is hereby granted, provided
 * that the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  This software is provided "AS IS." Thomas Boutell and
 * Boutell.Com, Inc. disclaim all warranties, either express or implied,
 * including but not limited to implied warranties of merchantability and
 * fitness for a particular purpose, with respect to this code and accompanying
 * documentation. */
 
/* stdio is needed for file I/O. */
#include "gd_io.h"
#include <stdarg.h>
#include <stdio.h>
 
/* The maximum number of palette entries in palette-based images.
   In the wonderful new world of gd 2.0, you can of course have
   many more colors when using truecolor mode. */
 
#define gdMaxColors 256
 
/* Image type. See functions below; you will not need to change
   the elements directly. Use the provided macros to
   access sx, sy, the color table, and colorsTotal for
   read-only purposes. */
 
/* If 'truecolor' is set true, the image is truecolor;
   pixels are represented by integers, which
   must be 32 bits wide or more.
 
   True colors are represented as follows:
 
   ARGB
 
   Where 'A' (alpha channel) occupies only the
   LOWER 7 BITS of the MSB. This very small
   loss of alpha channel resolution allows gd 2.x
   to keep backwards compatibility by allowing
   signed integers to be used to represent colors,
   and negative numbers to represent special cases,
   just as in gd 1.x. */
 
#define gdAlphaMax 127
#define gdAlphaOpaque 0
#define gdAlphaTransparent 127
#define gdRedMax 255
#define gdGreenMax 255
#define gdBlueMax 255
 
#define gdTrueColorGetAlpha(c) (((c) & 0x7F000000) >> 24)
 
#define gdTrueColorGetRed(c) (((c) & 0xFF0000) >> 16)
 
#define gdTrueColorGetGreen(c) (((c) & 0x00FF00) >> 8)
 
#define gdTrueColorGetBlue(c) ((c) & 0x0000FF)
 
#define gdEffectReplace 0
#define gdEffectAlphaBlend 1
#define gdEffectNormal 2
#define gdEffectOverlay 3
#define gdEffectMultiply 4
 
#define GD_TRUE 1
#define GD_FALSE 0
 
#define GD_EPSILON 1e-6
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
/* This function accepts truecolor pixel values only. The
   source color is composited with the destination color
   based on the alpha channel value of the source color.
   The resulting color is opaque. */
 
BGD_DECLARE(int) gdAlphaBlend(int dest, int src);
 
BGD_DECLARE(int) gdLayerOverlay(int dest, int src);
 
BGD_DECLARE(int) gdLayerMultiply(int dest, int src);
 
#define GD_SCALE_INTERPOLATION_AUTO -1
 
typedef enum {
    GD_DEFAULT = 0, 
    GD_BELL,        
    GD_BESSEL,      
    GD_BILINEAR_FIXED, 
    GD_BICUBIC,     
    GD_BICUBIC_FIXED, 
    GD_BLACKMAN,    
    GD_BOX,         
    GD_BSPLINE,     
    GD_CATMULLROM,  
    GD_GAUSSIAN,    
    GD_GENERALIZED_CUBIC, 
    GD_HERMITE,     
    GD_HAMMING,     
    GD_HANNING,     
    GD_MITCHELL,    
    GD_NEAREST_NEIGHBOUR, 
    GD_POWER,     
    GD_QUADRATIC, 
    GD_SINC,      
    GD_TRIANGLE,  
    GD_WEIGHTED4, 
    GD_LINEAR,    
    GD_LANCZOS3,  
    GD_LANCZOS8,  
    GD_BLACKMAN_BESSEL, 
    GD_BLACKMAN_SINC,   
    GD_QUADRATIC_BSPLINE, 
    GD_CUBIC_SPLINE,      
    GD_COSINE,         
    GD_WELSH,       
    GD_METHOD_COUNT = 30
} gdInterpolationMethod;
 
/* Interpolation function ptr */
typedef double (*interpolation_method)(double, double);
/*
   Group: Types
 
   typedef: gdImage
 
   typedef: gdImagePtr
 
   The data structure in which gd stores images. <gdImageCreate>,
   <gdImageCreateTrueColor> and the various image file-loading functions
   return a pointer to this type, and the other functions expect to
   receive a pointer to this type as their first argument.
 
   *gdImagePtr* is a pointer to *gdImage*.
 
   See also:
         <Accessor Macros>
 
   (Previous versions of this library encouraged directly manipulating
   the contents of the struct.
   We are attempting to move away from this practice so the fields
   will be considered private in 2.5 and later. )
*/
typedef struct gdImageStruct {
    /* Palette-based image pixels */
    unsigned char **pixels;
    int sx;
    int sy;
    /* These are valid in palette images only. See also
       'alpha', which appears later in the structure to
       preserve binary backwards compatibility */
    int colorsTotal;
    int red[gdMaxColors];
    int green[gdMaxColors];
    int blue[gdMaxColors];
    int open[gdMaxColors];
    /* For backwards compatibility, this is set to the
       first palette entry with 100% transparency,
       and is also set and reset by the
       gdImageColorTransparent function. Newer
       applications can allocate palette entries
       with any desired level of transparency; however,
       bear in mind that many viewers, notably
       many web browsers, fail to implement
       full alpha channel for PNG and provide
       support for full opacity or transparency only. */
    int transparent;
    int *polyInts;
    int polyAllocated;
    struct gdImageStruct *brush;
    struct gdImageStruct *tile;
    int brushColorMap[gdMaxColors];
    int tileColorMap[gdMaxColors];
    int styleLength;
    int stylePos;
    int *style;
    int interlace;
    /* New in 2.0: thickness of line. Initialized to 1. */
    int thick;
    /* New in 2.0: alpha channel for palettes. Note that only
       Macintosh Internet Explorer and (possibly) Netscape 6
       really support multiple levels of transparency in
       palettes, to my knowledge, as of 2/15/01. Most
       common browsers will display 100% opaque and
       100% transparent correctly, and do something
       unpredictable and/or undesirable for levels
       in between. TBB */
    int alpha[gdMaxColors];
    /* Truecolor flag and pixels. New 2.0 fields appear here at the
       end to minimize breakage of existing object code. */
    int trueColor;
    int **tpixels;
    /* Should alpha channel be copied, or applied, each time a
       pixel is drawn? This applies to truecolor images only.
       No attempt is made to alpha-blend in palette images,
       even if semitransparent palette entries exist.
       To do that, build your image as a truecolor image,
       then quantize down to 8 bits. */
    int alphaBlendingFlag;
    /* Should the alpha channel of the image be saved? This affects
       PNG at the moment; other future formats may also
       have that capability. JPEG doesn't. */
    int saveAlphaFlag;
 
    /* There should NEVER BE ACCESSOR MACROS FOR ITEMS BELOW HERE, so this
       part of the structure can be safely changed in new releases. */
 
    /* 2.0.12: anti-aliased globals. 2.0.26: just a few vestiges after
      switching to the fast, memory-cheap implementation from PHP-gd. */
    int AA;
    int AA_color;
    int AA_dont_blend;
 
    /* 2.0.12: simple clipping rectangle. These values
      must be checked for safety when set; please use
      gdImageSetClip */
    int cx1;
    int cy1;
    int cx2;
    int cy2;
 
    /* 2.1.0: allows to specify resolution in dpi */
    unsigned int res_x;
    unsigned int res_y;
 
    /* Selects quantization method, see gdImageTrueColorToPaletteSetMethod() and
     * gdPaletteQuantizationMethod enum. */
    int paletteQuantizationMethod;
    /* speed/quality trade-off. 1 = best quality, 10 = best speed. 0 =
       method-specific default. Applicable to GD_QUANT_LIQ and
       GD_QUANT_NEUQUANT. */
    int paletteQuantizationSpeed;
    /* Image will remain true-color if conversion to palette cannot achieve
       given quality. Value from 1 to 100, 1 = ugly, 100 = perfect. Applicable
       to GD_QUANT_LIQ.*/
    int paletteQuantizationMinQuality;
    /* Image will use minimum number of palette colors needed to achieve given
       quality. Must be higher than paletteQuantizationMinQuality Value from 1
       to 100, 1 = ugly, 100 = perfect. Applicable to GD_QUANT_LIQ.*/
    int paletteQuantizationMaxQuality;
    gdInterpolationMethod interpolation_id;
    interpolation_method interpolation;
} gdImage;
 
typedef gdImage *gdImagePtr;
 
typedef struct gdImageMetadata gdImageMetadata;
 
#define GD_META_OK 0
#define GD_META_ERR_FORMAT -1
#define GD_META_ERR_PARSE -2
#define GD_META_ERR_NOMEM -3
#define GD_META_ERR_LIMIT -4
#define GD_META_ERR_UNSUPPORTED -5
#define GD_META_ERR_INVALID -6
 
#define GD_METADATA_DEFAULT_MAX_PROFILE_SIZE ((size_t)64 * 1024 * 1024)
#define GD_METADATA_DEFAULT_MAX_TOTAL_SIZE ((size_t)256 * 1024 * 1024)
 
BGD_DECLARE(gdImageMetadata *) gdImageMetadataCreate(void);
BGD_DECLARE(void) gdImageMetadataFree(gdImageMetadata *metadata);
BGD_DECLARE(void) gdImageMetadataReset(gdImageMetadata *metadata);
BGD_DECLARE(int)
gdImageMetadataSetLimits(gdImageMetadata *metadata, size_t max_profile_size, size_t max_total_size);
BGD_DECLARE(void)
gdImageMetadataGetLimits(const gdImageMetadata *metadata, size_t *max_profile_size,
                         size_t *max_total_size);
BGD_DECLARE(int)
gdImageMetadataSetProfile(gdImageMetadata *metadata, const char *key, const unsigned char *data,
                          size_t size);
BGD_DECLARE(const unsigned char *)
gdImageMetadataGetProfile(const gdImageMetadata *metadata, const char *key, size_t *size);
BGD_DECLARE(int)
gdImageMetadataRemoveProfile(gdImageMetadata *metadata, const char *key);
BGD_DECLARE(size_t)
gdImageMetadataGetProfileCount(const gdImageMetadata *metadata);
BGD_DECLARE(int)
gdImageMetadataGetProfileAt(const gdImageMetadata *metadata, size_t index, const char **key,
                            const unsigned char **data, size_t *size);
 
/* Point type for use in polygon drawing. */
 
typedef struct {
    double x, y; 
} gdPointF, *gdPointFPtr;
 
/*
  Group: Types
 
  typedef: gdFont
 
  typedef: gdFontPtr
 
  A font structure, containing the bitmaps of all characters in a
  font.  Used to declare the characteristics of a font. Text-output
  functions expect these as their second argument, following the
  <gdImagePtr> argument.  <gdFontGetSmall> and <gdFontGetLarge> both
  return one.
 
  You can provide your own font data by providing such a structure and
  the associated pixel array. You can determine the width and height
  of a single character in a font by examining the w and h members of
  the structure. If you will not be creating your own fonts, you will
  not need to concern yourself with the rest of the components of this
  structure.
 
  Please see the files gdfontl.c and gdfontl.h for an example of
  the proper declaration of this structure.
 
  > typedef struct {
  >   // # of characters in font
  >   int nchars;
  >   // First character is numbered... (usually 32 = space)
  >   int offset;
  >   // Character width and height
  >   int w;
  >   int h;
  >   // Font data; array of characters, one row after another.
  >   // Easily included in code, also easily loaded from
  >   // data files.
  >   char *data;
  > } gdFont;
 
  gdFontPtr is a pointer to gdFont.
 
*/
typedef struct {
    /* # of characters in font */
    int nchars;
    /* First character is numbered... (usually 32 = space) */
    int offset;
    /* Character width and height */
    int w;
    int h;
    /* Font data; array of characters, one row after another.
       Easily included in code, also easily loaded from
       data files. */
    char *data;
} gdFont;
 
/* Text functions take these. */
typedef gdFont *gdFontPtr;
 
typedef void (*gdErrorMethod)(int, const char *, va_list);
 
BGD_DECLARE(void) gdSetErrorMethod(gdErrorMethod);
BGD_DECLARE(void) gdClearErrorMethod(void);
 
/* For backwards compatibility only. Use gdImageSetStyle()
   for MUCH more flexible line drawing. Also see
   gdImageSetBrush(). */
#define gdDashSize 4
#define gdStyled (-2)
#define gdBrushed (-3)
#define gdStyledBrushed (-4)
#define gdTiled (-5)
 
/* NOT the same as the transparent color index.
        This is used in line styles only. */
#define gdTransparent (-6)
 
#define gdAntiAliased (-7)
 
/* Functions to manipulate images. */
 
/* Creates a palette-based image (up to 256 colors). */
BGD_DECLARE(gdImagePtr) gdImageCreate(int sx, int sy);
 
/* An alternate name for the above (2.0). */
#define gdImageCreatePalette gdImageCreate
 
/* Creates a truecolor image (millions of colors). */
BGD_DECLARE(gdImagePtr) gdImageCreateTrueColor(int sx, int sy);
 
/* Creates an image from various file types. These functions
   return a palette or truecolor image based on the
   nature of the file being loaded. Truecolor PNG
   stays truecolor; palette PNG stays palette-based;
   JPEG is always truecolor. */
BGD_DECLARE(gdImagePtr) gdImageCreateFromPng(FILE *fd);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromPngCtx(gdIOCtxPtr in);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromPngPtr(int size, void *data);
 
BGD_DECLARE(void) gdImagePng(gdImagePtr im, FILE *out);
 
BGD_DECLARE(void) gdImagePngCtx(gdImagePtr im, gdIOCtxPtr out);
 
/* 2.0.12: Compression level: 0-9 or -1, where 0 is NO COMPRESSION at all,
   1 is FASTEST but produces larger files, 9 provides the best
   compression (smallest files) but takes a long time to compress, and
   -1 selects the default compiled into the zlib library. */
BGD_DECLARE(void) gdImagePngEx(gdImagePtr im, FILE *out, int level);
 
BGD_DECLARE(void) gdImagePngCtxEx(gdImagePtr im, gdIOCtxPtr out, int level);
 
/* Best to free this memory with gdFree(), not free() */
BGD_DECLARE(void *) gdImagePngPtr(gdImagePtr im, int *size);
 
BGD_DECLARE(void *) gdImagePngPtrEx(gdImagePtr im, int *size, int level);
 
#define GD_PNG_FILTER_AUTO 0U
#define GD_PNG_FILTER_NONE (1U << 0)
#define GD_PNG_FILTER_SUB (1U << 1)
#define GD_PNG_FILTER_UP (1U << 2)
#define GD_PNG_FILTER_AVERAGE (1U << 3)
#define GD_PNG_FILTER_PAETH (1U << 4)
#define GD_PNG_FILTER_ALL                                                                          \
    (GD_PNG_FILTER_NONE | GD_PNG_FILTER_SUB | GD_PNG_FILTER_UP | GD_PNG_FILTER_AVERAGE |           \
     GD_PNG_FILTER_PAETH)
 
enum {
    GD_PNG_COMPRESSION_STRATEGY_DEFAULT = 0, 
    GD_PNG_COMPRESSION_STRATEGY_FILTERED,    
    GD_PNG_COMPRESSION_STRATEGY_HUFFMAN_ONLY, 
    GD_PNG_COMPRESSION_STRATEGY_RLE,         
    GD_PNG_COMPRESSION_STRATEGY_FIXED        
};
 
typedef struct {
    int compression_level;           
    unsigned int filters;            
    int compression_strategy;        
    const gdImageMetadata *metadata; 
    unsigned int resolution_x;       
    unsigned int resolution_y;       
} gdPngWriteOptions;
 
typedef struct {
    int width;                   
    int height;                  
    int bit_depth;               
    int color_type;              
    int has_alpha;               
    int has_transparency;        
    int palette_entries;         
    int interlace_method;        
    int x_pixels_per_unit;       
    int y_pixels_per_unit;       
    int physical_unit;           
    gdImageMetadata *metadata;   
    int decoded_truecolor;       
    int resolution_x;            
    int resolution_y;            
} gdPngInfo;
 
BGD_DECLARE(void) gdPngWriteOptionsInit(gdPngWriteOptions *options);
 
BGD_DECLARE(void) gdPngInfoInit(gdPngInfo *info);
 
BGD_DECLARE(int) gdImagePngWithOptions(gdImagePtr im, FILE *out, const gdPngWriteOptions *options);
 
BGD_DECLARE(int)
gdImagePngCtxWithOptions(gdImagePtr im, gdIOCtxPtr out, const gdPngWriteOptions *options);
 
BGD_DECLARE(void *)
gdImagePngPtrWithOptions(gdImagePtr im, int *size, const gdPngWriteOptions *options);
 
BGD_DECLARE(int) gdPngGetInfo(FILE *in, gdPngInfo *info);
 
BGD_DECLARE(int) gdPngGetInfoCtx(gdIOCtxPtr in, gdPngInfo *info);
 
BGD_DECLARE(int) gdPngGetInfoPtr(int size, const void *data, gdPngInfo *info);
 
BGD_DECLARE(const char *) gdPngGetVersionString(void);
BGD_DECLARE(gdImagePtr) gdImageCreateFromQoi(FILE *fd);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromQoiCtx(gdIOCtxPtr in);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromQoiPtr(int size, void *data);
 
typedef struct {
    unsigned int width; 
    unsigned int height; 
    int channels; 
    int colorspace; 
} gdQoiInfo;
 
BGD_DECLARE(void) gdQoiInfoInit(gdQoiInfo *info);
 
BGD_DECLARE(int) gdQoiGetInfo(FILE *infile, gdQoiInfo *info);
 
BGD_DECLARE(int) gdQoiGetInfoCtx(gdIOCtxPtr infile, gdQoiInfo *info);
 
BGD_DECLARE(int) gdQoiGetInfoPtr(int size, const void *data, gdQoiInfo *info);
 
typedef struct {
    int colorspace; 
    const gdImageMetadata *metadata; 
} gdQoiWriteOptions;
 
BGD_DECLARE(void) gdQoiWriteOptionsInit(gdQoiWriteOptions *options);
 
BGD_DECLARE(int)
gdImageQoiWithOptions(gdImagePtr im, FILE *out, const gdQoiWriteOptions *options);
 
BGD_DECLARE(int)
gdImageQoiCtxWithOptions(gdImagePtr im, gdIOCtxPtr out, const gdQoiWriteOptions *options);
 
BGD_DECLARE(void *)
gdImageQoiPtrWithOptions(gdImagePtr im, int *size, const gdQoiWriteOptions *options);
 
BGD_DECLARE(void *) gdImageQoiPtr(gdImagePtr im, int *size);
 
BGD_DECLARE(void *) gdImageQoiPtrEx(gdImagePtr im, int *size, int colorspace);
 
BGD_DECLARE(void) gdImageQoi(gdImagePtr im, FILE *out);
 
BGD_DECLARE(void) gdImageQoiCtx(gdImagePtr im, gdIOCtxPtr out);
 
enum {
    GD_QOI_SRGB = 0,  
    GD_QOI_LINEAR = 1 
};
 
BGD_DECLARE(void) gdImageQoi(gdImagePtr im, FILE *out);
 
BGD_DECLARE(void) gdImageQoiCtx(gdImagePtr im, gdIOCtxPtr out);
 
BGD_DECLARE(void) gdImageQoiEx(gdImagePtr im, FILE *out, int colorspace);
 
BGD_DECLARE(void)
gdImageQoiCtxEx(gdImagePtr im, gdIOCtxPtr out, int colorspace);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromGif(FILE *fd);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromGifCtx(gdIOCtxPtr in);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromGifPtr(int size, void *data);
 
BGD_DECLARE(void) gdImageGifCtx(gdImagePtr im, gdIOCtxPtr out);
 
BGD_DECLARE(void) gdImageGif(gdImagePtr im, FILE *out);
 
BGD_DECLARE(void *) gdImageGifPtr(gdImagePtr im, int *size);
 
typedef struct gdGifReadStruct *gdGifReadPtr;
 
typedef struct {
    char version[4];       
    int width;            
    int height;           
    int background_index;      
    int global_color_table;    
    int color_resolution;      
    double pixel_aspect_ratio; 
    int loop_count;            
    int loop_count_present;    
} gdGifInfo;
 
typedef struct {
    int frame_index;       
    int x;                
    int y;                
    int width;            
    int height;           
    int delay;            
    int disposal;         
    int transparent_index; 
    int local_color_table; 
    int interlace;        
} gdGifFrameInfo;
 
BGD_DECLARE(int) gdGifIsAnimated(FILE *fd);
 
BGD_DECLARE(int) gdGifIsAnimatedCtx(gdIOCtxPtr in);
 
BGD_DECLARE(int) gdGifIsAnimatedPtr(int size, void *data);
 
BGD_DECLARE(gdGifReadPtr) gdGifReadOpen(FILE *fd);
 
BGD_DECLARE(gdGifReadPtr) gdGifReadOpenCtx(gdIOCtxPtr in);
 
BGD_DECLARE(gdGifReadPtr) gdGifReadOpenPtr(int size, void *data);
 
BGD_DECLARE(void) gdGifReadClose(gdGifReadPtr gif);
 
BGD_DECLARE(int) gdGifReadGetInfo(gdGifReadPtr gif, gdGifInfo *info);
 
BGD_DECLARE(int) gdGifGetInfo(FILE *file, gdGifInfo *info);
 
BGD_DECLARE(int) gdGifGetInfoCtx(gdIOCtxPtr input, gdGifInfo *info);
 
BGD_DECLARE(int) gdGifGetInfoPtr(int size, const void *data, gdGifInfo *info);
 
BGD_DECLARE(int)
gdGifReadNextFrame(gdGifReadPtr gif, gdGifFrameInfo *info, gdImagePtr *frame);
 
BGD_DECLARE(int)
gdGifReadNextImage(gdGifReadPtr gif, gdGifFrameInfo *info, gdImagePtr *image);
 
enum {
    gdDisposalUnknown,           
    gdDisposalNone,              
    gdDisposalRestoreBackground, 
    gdDisposalRestorePrevious    
};
 
#define GD_GIF_DISPOSAL_UNKNOWN gdDisposalUnknown
#define GD_GIF_DISPOSAL_NONE gdDisposalNone
#define GD_GIF_DISPOSAL_RESTORE_BACKGROUND gdDisposalRestoreBackground
#define GD_GIF_DISPOSAL_RESTORE_PREVIOUS gdDisposalRestorePrevious
 
BGD_DECLARE(void)
gdImageGifAnimBegin(gdImagePtr im, FILE *outFile, int GlobalCM, int Loops);
 
BGD_DECLARE(void)
gdImageGifAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, int LeftOfs, int TopOfs, int Delay,
                  int Disposal, gdImagePtr previm);
 
BGD_DECLARE(void) gdImageGifAnimEnd(FILE *outFile);
 
BGD_DECLARE(void)
gdImageGifAnimBeginCtx(gdImagePtr im, gdIOCtxPtr out, int GlobalCM, int Loops);
 
BGD_DECLARE(void)
gdImageGifAnimAddCtx(gdImagePtr im, gdIOCtxPtr out, int LocalCM, int LeftOfs, int TopOfs, int Delay,
                     int Disposal, gdImagePtr previm);
 
BGD_DECLARE(void) gdImageGifAnimEndCtx(gdIOCtxPtr out);
 
BGD_DECLARE(void *)
gdImageGifAnimBeginPtr(gdImagePtr im, int *size, int GlobalCM, int Loops);
 
BGD_DECLARE(void *)
gdImageGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay,
                     int Disposal, gdImagePtr previm);
 
BGD_DECLARE(void *) gdImageGifAnimEndPtr(int *size);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMP(FILE *inFile);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPCtx(gdIOCtxPtr infile);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPPtr(int size, void *data);
 
enum {
    GD_JPEG_COLOR_SPACE_UNKNOWN = 0,   
    GD_JPEG_COLOR_SPACE_GRAYSCALE = 1, 
    GD_JPEG_COLOR_SPACE_RGB = 2,       
    GD_JPEG_COLOR_SPACE_YCBCR = 3,     
    GD_JPEG_COLOR_SPACE_CMYK = 4,      
    GD_JPEG_COLOR_SPACE_YCCK = 5       
};
 
enum {
    GD_JPEG_DENSITY_UNIT_NONE = 0, 
    GD_JPEG_DENSITY_UNIT_DPI = 1,  
    GD_JPEG_DENSITY_UNIT_DPCM = 2  
};
 
enum {
    GD_JPEG_DCT_DEFAULT = 0, 
    GD_JPEG_DCT_SLOW = 1,    
    GD_JPEG_DCT_FAST = 2,    
    GD_JPEG_DCT_FLOAT = 3    
};
 
typedef struct {
    int width;            
    int height;           
    int bits_per_sample;  
    int components;       
    int color_space;      
    int progressive;      
    int density_unit;     
    int x_density;        
    int y_density;        
} gdJpegInfo;
 
typedef struct {
    int ignore_warning;       
    unsigned int scale_num;   
    unsigned int scale_denom; 
    int dct_method;           
} gdJpegReadOptions;
 
typedef struct {
    int quality;                     
    int progressive;                 
    int force_no_subsampling;        
    const gdImageMetadata *metadata; 
} gdJpegWriteOptions;
 
BGD_DECLARE(void) gdJpegInfoInit(gdJpegInfo *info);
 
BGD_DECLARE(void) gdJpegReadOptionsInit(gdJpegReadOptions *options);
 
BGD_DECLARE(void) gdJpegWriteOptionsInit(gdJpegWriteOptions *options);
 
BGD_DECLARE(int) gdJpegGetInfo(FILE *infile, gdJpegInfo *info);
 
 
BGD_DECLARE(int) gdJpegGetInfoCtx(gdIOCtxPtr infile, gdJpegInfo *info);
 
BGD_DECLARE(int) gdJpegGetInfoPtr(int size, const void *data, gdJpegInfo *info);
 
BGD_DECLARE(int) gdJpegGetMetadata(FILE *infile, gdImageMetadata *metadata);
BGD_DECLARE(int) gdJpegGetMetadataCtx(gdIOCtxPtr infile, gdImageMetadata *metadata);
BGD_DECLARE(int) gdJpegGetMetadataPtr(int size, const void *data, gdImageMetadata *metadata);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromJpeg(FILE *infile);
 
BGD_DECLARE(gdImagePtr)
gdImageCreateFromJpegEx(FILE *infile, int ignore_warning);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtx(gdIOCtxPtr infile);
 
BGD_DECLARE(gdImagePtr)
gdImageCreateFromJpegCtxEx(gdIOCtxPtr infile, int ignore_warning);
 
BGD_DECLARE(gdImagePtr)
gdImageCreateFromJpegCtxWithOptions(gdIOCtxPtr infile, const gdJpegReadOptions *options);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegPtr(int size, void *data);
BGD_DECLARE(gdImagePtr)
gdImageCreateFromJpegPtrEx(int size, void *data, int ignore_warning);
 
BGD_DECLARE(gdImagePtr)
gdImageCreateFromJpegPtrWithOptions(int size, void *data, const gdJpegReadOptions *options);
 
BGD_DECLARE(const char *) gdJpegGetVersionString();
BGD_DECLARE(gdImagePtr) gdImageCreateFromWebp(FILE *inFile);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpPtr(int size, void *data);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpCtx(gdIOCtxPtr infile);
 
typedef struct gdWebpRead *gdWebpReadPtr;
 
typedef struct gdWebpWrite *gdWebpWritePtr;
 
typedef struct {
    int width;           
    int height;          
    int frame_count;     
    int loop_count;      
    int background_color; 
    int format_flags;    
    int is_animation;    
} gdWebpInfo;
 
typedef struct {
    int frame_index; 
    int x;          
    int y;          
    int width;      
    int height;     
    int duration;   
    int timestamp;  
    int dispose;    
    int blend;      
    int has_alpha;  
    int complete;   
} gdWebpFrameInfo;
 
typedef struct {
    int coalesced;      
} gdWebpReadOptions;
 
typedef struct {
    int quality;                     
    const gdImageMetadata *metadata; 
} gdWebpWriteOptions;
 
typedef struct {
    int canvas_width;     
    int canvas_height;    
    int loop_count;       
    int background_color; 
    int quality;         
    int lossless;        
    int method;          
    int minimize_size;    
    int kmin;            
    int kmax;            
    int allow_mixed;      
} gdWebpAnimWriteOptions;
 
BGD_DECLARE(void) gdWebpReadOptionsInit(gdWebpReadOptions *options);
 
BGD_DECLARE(void) gdWebpWriteOptionsInit(gdWebpWriteOptions *options);
 
BGD_DECLARE(void) gdWebpAnimWriteOptionsInit(gdWebpAnimWriteOptions *options);
 
enum {
    gdWebpDisposeNone,      
    gdWebpDisposeBackground 
};
 
enum {
    gdWebpBlendAlpha, 
    gdWebpBlendNone   
};
 
BGD_DECLARE(int) gdWebpIsAnimated(FILE *fd);
 
BGD_DECLARE(int) gdWebpIsAnimatedCtx(gdIOCtxPtr in);
 
BGD_DECLARE(int) gdWebpIsAnimatedPtr(int size, void *data);
 
BGD_DECLARE(gdWebpReadPtr) gdWebpReadOpen(FILE *fd, const gdWebpReadOptions *options);
 
BGD_DECLARE(gdWebpReadPtr) gdWebpReadOpenCtx(gdIOCtxPtr in, const gdWebpReadOptions *options);
 
BGD_DECLARE(gdWebpReadPtr)
gdWebpReadOpenPtr(int size, void *data, const gdWebpReadOptions *options);
 
BGD_DECLARE(void) gdWebpReadClose(gdWebpReadPtr webp);
 
BGD_DECLARE(int) gdWebpReadGetInfo(gdWebpReadPtr webp, gdWebpInfo *info);
 
BGD_DECLARE(int) gdWebpReadGetMetadata(gdWebpReadPtr webp, gdImageMetadata *metadata);
 
BGD_DECLARE(int)
gdWebpReadNextFrame(gdWebpReadPtr webp, gdWebpFrameInfo *info, gdImagePtr *frame);
 
BGD_DECLARE(int)
gdWebpReadNextImage(gdWebpReadPtr webp, gdWebpFrameInfo *info, gdImagePtr *image);
 
BGD_DECLARE(gdWebpWritePtr)
gdWebpWriteOpen(FILE *outFile, const gdWebpAnimWriteOptions *options);
 
BGD_DECLARE(gdWebpWritePtr)
gdWebpWriteOpenCtx(gdIOCtxPtr out, const gdWebpAnimWriteOptions *options);
 
BGD_DECLARE(gdWebpWritePtr)
gdWebpWriteOpenPtr(const gdWebpAnimWriteOptions *options);
 
BGD_DECLARE(int)
gdWebpWriteAddImage(gdWebpWritePtr webp, gdImagePtr image, int durationMs);
 
BGD_DECLARE(void) gdWebpWriteClose(gdWebpWritePtr webp);
 
BGD_DECLARE(void *) gdWebpWritePtrFinish(gdWebpWritePtr webp, int *size);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromJxl(FILE *inFile);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromJxlPtr(int size, void *data);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromJxlCtx(gdIOCtxPtr infile);
 
BGD_DECLARE(void) gdImageJxl(gdImagePtr im, FILE *outFile);
 
BGD_DECLARE(void)
gdImageJxlEx(gdImagePtr im, FILE *outFile, int lossless, float distance, int effort);
 
BGD_DECLARE(void *) gdImageJxlPtr(gdImagePtr im, int *size);
 
BGD_DECLARE(void *)
gdImageJxlPtrEx(gdImagePtr im, int *size, int lossless, float distance, int effort);
 
BGD_DECLARE(void) gdImageJxlCtx(gdImagePtr im, gdIOCtxPtr outfile);
 
BGD_DECLARE(void)
gdImageJxlCtxEx(gdImagePtr im, gdIOCtxPtr outfile, int lossless, float distance, int effort);
 
typedef struct {
    int lossless;                         
    float distance;                       
    int effort;                           
    const gdImageMetadata *metadata;      
} gdJxlWriteOptions;
 
BGD_DECLARE(void) gdJxlWriteOptionsInit(gdJxlWriteOptions *options);
 
BGD_DECLARE(int)
gdImageJxlWithOptions(gdImagePtr im, FILE *outFile, const gdJxlWriteOptions *options);
 
BGD_DECLARE(int)
gdImageJxlCtxWithOptions(gdImagePtr im, gdIOCtxPtr outfile, const gdJxlWriteOptions *options);
 
BGD_DECLARE(void *)
gdImageJxlPtrWithOptions(gdImagePtr im, int *size, const gdJxlWriteOptions *options);
 
typedef struct gdJxlRead *gdJxlReadPtr;
 
typedef struct gdJxlWrite *gdJxlWritePtr;
 
typedef struct {
    int width;      
    int height;     
    int animated;   
    int loop_count; 
} gdJxlInfo;
 
typedef struct {
    int delay_ms;   
    int x_offset;   
    int y_offset;   
    int width;      
    int height;     
    int blend_mode; 
    int is_last;    
} gdJxlFrameInfo;
 
enum {
    gdJxlBlendReplace, 
    gdJxlBlendAdd,     
    gdJxlBlendBlend,   
    gdJxlBlendMuladd,  
    gdJxlBlendMul      
};
 
typedef struct {
    int coalesced;      
} gdJxlReadOptions;
 
typedef struct {
    int canvas_width;    
    int canvas_height;   
    int lossless;       
    float distance;     
    int effort;         
    int loop_count;      
} gdJxlAnimWriteOptions;
 
BGD_DECLARE(void) gdJxlReadOptionsInit(gdJxlReadOptions *options);
 
BGD_DECLARE(void) gdJxlAnimWriteOptionsInit(gdJxlAnimWriteOptions *options);
 
BGD_DECLARE(gdJxlReadPtr) gdJxlReadOpen(FILE *inFile, const gdJxlReadOptions *options);
 
BGD_DECLARE(gdJxlReadPtr) gdJxlReadOpenCtx(gdIOCtxPtr inCtx, const gdJxlReadOptions *options);
 
BGD_DECLARE(gdJxlReadPtr)
gdJxlReadOpenPtr(int size, void *data, const gdJxlReadOptions *options);
 
BGD_DECLARE(int) gdJxlReadGetInfo(gdJxlReadPtr reader, gdJxlInfo *info);
 
BGD_DECLARE(int) gdJxlReadGetMetadata(gdJxlReadPtr reader, gdImageMetadata *metadata);
 
BGD_DECLARE(int) gdJxlReadNextImage(gdJxlReadPtr reader, int *delay_ms, gdImagePtr *image);
 
BGD_DECLARE(int) gdJxlReadNextFrame(gdJxlReadPtr reader, gdJxlFrameInfo *info, gdImagePtr *frame);
 
BGD_DECLARE(void) gdJxlReadClose(gdJxlReadPtr reader);
 
BGD_DECLARE(gdJxlWritePtr) gdJxlWriteOpen(FILE *outFile, const gdJxlAnimWriteOptions *options);
 
BGD_DECLARE(gdJxlWritePtr) gdJxlWriteOpenCtx(gdIOCtxPtr outCtx, const gdJxlAnimWriteOptions *options);
 
BGD_DECLARE(gdJxlWritePtr) gdJxlWriteOpenPtr(const gdJxlAnimWriteOptions *options);
 
BGD_DECLARE(int) gdJxlWriteAddImage(gdJxlWritePtr writer, gdImagePtr image, int delay_ms);
 
BGD_DECLARE(void) gdJxlWriteClose(gdJxlWritePtr writer);
 
BGD_DECLARE(void *) gdJxlWritePtrFinish(gdJxlWritePtr writer, int *size);
 
typedef enum {
    GD_HEIF_CODEC_UNKNOWN = 0, 
    GD_HEIF_CODEC_HEVC,        
    GD_HEIF_CODEC_AV1 = 4,     
} gdHeifCodec;
 
typedef const char *gdHeifChroma;
 
#define GD_HEIF_CHROMA_420 "420"
#define GD_HEIF_CHROMA_422 "422"
#define GD_HEIF_CHROMA_444 "444"
 
typedef struct {
    int ignore_transformations; 
} gdHeifReadOptions;
 
typedef struct {
    int quality;        
    int lossless;       
    gdHeifCodec codec;  
    gdHeifChroma chroma; 
    const gdImageMetadata *metadata; 
} gdHeifWriteOptions;
 
typedef struct {
    int width;
    int height;
    int top_level_image_count;
    int has_alpha;
    int bit_depth;
    int is_animation;
    gdImageMetadata *metadata;
} gdHeifInfo;
 
BGD_DECLARE(void) gdHeifInfoInit(gdHeifInfo *info);
 
BGD_DECLARE(int) gdHeifGetInfo(FILE *inFile, gdHeifInfo *info);
 
BGD_DECLARE(int) gdHeifGetInfoCtx(gdIOCtxPtr in, gdHeifInfo *info);
 
BGD_DECLARE(int) gdHeifGetInfoPtr(int size, const void *data, gdHeifInfo *info);
 
 
BGD_DECLARE(void) gdHeifReadOptionsInit(gdHeifReadOptions *options);
 
BGD_DECLARE(void) gdHeifWriteOptionsInit(gdHeifWriteOptions *options);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromHeif(FILE *inFile);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromHeifPtr(int size, void *data);
 
BGD_DECLARE(gdImagePtr)
gdImageCreateFromHeifPtrWithOptions(int size, void *data, const gdHeifReadOptions *options);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromHeifCtx(gdIOCtxPtr infile);
 
BGD_DECLARE(void)
gdImageHeifEx(gdImagePtr im, FILE *outFile, int quality, gdHeifCodec codec, gdHeifChroma chroma);
 
BGD_DECLARE(void) gdImageHeif(gdImagePtr im, FILE *outFile);
 
BGD_DECLARE(void *) gdImageHeifPtr(gdImagePtr im, int *size);
 
BGD_DECLARE(void *)
gdImageHeifPtrEx(gdImagePtr im, int *size, int quality, gdHeifCodec codec, gdHeifChroma chroma);
 
BGD_DECLARE(void *)
gdImageHeifPtrWithOptions(gdImagePtr im, int *size, const gdHeifWriteOptions *options);
 
BGD_DECLARE(int)
gdImageHeifWithOptions(gdImagePtr im, FILE *outFile, const gdHeifWriteOptions *options);
 
BGD_DECLARE(int)
gdImageHeifCtxWithOptions(gdImagePtr im, gdIOCtxPtr outfile, const gdHeifWriteOptions *options);
 
BGD_DECLARE(void)
gdImageHeifCtx(gdImagePtr im, gdIOCtxPtr outfile, int quality, gdHeifCodec codec,
               gdHeifChroma chroma);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromAvif(FILE *inFile);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromAvifPtr(int size, void *data);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromAvifCtx(gdIOCtxPtr infile);
 
enum {
    GD_AVIF_CHROMA_SUBSAMPLING_AUTO = 0,  
    GD_AVIF_CHROMA_SUBSAMPLING_YUV420 = 1, 
    GD_AVIF_CHROMA_SUBSAMPLING_YUV444 = 2  
};
 
enum {
    GD_AVIF_PIXEL_FORMAT_NONE = 0,
    GD_AVIF_PIXEL_FORMAT_YUV444 = 1,
    GD_AVIF_PIXEL_FORMAT_YUV422 = 2,
    GD_AVIF_PIXEL_FORMAT_YUV420 = 3,
    GD_AVIF_PIXEL_FORMAT_YUV400 = 4
};
 
typedef struct {
    int quality;            
    int speed;              
    int lossless;           
    int chroma_subsampling; 
    const gdImageMetadata *metadata; 
} gdAvifWriteOptions;
 
typedef struct {
    int width; 
    int height; 
    int is_animation; 
    int is_progressive; 
    int frame_count; 
    double duration; 
    int has_alpha; 
    int bit_depth; 
    int yuv_format; 
    gdImageMetadata *metadata; 
} gdAvifInfo;
 
BGD_DECLARE(void) gdAvifInfoInit(gdAvifInfo *info);
 
BGD_DECLARE(int) gdAvifGetInfo(FILE *inFile, gdAvifInfo *info);
 
BGD_DECLARE(int) gdAvifGetInfoCtx(gdIOCtxPtr in, gdAvifInfo *info);
 
BGD_DECLARE(int) gdAvifGetInfoPtr(int size, const void *data, gdAvifInfo *info);
 
BGD_DECLARE(void) gdAvifWriteOptionsInit(gdAvifWriteOptions *options);
 
BGD_DECLARE(void) gdImageAvif(gdImagePtr im, FILE *outFile);
 
BGD_DECLARE(void)
gdImageAvifEx(gdImagePtr im, FILE *outFile, int quality, int speed);
 
BGD_DECLARE(void *) gdImageAvifPtr(gdImagePtr im, int *size);
 
BGD_DECLARE(void *)
gdImageAvifPtrEx(gdImagePtr im, int *size, int quality, int speed);
 
BGD_DECLARE(void *)
gdImageAvifPtrWithOptions(gdImagePtr im, int *size, const gdAvifWriteOptions *options);
 
BGD_DECLARE(int)
gdImageAvifWithOptions(gdImagePtr im, FILE *outFile, const gdAvifWriteOptions *options);
 
BGD_DECLARE(int)
gdImageAvifCtxWithOptions(gdImagePtr im, gdIOCtxPtr outfile, const gdAvifWriteOptions *options);
 
BGD_DECLARE(void)
gdImageAvifCtx(gdImagePtr im, gdIOCtxPtr outfile, int quality, int speed);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromTiff(FILE *inFile);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffCtx(gdIOCtxPtr infile);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffPtr(int size, void *data);
 
typedef struct gdTiffReadStruct *gdTiffReadPtr;
 
typedef struct {
    int notused;  
} gdTiffReadOptions;
 
typedef struct {
    int width;              
    int height;             
    int page_count;         
    int bits_per_sample;    
    int samples_per_pixel;  
    int compression;        
    int photometric;        
    float x_resolution;     
    float y_resolution;     
    int resolution_unit;    
} gdTiffInfo;
 
typedef struct {
    int page_index;         
    int width;              
    int height;             
    int bits_per_sample;    
    int samples_per_pixel;  
    int compression;        
    int photometric;        
    int planar;             
    int has_alpha;          
    int is_tiled;           
    float x_resolution;     
    float y_resolution;     
    int resolution_unit;    
} gdTiffPageInfo;
 
BGD_DECLARE(int) gdTiffIsMultiPage(FILE *fd);
 
BGD_DECLARE(int) gdTiffIsMultiPageCtx(gdIOCtxPtr in);
 
BGD_DECLARE(int) gdTiffIsMultiPagePtr(int size, void *data);
 
BGD_DECLARE(void) gdTiffReadOptionsInit(gdTiffReadOptions *options);
 
BGD_DECLARE(gdTiffReadPtr) gdTiffReadOpen(FILE *fd, const gdTiffReadOptions *options);
 
BGD_DECLARE(gdTiffReadPtr) gdTiffReadOpenCtx(gdIOCtxPtr in, const gdTiffReadOptions *options);
 
BGD_DECLARE(gdTiffReadPtr) gdTiffReadOpenPtr(int size, void *data, const gdTiffReadOptions *options);
 
BGD_DECLARE(void) gdTiffReadClose(gdTiffReadPtr tiff);
 
BGD_DECLARE(int) gdTiffReadGetInfo(gdTiffReadPtr tiff, gdTiffInfo *info);
 
BGD_DECLARE(int) gdTiffReadGetMetadata(gdTiffReadPtr tiff, gdImageMetadata *metadata);
 
BGD_DECLARE(int)
gdTiffReadNextImage(gdTiffReadPtr tiff, gdTiffPageInfo *info, gdImagePtr *image);
 
typedef enum {
    GD_TIFF_RGB = 1,     
    GD_TIFF_RGBA = 2,    
    GD_TIFF_GRAY = 3,    
    GD_TIFF_BILEVEL = 4  
} gdTiffColorSpace;
 
typedef enum {
    GD_TIFF_COMPRESSION_NONE = 1,            
    GD_TIFF_COMPRESSION_CCITT_RLE = 2,       
    GD_TIFF_COMPRESSION_CCITT_FAX3 = 3,      
    GD_TIFF_COMPRESSION_CCITT_FAX4 = 4,      
    GD_TIFF_COMPRESSION_LZW = 5,             
    GD_TIFF_COMPRESSION_JPEG = 7,            
    GD_TIFF_COMPRESSION_ADOBE_DEFLATE = 8,   
    GD_TIFF_COMPRESSION_DEFLATE = 32946,     
    GD_TIFF_COMPRESSION_PACKBITS = 32773     
} gdTiffCompression;
 
typedef enum {
    GD_TIFF_PHOTOMETRIC_MINISWHITE = 0,          
    GD_TIFF_PHOTOMETRIC_MINISBLACK = 1,          
    GD_TIFF_PHOTOMETRIC_RGB = 2,                 
    GD_TIFF_PHOTOMETRIC_PALETTE = 3,             
    GD_TIFF_PHOTOMETRIC_TRANSPARENCY_MASK = 4,   
    GD_TIFF_PHOTOMETRIC_SEPARATED = 5,           
    GD_TIFF_PHOTOMETRIC_YCBCR = 6,               
    GD_TIFF_PHOTOMETRIC_CIELAB = 8               
} gdTiffPhotometric;
 
typedef enum {
    GD_TIFF_PLANARCONFIG_CONTIG = 1,    
    GD_TIFF_PLANARCONFIG_SEPARATE = 2   
} gdTiffPlanarConfig;
 
typedef enum {
    GD_TIFF_RESUNIT_NONE = 1,       
    GD_TIFF_RESUNIT_INCH = 2,       
    GD_TIFF_RESUNIT_CENTIMETER = 3  
} gdTiffResolutionUnit;
 
typedef enum {
    GD_TIFF_ALPHA_UNASSOCIATED = 1,  
    GD_TIFF_ALPHA_ASSOCIATED = 2     
} gdTiffAlphaType;
 
typedef struct {
    int bitDepth;        
    gdTiffColorSpace colorspace;       
    gdTiffCompression compression;     
    int jpegQuality;     
    int minIsWhite;      
    gdTiffResolutionUnit resolutionUnit;  
    float xResolution;   
    float yResolution;   
    gdTiffAlphaType alphaType;         
    const gdImageMetadata *metadata;   
} gdTiffWriteOptions;
 
typedef struct gdTiffWriteStruct *gdTiffWritePtr;
 
BGD_DECLARE(void) gdTiffWriteOptionsInit(gdTiffWriteOptions *options);
 
BGD_DECLARE(gdTiffWritePtr)
gdTiffWriteOpen(FILE *outFile, const gdTiffWriteOptions *options);
 
BGD_DECLARE(gdTiffWritePtr)
gdTiffWriteOpenCtx(gdIOCtxPtr out, const gdTiffWriteOptions *options);
 
BGD_DECLARE(gdTiffWritePtr)
gdTiffWriteOpenPtr(const gdTiffWriteOptions *options);
 
BGD_DECLARE(int) gdTiffWriteAddImage(gdTiffWritePtr write, gdImagePtr image);
 
BGD_DECLARE(void) gdTiffWriteClose(gdTiffWritePtr write);
 
BGD_DECLARE(void *) gdTiffWritePtrFinish(gdTiffWritePtr write, int *size);
 
BGD_DECLARE(void) gdImageTiff(gdImagePtr im, FILE *outFile);
 
BGD_DECLARE(void *) gdImageTiffPtr(gdImagePtr im, int *size);
 
BGD_DECLARE(void) gdImageTiffCtx(gdImagePtr image, gdIOCtxPtr out);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromTga(FILE *fp);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaCtx(gdIOCtxPtr ctx);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaPtr(int size, void *data);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromBmp(FILE *inFile);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpPtr(int size, void *data);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpCtx(gdIOCtxPtr infile);
 
typedef struct {
    int header_type; 
    int width; 
    int height; 
    int top_down; 
    int planes; 
    int bits_per_pixel; 
    int compression; 
    int image_size; 
    int horizontal_resolution; 
    int vertical_resolution; 
    int colors_used; 
    int important_colors; 
    int palette_type; 
    int palette_entries; 
    unsigned int red_mask; 
    unsigned int green_mask; 
    unsigned int blue_mask; 
    unsigned int alpha_mask; 
} gdBmpInfo;
 
BGD_DECLARE(void) gdBmpInfoInit(gdBmpInfo *info);
 
BGD_DECLARE(int) gdBmpGetInfo(FILE *infile, gdBmpInfo *info);
 
BGD_DECLARE(int) gdBmpGetInfoCtx(gdIOCtxPtr infile, gdBmpInfo *info);
 
BGD_DECLARE(int) gdBmpGetInfoPtr(int size, const void *data, gdBmpInfo *info);
 
BGD_DECLARE(void *) gdImageBmpPtr(gdImagePtr im, int *size, int compression);
 
BGD_DECLARE(void) gdImageBmp(gdImagePtr im, FILE *outFile, int compression);
 
BGD_DECLARE(void) gdImageBmpCtx(gdImagePtr im, gdIOCtxPtr out, int compression);
 
#define GD_BMP_COMPRESS_NONE 0 
#define GD_BMP_COMPRESS_RLE8 1
#define GD_BMP_COMPRESS_RLE4 2
 
#define GD_BMP_FLAG_NONE 0
#define GD_BMP_FLAG_FORCE_V4HDR (1 << 0)
#define GD_BMP_FLAG_QUANTIZE (1 << 1)
#define GD_BMP_FLAG_RGB555 (1 << 2)
 
typedef struct {
    int bits_per_pixel; 
    int compression; 
    int flags; 
    const gdImageMetadata *metadata; 
} gdBmpWriteOptions;
 
BGD_DECLARE(void) gdBmpWriteOptionsInit(gdBmpWriteOptions *options);
 
BGD_DECLARE(int) gdImageBmpWithOptions(gdImagePtr im, FILE *outFile, const gdBmpWriteOptions *options);
 
BGD_DECLARE(int) gdImageBmpCtxWithOptions(gdImagePtr im, gdIOCtxPtr out, const gdBmpWriteOptions *options);
 
BGD_DECLARE(void *) gdImageBmpPtrWithOptions(gdImagePtr im, int *size, const gdBmpWriteOptions *options);
 
BGD_DECLARE(void *)
gdImageBmpPtrEx(gdImagePtr im, int *size, int bpp, int compression, int flags);
 
BGD_DECLARE(void)
gdImageBmpEx(gdImagePtr im, FILE *outFile, int bpp, int compression, int flags);
 
BGD_DECLARE(void)
gdImageBmpCtxEx(gdImagePtr im, gdIOCtxPtr out, int bpp, int compression, int flags);
 
#define GD_UHDR_SUCCESS 0        
#define GD_UHDR_NOT_AVAILABLE -1 
#define GD_UHDR_E_INVALID -2     
#define GD_UHDR_E_UNSUPPORTED -3 
#define GD_UHDR_E_ENCODE -4      
#define GD_UHDR_E_DECODE -5      
#define GD_UHDR_MIRROR_HORIZONTAL 0
#define GD_UHDR_MIRROR_VERTICAL 1
 
typedef enum {
    GD_UHDR_FORMAT_JPEG = 0, 
    GD_UHDR_FORMAT_WEBP = 1, 
    GD_UHDR_FORMAT_HEIF = 2  
} gdUhdrFormat;
 
typedef struct gdUhdrImageStruct gdUhdrImage;
 
typedef gdUhdrImage *gdUhdrImagePtr;
 
typedef struct {
    int code;           
    int provider_code;  
    char message[128];  
} gdUhdrError;
 
typedef gdUhdrError *gdUhdrErrorPtr;
 
BGD_DECLARE(gdUhdrImagePtr)
gdUhdrImageCreateFromFile(const char *filename, int format, gdUhdrErrorPtr err);
 
BGD_DECLARE(gdUhdrImagePtr)
gdUhdrImageCreateFromCtx(gdIOCtxPtr ctx, int format, gdUhdrErrorPtr err);
 
BGD_DECLARE(gdUhdrImagePtr)
gdUhdrImageCreateFromPtr(int size, void *data, int format, gdUhdrErrorPtr err);
 
BGD_DECLARE(void) gdUhdrImageDestroy(gdUhdrImagePtr im);
 
/*
  Group: Types
 
  typedef: gdSource
 
  typedef: gdSourcePtr
 
        *Note:* This interface is *obsolete* and kept only for
        *compatibility.  Use <gdIOCtx> instead.
 
        Represents a source from which a PNG can be read. Programmers who
        do not wish to read PNGs from a file can provide their own
        alternate input mechanism, using the @ref gdImageCreateFromPngSource
        function. See the documentation of that function for an example of
        the proper use of this type.
 
        > typedef struct {
        >         int (*source) (void *context, char *buffer, int len);
        >         void *context;
        > } gdSource, *gdSourcePtr;
 
        The source function must return -1 on error, otherwise the number
        of bytes fetched. 0 is EOF, not an error!
 
   'context' will be passed to your source function.
 
*/
typedef struct {
    int (*source)(void *context, char *buffer, int len);
    void *context;
} gdSource, *gdSourcePtr;
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromPngSource(gdSourcePtr in);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromQoiSource(gdSourcePtr in);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromGd(FILE *in);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromGdCtx(gdIOCtxPtr in);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromGdPtr(int size, void *data);
 
BGD_DECLARE(void *) gdImageGdPtr(gdImagePtr im, int *size);
 
BGD_DECLARE(void) gdImageGd(gdImagePtr im, FILE *out);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2(FILE *in);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ctx(gdIOCtxPtr in);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ptr(int size, void *data);
 
BGD_DECLARE(gdImagePtr)
gdImageCreateFromGd2Part(FILE *in, int srcx, int srcy, int w, int h);
 
BGD_DECLARE(gdImagePtr)
gdImageCreateFromGd2PartCtx(gdIOCtxPtr in, int srcx, int srcy, int w, int h);
 
BGD_DECLARE(gdImagePtr)
gdImageCreateFromGd2PartPtr(int size, void *data, int srcx, int srcy, int w, int h);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromXbm(FILE *in);
 
BGD_DECLARE(void)
gdImageXbmCtx(gdImagePtr image, char *file_name, int fg, gdIOCtxPtr out);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromXpm(char *filename);
 
BGD_DECLARE(void) gdImageWBMP(gdImagePtr image, int fg, FILE *out);
 
BGD_DECLARE(void) gdImageWBMPCtx(gdImagePtr image, int fg, gdIOCtxPtr out);
 
BGD_DECLARE(int) gdUhdrIsAvailable(void);
 
BGD_DECLARE(int) gdUhdrImageWidth(gdUhdrImagePtr im);
 
BGD_DECLARE(int) gdUhdrImageHeight(gdUhdrImagePtr im);
 
BGD_DECLARE(int) gdUhdrImageHasGainMap(gdUhdrImagePtr im);
 
BGD_DECLARE(int)
gdUhdrImageResize(gdUhdrImagePtr im, int width, int height, gdUhdrErrorPtr err);
 
BGD_DECLARE(int)
gdUhdrImageCrop(gdUhdrImagePtr im, int left, int top, int width, int height, gdUhdrErrorPtr err);
 
BGD_DECLARE(int)
gdUhdrImageRotate(gdUhdrImagePtr im, int degrees, gdUhdrErrorPtr err);
 
BGD_DECLARE(int)
gdUhdrImageMirror(gdUhdrImagePtr im, int axis, gdUhdrErrorPtr err);
 
BGD_DECLARE(int)
gdUhdrImageFile(gdUhdrImagePtr im, const char *filename, int format, int quality,
                gdUhdrErrorPtr err);
 
BGD_DECLARE(int)
gdUhdrImageCtx(gdUhdrImagePtr im, gdIOCtxPtr ctx, int format, int quality, gdUhdrErrorPtr err);
 
BGD_DECLARE(void *)
gdUhdrImageWritePtr(gdUhdrImagePtr im, int *size, int format, int quality, gdUhdrErrorPtr err);
 
BGD_DECLARE(gdImagePtr)
gdUhdrImageGetSdr(gdUhdrImagePtr im, gdUhdrErrorPtr err);
 
BGD_DECLARE(gdImagePtr) gdImageCreateFromFile(const char *filename);
 
BGD_DECLARE(gdImagePtr) gdImageReadFile(const char *filename);
 
BGD_DECLARE(gdImagePtr) gdImageReadCtx(gdIOCtxPtr ctx);
 
typedef enum {
    gdImageReadStatusOk = 0, 
    gdImageReadStatusUnrecognized, 
    gdImageReadStatusUnsupportedFormat, 
    gdImageReadStatusCodecUnavailable, 
    gdImageReadStatusDecodeFailed 
} gdImageReadStatus;
 
#define GD_IMAGE_READ_RESTRICT_CODEC_API 1
 
BGD_DECLARE(gdImagePtr) gdImageReadCtxEx(gdIOCtxPtr ctx, int flags, gdImageReadStatus *status, const char **format_name);
 
BGD_DECLARE(int) gdImageFile(gdImagePtr im, const char *filename);
 
BGD_DECLARE(int) gdSupportsFileType(const char *filename, int writing);
 
/* Guaranteed to correctly free memory returned by the gdImage*Ptr
   functions */
BGD_DECLARE(void) gdFree(void *m);
 
BGD_DECLARE(void *) gdImageWBMPPtr(gdImagePtr im, int *size, int fg);
 
BGD_DECLARE(void) gdImageJpeg(gdImagePtr im, FILE *out, int quality);
BGD_DECLARE(void) gdImageJpegCtx(gdImagePtr im, gdIOCtxPtr out, int quality);
 
BGD_DECLARE(int)
gdImageJpegWithOptions(gdImagePtr im, FILE *out, const gdJpegWriteOptions *options);
 
BGD_DECLARE(int)
gdImageJpegCtxWithOptions(gdImagePtr im, gdIOCtxPtr out, const gdJpegWriteOptions *options);
 
BGD_DECLARE(void *) gdImageJpegPtr(gdImagePtr im, int *size, int quality);
BGD_DECLARE(void *)
gdImageJpegPtrWithOptions(gdImagePtr im, int *size, const gdJpegWriteOptions *options);
#define gdWebpLossless 101
 
BGD_DECLARE(void) gdImageWebpEx(gdImagePtr im, FILE *outFile, int quantization);
 
BGD_DECLARE(void) gdImageWebp(gdImagePtr im, FILE *outFile);
 
BGD_DECLARE(void *) gdImageWebpPtr(gdImagePtr im, int *size);
 
BGD_DECLARE(void *)
gdImageWebpPtrEx(gdImagePtr im, int *size, int quantization);
 
BGD_DECLARE(int)
gdImageWebpWithOptions(gdImagePtr im, FILE *outFile, const gdWebpWriteOptions *options);
 
BGD_DECLARE(int)
gdImageWebpCtxWithOptions(gdImagePtr im, gdIOCtxPtr outfile, const gdWebpWriteOptions *options);
 
BGD_DECLARE(void *)
gdImageWebpPtrWithOptions(gdImagePtr im, int *size, const gdWebpWriteOptions *options);
 
BGD_DECLARE(void)
gdImageWebpCtx(gdImagePtr im, gdIOCtxPtr outfile, int quantization);
 
/*
  Group: Types
 
  typedef: gdSink
 
  typedef: gdSinkPtr
 
        *Note:* This interface is *obsolete* and kept only for
        *compatibility*.  Use <gdIOCtx> instead.
 
        Represents a "sink" (destination) to which a PNG can be
        written. Programmers who do not wish to write PNGs to a file can
        provide their own alternate output mechanism, using the
        <gdImagePngToSink> function. See the documentation of that
        function for an example of the proper use of this type.
 
        > typedef struct {
        >     int (*sink) (void *context, char *buffer, int len);
        >     void *context;
        > } gdSink, *gdSinkPtr;
 
        The _sink_ function must return -1 on error, otherwise the number of
        bytes written, which must be equal to len.
 
        _context_ will be passed to your sink function.
 
*/
 
typedef struct {
    int (*sink)(void *context, const char *buffer, int len);
    void *context;
} gdSink, *gdSinkPtr;
 
BGD_DECLARE(void) gdImagePngToSink(gdImagePtr im, gdSinkPtr out);
BGD_DECLARE(void) gdImageQoiToSink(gdImagePtr im, gdSinkPtr out);
 
BGD_DECLARE(void) gdImageGd2(gdImagePtr im, FILE *out, int cs, int fmt);
 
BGD_DECLARE(void *) gdImageGd2Ptr(gdImagePtr im, int cs, int fmt, int *size);
 
BGD_DECLARE(void) gdImageDestroy(gdImagePtr im);
 
BGD_DECLARE(int) gdImageColorAllocate(gdImagePtr im, int r, int g, int b);
 
BGD_DECLARE(int)
gdImageColorAllocateAlpha(gdImagePtr im, int r, int g, int b, int a);
 
BGD_DECLARE(int) gdImageColorClosest(gdImagePtr im, int r, int g, int b);
 
BGD_DECLARE(int)
gdImageColorClosestAlpha(gdImagePtr im, int r, int g, int b, int a);
 
BGD_DECLARE(int) gdImageColorClosestHWB(gdImagePtr im, int r, int g, int b);
 
BGD_DECLARE(int) gdImageColorExact(gdImagePtr im, int r, int g, int b);
 
BGD_DECLARE(int)
gdImageColorExactAlpha(gdImagePtr im, int r, int g, int b, int a);
 
BGD_DECLARE(int) gdImageColorResolve(gdImagePtr im, int r, int g, int b);
 
BGD_DECLARE(int)
gdImageColorResolveAlpha(gdImagePtr im, int r, int g, int b, int a);
 
#define gdTrueColor(r, g, b) (((r) << 16) + ((g) << 8) + (b))
 
#define gdTrueColorAlpha(r, g, b, a) (((a) << 24) + ((r) << 16) + ((g) << 8) + (b))
 
BGD_DECLARE(void) gdImageColorDeallocate(gdImagePtr im, int color);
 
BGD_DECLARE(int) gdImageColorMatch(gdImagePtr im1, gdImagePtr im2);
 
BGD_DECLARE(void) gdImageColorTransparent(gdImagePtr im, int color);
 
BGD_DECLARE(void) gdImagePaletteCopy(gdImagePtr dst, gdImagePtr src);
 
typedef int (*gdCallbackImageColor)(gdImagePtr im, int src);
 
BGD_DECLARE(int) gdImageColorReplace(gdImagePtr im, int src, int dst);
 
BGD_DECLARE(int)
gdImageColorReplaceThreshold(gdImagePtr im, int src, int dst, float threshold);
 
BGD_DECLARE(int)
gdImageColorReplaceArray(gdImagePtr im, int len, int *src, int *dst);
 
BGD_DECLARE(int)
gdImageColorReplaceCallback(gdImagePtr im, gdCallbackImageColor callback);
 
BGD_DECLARE(void) gdImageSetPixel(gdImagePtr im, int x, int y, int color);
 
BGD_DECLARE(int) gdImageGetPixel(gdImagePtr im, int x, int y);
 
BGD_DECLARE(int) gdImageGetTrueColorPixel(gdImagePtr im, int x, int y);
BGD_DECLARE(void)
gdImageSetResolution(gdImagePtr im, const unsigned int res_x, const unsigned int res_y);
 
BGD_DECLARE(gdFontPtr) gdFontGetGiant(void);
BGD_DECLARE(gdFontPtr) gdFontGetLarge(void);
BGD_DECLARE(gdFontPtr) gdFontGetMediumBold(void);
BGD_DECLARE(gdFontPtr) gdFontGetSmall(void);
BGD_DECLARE(gdFontPtr) gdFontGetTiny(void);
BGD_DECLARE(void) gdImageChar(gdImagePtr im, gdFontPtr f, int x, int y, int c, int color);
 
BGD_DECLARE(void) gdImageCharUp(gdImagePtr im, gdFontPtr f, int x, int y, int c, int color);
 
BGD_DECLARE(void)
gdImageString(gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color);
 
BGD_DECLARE(void)
gdImageStringUp(gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color);
 
BGD_DECLARE(void)
gdImageString16(gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color);
 
BGD_DECLARE(void)
gdImageStringUp16(gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color);
BGD_DECLARE(int) gdFontCacheSetup(void);
 
BGD_DECLARE(void) gdFontCacheShutdown(void);
 
BGD_DECLARE(void) gdFreeFontCache(void);
 
 
BGD_DECLARE(char *)
gdImageStringTTF(gdImagePtr im, int *brect, int fg, const char *fontlist, double ptsize,
                 double angle, int x, int y, const char *string);
 
 
BGD_DECLARE(char *)
gdImageStringFT(gdImagePtr im, int *brect, int fg, const char *fontlist, double ptsize,
                double angle, int x, int y, const char *string);
 
/* 2.0.5: provides an extensible way to pass additional parameters.
   Thanks to Wez Furlong, sorry for the delay. */
typedef struct {
    int flags; 
    double linespacing; 
    int charmap; 
    int hdpi; 
    int vdpi; 
    char *xshow; 
    char *fontpath; 
} gdFTStringExtra, *gdFTStringExtraPtr;
 
#define gdFTEX_LINESPACE 1 
#define gdFTEX_CHARMAP 2 
#define gdFTEX_RESOLUTION 4 
#define gdFTEX_DISABLE_KERNING 8 
#define gdFTEX_XSHOW 16 
#define gdFTEX_FONTPATHNAME 32 
#define gdFTEX_FONTCONFIG 64 
#define gdFTEX_RETURNFONTPATHNAME 128 
BGD_DECLARE(int) gdFTUseFontConfig(int flag);
 
#define gdFTEX_Unicode 0 
#define gdFTEX_Shift_JIS 1 
#define gdFTEX_Big5 2 
#define gdFTEX_Adobe_Custom 3 
#define gdFTEX_MacRoman gdFTEX_Adobe_Custom 
BGD_DECLARE(char *)
gdImageStringFTEx(gdImagePtr im, int *brect, int fg, const char *fontlist, double ptsize,
                  double angle, int x, int y, const char *string, gdFTStringExtraPtr strex);
 
typedef struct {
    int x, y; 
} gdPoint, *gdPointPtr; 
typedef struct {
    int x, y; 
    int width, height; 
} gdRect, *gdRectPtr; 
#define gdArc 0 
#define gdPie gdArc 
#define gdChord 1 
#define gdNoFill 2 
#define gdEdged 4 
BGD_DECLARE(void) gdImagePolygon(gdImagePtr im, gdPointPtr p, int n, int c);
 
BGD_DECLARE(void) gdImageOpenPolygon(gdImagePtr im, gdPointPtr p, int n, int c);
 
 
BGD_DECLARE(void)
gdImageFilledPolygon(gdImagePtr im, gdPointPtr p, int n, int c);
 
BGD_DECLARE(void)
gdImageFilledArc(gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color, int style);
 
BGD_DECLARE(void)
gdImageArc(gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color);
 
BGD_DECLARE(void)
gdImageEllipse(gdImagePtr im, int cx, int cy, int w, int h, int color);
 
BGD_DECLARE(void)
gdImageFilledEllipse(gdImagePtr im, int cx, int cy, int w, int h, int color);
 
BGD_DECLARE(void) gdImageAABlend(gdImagePtr im);
 
BGD_DECLARE(void) gdImageLine(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
 
/* For backwards compatibility only. Use gdImageSetStyle()
   for much more flexible line drawing. */
BGD_DECLARE(void) gdImageDashedLine(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
 
BGD_DECLARE(void) gdImageRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
 
BGD_DECLARE(void) gdImageFilledRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
 
BGD_DECLARE(void) gdImageSetClip(gdImagePtr im, int x1, int y1, int x2, int y2);
 
BGD_DECLARE(void) gdImageGetClip(gdImagePtr im, int *x1P, int *y1P, int *x2P, int *y2P);
 
BGD_DECLARE(void) gdImageSetBrush(gdImagePtr im, gdImagePtr brush);
 
BGD_DECLARE(void) gdImageSetTile(gdImagePtr im, gdImagePtr tile);
 
 
BGD_DECLARE(void) gdImageSetAntiAliased(gdImagePtr im, int c);
 
BGD_DECLARE(void) gdImageSetAntiAliasedDontBlend(gdImagePtr im, int c, int dont_blend);
 
BGD_DECLARE(void) gdImageSetStyle(gdImagePtr im, int *style, int noOfPixels);
 
 
BGD_DECLARE(void) gdImageSetThickness(gdImagePtr im, int thickness);
 
 
BGD_DECLARE(void)
gdImageFillToBorder(gdImagePtr im, int x, int y, int border, int color);
 
BGD_DECLARE(void) gdImageFill(gdImagePtr im, int x, int y, int color);
 
 
BGD_DECLARE(void)
gdImageCopy(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h);
 
BGD_DECLARE(void)
gdImageCopyMerge(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w,
                 int h, int pct);
 
 
BGD_DECLARE(void)
gdImageCopyMergeGray(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w,
                     int h, int pct);
 
 
BGD_DECLARE(void)
gdImageCopyResized(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW,
                   int dstH, int srcW, int srcH);
 
BGD_DECLARE(void)
gdImageCopyResampled(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY,
                     int dstW, int dstH, int srcW, int srcH);
 
BGD_DECLARE(void)
gdImageCopyRotated(gdImagePtr dst, gdImagePtr src, double dstX, double dstY, int srcX, int srcY,
                   int srcWidth, int srcHeight, int angle);
 
BGD_DECLARE(gdImagePtr) gdImageClone(gdImagePtr src);
 
BGD_DECLARE(void) gdImageInterlace(gdImagePtr im, int interlaceArg);
 
BGD_DECLARE(void) gdImageAlphaBlending(gdImagePtr im, int alphaBlendingArg);
 
BGD_DECLARE(void) gdImageSaveAlpha(gdImagePtr im, int saveAlphaArg);
 
enum gdPaletteQuantizationMethod {
    GD_QUANT_DEFAULT = 0, 
    GD_QUANT_JQUANT = 1, 
    GD_QUANT_NEUQUANT = 2, 
    GD_QUANT_LIQ = 3 
};
 
 
BGD_DECLARE(gdImagePtr)
gdImageNeuQuant(gdImagePtr im, const int max_color, int sample_factor);
 
 
BGD_DECLARE(int)
gdImageTrueColorToPaletteSetMethod(gdImagePtr im, int method, int speed);
 
BGD_DECLARE(void)
gdImageTrueColorToPaletteSetQuality(gdImagePtr im, int min_quality, int max_quality);
 
 
BGD_DECLARE(gdImagePtr)
gdImageCreatePaletteFromTrueColor(gdImagePtr im, int ditherFlag, int colorsWanted);
 
 
BGD_DECLARE(int)
gdImageTrueColorToPalette(gdImagePtr im, int ditherFlag, int colorsWanted);
 
BGD_DECLARE(int) gdImagePaletteToTrueColor(gdImagePtr src);
 
enum gdPixelateMode { 
    GD_PIXELATE_UPPERLEFT, 
    GD_PIXELATE_AVERAGE 
};
 
BGD_DECLARE(int)
gdImagePixelate(gdImagePtr im, int block_size, const unsigned int mode);
 
typedef struct {
    int sub; 
    int plus; 
    unsigned int num_colors; 
    int *colors; 
    unsigned int seed; 
} gdScatter, *gdScatterPtr;
 
BGD_DECLARE(int) gdImageScatter(gdImagePtr im, int sub, int plus);
 
BGD_DECLARE(int) gdImageScatterColor(gdImagePtr im, int sub, int plus, int colors[], unsigned int num_colors);
 
BGD_DECLARE(int) gdImageScatterEx(gdImagePtr im, gdScatterPtr s);
 
 BGD_DECLARE(int) gdImageSmooth(gdImagePtr im, float weight);
 
 BGD_DECLARE(int) gdImageMeanRemoval(gdImagePtr im);
 
BGD_DECLARE(int) gdImageEmboss(gdImagePtr im);
 
BGD_DECLARE(int) gdImageGaussianBlur(gdImagePtr im);
 
BGD_DECLARE(int) gdImageEdgeDetectQuick(gdImagePtr src);
 
BGD_DECLARE(int) gdImageSelectiveBlur(gdImagePtr src);
 
BGD_DECLARE(int)
gdImageConvolution(gdImagePtr src, float filter[3][3], float filter_div, float offset);
 
BGD_DECLARE(int)
gdImageColor(gdImagePtr src, const int red, const int green, const int blue, const int alpha);
 
BGD_DECLARE(int) gdImageContrast(gdImagePtr src, double contrast);
 
BGD_DECLARE(int) gdImageBrightness(gdImagePtr src, int brightness);
 
 
BGD_DECLARE(int) gdImageGrayScale(gdImagePtr src);
 
BGD_DECLARE(int) gdImageNegate(gdImagePtr src);
 
BGD_DECLARE(gdImagePtr)
gdImageCopyGaussianBlurred(gdImagePtr src, int radius, double sigma);
#define gdImageTrueColor(im) ((im)->trueColor)
 
#define gdImageSX(im) ((im)->sx)
 
#define gdImageSY(im) ((im)->sy)
 
#define gdImageColorsTotal(im) ((im)->colorsTotal)
 
#define gdImageRed(im, c) ((im)->trueColor ? gdTrueColorGetRed(c) : (im)->red[(c)])
 
#define gdImageGreen(im, c) ((im)->trueColor ? gdTrueColorGetGreen(c) : (im)->green[(c)])
 
#define gdImageBlue(im, c) ((im)->trueColor ? gdTrueColorGetBlue(c) : (im)->blue[(c)])
 
#define gdImageAlpha(im, c) ((im)->trueColor ? gdTrueColorGetAlpha(c) : (im)->alpha[(c)])
 
#define gdImageGetTransparent(im) ((im)->transparent)
 
#define gdImageGetInterlaced(im) ((im)->interlace)
 
#define gdImagePalettePixel(im, x, y) (im)->pixels[(y)][(x)]
 
#define gdImageTrueColorPixel(im, x, y) (im)->tpixels[(y)][(x)]
 
#define gdImageResolutionX(im) (im)->res_x
 
#define gdImageResolutionY(im) (im)->res_y
 
/* I/O Support routines. */
BGD_DECLARE(gdIOCtxPtr) gdNewFileCtx(FILE *);
 
BGD_DECLARE(gdIOCtxPtr) gdNewDynamicCtx(int size, void *data);
 
BGD_DECLARE(gdIOCtxPtr) gdNewDynamicCtxEx(int size, void *data, int freeFlag);
 
BGD_DECLARE(gdIOCtxPtr) gdNewSSCtx(gdSourcePtr in, gdSinkPtr out);
BGD_DECLARE(void *) gdDPExtractData(gdIOCtxPtr ctx, int *size);
#define GD2_CHUNKSIZE 128
#define GD2_CHUNKSIZE_MIN 64
#define GD2_CHUNKSIZE_MAX 4096
 
#define GD2_VERS 2
#define GD2_ID "gd2"
#define GD2_FMT_RAW 1
#define GD2_FMT_COMPRESSED 2
 
#define GD_CMP_IMAGE 1 
#define GD_CMP_NUM_COLORS 2 
#define GD_CMP_COLOR 4 
#define GD_CMP_SIZE_X 8 
#define GD_CMP_SIZE_Y 16 
#define GD_CMP_TRANSPARENT 32 
#define GD_CMP_BACKGROUND 64 
#define GD_CMP_INTERLACE 128 
#define GD_CMP_TRUECOLOR 256 
BGD_DECLARE(int) gdImageCompare(gdImagePtr im1, gdImagePtr im2);
 
typedef enum {
    GD_IMAGE_DIFF_NONE, 
    GD_IMAGE_DIFF_OVERLAY, 
    GD_IMAGE_DIFF_MASK 
} gdImageDiffMode;
 
typedef struct {
    gdImageDiffMode mode; 
    int highlight_color; 
} gdImagePerceptualDiffOptions;
 
typedef struct {
    unsigned int pixels_changed; 
    /* Largest normalized perceptual distance, in the range 0.0 to 1.0. */
    double maximum_delta; 
} gdImagePerceptualDiffResult;
 
/*
 * Compare two equally sized images using a perceptual YIQ distance.
 *
 * A NULL options pointer selects an overlay with opaque red highlights. A
 * non-NULL diff_image receives a newly allocated truecolor image for overlay
 * and mask modes; the caller owns it and must call @ref gdImageDestroy. Passing
 * NULL for diff_image computes statistics only. The result is always reset,
 * including on failure.
 *
 * Returns 1 on success, or 0 for invalid arguments or allocation failure.
 */
BGD_DECLARE(int)
gdImagePerceptualDiff(gdImagePtr image1, gdImagePtr image2, double threshold,
                      const gdImagePerceptualDiffOptions *options,
                      gdImagePtr *diff_image,
                      gdImagePerceptualDiffResult *result);
BGD_DECLARE(void) gdImageFlipHorizontal(gdImagePtr im);
 
BGD_DECLARE(void) gdImageFlipVertical(gdImagePtr im);
 
BGD_DECLARE(void) gdImageFlipBoth(gdImagePtr im);
 
enum gdCropMode {
    GD_CROP_DEFAULT = 0, 
    GD_CROP_TRANSPARENT, 
    GD_CROP_BLACK, 
    GD_CROP_WHITE, 
    GD_CROP_SIDES, 
    GD_CROP_THRESHOLD 
};
 
BGD_DECLARE(gdImagePtr) gdImageCrop(gdImagePtr src, const gdRect *crop);
 
 
BGD_DECLARE(gdImagePtr) gdImageCropAuto(gdImagePtr im, const unsigned int mode);
 
 
BGD_DECLARE(gdImagePtr)
gdImageCropThreshold(gdImagePtr im, const unsigned int color, const float threshold);
 
typedef struct {
    enum gdCropMode mode; 
    float threshold; 
    int color; 
} gdAutoCropOptions;
 
BGD_DECLARE(gdImagePtr)
gdImageAutoCropWithOptions(gdImagePtr src, const gdAutoCropOptions *options);
 
BGD_DECLARE(int)
gdImageSetInterpolationMethod(gdImagePtr im, gdInterpolationMethod id);
 
BGD_DECLARE(gdInterpolationMethod) gdImageGetInterpolationMethod(gdImagePtr im);
 
BGD_DECLARE(gdImagePtr)
gdImageScale(const gdImagePtr src, const unsigned int new_width, const unsigned int new_height);
 
typedef enum {
    GD_SCALE_FIT_COVER,   
    GD_SCALE_FIT_CONTAIN, 
    GD_SCALE_FIT_FILL,    
    GD_SCALE_FIT_INSIDE,  
    GD_SCALE_FIT_OUTSIDE  
} gdScaleFit;
 
typedef enum {
 
    GD_SCALE_GRAVITY_NORTHWEST, 
    GD_SCALE_GRAVITY_NORTH,     
    GD_SCALE_GRAVITY_NORTHEAST, 
    GD_SCALE_GRAVITY_WEST,      
    GD_SCALE_GRAVITY_CENTER,    
    GD_SCALE_GRAVITY_EAST,      
    GD_SCALE_GRAVITY_SOUTHWEST, 
    GD_SCALE_GRAVITY_SOUTH,     
    GD_SCALE_GRAVITY_SOUTHEAST  
} gdScaleGravity;
 
typedef enum {
    GD_SCALE_STRATEGY_NONE,      
    GD_SCALE_STRATEGY_ENTROPY,   
    GD_SCALE_STRATEGY_ATTENTION  
} gdScaleStrategy;
 
typedef struct {
    gdScaleFit fit;            
    gdScaleGravity gravity;    
    gdScaleStrategy strategy;  
    int background_color;      
    int interpolation;         
} gdScaleOptions;
 
BGD_DECLARE(gdImagePtr)
gdImageScaleWithOptions(const gdImagePtr src, const unsigned int new_width,
                        const unsigned int new_height, const gdScaleOptions *options);
 
typedef enum {
    GD_INTERESTING_ENTROPY,    
    GD_INTERESTING_ATTENTION   
} gdInterestingMethod;
 
BGD_DECLARE(int)
gdImageInterestingCropRegion(const gdImagePtr src, unsigned int target_width,
                             unsigned int target_height, gdInterestingMethod method,
                             gdRectPtr crop);
 
BGD_DECLARE(int)
gdImageEntropyCropRegion(const gdImagePtr src, unsigned int target_width,
                         unsigned int target_height, gdRectPtr crop);
 
BGD_DECLARE(gdImagePtr)
gdImageRotateInterpolated(const gdImagePtr src, const float angle, int bgcolor);
 
typedef enum {
    GD_AFFINE_TRANSLATE = 0,   
    GD_AFFINE_SCALE,           
    GD_AFFINE_ROTATE,          
    GD_AFFINE_SHEAR_HORIZONTAL,
    GD_AFFINE_SHEAR_VERTICAL   
} gdAffineStandardMatrix;
 
BGD_DECLARE(int)
gdAffineApplyToPointF(gdPointFPtr dst, const gdPointFPtr src, const double affine[6]);
 
BGD_DECLARE(int) gdAffineInvert(double dst[6], const double src[6]);
 
BGD_DECLARE(int)
gdAffineFlip(double dst_affine[6], const double src_affine[6], const int flip_h, const int flip_v);
 
BGD_DECLARE(int)
gdAffineConcat(double dst[6], const double m1[6], const double m2[6]);
 
BGD_DECLARE(int) gdAffineIdentity(double dst[6]);
 
BGD_DECLARE(int)
gdAffineScale(double dst[6], const double scale_x, const double scale_y);
 
BGD_DECLARE(int) gdAffineRotate(double dst[6], const double angle);
 
BGD_DECLARE(int) gdAffineShearHorizontal(double dst[6], const double angle);
 
BGD_DECLARE(int) gdAffineShearVertical(double dst[6], const double angle);
 
BGD_DECLARE(int)
gdAffineTranslate(double dst[6], const double offset_x, const double offset_y);
 
BGD_DECLARE(double) gdAffineExpansion(const double src[6]);
 
BGD_DECLARE(int) gdAffineRectilinear(const double src[6]);
 
BGD_DECLARE(int)
gdAffineEqual(const double matrix1[6], const double matrix2[6]);
 
BGD_DECLARE(int)
gdTransformAffineGetImage(gdImagePtr *dst, const gdImagePtr src, gdRectPtr src_area,
                          const double affine[6]);
 
BGD_DECLARE(int)
gdTransformAffineCopy(gdImagePtr dst, int dst_x, int dst_y, const gdImagePtr src,
                      gdRectPtr src_region, const double affine[6]);
/*
gdTransformAffineCopy(gdImagePtr dst, int x0, int y0, int x1, int y1,
                          const gdImagePtr src, int src_width, int src_height,
                          const double affine[6]);
*/
BGD_DECLARE(int)
gdTransformAffineBoundingBox(gdRectPtr src, const double affine[6], gdRectPtr bbox);
 
/* resolution affects ttf font rendering, particularly hinting */
#define GD_RESOLUTION 96 /* pixels per inch */
 
/* Version information functions */
BGD_DECLARE(int) gdMajorVersion(void);
BGD_DECLARE(int) gdMinorVersion(void);
BGD_DECLARE(int) gdReleaseVersion(void);
BGD_DECLARE(const char *) gdExtraVersion(void);
BGD_DECLARE(const char *) gdVersionString(void);
 
/* newfangled special effects */
#include "gdfx.h"
 
#ifdef __cplusplus
}
#endif
 
#endif /* GD_H */