| #include <stdio.h> |
| #include <math.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include "gd.h" |
| #include "gd_errors.h" |
| #include "gdhelpers.h" |
|
|
| #ifdef HAVE_LIBWEBP |
| #include "webp/decode.h" |
| #include "webp/encode.h" |
|
|
| #define GD_WEBP_ALLOC_STEP (4*1024) |
|
|
| gdImagePtr gdImageCreateFromWebp (FILE * inFile) |
| { |
| gdImagePtr im; |
| gdIOCtx *in = gdNewFileCtx(inFile); |
| if (!in) |
| return 0; |
| im = gdImageCreateFromWebpCtx(in); |
| in->gd_free(in); |
|
|
| return im; |
| } |
|
|
|
|
| gdImagePtr gdImageCreateFromWebpPtr (int size, void *data) |
| { |
| gdImagePtr im; |
| gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); |
| if (!in) |
| return 0; |
| im = gdImageCreateFromWebpCtx(in); |
| in->gd_free(in); |
| return im; |
| } |
|
|
| gdImagePtr gdImageCreateFromWebpCtx (gdIOCtx * infile) |
| { |
| int width, height; |
| uint8_t *filedata = NULL; |
| uint8_t *argb = NULL; |
| size_t size = 0, n; |
| gdImagePtr im; |
| int x, y; |
| uint8_t *p; |
|
|
| do { |
| unsigned char *read, *temp; |
|
|
| temp = gdRealloc(filedata, size+GD_WEBP_ALLOC_STEP); |
| if (temp) { |
| filedata = temp; |
| read = temp + size; |
| } else { |
| if (filedata) { |
| gdFree(filedata); |
| } |
| gd_error("WebP decode: realloc failed"); |
| return NULL; |
| } |
|
|
| n = gdGetBuf(read, GD_WEBP_ALLOC_STEP, infile); |
| if (n>0 && n!=EOF) { |
| size += n; |
| } |
| } while (n>0 && n!=EOF); |
|
|
| if (WebPGetInfo(filedata,size, &width, &height) == 0) { |
| gd_error("gd-webp cannot get webp info"); |
| gdFree(filedata); |
| return NULL; |
| } |
|
|
| im = gdImageCreateTrueColor(width, height); |
| if (!im) { |
| gdFree(filedata); |
| return NULL; |
| } |
| argb = WebPDecodeARGB(filedata, size, &width, &height); |
| if (!argb) { |
| gd_error("gd-webp cannot allocate temporary buffer"); |
| gdFree(filedata); |
| gdImageDestroy(im); |
| return NULL; |
| } |
| for (y = 0, p = argb; y < height; y++) { |
| for (x = 0; x < width; x++) { |
| register uint8_t a = gdAlphaMax - (*(p++) >> 1); |
| register uint8_t r = *(p++); |
| register uint8_t g = *(p++); |
| register uint8_t b = *(p++); |
| im->tpixels[y][x] = gdTrueColorAlpha(r, g, b, a); |
| } |
| } |
| gdFree(filedata); |
| |
| free(argb); |
| im->saveAlphaFlag = 1; |
| return im; |
| } |
|
|
| void gdImageWebpCtx (gdImagePtr im, gdIOCtx * outfile, int quality) |
| { |
| uint8_t *argb; |
| int x, y; |
| uint8_t *p; |
| uint8_t *out; |
| size_t out_size; |
|
|
| if (im == NULL) { |
| return; |
| } |
|
|
| if (!gdImageTrueColor(im)) { |
| gd_error("Palette image not supported by webp"); |
| return; |
| } |
|
|
| if (quality == -1) { |
| quality = 80; |
| } |
|
|
| if (overflow2(gdImageSX(im), 4)) { |
| return; |
| } |
|
|
| if (overflow2(gdImageSX(im) * 4, gdImageSY(im))) { |
| return; |
| } |
|
|
| argb = (uint8_t *)gdMalloc(gdImageSX(im) * 4 * gdImageSY(im)); |
| if (!argb) { |
| return; |
| } |
| p = argb; |
| for (y = 0; y < gdImageSY(im); y++) { |
| for (x = 0; x < gdImageSX(im); x++) { |
| register int c; |
| register char a; |
| c = im->tpixels[y][x]; |
| a = gdTrueColorGetAlpha(c); |
| if (a == 127) { |
| a = 0; |
| } else { |
| a = 255 - ((a << 1) + (a >> 6)); |
| } |
| *(p++) = gdTrueColorGetRed(c); |
| *(p++) = gdTrueColorGetGreen(c); |
| *(p++) = gdTrueColorGetBlue(c); |
| *(p++) = a; |
| } |
| } |
|
|
| if (quality >= gdWebpLossless) { |
| out_size = WebPEncodeLosslessRGBA(argb, gdImageSX(im), gdImageSY(im), gdImageSX(im) * 4, &out); |
| } else { |
| out_size = WebPEncodeRGBA(argb, gdImageSX(im), gdImageSY(im), gdImageSX(im) * 4, quality, &out); |
| } |
|
|
| if (out_size == 0) { |
| gd_error("gd-webp encoding failed"); |
| goto freeargb; |
| } |
| gdPutBuf(out, out_size, outfile); |
| free(out); |
|
|
| freeargb: |
| gdFree(argb); |
| } |
|
|
| void gdImageWebpEx (gdImagePtr im, FILE * outFile, int quality) |
| { |
| gdIOCtx *out = gdNewFileCtx(outFile); |
| gdImageWebpCtx(im, out, quality); |
| out->gd_free(out); |
| } |
|
|
| void gdImageWebp (gdImagePtr im, FILE * outFile) |
| { |
| gdIOCtx *out = gdNewFileCtx(outFile); |
| gdImageWebpCtx(im, out, -1); |
| out->gd_free(out); |
| } |
|
|
| void * gdImageWebpPtr (gdImagePtr im, int *size) |
| { |
| void *rv; |
| gdIOCtx *out = gdNewDynamicCtx(2048, NULL); |
| gdImageWebpCtx(im, out, -1); |
| rv = gdDPExtractData(out, size); |
| out->gd_free(out); |
|
|
| return rv; |
| } |
|
|
| void * gdImageWebpPtrEx (gdImagePtr im, int *size, int quality) |
| { |
| void *rv; |
| gdIOCtx *out = gdNewDynamicCtx(2048, NULL); |
| gdImageWebpCtx(im, out, quality); |
| rv = gdDPExtractData(out, size); |
| out->gd_free(out); |
| return rv; |
| } |
| #endif |
|
|
