2016-08-14 06:52:43 -07:00
|
|
|
|
/**
|
|
|
|
|
* File: GD IO
|
|
|
|
|
*
|
|
|
|
|
* Read and write GD images.
|
|
|
|
|
*
|
2016-08-14 10:59:46 -07:00
|
|
|
|
* The GD image format is a proprietary image format of libgd. *It has to be*
|
|
|
|
|
* *regarded as being obsolete, and should only be used for development and*
|
|
|
|
|
* *testing purposes.*
|
|
|
|
|
*
|
|
|
|
|
* Structure of a GD image file:
|
|
|
|
|
* - file header
|
|
|
|
|
* - color header (either truecolor or palette)
|
|
|
|
|
* - image data
|
|
|
|
|
*
|
2017-09-03 06:50:42 -07:00
|
|
|
|
* All numbers are stored in big-endian format. Note that all GD output is done
|
|
|
|
|
* in the GD 2.x format (not to be confused with the GD2 format), but input may
|
|
|
|
|
* also be in the GD 1.x format.
|
|
|
|
|
*
|
|
|
|
|
* GD 1.x file header structure:
|
|
|
|
|
* width - 1 word
|
|
|
|
|
* height - 1 word
|
|
|
|
|
*
|
|
|
|
|
* GD 1.x color header (palette only):
|
|
|
|
|
* count - 1 byte (the number of used palette colors)
|
|
|
|
|
* transparent - 1 word (257 signals no transparency)
|
2017-09-07 06:25:47 -07:00
|
|
|
|
* palette - 256×3 bytes (RGB triplets)
|
2018-06-21 19:47:42 -07:00
|
|
|
|
*
|
2017-09-03 06:50:42 -07:00
|
|
|
|
* GD 2.x file header structure:
|
2016-08-14 10:59:46 -07:00
|
|
|
|
* signature - 1 word ("\xFF\xFE" for truecolor, "\xFF\xFF" for palette)
|
|
|
|
|
* width - 1 word
|
|
|
|
|
* height - 1 word
|
|
|
|
|
*
|
2017-09-03 06:50:42 -07:00
|
|
|
|
* GD 2.x truecolor image color header:
|
2016-08-14 10:59:46 -07:00
|
|
|
|
* truecolor - 1 byte (always "\001")
|
2017-09-07 06:25:47 -07:00
|
|
|
|
* transparent - 1 dword (ARGB color); "\377\377\377\377" means that no
|
|
|
|
|
* transparent color is set
|
2016-08-14 10:59:46 -07:00
|
|
|
|
*
|
2017-09-03 06:50:42 -07:00
|
|
|
|
* GD 2.x palette image color header:
|
2016-08-14 10:59:46 -07:00
|
|
|
|
* truecolor - 1 byte (always "\0")
|
|
|
|
|
* count - 1 word (the number of used palette colors)
|
2017-09-07 06:25:47 -07:00
|
|
|
|
* transparent - 1 dword (palette index); "\377\377\377\377" means that no
|
|
|
|
|
* transparent color is set
|
|
|
|
|
* palette - 256 dwords (RGBA colors)
|
2016-08-14 10:59:46 -07:00
|
|
|
|
*
|
|
|
|
|
* Image data:
|
|
|
|
|
* Sequential pixel data; row-major from top to bottom, left to right:
|
|
|
|
|
* - 1 byte per pixel for palette images
|
|
|
|
|
* - 1 dword (ARGB) per pixel for truecolor images
|
2016-08-14 06:52:43 -07:00
|
|
|
|
*/
|
|
|
|
|
|
2006-04-05 08:44:56 -07:00
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
|
#include "config.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2006-04-05 08:35:53 -07:00
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <math.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include "gd.h"
|
2018-01-29 15:07:44 -08:00
|
|
|
|
#include "gd_errors.h"
|
|
|
|
|
|
|
|
|
|
/* 2.3: gd is no longer mandatory */
|
|
|
|
|
#if ENABLE_GD_FORMATS
|
2006-04-05 08:35:53 -07:00
|
|
|
|
|
|
|
|
|
#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. */
|
|
|
|
|
/* */
|
2006-04-05 08:42:56 -07:00
|
|
|
|
int
|
|
|
|
|
_gdGetColors (gdIOCtx * in, gdImagePtr im, int gd2xFlag)
|
2006-04-05 08:35:53 -07:00
|
|
|
|
{
|
2013-04-03 05:23:11 -07:00
|
|
|
|
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;
|
|
|
|
|
}
|
2018-02-03 09:31:16 -08:00
|
|
|
|
}
|
|
|
|
|
/* Make sure transparent index is within bounds of the palette. */
|
|
|
|
|
if (!(im->trueColor) && (im->transparent >= im->colorsTotal || im->transparent < 0)) {
|
|
|
|
|
im->transparent = (-1);
|
2006-04-05 08:42:56 -07:00
|
|
|
|
}
|
2013-04-03 05:23:11 -07:00
|
|
|
|
GD2_DBG (printf
|
|
|
|
|
("Palette had %d colours (T=%d)\n", im->colorsTotal,
|
|
|
|
|
im->transparent));
|
|
|
|
|
if (im->trueColor) {
|
|
|
|
|
return TRUE;
|
2006-04-05 08:42:56 -07:00
|
|
|
|
}
|
2013-04-03 05:23:11 -07:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
2006-04-05 08:42:56 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
for (i = 0; (i < im->colorsTotal); i++) {
|
|
|
|
|
im->open[i] = 0;
|
|
|
|
|
};
|
2006-04-05 08:42:56 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
return TRUE;
|
2006-04-05 08:35:53 -07:00
|
|
|
|
fail1:
|
2013-04-03 05:23:11 -07:00
|
|
|
|
return FALSE;
|
2006-04-05 08:35:53 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* */
|
|
|
|
|
/* Use the common basic header info to make the image object. */
|
|
|
|
|
/* */
|
2006-04-05 08:46:42 -07:00
|
|
|
|
static gdImagePtr
|
2006-04-05 08:42:56 -07:00
|
|
|
|
_gdCreateFromFile (gdIOCtx * in, int *sx, int *sy)
|
2006-04-05 08:35:53 -07:00
|
|
|
|
{
|
2013-04-03 05:23:11 -07:00
|
|
|
|
gdImagePtr im;
|
|
|
|
|
int gd2xFlag = 0;
|
|
|
|
|
int trueColorFlag = 0;
|
|
|
|
|
if (!gdGetWord (sx, in)) {
|
|
|
|
|
goto fail1;
|
2006-04-05 08:47:57 -07:00
|
|
|
|
}
|
2013-04-03 05:23:11 -07:00
|
|
|
|
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;
|
2006-04-05 08:42:56 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
GD2_DBG (printf ("Image is %dx%d\n", *sx, *sy));
|
|
|
|
|
if (trueColorFlag) {
|
|
|
|
|
im = gdImageCreateTrueColor (*sx, *sy);
|
|
|
|
|
} else {
|
|
|
|
|
im = gdImageCreate (*sx, *sy);
|
|
|
|
|
}
|
|
|
|
|
if (!im) {
|
2007-08-06 11:32:26 -07:00
|
|
|
|
goto fail1;
|
|
|
|
|
}
|
2013-04-03 05:23:11 -07:00
|
|
|
|
if (!_gdGetColors (in, im, gd2xFlag)) {
|
|
|
|
|
goto fail2;
|
|
|
|
|
}
|
2006-04-05 08:42:56 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
return im;
|
2006-04-05 08:35:53 -07:00
|
|
|
|
fail2:
|
2013-04-03 05:23:11 -07:00
|
|
|
|
gdImageDestroy (im);
|
2006-04-05 08:35:53 -07:00
|
|
|
|
fail1:
|
2013-04-03 05:23:11 -07:00
|
|
|
|
return 0;
|
2006-04-05 08:35:53 -07:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-07 12:29:06 -08:00
|
|
|
|
/*
|
|
|
|
|
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);
|
2018-06-21 19:47:42 -07:00
|
|
|
|
> // ... Use the image ...
|
2014-01-07 12:29:06 -08:00
|
|
|
|
> gdImageDestroy(im);
|
|
|
|
|
*/
|
2006-04-05 08:52:22 -07:00
|
|
|
|
BGD_DECLARE(gdImagePtr) gdImageCreateFromGd (FILE * inFile)
|
2006-04-05 08:35:53 -07:00
|
|
|
|
{
|
2013-04-03 05:23:11 -07:00
|
|
|
|
gdImagePtr im;
|
|
|
|
|
gdIOCtx *in;
|
2006-04-05 08:35:53 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
in = gdNewFileCtx (inFile);
|
|
|
|
|
if (in == NULL) return NULL;
|
|
|
|
|
im = gdImageCreateFromGdCtx (in);
|
2006-04-05 08:35:53 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
in->gd_free (in);
|
2006-04-05 08:35:53 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
return im;
|
2006-04-05 08:35:53 -07:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-07 12:29:06 -08:00
|
|
|
|
/*
|
|
|
|
|
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>.
|
|
|
|
|
*/
|
2006-04-05 08:52:22 -07:00
|
|
|
|
BGD_DECLARE(gdImagePtr) gdImageCreateFromGdPtr (int size, void *data)
|
2006-04-05 08:50:59 -07:00
|
|
|
|
{
|
2013-04-03 05:23:11 -07:00
|
|
|
|
gdImagePtr im;
|
|
|
|
|
gdIOCtx *in = gdNewDynamicCtxEx (size, data, 0);
|
|
|
|
|
if(!in)
|
|
|
|
|
return 0;
|
|
|
|
|
im = gdImageCreateFromGdCtx (in);
|
|
|
|
|
in->gd_free (in);
|
|
|
|
|
return im;
|
2006-04-05 08:50:59 -07:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-07 12:29:06 -08:00
|
|
|
|
/*
|
|
|
|
|
Function: gdImageCreateFromGdCtx
|
|
|
|
|
|
|
|
|
|
Reads in a GD image via a <gdIOCtx> struct. See
|
|
|
|
|
<gdImageCreateFromGd>.
|
|
|
|
|
*/
|
2006-04-05 08:52:22 -07:00
|
|
|
|
BGD_DECLARE(gdImagePtr) gdImageCreateFromGdCtx (gdIOCtxPtr in)
|
2006-04-05 08:35:53 -07:00
|
|
|
|
{
|
2013-04-03 05:23:11 -07:00
|
|
|
|
int sx, sy;
|
|
|
|
|
int x, y;
|
|
|
|
|
gdImagePtr im;
|
2006-04-05 08:42:56 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
/* Read the header */
|
|
|
|
|
im = _gdCreateFromFile (in, &sx, &sy);
|
2006-04-05 08:42:56 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
if (im == NULL) {
|
|
|
|
|
goto fail1;
|
|
|
|
|
};
|
2006-04-05 08:42:56 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
/* 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;
|
|
|
|
|
}
|
2006-04-05 08:47:57 -07:00
|
|
|
|
}
|
2013-04-03 05:23:11 -07:00
|
|
|
|
} 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;
|
|
|
|
|
}
|
2006-04-05 08:47:57 -07:00
|
|
|
|
}
|
2006-04-05 08:35:53 -07:00
|
|
|
|
}
|
2013-04-03 05:23:11 -07:00
|
|
|
|
return im;
|
2006-04-05 08:35:53 -07:00
|
|
|
|
|
|
|
|
|
fail2:
|
2013-04-03 05:23:11 -07:00
|
|
|
|
gdImageDestroy (im);
|
2006-04-05 08:35:53 -07:00
|
|
|
|
fail1:
|
2013-04-03 05:23:11 -07:00
|
|
|
|
return 0;
|
2006-04-05 08:35:53 -07:00
|
|
|
|
}
|
|
|
|
|
|
2006-04-05 08:42:56 -07:00
|
|
|
|
void
|
|
|
|
|
_gdPutColors (gdImagePtr im, gdIOCtx * out)
|
2006-04-05 08:35:53 -07:00
|
|
|
|
{
|
2013-04-03 05:23:11 -07:00
|
|
|
|
int i;
|
2006-04-05 08:42:56 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
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);
|
|
|
|
|
}
|
2006-04-05 08:42:22 -07:00
|
|
|
|
}
|
2006-04-05 08:35:53 -07:00
|
|
|
|
}
|
|
|
|
|
|
2006-04-05 08:46:42 -07:00
|
|
|
|
static void
|
2006-04-05 08:42:56 -07:00
|
|
|
|
_gdPutHeader (gdImagePtr im, gdIOCtx * out)
|
2006-04-05 08:35:53 -07:00
|
|
|
|
{
|
2013-04-03 05:23:11 -07:00
|
|
|
|
/* 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);
|
2006-04-05 08:35:53 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
_gdPutColors (im, out);
|
2006-04-05 08:35:53 -07:00
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2006-04-05 08:42:56 -07:00
|
|
|
|
static void
|
|
|
|
|
_gdImageGd (gdImagePtr im, gdIOCtx * out)
|
2006-04-05 08:35:53 -07:00
|
|
|
|
{
|
2013-04-03 05:23:11 -07:00
|
|
|
|
int x, y;
|
2006-04-05 08:42:56 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
_gdPutHeader (im, out);
|
2006-04-05 08:42:56 -07:00
|
|
|
|
|
2013-04-03 05:23:11 -07:00
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
2006-04-05 08:35:53 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-20 12:13:38 -07:00
|
|
|
|
/*
|
|
|
|
|
Function: gdImageGd
|
|
|
|
|
*/
|
2006-04-05 08:52:22 -07:00
|
|
|
|
BGD_DECLARE(void) gdImageGd (gdImagePtr im, FILE * outFile)
|
2006-04-05 08:35:53 -07:00
|
|
|
|
{
|
2013-04-03 05:23:11 -07:00
|
|
|
|
gdIOCtx *out = gdNewFileCtx (outFile);
|
|
|
|
|
if (out == NULL) return;
|
|
|
|
|
_gdImageGd (im, out);
|
|
|
|
|
out->gd_free (out);
|
2006-04-05 08:35:53 -07:00
|
|
|
|
}
|
|
|
|
|
|
2016-07-20 12:13:38 -07:00
|
|
|
|
/*
|
|
|
|
|
Function: gdImageGdPtr
|
|
|
|
|
*/
|
2006-04-05 08:52:22 -07:00
|
|
|
|
BGD_DECLARE(void *) gdImageGdPtr (gdImagePtr im, int *size)
|
2006-04-05 08:35:53 -07:00
|
|
|
|
{
|
2013-04-03 05:23:11 -07:00
|
|
|
|
void *rv;
|
|
|
|
|
gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
|
|
|
|
|
if (out == NULL) return NULL;
|
2021-07-19 19:50:57 -07:00
|
|
|
|
_gdImageGd (im, out);
|
|
|
|
|
rv = gdDPExtractData (out, size);
|
2013-04-03 05:23:11 -07:00
|
|
|
|
out->gd_free (out);
|
|
|
|
|
return rv;
|
2006-04-05 08:35:53 -07:00
|
|
|
|
}
|
2018-01-29 15:07:44 -08:00
|
|
|
|
|
|
|
|
|
#else /* no HAVE_LIBZ or !ENABLE_GD_FORMATS */
|
|
|
|
|
|
|
|
|
|
static void _noGdError (void)
|
|
|
|
|
{
|
|
|
|
|
gd_error("GD image support has been disabled\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BGD_DECLARE(gdImagePtr) gdImageCreateFromGd (FILE * inFile)
|
|
|
|
|
{
|
2021-08-16 03:03:52 -07:00
|
|
|
|
ARG_NOT_USED(inFile);
|
2018-01-29 15:07:44 -08:00
|
|
|
|
_noGdError();
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BGD_DECLARE(gdImagePtr) gdImageCreateFromGdPtr (int size, void *data)
|
|
|
|
|
{
|
2021-08-16 03:03:52 -07:00
|
|
|
|
ARG_NOT_USED(size);
|
|
|
|
|
ARG_NOT_USED(data);
|
2018-01-29 15:07:44 -08:00
|
|
|
|
_noGdError();
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BGD_DECLARE(gdImagePtr) gdImageCreateFromGdCtx (gdIOCtxPtr in)
|
|
|
|
|
{
|
2021-08-16 03:03:52 -07:00
|
|
|
|
ARG_NOT_USED(in);
|
2018-01-29 15:07:44 -08:00
|
|
|
|
_noGdError();
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BGD_DECLARE(void) gdImageGd (gdImagePtr im, FILE * outFile)
|
|
|
|
|
{
|
2021-08-16 03:03:52 -07:00
|
|
|
|
ARG_NOT_USED(im);
|
|
|
|
|
ARG_NOT_USED(outFile);
|
2018-01-29 15:07:44 -08:00
|
|
|
|
_noGdError();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BGD_DECLARE(void *) gdImageGdPtr (gdImagePtr im, int *size)
|
|
|
|
|
{
|
2021-08-16 03:03:52 -07:00
|
|
|
|
ARG_NOT_USED(im);
|
|
|
|
|
ARG_NOT_USED(size);
|
2018-01-29 15:07:44 -08:00
|
|
|
|
_noGdError();
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* ENABLE_GD_FORMATS */
|