summaryrefslogtreecommitdiff
path: root/Build/source/libs/gd/libgd-src/src/gd_gd.c
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/gd/libgd-src/src/gd_gd.c')
-rw-r--r--Build/source/libs/gd/libgd-src/src/gd_gd.c346
1 files changed, 346 insertions, 0 deletions
diff --git a/Build/source/libs/gd/libgd-src/src/gd_gd.c b/Build/source/libs/gd/libgd-src/src/gd_gd.c
new file mode 100644
index 00000000000..f8d39cb00ce
--- /dev/null
+++ b/Build/source/libs/gd/libgd-src/src/gd_gd.c
@@ -0,0 +1,346 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "gd.h"
+
+#define TRUE 1
+#define FALSE 0
+
+/* Use this for commenting out debug-print statements. */
+/* Just use the first '#define' to allow all the prints... */
+/*#define GD2_DBG(s) (s) */
+#define GD2_DBG(s)
+
+/* */
+/* Shared code to read color tables from gd file. */
+/* */
+int
+_gdGetColors (gdIOCtx * in, gdImagePtr im, int gd2xFlag)
+{
+ int i;
+ if (gd2xFlag) {
+ int trueColorFlag;
+ if (!gdGetByte (&trueColorFlag, in)) {
+ goto fail1;
+ }
+ /* 2.0.12: detect bad truecolor .gd files created by pre-2.0.12.
+ Beginning in 2.0.12 truecolor is indicated by the initial 2-byte
+ signature. */
+ if (trueColorFlag != im->trueColor) {
+ goto fail1;
+ }
+ /* This should have been a word all along */
+ if (!im->trueColor) {
+ if (!gdGetWord (&im->colorsTotal, in)) {
+ goto fail1;
+ }
+ if (im->colorsTotal > gdMaxColors) {
+ goto fail1;
+ }
+ }
+ /* Int to accommodate truecolor single-color transparency */
+ if (!gdGetInt (&im->transparent, in)) {
+ goto fail1;
+ }
+ } else {
+ if (!gdGetByte (&im->colorsTotal, in)) {
+ goto fail1;
+ }
+ if (!gdGetWord (&im->transparent, in)) {
+ goto fail1;
+ }
+ if (im->transparent == 257) {
+ im->transparent = (-1);
+ }
+ }
+ GD2_DBG (printf
+ ("Palette had %d colours (T=%d)\n", im->colorsTotal,
+ im->transparent));
+ if (im->trueColor) {
+ return TRUE;
+ }
+ for (i = 0; (i < gdMaxColors); i++) {
+ if (!gdGetByte (&im->red[i], in)) {
+ goto fail1;
+ }
+ if (!gdGetByte (&im->green[i], in)) {
+ goto fail1;
+ }
+ if (!gdGetByte (&im->blue[i], in)) {
+ goto fail1;
+ }
+ if (gd2xFlag) {
+ if (!gdGetByte (&im->alpha[i], in)) {
+ goto fail1;
+ }
+ }
+ }
+
+ for (i = 0; (i < im->colorsTotal); i++) {
+ im->open[i] = 0;
+ };
+
+ return TRUE;
+fail1:
+ return FALSE;
+}
+
+/* */
+/* Use the common basic header info to make the image object. */
+/* */
+static gdImagePtr
+_gdCreateFromFile (gdIOCtx * in, int *sx, int *sy)
+{
+ gdImagePtr im;
+ int gd2xFlag = 0;
+ int trueColorFlag = 0;
+ if (!gdGetWord (sx, in)) {
+ goto fail1;
+ }
+ if ((*sx == 65535) || (*sx == 65534)) {
+ /* This is a gd 2.0 .gd file */
+ gd2xFlag = 1;
+ /* 2.0.12: 65534 signals a truecolor .gd file.
+ There is a slight redundancy here but we can
+ live with it. */
+ if (*sx == 65534) {
+ trueColorFlag = 1;
+ }
+ if (!gdGetWord (sx, in)) {
+ goto fail1;
+ }
+ }
+ if (!gdGetWord (sy, in)) {
+ goto fail1;
+ }
+
+ GD2_DBG (printf ("Image is %dx%d\n", *sx, *sy));
+ if (trueColorFlag) {
+ im = gdImageCreateTrueColor (*sx, *sy);
+ } else {
+ im = gdImageCreate (*sx, *sy);
+ }
+ if (!im) {
+ goto fail1;
+ }
+ if (!_gdGetColors (in, im, gd2xFlag)) {
+ goto fail2;
+ }
+
+ return im;
+fail2:
+ gdImageDestroy (im);
+fail1:
+ return 0;
+}
+
+/*
+ Function: gdImageCreateFromGd
+
+ <gdImageCreateFromGd> is called to load images from gd format
+ files. Invoke <gdImageCreateFromGd> with an already opened pointer
+ to a file containing the desired image in the gd file format,
+ which is specific to gd and intended for very fast loading. (It is
+ not intended for compression; for compression, use PNG or JPEG.)
+
+ <gdImageCreateFromGd> returns a <gdImagePtr> to the new image, or
+ NULL if unable to load the image (most often because the file is
+ corrupt or does not contain a gd format
+ image). <gdImageCreateFromGd> does not close the file. You can
+ inspect the sx and sy members of the image to determine its
+ size. The image must eventually be destroyed using
+ <gdImageDestroy>.
+
+ Variants:
+
+ <gdImageCreateFromGdPtr> creates an image from GD data (i.e. the
+ contents of a GD file) already in memory.
+
+ <gdImageCreateFromGdCtx> reads in an image using the functions in
+ a <gdIOCtx> struct.
+
+ Parameters:
+
+ infile - The input FILE pointer
+
+ Returns:
+
+ A pointer to the new image or NULL if an error occurred.
+
+ Example:
+
+ > gdImagePtr im;
+ > FILE *in;
+ > in = fopen("mygd.gd", "rb");
+ > im = gdImageCreateFromGd(in);
+ > fclose(in);
+ > // ... Use the image ...
+ > gdImageDestroy(im);
+*/
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGd (FILE * inFile)
+{
+ gdImagePtr im;
+ gdIOCtx *in;
+
+ in = gdNewFileCtx (inFile);
+ if (in == NULL) return NULL;
+ im = gdImageCreateFromGdCtx (in);
+
+ in->gd_free (in);
+
+ return im;
+}
+
+/*
+ Function: gdImageCreateFromGdPtr
+
+ Parameters:
+
+ size - size of GD data in bytes.
+ data - GD data (i.e. contents of a GIF file).
+
+ Reads in GD data from memory. See <gdImageCreateFromGd>.
+*/
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGdPtr (int size, void *data)
+{
+ gdImagePtr im;
+ gdIOCtx *in = gdNewDynamicCtxEx (size, data, 0);
+ if(!in)
+ return 0;
+ im = gdImageCreateFromGdCtx (in);
+ in->gd_free (in);
+ return im;
+}
+
+/*
+ Function: gdImageCreateFromGdCtx
+
+ Reads in a GD image via a <gdIOCtx> struct. See
+ <gdImageCreateFromGd>.
+*/
+BGD_DECLARE(gdImagePtr) gdImageCreateFromGdCtx (gdIOCtxPtr in)
+{
+ int sx, sy;
+ int x, y;
+ gdImagePtr im;
+
+ /* Read the header */
+ im = _gdCreateFromFile (in, &sx, &sy);
+
+ if (im == NULL) {
+ goto fail1;
+ };
+
+ /* Then the data... */
+ /* 2.0.12: support truecolor properly in .gd as well as in .gd2.
+ Problem reported by Andreas Pfaller. */
+ if (im->trueColor) {
+ for (y = 0; (y < sy); y++) {
+ for (x = 0; (x < sx); x++) {
+ int pix;
+ if (!gdGetInt (&pix, in)) {
+ goto fail2;
+ }
+ im->tpixels[y][x] = pix;
+ }
+ }
+ } else {
+ for (y = 0; (y < sy); y++) {
+ for (x = 0; (x < sx); x++) {
+ int ch;
+ ch = gdGetC (in);
+ if (ch == EOF) {
+ goto fail2;
+ }
+ /* ROW-MAJOR IN GD 1.3 */
+ im->pixels[y][x] = ch;
+ }
+ }
+ }
+ return im;
+
+fail2:
+ gdImageDestroy (im);
+fail1:
+ return 0;
+}
+
+void
+_gdPutColors (gdImagePtr im, gdIOCtx * out)
+{
+ int i;
+
+ gdPutC (im->trueColor, out);
+ if (!im->trueColor) {
+ gdPutWord (im->colorsTotal, out);
+ }
+ gdPutInt (im->transparent, out);
+ if (!im->trueColor) {
+ for (i = 0; (i < gdMaxColors); i++) {
+ gdPutC ((unsigned char) im->red[i], out);
+ gdPutC ((unsigned char) im->green[i], out);
+ gdPutC ((unsigned char) im->blue[i], out);
+ gdPutC ((unsigned char) im->alpha[i], out);
+ }
+ }
+}
+
+static void
+_gdPutHeader (gdImagePtr im, gdIOCtx * out)
+{
+ /* 65535 indicates this is a gd 2.x .gd file.
+ 2.0.12: 65534 indicates truecolor. */
+ if (im->trueColor) {
+ gdPutWord (65534, out);
+ } else {
+ gdPutWord (65535, out);
+ }
+ gdPutWord (im->sx, out);
+ gdPutWord (im->sy, out);
+
+ _gdPutColors (im, out);
+
+}
+
+static void
+_gdImageGd (gdImagePtr im, gdIOCtx * out)
+{
+ int x, y;
+
+ _gdPutHeader (im, out);
+
+ for (y = 0; (y < im->sy); y++) {
+ for (x = 0; (x < im->sx); x++) {
+ /* ROW-MAJOR IN GD 1.3 */
+ if (im->trueColor) {
+ gdPutInt (im->tpixels[y][x], out);
+ } else {
+ gdPutC ((unsigned char) im->pixels[y][x], out);
+ }
+ }
+ }
+}
+
+BGD_DECLARE(void) gdImageGd (gdImagePtr im, FILE * outFile)
+{
+ gdIOCtx *out = gdNewFileCtx (outFile);
+ if (out == NULL) return;
+ _gdImageGd (im, out);
+ out->gd_free (out);
+}
+
+BGD_DECLARE(void *) gdImageGdPtr (gdImagePtr im, int *size)
+{
+ void *rv;
+ gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
+ if (out == NULL) return NULL;
+ _gdImageGd (im, out);
+ rv = gdDPExtractData (out, size);
+ out->gd_free (out);
+ return rv;
+}