Annotation of embedaddon/php/ext/gd/libgd/gd.h, revision 1.1
1.1 ! misho 1: #ifndef GD_H
! 2: #define GD_H 1
! 3:
! 4: #ifdef __cplusplus
! 5: extern "C" {
! 6: #endif
! 7:
! 8: #ifdef HAVE_CONFIG_H
! 9: #include "config.h"
! 10: #endif
! 11:
! 12: #include "php_compat.h"
! 13:
! 14: #define GD_MAJOR_VERSION 2
! 15: #define GD_MINOR_VERSION 0
! 16: #define GD_RELEASE_VERSION 35
! 17: #define GD_EXTRA_VERSION ""
! 18: #define GD_VERSION_STRING "2.0.35"
! 19:
! 20: #ifdef NETWARE
! 21: /* default fontpath for netware systems */
! 22: #define DEFAULT_FONTPATH "sys:/java/nwgfx/lib/x11/fonts/ttf;."
! 23: #define PATHSEPARATOR ";"
! 24: #elif defined(WIN32)
! 25: /* default fontpath for windows systems */
! 26: #define DEFAULT_FONTPATH "c:\\winnt\\fonts;c:\\windows\\fonts;."
! 27: #define PATHSEPARATOR ";"
! 28: #else
! 29: /* default fontpath for unix systems */
! 30: #define DEFAULT_FONTPATH "/usr/X11R6/lib/X11/fonts/TrueType:/usr/X11R6/lib/X11/fonts/truetype:/usr/X11R6/lib/X11/fonts/TTF:/usr/share/fonts/TrueType:/usr/share/fonts/truetype:/usr/openwin/lib/X11/fonts/TrueType:/usr/X11R6/lib/X11/fonts/Type1:."
! 31: #define PATHSEPARATOR ":"
! 32: #endif
! 33:
! 34: /* gd.h: declarations file for the graphic-draw module.
! 35: * Permission to use, copy, modify, and distribute this software and its
! 36: * documentation for any purpose and without fee is hereby granted, provided
! 37: * that the above copyright notice appear in all copies and that both that
! 38: * copyright notice and this permission notice appear in supporting
! 39: * documentation. This software is provided "AS IS." Thomas Boutell and
! 40: * Boutell.Com, Inc. disclaim all warranties, either express or implied,
! 41: * including but not limited to implied warranties of merchantability and
! 42: * fitness for a particular purpose, with respect to this code and accompanying
! 43: * documentation. */
! 44:
! 45: /* stdio is needed for file I/O. */
! 46: #include <stdio.h>
! 47: #include "gd_io.h"
! 48:
! 49: void php_gd_error_ex(int type, const char *format, ...);
! 50:
! 51: void php_gd_error(const char *format, ...);
! 52:
! 53:
! 54: /* The maximum number of palette entries in palette-based images.
! 55: In the wonderful new world of gd 2.0, you can of course have
! 56: many more colors when using truecolor mode. */
! 57:
! 58: #define gdMaxColors 256
! 59:
! 60: /* Image type. See functions below; you will not need to change
! 61: the elements directly. Use the provided macros to
! 62: access sx, sy, the color table, and colorsTotal for
! 63: read-only purposes. */
! 64:
! 65: /* If 'truecolor' is set true, the image is truecolor;
! 66: pixels are represented by integers, which
! 67: must be 32 bits wide or more.
! 68:
! 69: True colors are repsented as follows:
! 70:
! 71: ARGB
! 72:
! 73: Where 'A' (alpha channel) occupies only the
! 74: LOWER 7 BITS of the MSB. This very small
! 75: loss of alpha channel resolution allows gd 2.x
! 76: to keep backwards compatibility by allowing
! 77: signed integers to be used to represent colors,
! 78: and negative numbers to represent special cases,
! 79: just as in gd 1.x. */
! 80:
! 81: #define gdAlphaMax 127
! 82: #define gdAlphaOpaque 0
! 83: #define gdAlphaTransparent 127
! 84: #define gdRedMax 255
! 85: #define gdGreenMax 255
! 86: #define gdBlueMax 255
! 87: #define gdTrueColorGetAlpha(c) (((c) & 0x7F000000) >> 24)
! 88: #define gdTrueColorGetRed(c) (((c) & 0xFF0000) >> 16)
! 89: #define gdTrueColorGetGreen(c) (((c) & 0x00FF00) >> 8)
! 90: #define gdTrueColorGetBlue(c) ((c) & 0x0000FF)
! 91: #define gdEffectReplace 0
! 92: #define gdEffectAlphaBlend 1
! 93: #define gdEffectNormal 2
! 94: #define gdEffectOverlay 3
! 95:
! 96:
! 97: /* This function accepts truecolor pixel values only. The
! 98: source color is composited with the destination color
! 99: based on the alpha channel value of the source color.
! 100: The resulting color is opaque. */
! 101:
! 102: int gdAlphaBlend(int dest, int src);
! 103:
! 104: typedef struct gdImageStruct {
! 105: /* Palette-based image pixels */
! 106: unsigned char ** pixels;
! 107: int sx;
! 108: int sy;
! 109: /* These are valid in palette images only. See also
! 110: 'alpha', which appears later in the structure to
! 111: preserve binary backwards compatibility */
! 112: int colorsTotal;
! 113: int red[gdMaxColors];
! 114: int green[gdMaxColors];
! 115: int blue[gdMaxColors];
! 116: int open[gdMaxColors];
! 117: /* For backwards compatibility, this is set to the
! 118: first palette entry with 100% transparency,
! 119: and is also set and reset by the
! 120: gdImageColorTransparent function. Newer
! 121: applications can allocate palette entries
! 122: with any desired level of transparency; however,
! 123: bear in mind that many viewers, notably
! 124: many web browsers, fail to implement
! 125: full alpha channel for PNG and provide
! 126: support for full opacity or transparency only. */
! 127: int transparent;
! 128: int *polyInts;
! 129: int polyAllocated;
! 130: struct gdImageStruct *brush;
! 131: struct gdImageStruct *tile;
! 132: int brushColorMap[gdMaxColors];
! 133: int tileColorMap[gdMaxColors];
! 134: int styleLength;
! 135: int stylePos;
! 136: int *style;
! 137: int interlace;
! 138: /* New in 2.0: thickness of line. Initialized to 1. */
! 139: int thick;
! 140: /* New in 2.0: alpha channel for palettes. Note that only
! 141: Macintosh Internet Explorer and (possibly) Netscape 6
! 142: really support multiple levels of transparency in
! 143: palettes, to my knowledge, as of 2/15/01. Most
! 144: common browsers will display 100% opaque and
! 145: 100% transparent correctly, and do something
! 146: unpredictable and/or undesirable for levels
! 147: in between. TBB */
! 148: int alpha[gdMaxColors];
! 149: /* Truecolor flag and pixels. New 2.0 fields appear here at the
! 150: end to minimize breakage of existing object code. */
! 151: int trueColor;
! 152: int ** tpixels;
! 153: /* Should alpha channel be copied, or applied, each time a
! 154: pixel is drawn? This applies to truecolor images only.
! 155: No attempt is made to alpha-blend in palette images,
! 156: even if semitransparent palette entries exist.
! 157: To do that, build your image as a truecolor image,
! 158: then quantize down to 8 bits. */
! 159: int alphaBlendingFlag;
! 160: /* Should antialias functions be used */
! 161: int antialias;
! 162: /* Should the alpha channel of the image be saved? This affects
! 163: PNG at the moment; other future formats may also
! 164: have that capability. JPEG doesn't. */
! 165: int saveAlphaFlag;
! 166:
! 167:
! 168: /* 2.0.12: anti-aliased globals */
! 169: int AA;
! 170: int AA_color;
! 171: int AA_dont_blend;
! 172: unsigned char **AA_opacity;
! 173: int AA_polygon;
! 174: /* Stored and pre-computed variables for determining the perpendicular
! 175: * distance from a point to the anti-aliased line being drawn:
! 176: */
! 177: int AAL_x1;
! 178: int AAL_y1;
! 179: int AAL_x2;
! 180: int AAL_y2;
! 181: int AAL_Bx_Ax;
! 182: int AAL_By_Ay;
! 183: int AAL_LAB_2;
! 184: float AAL_LAB;
! 185:
! 186: /* 2.0.12: simple clipping rectangle. These values must be checked for safety when set; please use gdImageSetClip */
! 187: int cx1;
! 188: int cy1;
! 189: int cx2;
! 190: int cy2;
! 191: } gdImage;
! 192:
! 193: typedef gdImage * gdImagePtr;
! 194:
! 195: typedef struct {
! 196: /* # of characters in font */
! 197: int nchars;
! 198: /* First character is numbered... (usually 32 = space) */
! 199: int offset;
! 200: /* Character width and height */
! 201: int w;
! 202: int h;
! 203: /* Font data; array of characters, one row after another.
! 204: Easily included in code, also easily loaded from
! 205: data files. */
! 206: char *data;
! 207: } gdFont;
! 208:
! 209: /* Text functions take these. */
! 210: typedef gdFont *gdFontPtr;
! 211:
! 212: /* For backwards compatibility only. Use gdImageSetStyle()
! 213: for MUCH more flexible line drawing. Also see
! 214: gdImageSetBrush(). */
! 215: #define gdDashSize 4
! 216:
! 217: /* Special colors. */
! 218:
! 219: #define gdStyled (-2)
! 220: #define gdBrushed (-3)
! 221: #define gdStyledBrushed (-4)
! 222: #define gdTiled (-5)
! 223:
! 224: /* NOT the same as the transparent color index.
! 225: This is used in line styles only. */
! 226: #define gdTransparent (-6)
! 227:
! 228: #define gdAntiAliased (-7)
! 229:
! 230: /* Functions to manipulate images. */
! 231:
! 232: /* Creates a palette-based image (up to 256 colors). */
! 233: gdImagePtr gdImageCreate(int sx, int sy);
! 234:
! 235: /* An alternate name for the above (2.0). */
! 236: #define gdImageCreatePalette gdImageCreate
! 237:
! 238: /* Creates a truecolor image (millions of colors). */
! 239: gdImagePtr gdImageCreateTrueColor(int sx, int sy);
! 240:
! 241: /* Creates an image from various file types. These functions
! 242: return a palette or truecolor image based on the
! 243: nature of the file being loaded. Truecolor PNG
! 244: stays truecolor; palette PNG stays palette-based;
! 245: JPEG is always truecolor. */
! 246: gdImagePtr gdImageCreateFromPng(FILE *fd);
! 247: gdImagePtr gdImageCreateFromPngCtx(gdIOCtxPtr in);
! 248: gdImagePtr gdImageCreateFromWBMP(FILE *inFile);
! 249: gdImagePtr gdImageCreateFromWBMPCtx(gdIOCtx *infile);
! 250: gdImagePtr gdImageCreateFromJpeg(FILE *infile, int ignore_warning);
! 251: gdImagePtr gdImageCreateFromJpegCtx(gdIOCtx *infile, int ignore_warning);
! 252:
! 253: int gdJpegGetVersionInt();
! 254: const char * gdPngGetVersionString();
! 255:
! 256: int gdJpegGetVersionInt();
! 257: const char * gdJpegGetVersionString();
! 258:
! 259: /* A custom data source. */
! 260: /* The source function must return -1 on error, otherwise the number
! 261: of bytes fetched. 0 is EOF, not an error! */
! 262: /* context will be passed to your source function. */
! 263:
! 264: typedef struct {
! 265: int (*source) (void *context, char *buffer, int len);
! 266: void *context;
! 267: } gdSource, *gdSourcePtr;
! 268:
! 269: gdImagePtr gdImageCreateFromPngSource(gdSourcePtr in);
! 270:
! 271: gdImagePtr gdImageCreateFromGd(FILE *in);
! 272: gdImagePtr gdImageCreateFromGdCtx(gdIOCtxPtr in);
! 273:
! 274: gdImagePtr gdImageCreateFromGd2(FILE *in);
! 275: gdImagePtr gdImageCreateFromGd2Ctx(gdIOCtxPtr in);
! 276:
! 277: gdImagePtr gdImageCreateFromGd2Part(FILE *in, int srcx, int srcy, int w, int h);
! 278: gdImagePtr gdImageCreateFromGd2PartCtx(gdIOCtxPtr in, int srcx, int srcy, int w, int h);
! 279:
! 280: gdImagePtr gdImageCreateFromXbm(FILE *fd);
! 281: void gdImageXbmCtx(gdImagePtr image, char* file_name, int fg, gdIOCtx * out);
! 282:
! 283: gdImagePtr gdImageCreateFromXpm (char *filename);
! 284:
! 285: void gdImageDestroy(gdImagePtr im);
! 286:
! 287: /* Replaces or blends with the background depending on the
! 288: most recent call to gdImageAlphaBlending and the
! 289: alpha channel value of 'color'; default is to overwrite.
! 290: Tiling and line styling are also implemented
! 291: here. All other gd drawing functions pass through this call,
! 292: allowing for many useful effects. */
! 293:
! 294: void gdImageSetPixel(gdImagePtr im, int x, int y, int color);
! 295:
! 296: int gdImageGetTrueColorPixel (gdImagePtr im, int x, int y);
! 297: int gdImageGetPixel(gdImagePtr im, int x, int y);
! 298:
! 299: void gdImageAABlend(gdImagePtr im);
! 300:
! 301: void gdImageLine(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
! 302: void gdImageAALine(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
! 303:
! 304: /* For backwards compatibility only. Use gdImageSetStyle()
! 305: for much more flexible line drawing. */
! 306: void gdImageDashedLine(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
! 307: /* Corners specified (not width and height). Upper left first, lower right
! 308: second. */
! 309: void gdImageRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
! 310: /* Solid bar. Upper left corner first, lower right corner second. */
! 311: void gdImageFilledRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
! 312: void gdImageSetClip(gdImagePtr im, int x1, int y1, int x2, int y2);
! 313: void gdImageGetClip(gdImagePtr im, int *x1P, int *y1P, int *x2P, int *y2P);
! 314: void gdImageChar(gdImagePtr im, gdFontPtr f, int x, int y, int c, int color);
! 315: void gdImageCharUp(gdImagePtr im, gdFontPtr f, int x, int y, int c, int color);
! 316: void gdImageString(gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color);
! 317: void gdImageStringUp(gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color);
! 318: void gdImageString16(gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color);
! 319: void gdImageStringUp16(gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color);
! 320:
! 321: /*
! 322: * The following functions are required to be called prior to the
! 323: * use of any sort of threads in a module load / shutdown function
! 324: * respectively.
! 325: */
! 326: void gdFontCacheMutexSetup();
! 327: void gdFontCacheMutexShutdown();
! 328:
! 329: /* 2.0.16: for thread-safe use of gdImageStringFT and friends,
! 330: * call this before allowing any thread to call gdImageStringFT.
! 331: * Otherwise it is invoked by the first thread to invoke
! 332: * gdImageStringFT, with a very small but real risk of a race condition.
! 333: * Return 0 on success, nonzero on failure to initialize freetype.
! 334: */
! 335: int gdFontCacheSetup(void);
! 336:
! 337: /* Optional: clean up after application is done using fonts in gdImageStringFT(). */
! 338: void gdFontCacheShutdown(void);
! 339:
! 340: /* Calls gdImageStringFT. Provided for backwards compatibility only. */
! 341: char *gdImageStringTTF(gdImage *im, int *brect, int fg, char *fontlist,
! 342: double ptsize, double angle, int x, int y, char *string);
! 343:
! 344: /* FreeType 2 text output */
! 345: char *gdImageStringFT(gdImage *im, int *brect, int fg, char *fontlist,
! 346: double ptsize, double angle, int x, int y, char *string);
! 347:
! 348: typedef struct {
! 349: double linespacing; /* fine tune line spacing for '\n' */
! 350: int flags; /* Logical OR of gdFTEX_ values */
! 351: int charmap; /* TBB: 2.0.12: may be gdFTEX_Unicode,
! 352: gdFTEX_Shift_JIS, or gdFTEX_Big5;
! 353: when not specified, maps are searched
! 354: for in the above order. */
! 355: int hdpi;
! 356: int vdpi;
! 357: }
! 358: gdFTStringExtra, *gdFTStringExtraPtr;
! 359:
! 360: #define gdFTEX_LINESPACE 1
! 361: #define gdFTEX_CHARMAP 2
! 362: #define gdFTEX_RESOLUTION 4
! 363:
! 364: /* These are NOT flags; set one in 'charmap' if you set the gdFTEX_CHARMAP bit in 'flags'. */
! 365: #define gdFTEX_Unicode 0
! 366: #define gdFTEX_Shift_JIS 1
! 367: #define gdFTEX_Big5 2
! 368:
! 369: /* FreeType 2 text output with fine tuning */
! 370: char *
! 371: gdImageStringFTEx(gdImage * im, int *brect, int fg, char * fontlist,
! 372: double ptsize, double angle, int x, int y, char * string,
! 373: gdFTStringExtraPtr strex);
! 374:
! 375:
! 376: /* Point type for use in polygon drawing. */
! 377: typedef struct {
! 378: int x, y;
! 379: } gdPoint, *gdPointPtr;
! 380:
! 381: void gdImagePolygon(gdImagePtr im, gdPointPtr p, int n, int c);
! 382: void gdImageFilledPolygon(gdImagePtr im, gdPointPtr p, int n, int c);
! 383:
! 384: /* These functions still work with truecolor images,
! 385: for which they never return error. */
! 386: int gdImageColorAllocate(gdImagePtr im, int r, int g, int b);
! 387: /* gd 2.0: palette entries with non-opaque transparency are permitted. */
! 388: int gdImageColorAllocateAlpha(gdImagePtr im, int r, int g, int b, int a);
! 389: /* Assumes opaque is the preferred alpha channel value */
! 390: int gdImageColorClosest(gdImagePtr im, int r, int g, int b);
! 391: /* Closest match taking all four parameters into account.
! 392: A slightly different color with the same transparency
! 393: beats the exact same color with radically different
! 394: transparency */
! 395: int gdImageColorClosestAlpha(gdImagePtr im, int r, int g, int b, int a);
! 396: /* An alternate method */
! 397: int gdImageColorClosestHWB(gdImagePtr im, int r, int g, int b);
! 398: /* Returns exact, 100% opaque matches only */
! 399: int gdImageColorExact(gdImagePtr im, int r, int g, int b);
! 400: /* Returns an exact match only, including alpha */
! 401: int gdImageColorExactAlpha(gdImagePtr im, int r, int g, int b, int a);
! 402: /* Opaque only */
! 403: int gdImageColorResolve(gdImagePtr im, int r, int g, int b);
! 404: /* Based on gdImageColorExactAlpha and gdImageColorClosestAlpha */
! 405: int gdImageColorResolveAlpha(gdImagePtr im, int r, int g, int b, int a);
! 406:
! 407: /* A simpler way to obtain an opaque truecolor value for drawing on a
! 408: truecolor image. Not for use with palette images! */
! 409:
! 410: #define gdTrueColor(r, g, b) (((r) << 16) + \
! 411: ((g) << 8) + \
! 412: (b))
! 413:
! 414: /* Returns a truecolor value with an alpha channel component.
! 415: gdAlphaMax (127, **NOT 255**) is transparent, 0 is completely
! 416: opaque. */
! 417:
! 418: #define gdTrueColorAlpha(r, g, b, a) (((a) << 24) + \
! 419: ((r) << 16) + \
! 420: ((g) << 8) + \
! 421: (b))
! 422:
! 423: void gdImageColorDeallocate(gdImagePtr im, int color);
! 424:
! 425: /* Converts a truecolor image to a palette-based image,
! 426: using a high-quality two-pass quantization routine
! 427: which attempts to preserve alpha channel information
! 428: as well as R/G/B color information when creating
! 429: a palette. If ditherFlag is set, the image will be
! 430: dithered to approximate colors better, at the expense
! 431: of some obvious "speckling." colorsWanted can be
! 432: anything up to 256. If the original source image
! 433: includes photographic information or anything that
! 434: came out of a JPEG, 256 is strongly recommended.
! 435:
! 436: Better yet, don't use this function -- write real
! 437: truecolor PNGs and JPEGs. The disk space gain of
! 438: conversion to palette is not great (for small images
! 439: it can be negative) and the quality loss is ugly. */
! 440:
! 441: gdImagePtr gdImageCreatePaletteFromTrueColor (gdImagePtr im, int ditherFlag, int colorsWanted);
! 442:
! 443: void gdImageTrueColorToPalette(gdImagePtr im, int ditherFlag, int colorsWanted);
! 444:
! 445:
! 446: /* An attempt at getting the results of gdImageTrueColorToPalette
! 447: to look a bit more like the original (im1 is the original
! 448: and im2 is the palette version */
! 449: int gdImageColorMatch(gdImagePtr im1, gdImagePtr im2);
! 450:
! 451: /* Specifies a color index (if a palette image) or an
! 452: RGB color (if a truecolor image) which should be
! 453: considered 100% transparent. FOR TRUECOLOR IMAGES,
! 454: THIS IS IGNORED IF AN ALPHA CHANNEL IS BEING
! 455: SAVED. Use gdImageSaveAlpha(im, 0); to
! 456: turn off the saving of a full alpha channel in
! 457: a truecolor image. Note that gdImageColorTransparent
! 458: is usually compatible with older browsers that
! 459: do not understand full alpha channels well. TBB */
! 460: void gdImageColorTransparent(gdImagePtr im, int color);
! 461:
! 462: void gdImagePaletteCopy(gdImagePtr dst, gdImagePtr src);
! 463: void gdImagePng(gdImagePtr im, FILE *out);
! 464: void gdImagePngCtx(gdImagePtr im, gdIOCtx *out);
! 465: void gdImageGif(gdImagePtr im, FILE *out);
! 466: void gdImageGifCtx(gdImagePtr im, gdIOCtx *out);
! 467: /* 2.0.12: Compression level: 0-9 or -1, where 0 is NO COMPRESSION at all,
! 468: * 1 is FASTEST but produces larger files, 9 provides the best
! 469: * compression (smallest files) but takes a long time to compress, and
! 470: * -1 selects the default compiled into the zlib library.
! 471: */
! 472: void gdImagePngEx(gdImagePtr im, FILE * out, int level, int basefilter);
! 473: void gdImagePngCtxEx(gdImagePtr im, gdIOCtx * out, int level, int basefilter);
! 474:
! 475: void gdImageWBMP(gdImagePtr image, int fg, FILE *out);
! 476: void gdImageWBMPCtx(gdImagePtr image, int fg, gdIOCtx *out);
! 477:
! 478: /* Guaranteed to correctly free memory returned
! 479: by the gdImage*Ptr functions */
! 480: void gdFree(void *m);
! 481:
! 482: /* Best to free this memory with gdFree(), not free() */
! 483: void *gdImageWBMPPtr(gdImagePtr im, int *size, int fg);
! 484:
! 485: /* 100 is highest quality (there is always a little loss with JPEG).
! 486: 0 is lowest. 10 is about the lowest useful setting. */
! 487: void gdImageJpeg(gdImagePtr im, FILE *out, int quality);
! 488: void gdImageJpegCtx(gdImagePtr im, gdIOCtx *out, int quality);
! 489:
! 490: /* Best to free this memory with gdFree(), not free() */
! 491: void *gdImageJpegPtr(gdImagePtr im, int *size, int quality);
! 492:
! 493: gdImagePtr gdImageCreateFromGif(FILE *fd);
! 494: gdImagePtr gdImageCreateFromGifCtx(gdIOCtxPtr in);
! 495: gdImagePtr gdImageCreateFromGifSource(gdSourcePtr in);
! 496:
! 497: /* A custom data sink. For backwards compatibility. Use
! 498: gdIOCtx instead. */
! 499: /* The sink function must return -1 on error, otherwise the number
! 500: of bytes written, which must be equal to len. */
! 501: /* context will be passed to your sink function. */
! 502: typedef struct {
! 503: int (*sink) (void *context, const char *buffer, int len);
! 504: void *context;
! 505: } gdSink, *gdSinkPtr;
! 506:
! 507: void gdImagePngToSink(gdImagePtr im, gdSinkPtr out);
! 508:
! 509: void gdImageGd(gdImagePtr im, FILE *out);
! 510: void gdImageGd2(gdImagePtr im, FILE *out, int cs, int fmt);
! 511:
! 512: /* Best to free this memory with gdFree(), not free() */
! 513: void* gdImagePngPtr(gdImagePtr im, int *size);
! 514:
! 515: /* Best to free this memory with gdFree(), not free() */
! 516: void* gdImageGdPtr(gdImagePtr im, int *size);
! 517: void *gdImagePngPtrEx(gdImagePtr im, int *size, int level, int basefilter);
! 518:
! 519: /* Best to free this memory with gdFree(), not free() */
! 520: void* gdImageGd2Ptr(gdImagePtr im, int cs, int fmt, int *size);
! 521:
! 522: void gdImageEllipse(gdImagePtr im, int cx, int cy, int w, int h, int c);
! 523:
! 524: /* Style is a bitwise OR ( | operator ) of these.
! 525: gdArc and gdChord are mutually exclusive;
! 526: gdChord just connects the starting and ending
! 527: angles with a straight line, while gdArc produces
! 528: a rounded edge. gdPie is a synonym for gdArc.
! 529: gdNoFill indicates that the arc or chord should be
! 530: outlined, not filled. gdEdged, used together with
! 531: gdNoFill, indicates that the beginning and ending
! 532: angles should be connected to the center; this is
! 533: a good way to outline (rather than fill) a
! 534: 'pie slice'. */
! 535: #define gdArc 0
! 536: #define gdPie gdArc
! 537: #define gdChord 1
! 538: #define gdNoFill 2
! 539: #define gdEdged 4
! 540:
! 541: void gdImageFilledArc(gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color, int style);
! 542: void gdImageArc(gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color);
! 543: void gdImageFilledEllipse(gdImagePtr im, int cx, int cy, int w, int h, int color);
! 544: void gdImageFillToBorder(gdImagePtr im, int x, int y, int border, int color);
! 545: void gdImageFill(gdImagePtr im, int x, int y, int color);
! 546: void gdImageCopy(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h);
! 547: void gdImageCopyMerge(gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
! 548: int srcX, int srcY, int w, int h, int pct);
! 549: void gdImageCopyMergeGray(gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
! 550: int srcX, int srcY, int w, int h, int pct);
! 551:
! 552: /* Stretches or shrinks to fit, as needed. Does NOT attempt
! 553: to average the entire set of source pixels that scale down onto the
! 554: destination pixel. */
! 555: void gdImageCopyResized(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH);
! 556:
! 557: /* gd 2.0: stretches or shrinks to fit, as needed. When called with a
! 558: truecolor destination image, this function averages the
! 559: entire set of source pixels that scale down onto the
! 560: destination pixel, taking into account what portion of the
! 561: destination pixel each source pixel represents. This is a
! 562: floating point operation, but this is not a performance issue
! 563: on modern hardware, except for some embedded devices. If the
! 564: destination is a palette image, gdImageCopyResized is
! 565: substituted automatically. */
! 566: void gdImageCopyResampled(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH);
! 567:
! 568: gdImagePtr gdImageRotate90(gdImagePtr src, int ignoretransparent);
! 569: gdImagePtr gdImageRotate180(gdImagePtr src, int ignoretransparent);
! 570: gdImagePtr gdImageRotate270(gdImagePtr src, int ignoretransparent);
! 571: gdImagePtr gdImageRotate45(gdImagePtr src, double dAngle, int clrBack, int ignoretransparent);
! 572: gdImagePtr gdImageRotate (gdImagePtr src, double dAngle, int clrBack, int ignoretransparent);
! 573:
! 574: void gdImageSetBrush(gdImagePtr im, gdImagePtr brush);
! 575: void gdImageSetTile(gdImagePtr im, gdImagePtr tile);
! 576: void gdImageSetAntiAliased(gdImagePtr im, int c);
! 577: void gdImageSetAntiAliasedDontBlend(gdImagePtr im, int c, int dont_blend);
! 578: void gdImageSetStyle(gdImagePtr im, int *style, int noOfPixels);
! 579: /* Line thickness (defaults to 1). Affects lines, ellipses,
! 580: rectangles, polygons and so forth. */
! 581: void gdImageSetThickness(gdImagePtr im, int thickness);
! 582: /* On or off (1 or 0) for all three of these. */
! 583: void gdImageInterlace(gdImagePtr im, int interlaceArg);
! 584: void gdImageAlphaBlending(gdImagePtr im, int alphaBlendingArg);
! 585: void gdImageAntialias(gdImagePtr im, int antialias);
! 586: void gdImageSaveAlpha(gdImagePtr im, int saveAlphaArg);
! 587:
! 588: enum gdPixelateMode {
! 589: GD_PIXELATE_UPPERLEFT,
! 590: GD_PIXELATE_AVERAGE
! 591: };
! 592:
! 593: int gdImagePixelate(gdImagePtr im, int block_size, const unsigned int mode);
! 594:
! 595: /* Macros to access information about images. */
! 596:
! 597: /* Returns nonzero if the image is a truecolor image,
! 598: zero for a palette image. */
! 599:
! 600: #define gdImageTrueColor(im) ((im)->trueColor)
! 601:
! 602: #define gdImageSX(im) ((im)->sx)
! 603: #define gdImageSY(im) ((im)->sy)
! 604: #define gdImageColorsTotal(im) ((im)->colorsTotal)
! 605: #define gdImageRed(im, c) ((im)->trueColor ? gdTrueColorGetRed(c) : \
! 606: (im)->red[(c)])
! 607: #define gdImageGreen(im, c) ((im)->trueColor ? gdTrueColorGetGreen(c) : \
! 608: (im)->green[(c)])
! 609: #define gdImageBlue(im, c) ((im)->trueColor ? gdTrueColorGetBlue(c) : \
! 610: (im)->blue[(c)])
! 611: #define gdImageAlpha(im, c) ((im)->trueColor ? gdTrueColorGetAlpha(c) : \
! 612: (im)->alpha[(c)])
! 613: #define gdImageGetTransparent(im) ((im)->transparent)
! 614: #define gdImageGetInterlaced(im) ((im)->interlace)
! 615:
! 616: /* These macros provide direct access to pixels in
! 617: palette-based and truecolor images, respectively.
! 618: If you use these macros, you must perform your own
! 619: bounds checking. Use of the macro for the correct type
! 620: of image is also your responsibility. */
! 621: #define gdImagePalettePixel(im, x, y) (im)->pixels[(y)][(x)]
! 622: #define gdImageTrueColorPixel(im, x, y) (im)->tpixels[(y)][(x)]
! 623:
! 624: /* I/O Support routines. */
! 625:
! 626: gdIOCtx* gdNewFileCtx(FILE*);
! 627: gdIOCtx* gdNewDynamicCtx(int, void*);
! 628: gdIOCtx *gdNewDynamicCtxEx(int size, void *data, int freeFlag);
! 629: gdIOCtx* gdNewSSCtx(gdSourcePtr in, gdSinkPtr out);
! 630: void* gdDPExtractData(struct gdIOCtx* ctx, int *size);
! 631:
! 632: #define GD2_CHUNKSIZE 128
! 633: #define GD2_CHUNKSIZE_MIN 64
! 634: #define GD2_CHUNKSIZE_MAX 4096
! 635:
! 636: #define GD2_VERS 2
! 637: #define GD2_ID "gd2"
! 638: #define GD2_FMT_RAW 1
! 639: #define GD2_FMT_COMPRESSED 2
! 640:
! 641:
! 642: /* filters section
! 643: *
! 644: * Negate the imag src, white becomes black,
! 645: * The red, green, and blue intensities of an image are negated.
! 646: * White becomes black, yellow becomes blue, etc.
! 647: */
! 648: int gdImageNegate(gdImagePtr src);
! 649:
! 650: /* Convert the image src to a grayscale image */
! 651: int gdImageGrayScale(gdImagePtr src);
! 652:
! 653: /* Set the brightness level <brightness> for the image src */
! 654: int gdImageBrightness(gdImagePtr src, int brightness);
! 655:
! 656: /* Set the contrast level <contrast> for the image <src> */
! 657: int gdImageContrast(gdImagePtr src, double contrast);
! 658:
! 659: /* Simply adds or substracts respectively red, green or blue to a pixel */
! 660: int gdImageColor(gdImagePtr src, const int red, const int green, const int blue, const int alpha);
! 661:
! 662: /* Image convolution by a 3x3 custom matrix */
! 663: int gdImageConvolution(gdImagePtr src, float ft[3][3], float filter_div, float offset);
! 664:
! 665: int gdImageEdgeDetectQuick(gdImagePtr src);
! 666:
! 667: int gdImageGaussianBlur(gdImagePtr im);
! 668:
! 669: int gdImageSelectiveBlur( gdImagePtr src);
! 670:
! 671: int gdImageEmboss(gdImagePtr im);
! 672:
! 673: int gdImageMeanRemoval(gdImagePtr im);
! 674:
! 675: int gdImageSmooth(gdImagePtr im, float weight);
! 676:
! 677: /* Image comparison definitions */
! 678: int gdImageCompare(gdImagePtr im1, gdImagePtr im2);
! 679:
! 680: #define GD_CMP_IMAGE 1 /* Actual image IS different */
! 681: #define GD_CMP_NUM_COLORS 2 /* Number of Colours in pallette differ */
! 682: #define GD_CMP_COLOR 4 /* Image colours differ */
! 683: #define GD_CMP_SIZE_X 8 /* Image width differs */
! 684: #define GD_CMP_SIZE_Y 16 /* Image heights differ */
! 685: #define GD_CMP_TRANSPARENT 32 /* Transparent colour */
! 686: #define GD_CMP_BACKGROUND 64 /* Background colour */
! 687: #define GD_CMP_INTERLACE 128 /* Interlaced setting */
! 688: #define GD_CMP_TRUECOLOR 256 /* Truecolor vs palette differs */
! 689:
! 690: /* resolution affects ttf font rendering, particularly hinting */
! 691: #define GD_RESOLUTION 96 /* pixels per inch */
! 692:
! 693: #ifdef __cplusplus
! 694: }
! 695: #endif
! 696:
! 697: /* 2.0.12: this now checks the clipping rectangle */
! 698: #define gdImageBoundsSafe(im, x, y) (!((((y) < (im)->cy1) || ((y) > (im)->cy2)) || (((x) < (im)->cx1) || ((x) > (im)->cx2))))
! 699:
! 700: #endif /* GD_H */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gd.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd / libgd