#ifdef __cplusplus

extern "C" {

#endif

#include <stdlib.h>

#ifndef GD_H

#define GD_H 1

/* 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    2           /*version605b5d1778*/

#define GD_RELEASE_VERSION  5           /*version605b5d1778*/

#define GD_EXTRA_VERSION    ""          /*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

#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

#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, snprintf, 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 

#if _MSC_VER < 1900

     extern int snprintf(char*, size_t, const char*, ...);

#endif

#endif 

#ifdef __cplusplus

	extern "C"

	{

#endif

/* 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 <stdio.h>

#include <stdarg.h>

#include "gd_io.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 repsented 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

/**

 * Group: Color Decomposition

 */

/**

 * Macro: gdTrueColorGetAlpha

 *

 * Gets the alpha channel value

 *

 * Parameters:

 *   c - The color

 *

 * See also:

 *   - <gdTrueColorAlpha>

 */

#define gdTrueColorGetAlpha(c) (((c) & 0x7F000000) >> 24)

/**

 * Macro: gdTrueColorGetRed

 *

 * Gets the red channel value

 *

 * Parameters:

 *   c - The color

 *

 * See also:

 *   - <gdTrueColorAlpha>

 */

#define gdTrueColorGetRed(c) (((c) & 0xFF0000) >> 16)

/**

 * Macro: gdTrueColorGetGreen

 *

 * Gets the green channel value

 *

 * Parameters:

 *   c - The color

 *

 * See also:

 *   - <gdTrueColorAlpha>

 */

#define gdTrueColorGetGreen(c) (((c) & 0x00FF00) >> 8)

/**

 * Macro: gdTrueColorGetBlue

 *

 * Gets the blue channel value

 *

 * Parameters:

 *   c - The color

 *

 * See also:

 *   - <gdTrueColorAlpha>

 */

#define gdTrueColorGetBlue(c) ((c) & 0x0000FF)

/**

 * Group: Effects

 *

 * The layering effect

 * 

 * When pixels are drawn the new colors are "mixed" with the background

 * depending on the effect.

 *

 * Note that the effect does not apply to palette images, where pixels

 * are always replaced.

 *

 * Modes:

 *   gdEffectReplace    - replace pixels

 *   gdEffectAlphaBlend - blend pixels, see <gdAlphaBlend>

 *   gdEffectNormal     - default mode; same as gdEffectAlphaBlend

 *   gdEffectOverlay    - overlay pixels, see <gdLayerOverlay>

 *   gdEffectMultiply   - overlay pixels with multiply effect, see

 *                        <gdLayerMultiply>

 *

 * See also:

 *   - <gdImageAlphaBlending>

 */

#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);

/**

 * Group: Color Quantization

 *

 * Enum: gdPaletteQuantizationMethod

 *

 * Constants:

 *   GD_QUANT_DEFAULT  - GD_QUANT_LIQ if libimagequant is available,

 *                       GD_QUANT_JQUANT otherwise.

 *   GD_QUANT_JQUANT   - libjpeg's old median cut. Fast, but only uses 16-bit

 *                       color.

 *   GD_QUANT_NEUQUANT - NeuQuant - approximation using Kohonen neural network.

 *   GD_QUANT_LIQ      - A combination of algorithms used in libimagequant

 *                       aiming for the highest quality at cost of speed.

 *

 * Note that GD_QUANT_JQUANT does not retain the alpha channel, and

 * GD_QUANT_NEUQUANT does not support dithering.

 *

 * See also:

 *   - <gdImageTrueColorToPaletteSetMethod>

 */

enum gdPaletteQuantizationMethod {

	GD_QUANT_DEFAULT = 0,

	GD_QUANT_JQUANT = 1,

	GD_QUANT_NEUQUANT = 2,

	GD_QUANT_LIQ = 3

};

/**

 * Group: Transform

 *

 * Constants: gdInterpolationMethod

 *

 *  GD_BELL				 - Bell

 *  GD_BESSEL			 - Bessel

 *  GD_BILINEAR_FIXED 	 - fixed point bilinear 

 *  GD_BICUBIC 			 - Bicubic

 *  GD_BICUBIC_FIXED 	 - fixed point bicubic integer

 *  GD_BLACKMAN			 - Blackman

 *  GD_BOX				 - Box

 *  GD_BSPLINE			 - BSpline

 *  GD_CATMULLROM		 - Catmullrom

 *  GD_GAUSSIAN			 - Gaussian

 *  GD_GENERALIZED_CUBIC - Generalized cubic

 *  GD_HERMITE			 - Hermite

 *  GD_HAMMING			 - Hamming

 *  GD_HANNING			 - Hannig

 *  GD_MITCHELL			 - Mitchell

 *  GD_NEAREST_NEIGHBOUR - Nearest neighbour interpolation

 *  GD_POWER			 - Power

 *  GD_QUADRATIC		 - Quadratic

 *  GD_SINC				 - Sinc

 *  GD_TRIANGLE			 - Triangle

 *  GD_WEIGHTED4		 - 4 pixels weighted bilinear interpolation

 *  GD_LINEAR            - bilinear interpolation

 *

 * See also:

 *  - <gdImageSetInterpolationMethod>

 *  - <gdImageGetInterpolationMethod>

 */

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_METHOD_COUNT = 23

} gdInterpolationMethod;

/* define struct with name and func ptr and add it to gdImageStruct gdInterpolationMethod interpolation; */

/* Interpolation function ptr */

typedef double (* interpolation_method )(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 ofthe struct but we are attempting to move away from

   this practice so the fields are no longer documented here.  If you

   need to poke at the internals of this struct, feel free to look at

   *gd.h*.)

*/

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;

/* Point type for use in polygon drawing. */

/**

 * Group: Types

 *

 * typedef: gdPointF

 *  Defines a point in a 2D coordinate system using floating point

 *  values.

 * x - Floating point position (increase from left to right)

 * y - Floating point Row position (increase from top to bottom)

 *

 * typedef: gdPointFPtr

 *  Pointer to a <gdPointF>

 *

 * See also:

 *  <gdImageCreate>, <gdImageCreateTrueColor>,

 **/

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

/**

 * Group: Colors

 *

 * Colors are always of type int which is supposed to be at least 32 bit large.

 *

 * Kinds of colors:

 *   true colors     - ARGB values where the alpha channel is stored as most

 *                     significant, and the blue channel as least significant

 *                     byte. Note that the alpha channel only uses the 7 least

 *                     significant bits.

 *                     Don't rely on the internal representation, though, and

 *                     use <gdTrueColorAlpha> to compose a truecolor value, and

 *                     <gdTrueColorGetAlpha>, <gdTrueColorGetRed>,

 *                     <gdTrueColorGetGreen> and <gdTrueColorGetBlue> to access

 *                     the respective channels.

 *   palette indexes - The index of a color palette entry (0-255).

 *   special colors  - As listed in the following section.

 *

 * Constants: Special Colors

 *   gdStyled        - use the current style, see <gdImageSetStyle>

 *   gdBrushed       - use the current brush, see <gdImageSetBrush>

 *   gdStyledBrushed - use the current style and brush

 *   gdTiled         - use the current tile, see <gdImageSetTile>

 *   gdTransparent   - indicate transparency, what is not the same as the

 *                     transparent color index; used for lines only

 *   gdAntiAliased   - draw anti aliased

 */

#define gdStyled (-2)

#define gdBrushed (-3)

#define gdStyledBrushed (-4)

#define gdTiled (-5)

#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);

/* These read the first frame only */

BGD_DECLARE(gdImagePtr) gdImageCreateFromGif (FILE * fd);

BGD_DECLARE(gdImagePtr) gdImageCreateFromGifCtx (gdIOCtxPtr in);

BGD_DECLARE(gdImagePtr) gdImageCreateFromGifPtr (int size, void *data);

BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMP (FILE * inFile);

BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPCtx (gdIOCtx * infile);

BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPPtr (int size, void *data);

BGD_DECLARE(gdImagePtr) gdImageCreateFromJpeg (FILE * infile);

BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegEx (FILE * infile, int ignore_warning);

BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtx (gdIOCtx * infile);

BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtxEx (gdIOCtx * infile, int ignore_warning);

BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegPtr (int size, void *data);

BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegPtrEx (int size, void *data, int ignore_warning);

BGD_DECLARE(gdImagePtr) gdImageCreateFromWebp (FILE * inFile);

BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpPtr (int size, void *data);

BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpCtx (gdIOCtx * infile);

BGD_DECLARE(gdImagePtr) gdImageCreateFromTiff(FILE *inFile);

BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffCtx(gdIOCtx *infile);

BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffPtr(int size, void *data);

BGD_DECLARE(gdImagePtr) gdImageCreateFromTga( FILE * fp );

BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaCtx(gdIOCtx* 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);

BGD_DECLARE(gdImagePtr) gdImageCreateFromFile(const char *filename);

/*

  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 <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;

/* Deprecated in favor of gdImageCreateFromPngCtx */

BGD_DECLARE(gdImagePtr) gdImageCreateFromPngSource (gdSourcePtr in);

BGD_DECLARE(gdImagePtr) gdImageCreateFromGd (FILE * in);

BGD_DECLARE(gdImagePtr) gdImageCreateFromGdCtx (gdIOCtxPtr in);

BGD_DECLARE(gdImagePtr) gdImageCreateFromGdPtr (int size, void *data);

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);

