[packages/gd] - added some AVIF and HEIF fixes from git
qboosh
qboosh at pld-linux.org
Wed Mar 5 21:12:37 CET 2025
commit f27af2337e2cfe120bbfcd2b4b8825019e008ac8
Author: Jakub Bogusz <qboosh at pld-linux.org>
Date: Wed Mar 5 21:04:52 2025 +0100
- added some AVIF and HEIF fixes from git
gd-avif.patch | 297 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
gd-heif.patch | 200 +++++++++++++++++++++++++++++++++++++++
gd.spec | 4 +
3 files changed, 501 insertions(+)
---
diff --git a/gd.spec b/gd.spec
index f297131..2677e5b 100644
--- a/gd.spec
+++ b/gd.spec
@@ -27,6 +27,8 @@ Source0: https://github.com/libgd/libgd/releases/download/%{name}-%{version}/lib
Patch0: %{name}-fontpath.patch
Patch1: %{name}-loop.patch
Patch2: api-breakage.patch
+Patch3: %{name}-avif.patch
+Patch4: %{name}-heif.patch
URL: https://libgd.github.io/
BuildRequires: autoconf >= 2.54
BuildRequires: automake
@@ -173,6 +175,8 @@ para uso pelos programas que usam a libgd.
%patch -P0 -p1
%patch -P1 -p1
%patch -P2 -p1
+%patch -P3 -p1
+%patch -P4 -p1
%build
%{__libtoolize}
diff --git a/gd-avif.patch b/gd-avif.patch
new file mode 100644
index 0000000..16b12b2
--- /dev/null
+++ b/gd-avif.patch
@@ -0,0 +1,297 @@
+From aed71816906f8d86c060b0c51807b79acff7bc64 Mon Sep 17 00:00:00 2001
+From: Pierre Joye <pierre.php at gmail.com>
+Date: Tue, 14 Sep 2021 04:39:31 +0700
+Subject: [PATCH] Fix #764 prevent crash in test code when AVIF encode/decode
+ fails, fix memory leaks
+
+---
+ tests/avif/avif_im2im.c | 5 +++--
+ tests/avif/compare_avif_to_png.c | 35 +++++---------------------------
+ 2 files changed, 8 insertions(+), 32 deletions(-)
+
+#diff --git a/tests/avif/avif_im2im.c b/tests/avif/avif_im2im.c
+#index 3a07ebdae..2331484d1 100644
+#--- a/tests/avif/avif_im2im.c
+#+++ b/tests/avif/avif_im2im.c
+#@@ -13,7 +13,7 @@
+#
+# int main()
+# {
+#- gdImagePtr srcGdIm, destGdIm;
+#+ gdImagePtr srcGdIm = NULL, destGdIm = NULL;
+# void *avifImageDataPtr;
+# FILE *fp;
+# int r, g, b;
+#@@ -38,7 +38,7 @@ int main()
+#
+# // Encode the gd image to an AVIF image in memory.
+# avifImageDataPtr = gdImageAvifPtrEx(srcGdIm, &size, 100, 10);
+#- gdTestAssertMsg(avifImageDataPtr != NULL, "gdImageAvifPtr() returned null\n");
+#+ if (!gdTestAssertMsg(avifImageDataPtr != NULL, "gdImageAvifPtr() returned null\n")) goto exit;
+# gdTestAssertMsg(size > 0, "gdImageAvifPtr() returned a non-positive size\n");
+#
+# // Encode the AVIF image back into a gd image.
+#@@ -54,6 +54,7 @@ int main()
+# gdTestImageDiff(srcGdIm, destGdIm, NULL, &result);
+# gdTestAssertMsg(result.pixels_changed == 0, "pixels changed: %d\n", result.pixels_changed);
+#
+#+exit:
+# if (srcGdIm)
+# gdImageDestroy(srcGdIm);
+#
+diff --git a/tests/avif/compare_avif_to_png.c b/tests/avif/compare_avif_to_png.c
+index 6330ea3ee..50a80419d 100644
+--- a/tests/avif/compare_avif_to_png.c
++++ b/tests/avif/compare_avif_to_png.c
+@@ -20,7 +20,7 @@
+ int main() {
+ FILE *fp;
+ gdImagePtr imFromPng = NULL, imFromAvif = NULL;
+- void *avifImDataPtr = NULL, *pngImDataPtr = NULL;
++ void *avifImDataPtr = NULL;
+ int size;
+ char pngFilename[100], avifFilename[100], *pngFilePath;
+ char errMsg[4096];
+@@ -56,37 +56,12 @@ int main() {
+ gdTestAssertMsg(gdAssertImageEquals(imFromPng, imFromAvif), errMsg);
+
+ // Then, decode each AVIF into a GD format, and compare that with the orginal PNG.
+-avif2png:
+-
+ // Skip this reverse test for now, until we can find images that encode to PNGs losslessly.
+-if (0) {
+- sprintf(avifFilename, "%s.avif", filenames[i]);
+- fp = gdTestFileOpen2("avif", avifFilename);
+- imFromAvif = gdImageCreateFromAvif(fp);
+- fclose(fp);
+-
+- strcat(strcpy(errMsg, filenames[i]), ".avif: gdImageCreateFromAvif failed\n");
+- if (!gdTestAssertMsg(imFromAvif != NULL, errMsg))
+- continue;
+-
+- strcat(strcpy(errMsg, filenames[i]), ".avif: Encoded PNG image did not match original AVIF\n");
+- pngFilePath = gdTestFilePath2("avif", pngFilename);
+- gdTestAssertMsg(gdAssertImageEqualsToFile(pngFilePath, imFromAvif), errMsg);
+- free(pngFilePath);
+-}
++avif2png:
++ if (imFromPng) gdImageDestroy(imFromPng);
++ if (imFromAvif) gdImageDestroy(imFromAvif);
++ if (avifImDataPtr) gdFree(avifImDataPtr);
+ }
+
+- if (imFromPng)
+- gdImageDestroy(imFromPng);
+-
+- if (imFromAvif)
+- gdImageDestroy(imFromAvif);
+-
+- if (avifImDataPtr)
+- gdFree(avifImDataPtr);
+-
+- if (pngImDataPtr)
+- gdFree(pngImDataPtr);
+-
+ return gdNumFailures();
+ }
+From 4b5b2f122bf5df628d4e07631b599e8ef3144f70 Mon Sep 17 00:00:00 2001
+From: "Christoph M. Becker" <cmbecker69 at gmx.de>
+Date: Fri, 10 Jun 2022 13:58:56 +0200
+Subject: [PATCH] Fix #831: gdImageAvif memory leak
+
+First, we must not forget to call `avifImageDestroy()` when we're
+finished with the image.
+
+Then we also need to cater to the allocated `dataBuf`. To keep track
+of that, we "extend" `avifIO` as `avifIOCtxReader`. To simplify, and
+to avoid unnecessary allocations, we use `realloc()`. To better fit
+with GD, we also use the GD memory allocation functions instead of the
+ones provided by libavif.
+---
+ src/gd_avif.c | 52 +++++++++++++++++++++++++++++++++------------------
+ 1 file changed, 34 insertions(+), 18 deletions(-)
+
+diff --git a/src/gd_avif.c b/src/gd_avif.c
+index 593562330..48369feb9 100644
+--- a/src/gd_avif.c
++++ b/src/gd_avif.c
+@@ -159,6 +159,11 @@ static avifBool isAvifError(avifResult result, const char *msg) {
+ }
+
+
++typedef struct avifIOCtxReader {
++ avifIO io; // this must be the first member for easy casting to avifIO*
++ avifROData rodata;
++} avifIOCtxReader;
++
+ /*
+ <readfromCtx> implements the avifIOReadFunc interface by calling the relevant functions
+ in the gdIOCtx. Our logic is inspired by avifIOMemoryReaderRead() and avifIOFileReaderRead().
+@@ -174,8 +179,8 @@ static avifBool isAvifError(avifResult result, const char *msg) {
+ */
+ static avifResult readFromCtx(avifIO *io, uint32_t readFlags, uint64_t offset, size_t size, avifROData *out)
+ {
+- void *dataBuf = NULL;
+ gdIOCtx *ctx = (gdIOCtx *) io->data;
++ avifIOCtxReader *reader = (avifIOCtxReader *) io;
+
+ // readFlags is unsupported
+ if (readFlags != 0) {
+@@ -191,28 +196,34 @@ static avifResult readFromCtx(avifIO *io, uint32_t readFlags, uint64_t offset, s
+ if (!ctx->seek(ctx, (int) offset))
+ return AVIF_RESULT_IO_ERROR;
+
+- dataBuf = avifAlloc(size);
+- if (!dataBuf) {
++ if (size > reader->rodata.size) {
++ reader->rodata.data = gdRealloc((void *) reader->rodata.data, size);
++ reader->rodata.size = size;
++ }
++ if (!reader->rodata.data) {
+ gd_error("avif error - couldn't allocate memory");
+ return AVIF_RESULT_UNKNOWN_ERROR;
+ }
+
+ // Read the number of bytes requested.
+ // If getBuf() returns a negative value, that means there was an error.
+- int charsRead = ctx->getBuf(ctx, dataBuf, (int) size);
++ int charsRead = ctx->getBuf(ctx, (void *) reader->rodata.data, (int) size);
+ if (charsRead < 0) {
+- avifFree(dataBuf);
+ return AVIF_RESULT_IO_ERROR;
+ }
+
+- out->data = dataBuf;
++ out->data = reader->rodata.data;
+ out->size = charsRead;
+ return AVIF_RESULT_OK;
+ }
+
+ // avif.h says this is optional, but it seemed easy to implement.
+ static void destroyAvifIO(struct avifIO *io) {
+- avifFree(io);
++ avifIOCtxReader *reader = (avifIOCtxReader *) io;
++ if (reader->rodata.data != NULL) {
++ gdFree((void *) reader->rodata.data);
++ }
++ gdFree(reader);
+ }
+
+ /* Set up an avifIO object.
+@@ -226,21 +237,23 @@ static void destroyAvifIO(struct avifIO *io) {
+
+ // TODO: can we get sizeHint somehow?
+ static avifIO *createAvifIOFromCtx(gdIOCtx *ctx) {
+- avifIO *io;
++ struct avifIOCtxReader *reader;
+
+- io = gdMalloc(sizeof(*io));
+- if (io == NULL)
++ reader = gdMalloc(sizeof(*reader));
++ if (reader == NULL)
+ return NULL;
+
+ // TODO: setting persistent=FALSE is safe, but it's less efficient. Is it necessary?
+- io->persistent = AVIF_FALSE;
+- io->read = readFromCtx;
+- io->write = NULL; // this function is currently unused; see avif.h
+- io->destroy = destroyAvifIO;
+- io->sizeHint = 0; // sadly, we don't get this information from the gdIOCtx.
+- io->data = ctx;
+-
+- return io;
++ reader->io.persistent = AVIF_FALSE;
++ reader->io.read = readFromCtx;
++ reader->io.write = NULL; // this function is currently unused; see avif.h
++ reader->io.destroy = destroyAvifIO;
++ reader->io.sizeHint = 0; // sadly, we don't get this information from the gdIOCtx.
++ reader->io.data = ctx;
++ reader->rodata.data = NULL;
++ reader->rodata.size = 0;
++
++ return (avifIO *) reader;
+ }
+
+
+@@ -599,6 +612,9 @@ static avifBool _gdImageAvifCtx(gdImagePtr im, gdIOCtx *outfile, int quality, in
+ if (avifOutput.data)
+ avifRWDataFree(&avifOutput);
+
++ if (avifIm)
++ avifImageDestroy(avifIm);
++
+ return failed;
+ }
+
+From c2867fd56dd3198ca4d09572913166d60fb657f9 Mon Sep 17 00:00:00 2001
+From: "Christoph M. Becker" <cmbecker69 at gmx.de>
+Date: Thu, 17 Oct 2024 06:26:21 +0200
+Subject: [PATCH] Check libavif API return values, if available
+
+Prior to libavif 1.1.0, `avifAlloc()` was infallible (it called
+`abort()` on OOM conditions); thus, several API functions which used
+`avifAlloc()` did not report failure. That changed as of libavif
+1.0.0[1], so checking and handling failure conditions can now be done.
+However, due to `avifAlloc()` being fallible as of libavif 1.1.0, this
+error checking and handling is mandatory to avoid more serious issues.
+
+[1] <https://github.com/AOMediaCodec/libavif/blob/eb02b2ec52df5c0f50b71fbc51321c5ce435aaca/CHANGELOG.md?plain=1#L273-L281>
+---
+ src/gd_avif.c | 21 +++++++++++++++++++++
+ 1 file changed, 21 insertions(+)
+
+diff --git a/src/gd_avif.c b/src/gd_avif.c
+index 48369feb9..f0e5f2aaf 100644
+--- a/src/gd_avif.c
++++ b/src/gd_avif.c
+@@ -402,7 +402,13 @@ BGD_DECLARE(gdImagePtr) gdImageCreateFromAvifCtx (gdIOCtx *ctx)
+ // (While AVIF image pixel depth can be 8, 10, or 12 bits, GD truecolor images are 8-bit.)
+ avifRGBImageSetDefaults(&rgb, decoder->image);
+ rgb.depth = 8;
++#if AVIF_VERSION >= 1000000
++ result = avifRGBImageAllocatePixels(&rgb);
++ if (isAvifError(result, "Allocating RGB pixels failed"))
++ goto cleanup;
++#else
+ avifRGBImageAllocatePixels(&rgb);
++#endif
+
+ result = avifImageYUVToRGB(decoder->image, &rgb);
+ if (isAvifError(result, "Conversion from YUV to RGB failed"))
+@@ -540,6 +546,10 @@ static avifBool _gdImageAvifCtx(gdImagePtr im, gdIOCtx *outfile, int quality, in
+ // Note that MATRIX_COEFFICIENTS_IDENTITY enables lossless conversion from RGB to YUV.
+
+ avifImage *avifIm = avifImageCreate(gdImageSX(im), gdImageSY(im), 8, subsampling);
++ if (avifIm == NULL) {
++ gd_error("avif error - Creating image failed\n");
++ goto cleanup;
++ }
+
+ avifIm->colorPrimaries = AVIF_COLOR_PRIMARIES_BT709;
+ avifIm->transferCharacteristics = AVIF_TRANSFER_CHARACTERISTICS_SRGB;
+@@ -547,7 +557,13 @@ static avifBool _gdImageAvifCtx(gdImagePtr im, gdIOCtx *outfile, int quality, in
+
+ avifRGBImageSetDefaults(&rgb, avifIm);
+ // this allocates memory, and sets rgb.rowBytes and rgb.pixels.
++#if AVIF_VERSION >= 1000000
++ result = avifRGBImageAllocatePixels(&rgb);
++ if (isAvifError(result, "Allocating RGB pixels failed"))
++ goto cleanup;
++#else
+ avifRGBImageAllocatePixels(&rgb);
++#endif
+
+ // Parse RGB data from the GD image, and copy it into the AVIF RGB image.
+ // Convert 7-bit GD alpha channel values to 8-bit AVIF values.
+@@ -574,6 +590,11 @@ static avifBool _gdImageAvifCtx(gdImagePtr im, gdIOCtx *outfile, int quality, in
+ // Encode the image in AVIF format.
+
+ encoder = avifEncoderCreate();
++ if (encoder == NULL) {
++ gd_error("avif error - Creating encoder failed\n");
++ goto cleanup;
++ }
++
+ int quantizerQuality = quality == QUALITY_DEFAULT ?
+ QUANTIZER_DEFAULT : quality2Quantizer(quality);
+
diff --git a/gd-heif.patch b/gd-heif.patch
new file mode 100644
index 0000000..a2481a6
--- /dev/null
+++ b/gd-heif.patch
@@ -0,0 +1,200 @@
+From f1a53c082173567b8ad07eaba8fc7ba66457a730 Mon Sep 17 00:00:00 2001
+From: Pierre Joye <pierre.php at gmail.com>
+Date: Sat, 22 Jan 2022 17:29:04 +0700
+Subject: [PATCH] #788 fix bug in HEIF usage, stride is require (#801)
+
+fix bug #788 in HEIF usage, stride is require
+---
+ CMakeLists.txt | 4 ++--
+ src/gd_heif.c | 17 ++++++++++-----
+ tests/heif/CMakeLists.txt | 1 +
+ tests/heif/bug788.c | 43 ++++++++++++++++++++++++++++++++++++++
+ tests/heif/bug788.png | Bin 0 -> 124720 bytes
+ 5 files changed, 58 insertions(+), 7 deletions(-)
+ create mode 100644 tests/heif/bug788.c
+ create mode 100644 tests/heif/bug788.png
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 6b3e5b3bd..979d1ccf8 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -1,9 +1,9 @@
+ CMAKE_MINIMUM_REQUIRED(VERSION 3.7 FATAL_ERROR)
+-
++project(GD)
+ SET(PACKAGE GD)
+ SET(PACKAGE_NAME GD)
+
+-PROJECT(GD)
++
+
+ SET(CMAKE_MODULE_PATH "${GD_SOURCE_DIR}/cmake/modules")
+
+diff --git a/src/gd_heif.c b/src/gd_heif.c
+index 2c7c3d3cf..adccbabed 100644
+--- a/src/gd_heif.c
++++ b/src/gd_heif.c
+@@ -125,7 +125,8 @@ static gdImagePtr _gdImageCreateFromHeifCtx(gdIOCtx *infile, gd_heif_brand expec
+ size_t size = 0, n = GD_HEIF_ALLOC_STEP;
+ gdImagePtr im;
+ int x, y;
+- uint8_t *p;
++ uint8_t *p, *row_start;
++ int stride;
+
+ magic_len = gdGetBuf(magic, GD_HEIF_HEADER, infile);
+ if (magic_len != GD_HEIF_HEADER || !_gdHeifCheckBrand(magic, expected_brand)) {
+@@ -207,7 +208,7 @@ static gdImagePtr _gdImageCreateFromHeifCtx(gdIOCtx *infile, gd_heif_brand expec
+ heif_context_free(heif_ctx);
+ return NULL;
+ }
+- rgba = (uint8_t *)heif_image_get_plane_readonly(heif_im, heif_channel_interleaved, NULL);
++ rgba = (uint8_t *)heif_image_get_plane_readonly(heif_im, heif_channel_interleaved, &stride);
+ if (!rgba) {
+ gd_error("gd-heif cannot get image plane\n");
+ gdFree(filedata);
+@@ -217,7 +218,9 @@ static gdImagePtr _gdImageCreateFromHeifCtx(gdIOCtx *infile, gd_heif_brand expec
+ gdImageDestroy(im);
+ return NULL;
+ }
++ row_start = rgba;
+ for (y = 0, p = rgba; y < height; y++) {
++ p = row_start;
+ for (x = 0; x < width; x++) {
+ uint8_t r = *(p++);
+ uint8_t g = *(p++);
+@@ -225,6 +228,7 @@ static gdImagePtr _gdImageCreateFromHeifCtx(gdIOCtx *infile, gd_heif_brand expec
+ uint8_t a = gdAlphaMax - (*(p++) >> 1);
+ im->tpixels[y][x] = gdTrueColorAlpha(r, g, b, a);
+ }
++ row_start += stride;
+ }
+ gdFree(filedata);
+ heif_image_release(heif_im);
+@@ -273,7 +277,8 @@ static int _gdImageHeifCtx(gdImagePtr im, gdIOCtx *outfile, int quality, gdHeifC
+ uint8_t *rgba;
+ int x, y;
+ uint8_t *p;
+-
++ uint8_t *row_start;
++ int stride;
+ if (im == NULL) {
+ return GD_FALSE;
+ }
+@@ -349,7 +354,7 @@ static int _gdImageHeifCtx(gdImagePtr im, gdIOCtx *outfile, int quality, gdHeifC
+ return GD_FALSE;
+ }
+
+- rgba = (uint8_t *)heif_image_get_plane_readonly(heif_im, heif_channel_interleaved, NULL);
++ rgba = (uint8_t *)heif_image_get_plane_readonly(heif_im, heif_channel_interleaved, &stride);
+ if (!rgba) {
+ gd_error("gd-heif cannot get image plane\n");
+ heif_image_release(heif_im);
+@@ -357,8 +362,9 @@ static int _gdImageHeifCtx(gdImagePtr im, gdIOCtx *outfile, int quality, gdHeifC
+ heif_context_free(heif_ctx);
+ return GD_FALSE;
+ }
+- p = rgba;
++ row_start = rgba;
+ for (y = 0; y < gdImageSY(im); y++) {
++ p = row_start;
+ for (x = 0; x < gdImageSX(im); x++) {
+ int c;
+ char a;
+@@ -374,6 +380,7 @@ static int _gdImageHeifCtx(gdImagePtr im, gdIOCtx *outfile, int quality, gdHeifC
+ *(p++) = gdTrueColorGetBlue(c);
+ *(p++) = a;
+ }
++ row_start += stride;
+ }
+ err = heif_context_encode_image(heif_ctx, heif_im, heif_enc, NULL, NULL);
+ heif_encoder_release(heif_enc);
+#diff --git a/tests/heif/CMakeLists.txt b/tests/heif/CMakeLists.txt
+#index 4a41528d3..a45b957fb 100644
+#--- a/tests/heif/CMakeLists.txt
+#+++ b/tests/heif/CMakeLists.txt
+#@@ -5,6 +5,7 @@ LIST(APPEND TESTS_FILES
+# heif_null
+# heif_ptr_double_free
+# heif_read
+#+ bug788
+# )
+# ENDIF(HEIF_FOUND)
+#
+diff --git a/tests/heif/bug788.c b/tests/heif/bug788.c
+new file mode 100644
+index 000000000..5475251b6
+--- /dev/null
++++ b/tests/heif/bug788.c
+@@ -0,0 +1,43 @@
++/**
++ * Bug 788 stride not implemented.
++ */
++
++#include "gd.h"
++#include "gdtest.h"
++
++#include <libheif/heif.h>
++
++int main () {
++ FILE *fp;
++ gdImagePtr in;
++ gdImagePtr dst;
++ gdImagePtr diff;
++ int size;
++ void *data;
++ CuTestImageResult result = {0, 0};
++ fp = gdTestFileOpen2("heif", "bug788.png");
++ in = gdImageCreateFromPng(fp);
++ fclose(fp);
++ fp = fopen("1.png", "wb");
++ gdImagePng(in, fp);
++ fclose(fp);
++ data = gdImageHeifPtrEx(in, &size, 200, GD_HEIF_CODEC_HEVC, GD_HEIF_CHROMA_444);
++
++ dst = gdImageCreateFromHeifPtr(size, data);
++ diff = gdImageCreateTrueColor(gdImageSX(dst), gdImageSY(dst));
++ if (gdTestAssertMsg(dst != NULL, "cannot compare with NULL buffer")) {
++ gdTestImageDiff(in, dst, diff, &result);
++ }
++ fp = fopen("2.png", "wb");
++ gdImageHeif(dst, fp);
++ fclose(fp);
++ fp = fopen("3.png", "wb");
++ gdImagePng(diff, fp);
++ fclose(fp);
++ /* colorspace conversion cannot avoid colors differences, even if we use the same format/colorspace for in and out */
++ gdTestAssertMsg(result.pixels_changed > 30, "pixels changed: %d\n", result.pixels_changed);
++ gdImageDestroy(dst);
++ gdImageDestroy(in);
++ gdImageDestroy(diff);
++ return 0;
++}
+\ No newline at end of file
+From 21633377174354199c3ea3e4b23f64cfaeacc50a Mon Sep 17 00:00:00 2001
+From: "Christoph M. Becker" <cmbecker69 at gmx.de>
+Date: Thu, 26 Dec 2024 11:56:38 +0100
+Subject: [PATCH] Avoid segfault of bug788 (#907)
+
+If the heif image can't be created for whatever reason, `dst` is `NULL`
+what causes a segfault when we try to access its dimensions. We catch
+that with a test assertion, and bail out if that fails.
+---
+ tests/heif/bug788.c | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/tests/heif/bug788.c b/tests/heif/bug788.c
+index 5475251b6..2e2a9ea6f 100644
+--- a/tests/heif/bug788.c
++++ b/tests/heif/bug788.c
+@@ -24,6 +24,10 @@ int main () {
+ data = gdImageHeifPtrEx(in, &size, 200, GD_HEIF_CODEC_HEVC, GD_HEIF_CHROMA_444);
+
+ dst = gdImageCreateFromHeifPtr(size, data);
++ if (!gdTestAssert(dst != NULL)) {
++ gdImageDestroy(in);
++ return gdNumFailures();
++ }
+ diff = gdImageCreateTrueColor(gdImageSX(dst), gdImageSY(dst));
+ if (gdTestAssertMsg(dst != NULL, "cannot compare with NULL buffer")) {
+ gdTestImageDiff(in, dst, diff, &result);
================================================================
---- gitweb:
http://git.pld-linux.org/gitweb.cgi/packages/gd.git/commitdiff/f27af2337e2cfe120bbfcd2b4b8825019e008ac8
More information about the pld-cvs-commit
mailing list