/
gd.h
1716 lines (1474 loc) · 58.7 KB
/
gd.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#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 <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_LANCZOS3,
GD_LANCZOS8,
GD_BLACKMAN_BESSEL,
GD_BLACKMAN_SINC,
GD_QUADRATIC_BSPLINE,
GD_CUBIC_SPLINE,
GD_COSINE,
GD_WELSH,
GD_METHOD_COUNT = 30
} gdInterpolationMethod;
/**
* Group: HEIF Coding Format
*
* Values that select the HEIF coding format.
*
* Constants: gdHeifCodec
*
* GD_HEIF_CODEC_UNKNOWN
* GD_HEIF_CODEC_HEVC
* GD_HEIF_CODEC_AV1
*
* See also:
* - <gdImageHeif>
*/
typedef enum {
GD_HEIF_CODEC_UNKNOWN = 0,
GD_HEIF_CODEC_HEVC,
GD_HEIF_CODEC_AV1 = 4,
} gdHeifCodec;
/**
* Group: HEIF Chroma Subsampling
*
* Values that select the HEIF chroma subsampling.
*
* Constants: gdHeifCompression
*
* GD_HEIF_CHROMA_420
* GD_HEIF_CHROMA_422
* GD_HEIF_CHROMA_444
*
* See also:
* - <gdImageHeif>
*/
typedef const char *gdHeifChroma;
#define GD_HEIF_CHROMA_420 "420"
#define GD_HEIF_CHROMA_422 "422"
#define GD_HEIF_CHROMA_444 "444"
/* define struct with name and func ptr and add it to gdImageStruct gdInterpolationMethod interpolation; */
/* 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 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(gdIOCtxPtr 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(gdIOCtxPtr infile);
BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtxEx(gdIOCtxPtr 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(gdIOCtxPtr infile);
BGD_DECLARE(gdImagePtr) gdImageCreateFromHeif(FILE *inFile);
BGD_DECLARE(gdImagePtr) gdImageCreateFromHeifPtr(int size, void *data);
BGD_DECLARE(gdImagePtr) gdImageCreateFromHeifCtx(gdIOCtxPtr infile);
BGD_DECLARE(gdImagePtr) gdImageCreateFromAvif(FILE *inFile);
BGD_DECLARE(gdImagePtr) gdImageCreateFromAvifPtr(int size, void *data);
BGD_DECLARE(gdImagePtr) gdImageCreateFromAvifCtx(gdIOCtxPtr infile);
BGD_DECLARE(gdImagePtr) gdImageCreateFromTiff(FILE *inFile);
BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffCtx(gdIOCtxPtr infile);
BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffPtr(int size, void *data);
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);
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, gdIOCtxPtr 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 (gdImagePtr im, int *brect, int fg, const char *fontlist,
double ptsize, double angle, int x, int y,
const char *string);
/* FreeType 2 text output */
BGD_DECLARE(char *) gdImageStringFT (gdImagePtr im, int *brect, int fg, const char *fontlist,
double ptsize, double angle, int x, int y,
const 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 (gdImagePtr im, int *brect, int fg, const char *fontlist,
double ptsize, double angle, int x, int y,
const 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;
*/
typedef struct {
int x, y;
}
gdPoint, *gdPointPtr;
/**
* Typedef: gdRect
*
* A rectangle in the coordinate space of the image
*
* Members:
* x - The x-coordinate of the upper left corner.
* y - The y-coordinate of the upper left corner.
* width - The width.
* height - The height.
*
* Typedef: gdRectPtr
*
* A pointer to a <gdRect>
*/
typedef struct {
int x, y;
int width, height;
}
gdRect, *gdRectPtr;
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);
/* These functions still work with truecolor images,
for which they never return error. */
BGD_DECLARE(int) gdImageColorAllocate (gdImagePtr im, int r, int g, int b);
/* gd 2.0: palette entries with non-opaque transparency are permitted. */
BGD_DECLARE(int) gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a);
/* Assumes opaque is the preferred alpha channel value */
BGD_DECLARE(int) gdImageColorClosest (gdImagePtr im, int r, int g, int b);
/* Closest match taking all four parameters into account.
A slightly different color with the same transparency
beats the exact same color with radically different
transparency */
BGD_DECLARE(int) gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a);
/* An alternate method */
BGD_DECLARE(int) gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b);
/* Returns exact, 100% opaque matches only */
BGD_DECLARE(int) gdImageColorExact (gdImagePtr im, int r, int g, int b);
/* Returns an exact match only, including alpha */
BGD_DECLARE(int) gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a);
/* Opaque only */
BGD_DECLARE(int) gdImageColorResolve (gdImagePtr im, int r, int g, int b);
/* Based on gdImageColorExactAlpha and gdImageColorClosestAlpha */
BGD_DECLARE(int) gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a);
/* A simpler way to obtain an opaque truecolor value for drawing on a
truecolor image. Not for use with palette images! */
#define gdTrueColor(r, g, b) (((r) << 16) + \
((g) << 8) + \
(b))
/**
* Group: Color Composition
*
* Macro: gdTrueColorAlpha
*
* Compose a truecolor value from its components
*