/* 2.0.10: prototype was missing */

BGD_DECLARE(gdImagePtr) gdImageCreateFromXbm (FILE * in);

BGD_DECLARE(void) gdImageXbmCtx(gdImagePtr image, char* file_name, int fg, gdIOCtx * out);

/* NOTE: filename, not FILE */

BGD_DECLARE(gdImagePtr) gdImageCreateFromXpm (char *filename);

BGD_DECLARE(void) gdImageDestroy (gdImagePtr im);

/* Replaces or blends with the background depending on the

   most recent call to gdImageAlphaBlending and the

   alpha channel value of 'color'; default is to overwrite.

   Tiling and line styling are also implemented

   here. All other gd drawing functions pass through this call,

   allowing for many useful effects. 

   Overlay and multiply effects are used when gdImageAlphaBlending

   is passed gdEffectOverlay and gdEffectMultiply */

BGD_DECLARE(void) gdImageSetPixel (gdImagePtr im, int x, int y, int color);

/* FreeType 2 text output with hook to extra flags */

BGD_DECLARE(int) gdImageGetPixel (gdImagePtr im, int x, int y);

BGD_DECLARE(int) gdImageGetTrueColorPixel (gdImagePtr im, int x, int y);

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);

/* Corners specified (not width and height). Upper left first, lower right

   second. */

BGD_DECLARE(void) gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2,

                                    int color);

/* Solid bar. Upper left corner first, lower right corner second. */

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) gdImageSetResolution(gdImagePtr im, const unsigned int res_x, const unsigned int res_y);

BGD_DECLARE(int) gdImageBoundsSafe (gdImagePtr im, int x, int y);

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);

/* 2.0.16: for thread-safe use of gdImageStringFT and friends,

   call this before allowing any thread to call gdImageStringFT.

   Otherwise it is invoked by the first thread to invoke

   gdImageStringFT, with a very small but real risk of a race condition.

   Return 0 on success, nonzero on failure to initialize freetype. */

BGD_DECLARE(int) gdFontCacheSetup (void);

/* Optional: clean up after application is done using fonts in

   gdImageStringFT(). */

BGD_DECLARE(void) gdFontCacheShutdown (void);

/* 2.0.20: for backwards compatibility. A few applications did start calling

   this function when it first appeared although it was never documented.

   Simply invokes gdFontCacheShutdown. */

BGD_DECLARE(void) gdFreeFontCache (void);

/* Calls gdImageStringFT. Provided for backwards compatibility only. */

BGD_DECLARE(char *) gdImageStringTTF (gdImage * im, int *brect, int fg, char *fontlist,

                                      double ptsize, double angle, int x, int y,

                                      char *string);

/* FreeType 2 text output */

BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist,

                                     double ptsize, double angle, int x, int y,

                                     char *string);

/*

  Group: Types

  typedef: gdFTStringExtra

  typedef: gdFTStringExtraPtr

  A structure and associated pointer type used to pass additional

  parameters to the <gdImageStringFTEx> function. See

  <gdImageStringFTEx> for the structure definition.

  Thanks to Wez Furlong.

*/

/* 2.0.5: provides an extensible way to pass additional parameters.

   Thanks to Wez Furlong, sorry for the delay. */

typedef struct {

	int flags;		/* Logical OR of gdFTEX_ values */

	double linespacing;	/* fine tune line spacing for '\n' */

	int charmap;		/* TBB: 2.0.12: may be gdFTEX_Unicode,

				   gdFTEX_Shift_JIS, gdFTEX_Big5,

				   or gdFTEX_Adobe_Custom;

				   when not specified, maps are searched

				   for in the above order. */

	int hdpi;                /* if (flags & gdFTEX_RESOLUTION) */

	int vdpi;		 /* if (flags & gdFTEX_RESOLUTION) */

	char *xshow;             /* if (flags & gdFTEX_XSHOW)

				    then, on return, xshow is a malloc'ed

				    string containing xshow position data for

				    the last string.

				    NB. The caller is responsible for gdFree'ing

				    the xshow string.

				 */

	char *fontpath;	         /* if (flags & gdFTEX_RETURNFONTPATHNAME)

				    then, on return, fontpath is a malloc'ed

				    string containing the actual font file path name

				    used, which can be interesting when fontconfig

				    is in use.

				    The caller is responsible for gdFree'ing the

				    fontpath string.

				 */

}

gdFTStringExtra, *gdFTStringExtraPtr;

#define gdFTEX_LINESPACE 1

#define gdFTEX_CHARMAP 2

#define gdFTEX_RESOLUTION 4

#define gdFTEX_DISABLE_KERNING 8

#define gdFTEX_XSHOW 16

/* The default unless gdFTUseFontConfig(1); has been called:

   fontlist is a full or partial font file pathname or list thereof

   (i.e. just like before 2.0.29) */

#define gdFTEX_FONTPATHNAME 32

/* Necessary to use fontconfig patterns instead of font pathnames

   as the fontlist argument, unless gdFTUseFontConfig(1); has

   been called. New in 2.0.29 */

#define gdFTEX_FONTCONFIG 64

/* Sometimes interesting when fontconfig is used: the fontpath

   element of the structure above will contain a gdMalloc'd string

   copy of the actual font file pathname used, if this flag is set

   when the call is made */

#define gdFTEX_RETURNFONTPATHNAME 128

/* If flag is nonzero, the fontlist parameter to gdImageStringFT

   and gdImageStringFTEx shall be assumed to be a fontconfig font pattern

   if fontconfig was compiled into gd. This function returns zero

   if fontconfig is not available, nonzero otherwise. */

BGD_DECLARE(int) gdFTUseFontConfig(int flag);

/* These are NOT flags; set one in 'charmap' if you set the

   gdFTEX_CHARMAP bit in 'flags'. */

#define gdFTEX_Unicode 0

#define gdFTEX_Shift_JIS 1

#define gdFTEX_Big5 2

#define gdFTEX_Adobe_Custom 3

BGD_DECLARE(char *) gdImageStringFTEx (gdImage * im, int *brect, int fg, char *fontlist,

                                       double ptsize, double angle, int x, int y,

                                       char *string, gdFTStringExtraPtr strex);

/*

  Group: Types

  typedef: gdPoint

  typedef: gdPointPtr

  Represents a point in the coordinate space of the image; used by

  <gdImagePolygon>, <gdImageOpenPolygon> and <gdImageFilledPolygon>

  for polygon drawing.

  > typedef struct {

  >     int x, y;

  > } gdPoint, *gdPointPtr;

*/